Search NTFS at machine speed.

UFFS is a benchmark-driven NTFS search engine for Windows, built in Rust. It reads the Master File Table directly, builds a compact persisted index, and keeps large NTFS estates searchable through a warm daemon — with one engine behind CLI, TUI, API, and MCP.

Rust-native Open source · MPL-2.0 100.4M-record scale-tested Direct MFT read MCP-ready

Download for Windows See the benchmarks Star on GitHub

30 / 30

head-to-head cells faster than Everything (p50, drives C+D+F+G + combined)

median 0.36× · ~2.8× faster · v0.5.120

0–3 ms

daemon-side latency for targeted queries at 26M records

17–96 ms CLI end-to-end · v0.5.120

68.5 s

cold build: raw MFT read + compact index, all 7 drives (25.9M)

5.7 s warm-cache restart · v0.5.71

100.4M

records scale-ceiling tested with offline MFT clones

v0.5.4 synthetic data

Every number is version-stamped and backed by a raw log. Full methodology, per-drive tables, and the two workloads UFFS is currently slower on are published in the benchmark hub.

What it is

A specialist retrieval engine, not a file-manager add-on

Windows search is often too slow, too fuzzy, or too opaque for power users, developers, and large NTFS estates. UFFS is built for exact filename, path, and metadata search at scales where directory walking and shell search become the bottleneck.

Direct MFT reading

Reads the NTFS Master File Table directly instead of crawling the filesystem tree.

Compact persisted index

Builds once, serializes a compact index, and restarts warm from cache in seconds.

Warm / hot daemon

A background daemon keeps the index hot so targeted queries answer in single-digit milliseconds.

See it in action

Real binary, real drives, real timings

Every clip runs the actual UFFS binary against real NTFS data with unedited timings and result counts — captured with the reproducible demo kit.

UFFS TUI: unzip, run uffs-tui, and browse your real NTFS drives against a hot daemon in seconds. — **TUI** — unzip, run `uffs-tui`, and browse your own drives in seconds against a hot daemon.

UFFS CLI: real searches, filters, and aggregations across 25.9M indexed files with measured latency. — **CLI** — real searches, filters, and aggregations across 25.9M+ indexed files with measured latency.

Claude using the UFFS MCP server to find the largest files untouched in over a year — 26M+ records scanned in under 200 ms on a hot daemon, one tool call. — **MCP** — one question to Claude, one UFFS tool call: 26M+ records scanned in under 200 ms (hot daemon), with the measured query time cited in the reply. Deterministic search underneath, MCP on top.

Proof first

Benchmarked honestly against Everything — and against its own C++ reference

Measured on a real 7-drive, 26M-record Windows 11 system (AMD Ryzen 9 3900XT, 64 GB RAM). Cold build, warm restart, and hot query are three different workloads — we measure and publish them separately instead of averaging them into one "startup time" number.

UFFS wins 30 of 30 head-to-head cells against Everything at p50 — 30/30 head-to-head cells faster than Everything at p50 (six pattern classes, drives C+D+F+G + combined). Median ratio 0.36× — every cell published in the April snapshot improved, median −33%. v0.5.120.

UFFS Rust cold start is 2.6x faster than the C++ reference warm-disk read — UFFS cold-builds a 26M-record index (177.4 s) faster than the C++ reference reads the same MFTs warm (457.2 s) — 2.6× faster, while also building the persistent index. (v0.5.66 capture.)

Daemon HOT vs per-invocation MFT reread: UFFS wins 5 of 5 full-scan cells — Full-scan export, daemon HOT vs the C++ reference's per-invocation MFT re-read: 5/5 cells faster (6.6× on the combined four-drive run; targeted queries are 180×–3,400× faster, and the combined regex cell never finished). v0.5.120.

UFFS daemon memory scales linearly at about 181 MB per million records — Daemon memory scales linearly at ~181 MB per million records — predictable footprint as estates grow.

Full-scan export: 23.3M records to CSV in 12.0s at 1.95M records per second

Bulk path: full-scan export of the complete 7-drive estate — 23.3M records to CSV in 12.0 s (≈1.95M records/sec end-to-end through the daemon pipe; per-drive peaks of 2.29M rec/s). v0.5.120.

What we do not claim. UFFS is not "the fastest file search on Windows" in every workload. The benchmark hub names two workloads (* top-100 and --sort path) where the current build is slower than its own v0.5.4 baseline, with root causes and tracking. Publishing the regressions is part of the product.

Read the full report Fairness methodology

Architecture

Cold, warm, hot — one Rust engine, many interfaces

COLD

Raw MFT read, parse, build the compact index, write the cache. The source of truth.

WARM

Daemon restarts from the serialized cache in seconds — no re-read of the drive required.

HOT

The index is resident in the daemon; targeted queries answer from memory in 0–3 ms.

The same Rust core powers every surface — so humans, scripts, and AI agents all query one engine:

CLI — scriptable, exact filename / path / metadata search with 40+ filters.
TUI — interactive terminal UI for live exploration.
API / daemon — a warm background service for low-latency repeated queries.
MCP — exposes deterministic local retrieval as tools for AI agents, with explicit, human-controlled actions.

Install

Up and running in under a minute

Windows one-command install via WinGet:

# Windows Package Manager
winget install SkyLLC.UFFS

Or download pre-built binaries directly — each release ships a CHECKSUMS.txt (SHA256), per-crate SBOMs (CycloneDX), and SLSA build-provenance attestations. No build toolchain needed.

Windows x64

CLI + daemon + MCP + MFT tools. Full live-NTFS support. Recommended.

macOS (Apple Silicon)

Offline MFT analysis. Includes the UFFS.app bundle.

Linux x64

Offline MFT analysis. Includes install.sh.

Latest release User manual

Key differentiators

Why a specialist engine?

vs. Explorer / Windows Search

Deterministic exact match — no fuzzy ranking guesswork.
Searches whole NTFS estates, not just indexed locations.
Single-digit-ms targeted queries from the warm daemon.

vs. the UFFS C++ reference

2.6× faster cold build while also persisting the index.
180×–3,400× faster on targeted queries; 6.6× on full-scan export (v0.5.120).
Memory safety without a GC — Rust ownership + borrow checker.

Open source, forever

Support the engine

The UFFS platform — engine, daemon, CLI, and MCP server — is MPL-2.0 and will never be made less open. No telemetry, no accounts, no outbound network calls — UFFS runs entirely on your machine. If it saves you time, sponsorship funds a custom domain, code signing, and continued benchmark work.

Open Collective Ko-fi GitHub repo