The native PoC, against Redis.

16 requests per batch, same city_5km queries. Latency here is for a complete batch, not an individual request.

• SQLite FULL: 6,910 requests/sec; batch p95 4.002 ms.
• Redis (no persistence): 363 requests/sec; batch p95 47.790 ms.

Four reader connections and one writer connection; 250 requests per client. Updates change points in the queried collection. The PoC dispatches commands serially in one process. Values include client scheduling and queueing.

200 transactions per case, changing coordinates in a separate 1,000-member collection. Batch construction is excluded from transaction latency and included in throughput.

• Initial load: 121.03 seconds; 8,262 points/sec. Includes synthetic generation, FULL commits in 1,000-point batches, and final checkpoint.
• Database after native update tests: 208.0 MiB.
• Native benchmark process peak RSS: 83.6 MiB; this includes ingestion and all methods.

200 shared queries; 0 top-20 membership differences. Maximum distance difference among common members: 0.301 m. Redis quantizes coordinates; the PoC preserves input doubles. Independent Haversine correctness tests are separate from this cross-check.

• Reproducible synthetic dataset: 80% clustered around eight cities, 20% broadly distributed; seed 20260916. Not production traffic.
• Native baselines share query prefixes. Best-first has 2,000 samples by default, bounding-cube 200, full scan 20; p99 from 20 samples is descriptive, not a reliable tail estimate.
• Native and TCP workloads use different PRNG implementations. Both TCP engines receive identical commands and exact same source coordinates. Compare within each section.
• Warm cache measurements; no result cache. Process/OS cold starts and sustained saturation are not measured. The full database need not fit in SQLite's configured cache.
• TCP includes the identical Python client's encoding, socket I/O, and response decoding; this is end-to-end observed throughput, not maximum server capacity.
• Redis read-only comparisons disable AOF and snapshots. SQLite remains disk-backed. Read results do not establish equivalent write durability.
• On macOS, Redis AOF always uses F_FULLFSYNC; SQLite FULL uses ordinary fsync by default. Those default rows are NOT equivalent durability comparisons. The separately measured SQLite FULL + F_FULLFSYNC row, when present, enables fullfsync and checkpoint_fullfsync for the closer comparison. Neither is a hardware power-failure certification.
• SQLite NORMAL can lose recent acknowledged writes after power loss. SIGKILL recovery was tested with FULL; actual power loss was not simulated.
• Nearest 20 allows early stopping. Large returned result sets, polygons, arbitrary metadata filters, multiple hosts, and huge numbers of collections are outside this benchmark.
• No CPU affinity, isolated machine, repeated-run confidence intervals, or open-loop arrival generator. Other applications and coordinated omission can affect the tails.

Raw timings and environment: benchmark.json and native.json beside this report.

Completed on 2026-09-16 with Apple clang 17, SQLite 3.51.3 and Redis 8.2.9.

• make test: passed native and RESP2 integration suites.
• Native correctness: 127 independent Haversine-oracle queries against each of three search implementations, over 12,004 points; date line, poles, boundaries, zero radius, ties, invalid-batch atomicity, updates/deletes and namespace isolation.
• Concurrent WAL test: a writer atomically moved 100 points while another connection searched them. Readers observed complete before/after snapshots.
• RESP2 tests: fragments, binary strings, pipelines, malformed requests, eight simultaneous clients and restart after SIGKILL with acknowledged FULL writes.
• AddressSanitizer and UndefinedBehaviorSanitizer: native suite passed.
• Full million-point run: SQLite integrity_check, R*Tree rtreecheck and point/index membership checks passed.
• Redis cross-check: 200 queries, zero top-20 membership differences; maximum reported distance difference for common members was 0.301 m.
• Result validation: all 12 native cases, 10 TCP/pipeline cases and four mixed traffic configurations present; percentile ordering checked.
• Dedicated macOS F_FULLFSYNC measurement added after verifying that Redis uses this stronger flush primitive. Its source fingerprints and timestamp are in benchmark.json; no spatial search logic changed for this supplement.

No benchmark service is left running. Native and TCP measurements are different measurement layers; only compare equivalent rows. Power-failure behavior and production readiness are not established by these tests.