Loading...
Loading...
Developers are reimagining web apps as fully local backends by combining WebAssembly, in-browser SQLite with OPFS, and compact on-disk formats like finite state transducers. One approach compiles server code (e.g., Go) to WASM and uses SQLite stored in the browser’s Origin Private File System to expose a local HTTP API, enabling offline, privacy-preserving apps without cloud servers or accounts. Complementing this, projects replacing multi-gigabyte SQLite datasets with tiny FST binaries demonstrate how compact, read-optimized data structures can deliver fast prefix search and make single-file, offline executables practical. Together these trends favor client-only delivery, lower infrastructure costs, and new tradeoffs around browser limits and cross-device sync.
These developments show web apps can move full backend functionality into the browser, reducing server costs and improving privacy and offline capability. Tech professionals must rethink data storage, delivery, and sync strategies for client-only architectures.
Dossier last updated: 2026-05-10 15:01:09
Simon Willison quoted Andrew Quinn on May 10, 2026: Quinn argues that developers shouldn’t be paralyzed by discovering existing tools that solve problems they’re tackling. Instead, he recommends reinventing a modest number of “wheels” — enough (perhaps 4–5, or more in rigorous fields) to reach the frontier of knowledge — because hands-on experimentation and targeted questioning accelerate learning more than passive study. The quote came from Quinn’s footnote on a post about replacing a 3 GB SQLite database with a 10 MB finite state transducer (FST) binary. This perspective matters to engineers, startups, and open-source contributors weighing build vs. buy decisions and exploring performance-focused tooling.
A developer replaced a 3 GB SQLite database of word forms and metadata with a 7–10 MB finite-state transducer (FST) binary, dramatically shrinking storage and speeding lookups. The post links to a write-up demonstrating how FSTs compactly encode large vocabularies and associated data by sharing prefixes and using efficient serialization, yielding faster queries and reduced memory use. This matters for search, NLP, mobile apps, and other systems where large lexicons or mapping tables are bottlenecks, enabling lower disk, RAM, and indexing overhead. The technique highlights trade-offs—build complexity and tooling versus runtime efficiency—and points to FST libraries and serialization formats as practical alternatives to heavy SQL-based storage for static key-value datasets.
Replacing a 3 GB SQLite database with a 10 MB FST (finite state transducer) binary
A developer argues that WebAssembly (WASM) and in-browser SQLite change the SaaS model by letting full backends run inside the browser, avoiding remote servers and user accounts. The piece describes compiling server-side code (in Go or other languages) to WASM, using SQLite with the browser OPFS for persistent storage, and exposing a local HTTP API within the tab so traditional apps run unchanged. Key benefits: offline functionality, privacy, lower infrastructure costs, and simplified deployment. The approach could shift many single-user productivity apps from cloud-hosted services to client-only binaries delivered via the web, though tradeoffs include browser limits, security boundaries, and synchronization for multi-device use.
A developer replaced a 3 GB SQLite database used by a Finnish-English incremental search tool (Taskusanakirja, tsk) with a 10 MB finite state transducer (FST) binary to enable compact, fast prefix search and ship a single static executable. The author explains that tries worked initially but ballooned due to Finnish’s agglutinative morphology; by converting the dataset into a compact, static FST tailored for prefix lookup and limiting match counts plus memoizing short prefixes, they achieved roughly a 300x reduction in storage while retaining instant autocomplete performance. This matters for developers building offline language tools or any app that needs tiny, fast lookup structures embedded in single binaries. Key players: the tsk project and the FST approach.