bertbrowser

A very fast and memory efficient Windows file browser. Written in Rust, with a custom rendering layer in C++.

• Instant global search - MFT indexing and USN journal tracking for fastest possible performance.
• Directory sizes — Show total size on directories, just like files.
• Split panes with tabs - Infinite pane splitting and tabs per pane.
• Tree Map browser by filesize - Visualize recursive directory sizes, easily find whats taking the most space.
• Rich Preview Panel - Inline media playback, syntax highlighting in text, hex viewer
• Tools - Find duplicates, compare files and directories, track file system changes, and more!
• Customizable - Customizable command palette, menus, toolbars, browser columns, context menus, themes; saved workspaces and searches.

Install

winget install RobWalsh.BertBrowser

• Or grab the latest installer and run it.
• Or download the latest portable executable if you'd rather not install anything.

Windows 10/11, x64. Nothing else to install: the app is native, with no .NET runtime and no Visual C++ redistributable.

Unstable

The latest code in main, rebuilt and published on every push. It gets the same test suite a release gets and none of the settling time.

• Grab the unstable installer, or the unstable portable build.

It replaces an installed copy rather than sitting beside it, and from then on that copy updates along unstable instead of along releases. Help ▸ About says which you are on, as does the taskbar — BertBrowser 2.0.1-unstable.42 against BertBrowser 2.0.0. Your data in %USERPROFILE%\.bertbrowser is untouched either way, and running the stable installer over the top puts you back.

Building and running

Needs Visual Studio 2022 with the Desktop development with C++ workload, Rust stable (x86_64-pc-windows-msvc) and cargo install cbindgen.

git clone https://github.com/robgwalsh/bertbrowser.git
cd bertbrowser

pwsh .\build.ps1                  # build (add -Config release for a release build)
cargo test --workspace            # run the Rust tests

build.ps1 enters the Visual Studio developer shell, then configures and builds the CMake preset; the build itself runs cargo build -p bb-ffi -p bb-indexer -p bb-elevator and cbindgen, so the C++ side always links the current Rust code. The header include/bbcore.h is generated and committed.

Warnings are errors on both sides (clippy -D warnings, MSVC /W4 /WX), so a clean build is a warning-free build. The app lands in out\<config>\app\BertBrowser.exe.

See docs/build-and-release.md for packaging, the tag-driven release workflow, and how updates reach installed copies.

Testing the interface

harness/ builds bb-harness.exe, which allows testing BertBrowser in a headless way: it links the app's own UI library and Rust core, shows the real main window parked outside every monitor and refused activation, then drives it with a small script language and captures it through Direct2D on the WARP software rasteriser - so being offscreen and covered costs nothing.

$harness = "out\debug\harness\bb-harness.exe"

& $harness --script tools\ui\smoke.bbs --out $env:TEMP\look-1     # browse, search, move, rename, delete, undo
& $harness --script tools\ui\themes.bbs --out $env:TEMP\look-2    # every built-in theme, and the dialogs
& $harness --script tools\ui\tree.bbs --out $env:TEMP\look-3 --sandbox C:\Source\treecheck --allow-outside
& $harness -c "tree .; refresh; shot look" --out $env:TEMP\look-4 # ad hoc; prints the PNG path
& $harness --help

Each run gets a throwaway fixture tree and its own scratch data directory (BERTBROWSER_DATA_DIR), so it never touches your real index, settings or themes. It starts no programs, never touches the clipboard, and refuses to write outside its sandbox — the harness drives the real transfer, rename and delete executors, not stubs.

Benchmarking

bb-bench (src/crates/bb-bench) benchmarks the core, whole UI scenarios and startup. Results are compared against a committed per-machine baseline, CI gates allocations on every push, and docs/performance.md is generated from the baselines. See bench/README.md.

$bench = "target\release\bb-bench.exe"
& $bench run --filter *fsindex*          # a core area
& $bench ui --scenario listing-10k       # a UI scenario, five fresh processes
& $bench compare --baseline bench\baselines\<key>.json --current bench-results\current.json

Data locations

What	Where
Size-cache + search-index database	%USERPROFILE%\.bertbrowser\bertbrowser.db
Window/session settings	%USERPROFILE%\.bertbrowser\settings.json

Delete the folder to reset the app completely. Data left by the 1.x (C#) versions is moved into %USERPROFILE%\.bertbrowser\legacy-<date>\ on the first 2.x launch, never deleted.

Project layout

• src/crates/ — the Rust core: bb-paths (path keys), bb-core (everything testable and UI-free: SQLite persistence, search, executors, undo, metadata, archives), bb-shell (shell/registry/COM services), bb-app (orchestration), bb-ffi (the C ABI), the two elevated helpers bb-indexer and bb-elevator, and bb-bench (the benchmark driver). bb-ffi is the bbcore staticlib that cbindgen reads; bb-ffi-harness is the same ABI plus test fixtures, used by the harness only.
• src/app/ — the C++20 Win32 + Direct2D/DirectWrite UI, custom-drawn: a static library bbapp plus BertBrowser.exe (WinMain only).
• harness/ — the offscreen UI harness; tools/ui/*.bbs are its scripts.
• bench/, docs/ — benchmark baselines and notes; design and build documents.
• tools/ — ui/ harness scripts, icons/ (the icon pipeline), parity/ (diffs the C# test suite against the Rust one), and the version, staging and harness-runner scripts CI uses.
• The frozen C#/WPF app of the 1.x releases lives in the separate private bertbrowser-csharp-archive repository, kept as a behavioural reference. Not built or shipped.

See CLAUDE.md for a deeper architecture walkthrough (path-key invariants, the FFI rules, the size-scan algorithm).

License

MIT. Third-party components are listed in THIRD-PARTY-NOTICES.md.