sparqlite is a Rust loadable extension that gives SQLite a native SPARQL 1.1 engine over RDF quads, and it is worth ten minutes of your attention for two separate reasons: it removes a database server from a local graph stack, and it is one of the clearest public examples of what a long-running coding agent actually produces when nobody is watching.
Key facts
| Fact | Detail |
|---|---|
| Question answered | sparqlite: A Rust Extension That Runs SPARQL 1.1 Inside SQLite |
| Short answer | sparqlite is a Rust loadable extension that keeps RDF quads in ordinary SQLite tables and executes SPARQL 1.1 in-process, reporting 3.5x speedups over SQL translation and 636 of 639 applicable W3C tests. |
| Reading time | ~3 min |
| Last updated | 2026-10-22 |
What it does
The extension keeps RDF quads in ordinary SQLite tables. Queries and updates are executed natively inside the SQLite process instead of being rewritten into SQL and handed back to the query planner. The published description lists integer-encoded terms, covering indexes, a cost-based planner, batched joins, and an optional reader that hits SQLite B-trees directly (source).
The reported numbers are specific: 3.5x faster than SQL translation in count mode, 2.8x faster when returning full results, and 636 of 639 applicable W3C evaluation tests passing, plus millions of differential-fuzz comparisons.
Those are the author’s measurements on the author’s workloads. They are a credible signal that the architecture is not a toy, not a guarantee that your query shapes will see the same multiple. If you are evaluating it, benchmark your own triple patterns rather than the demo dataset.
The part that is actually new
The extension itself is a solid piece of engineering. The interesting part is how it was made. Simon Willison describes the work as an experiment in running Claude Code for web in “Ultracode” mode, where the agent generates JavaScript that coordinates a network of subagents. His initial prompt contained a typo: he meant “hit the rows directly” and wrote “delete rows directly” on his phone.
That prompt kept the agent running for more than 12 hours. He checked in the next day, noticed how many Rust crates had appeared, and sent one follow-up: every crate needs a README, plus a tutorial covering installation, CLI usage, SPARQL basics and a script that populates a realistic example database.
The agent did that too. The result is a full SPARQL implementation in Rust inside SQLite, produced on a whim, with documentation.
What the author says about it
The write-up is unusually honest about the limits, and the honesty is the useful part. Willison’s own summary is that the project “feels like next-level vibe coding”, that it is “not remotely feasible to review the code that was produced here”, and that following the documentation is already a significant investment of work. He ends by asking what the artifact is worth if he created it on a whim and will not invest the time to understand what it can do.
That is the correct question, and it applies to every long-horizon agent run, not just this one. Output volume is not output value. An agent that spends 12 hours and 40 crates produces something that looks finished long before anyone has verified it.
What to take away if you run agents locally
Three practical points.
- Scope the review, not the run. Before starting a multi-hour task, decide what you will actually inspect afterwards. If the answer is “all of it”, the task is too large. If the answer is “the tests and the public interface”, say so up front and have the agent write those first.
- Demand the tutorial. Asking for documentation and a runnable example dataset was a single follow-up prompt and it changed the deliverable from unreviewable source into something a stranger can evaluate. That is a cheap instruction with a high return.
- Keep the runtime local where you can. A loadable SQLite extension is a good shape for desktop tooling precisely because there is no service to deploy, no port to open, and no separate credential store. If your agent stack already depends on SQLite, a graph layer that loads in-process is one less moving part on a Windows machine.
If you want an agent that operates the desktop itself rather than just writing code, that is a different tool: you can download MOOGH and point it at the apps and files you already use.
The bottom line
sparqlite is a legitimate SPARQL 1.1 engine for SQLite with credible performance claims and near-complete W3C conformance, produced in a single unattended agent run. Use it if you need graph queries next to relational data without standing up a server. Read the write-up if you care about what agent-generated code costs to own, because the author’s discomfort is the most transferable finding in it.
Related reading: