measured before it is marketed.
filtered vector search is often described as a database problem long before anyone measures the work a real query does. qenlo starts with the measurement: an embedded rust prototype testing if exact gpu search beats cpu by 2× at p95, with the actual adapter named in every run.
the question
Filtered vector search is often described as a database problem long before anyone measures the work a real query does. Qenlo starts with the measurement.
It is a Rust research prototype for native applications that embed dense-vector search directly in the client. The engine indexes pre-computed embeddings; it does not generate them, transform tensors, or run neural inference. Those belong to the runtime that produced the vectors.
The current bet is narrow: on a repeatable 1m × 768, 1%-eligible, batch-1, k=10 workload, can an exact GPU path beat the strongest qualifying CPU path by 2× at P95 without giving up recall or correct filtering? Until that run exists, GPU acceleration is an experiment, not a claim.
what’s in here
A modular workspace partitioned strictly by responsibility. The baseline is deliberately plain: portable exact CPU search with no C++ or GPU build requirement.
Canonical records, unit-normalized float32 vectors, BTree-indexed predicate filtering (user_id, timestamp), and exact cosine search with deterministic ID tie-breaking.
Async embedded collection API, ExecutionReport telemetry, durable snapshot serialization with tombstone tracking, and optional USearch & wgpu acceleration backends.
Independent float64 correctness oracle, nearest-rank P95/P99 latency calculations, synthetic metadata distributions, and OpenTelemetry HTTP/protobuf export examples.
Claude Code-style terminal browser, embedded zero-dependency local Web UI, and Tauri v2 desktop application for visual inspection and vector query testing.
qenloDB browser
Radical transparency for vector collections. Inspect canonical rows, tombstones, and WAL compaction across TUI, Web, and Desktop interfaces.
Interactive terminal application with vim navigation (j/k, Enter), compound filters, similarity score meters (████████░░ 0.9541), and Claude Code command prompt (:open, :search, :flush).
Zero-dependency single-page application served directly from the compiled binary. Browse records, test query vectors interactively, and inspect on-disk .qdb, .wal, and HEAD files.
Cross-platform native desktop GUI in apps/desktop with OS folder dialogs, native window chrome, and direct connection to the underlying Rust storage engine.
execution paths & telemetry
Optional backends are explicit because a feature flag should tell the truth about the toolchain it brings along.
| Path | Algorithm | Filter Execution | Intent & Toolchain |
|---|---|---|---|
CPU (default) |
Exact cosine | Ordered metadata indexes | Correctness baseline · zero external C++/GPU dependencies |
usearch |
HNSW | Graph predicate | Approximate comparison · requires C++ compiler / toolchain |
gpu-wgpu |
Exact cosine | CPU mask, eligible rows, or GPU predicate | Acceleration research · requires native Vulkan/DX12/Metal driver |
Every search returns an ExecutionReport: requested and actual backend, algorithm, filtering path, rebuild state, phase timings, transfer sizes, and a fallback reason where one exists. That is there so a fast-looking result has to explain itself.
pub struct ExecutionReport {
pub requested_backend: BackendSelection,
pub actual_backend: BackendKind,
pub algorithm: Algorithm,
pub filter_execution: FilterExecution,
pub index_generation: u64,
pub rebuilt: bool,
pub fallback_reason: Option<String>,
pub total_duration: Duration,
pub phases: PhaseTimings, // preparation, upload, dispatch, execution, readback, selection
pub upload_bytes: Measurement<u64>,
pub readback_bytes: Measurement<u64>,
pub dispatch_count: Measurement<u32>,
pub qenlo_allocation_bytes: Measurement<u64>,
pub candidates: Measurement<u64>,
pub results: usize,
}research status
Current milestone records what has been built, measured, and still needs a larger machine before it can be evaluated.
| Area | Current State | Notes |
|---|---|---|
| Exact CPU search & metadata filtering | Implemented & Tested | Deterministic tie-breaking, BTree range scans |
| USearch filtered ANN path | Implemented | Windows toolchain workaround documented |
wgpu device smoke tests |
Implemented & Tested | Vulkan & DX12 compute dispatch |
| Dataset preparation & competitor benchmarks | 100k × 384 Measured | DTU AG News vectors; USearch and native Chroma replay retained |
| 2× P95 gate evaluation | 1m × 768 Untested | 100k × 384 RTX 4050 GPU predicate: 5.14× vs Qenlo exact CPU; gate still open |
| Native runtime acceptance | Windows DX12/Vulkan | RTX 4050 plus Intel UHD hybrid host, and a separate Intel Arc Vulkan quick/soak submission |
get running
You need the Rust toolchain declared in rust-toolchain.toml. Clone the repository and run the portable suite:
git clone https://github.com/a3ro-dev/qenlo.git
cd qenlo
cargo test --workspace --no-default-featuresBuild the optional paths only when you are ready for their dependencies. On a hybrid machine, check the reported adapter after a GPU run; this host has Intel UHD Graphics and NVIDIA GeForce RTX 4050 Laptop GPU, and the retained measurements use the NVIDIA discrete adapter.
# wgpu exact-search path
cargo test -p qenlo --features gpu-wgpu
# USearch / C++ path
cargo test -p qenlo --features usearch
# benchmark crate and OTLP example
cargo check -p qenlo-bench --all-features --examplesOn Windows, if MSVC 14.29 crashes in USearch's numkong dependency, clang-cl is a verified local workaround:
$env:CC = 'clang-cl'
$env:CXX = 'clang-cl'
cargo test -p qenlo --features usearch