kfsn

Status: early port, in progress. A Qt/KDE port of neofsn — a spatial filesystem navigator, itself a homage to SGI's FSN (the 3D UNIX file browser from Jurassic Park).

Folders become blue platforms, files become flat slabs you fly through, colored by modification age (FSN-style heatmap) or by file type. Built with Qt Quick 3D for the scene, Qt Quick for the shell, and KDE Frameworks 6 (KIO, Breeze icons) for native integration.

Platform: Linux / KDE only. kfsn depends on KDE Frameworks 6 (KIO actions, the Breeze icon theme for in-scene glyphs) and does not target macOS — the Mac build lives in neofsn. This is by design.

"It's a UNIX system. I know this."

Architecture

The Swift original splits into a model layer, a SceneKit 3D scene, and a SwiftUI shell. The port preserves that split:

Original (Swift)	Port (C++ / QML)
Model/FileKind / FileSystemNode / FileSystemScanner	src/filekind.*, src/model/filesystemnode.*, src/model/filesystemscanner.* (QtConcurrent)
Scene/SceneBuilder (SCNNode tree)	src/scene/scenebuilder.* → flattened SceneItem/SceneLevel data for QML
Scene/FlyCameraController	src/scene/flycamera.* (engine-agnostic math, drives the Quick3D camera)
Scene/SceneHostView.Coordinator (level stack, picking)	src/browsermodel.* + qml/scene/Scene3D.qml
SF Symbols / label bitmaps	src/scene/textureprovider.* (Breeze icons + painted labels → QImage)
BrowserViewModel	src/browsermodel.* (QML singleton)
sidebar OutlineGroup tree	src/model/filetreemodel.* (QAbstractItemModel)
UI/Theme / ContentView / HUD / sidebar	qml/Theme.qml, qml/ui/*.qml

Platform substitutions: NSWorkspace.open → KIO::OpenUrlJob; "Reveal in Finder" → KIO::highlightInFileManager (Dolphin); Quick Look → a lightweight in-app preview; SF Symbols → Breeze icon theme; macOS sandbox/bookmarks → dropped.

Project layout

kfsn/
├── src/
│   ├── main.cpp
│   ├── browsermodel.*        # navigation, level stack, selection, KIO actions (QML singleton)
│   ├── filekind.*            # file-type taxonomy → Breeze icon names + scene colors
│   ├── model/
│   │   ├── filesystemnode.*      # tree node
│   │   ├── filesystemscanner.*   # async directory scanner
│   │   └── filetreemodel.*       # QAbstractItemModel for the sidebar
│   └── scene/
│       ├── scenebuilder.*        # grid layout → SceneItem/SceneLevel data
│       ├── sceneitem.* / scenelevel.*
│       ├── flycamera.*           # WASD/look/scroll fly camera
│       └── textureprovider.*     # label + icon glyph textures
└── qml/
    ├── Main.qml  Theme.qml
    ├── scene/Scene3D.qml         # View3D, lights, level stack, picking, spotlight
    └── ui/                       # Sidebar, TopBar, Breadcrumbs, MetadataHud, PreviewPopup, EmptyState

Requirements

A Linux desktop with KDE Frameworks 6 (KIO and the Breeze icon theme are required at runtime — in-scene glyphs and file actions resolve through them; there is no macOS fallback). KF6 is a hard find_package dependency, so configuring will fail fast without it.

• Qt 6.6+ with Qt Quick 3D (Core, Gui, Qml, Quick, Quick3D, Concurrent)
• KDE Frameworks 6: CoreAddons, KIO, IconThemes, Config, I18n, GuiAddons
• extra-cmake-modules, a C++20 compiler, CMake 3.21+, Ninja

Building

cmake -B build -G Ninja -DCMAKE_BUILD_TYPE=Release
cmake --build build

Note: if your system's default qmake is Qt 5, the CMake config pins QT_DEFAULT_MAJOR_VERSION=6 so ECM targets Qt 6.

Installing

cmake --install installs the binary and the .desktop file. Installing the desktop entry also resolves the harmless xdg-desktop-portal "App info not found" warning you'll see when running straight from build/.

cmake --install build --prefix ~/.local   # → ~/.local/bin/kfsn + applications entry
# or system-wide:
sudo cmake --install build --prefix /usr/local

Developing (Qt Creator / IDEs)

The project is a plain CMake project with CMakePresets.json, so it opens cleanly in any CMake-aware IDE.

• Qt Creator — File → Open File or Project… and pick CMakeLists.txt. Qt Creator imports the debug / release presets automatically; pick a kit and build/run. QML completion works from the generated module types.
• VS Code / clangd / others — configuring (or building) writes build/compile_commands.json for the C++ code model. Point clangd at it (or symlink it to the project root).

cmake --preset debug && cmake --build --preset debug

Running

./build/kfsn            # opens the empty state; pick a folder
./build/kfsn ~/Projects # open a folder directly

Keyboard & mouse

Action	Binding
Move / strafe	W A S D or arrow keys
Altitude	E (up) / Q (down)
Speed boost	hold Shift
Look around	drag
Dolly	scroll
Select / enter	click
Open file / descend folder	double-click

Port progress

• Model layer (taxonomy, tree, async scanner)
• Layout engine (SceneBuilder → SceneItem/SceneLevel)
• 3D scene: levels, floors, slabs, platforms, labels, icon glyphs
• Fly camera + overview framing
• Picking, hover, selection, descent, level stack, back navigation
• Age / type coloring (in-place recolor)
• KIO open / reveal, copy path
• FSN selection spotlight + corona + volumetric cone
• In-place subfolder focus (label items without re-rooting)
• UI shell: sidebar tree, top bar, breadcrumbs, metadata HUD, color toggle
• In-app Quick Look preview popup
• App icon (scalable SVG + hicolor PNG sizes) and cmake --install
• Distro packaging (Flatpak / AUR)

Acknowledgements

Inspired by Silicon Graphics' fsn (1992) and its Jurassic Park cameo, and by the macOS neofsn. Independent reimplementation, not affiliated with SGI.

License

BSD 2-Clause (matching neofsn).