The graph database that actually scales to zero.

Nothing runs until you ask it to.

A point lookup runs right inside the service, so there's no worker to spin up and no cluster sitting on standby waiting for you to show up. You're billed for the query itself, and the moment it's answered the compute behind it disappears. Your data doesn't go anywhere; it's still sitting in storage where you left it. The compute is what stops.

Most managed graph databases still bill you a floor even on the days nobody queries them, and the best workaround anyone's found is pausing your cluster so you're paying a smaller floor instead of a bigger one. Leyline skips the floor entirely. A query shows up, runs, and once it's done there's nothing left to pay for.

A terabyte scan that finishes in seconds.

A point lookup doesn't need a fleet, but a scan across a graph that size does, and Leyline spins one up on its own, runs the scan, and tears it back down before you'd have finished provisioning a cluster anywhere else. Hundreds of workers pick up pieces of the same scan at once, so a query that would take a single machine hours finishes in seconds.

You never size that fleet or provision it yourself, and you don't keep paying for it once the answer comes back. It exists because the query needed it, does the work, and disappears again. What's left is the answer, not a cluster you now have to remember to shut down.

One engine, not two products.

Everywhere else, transactional graph and analytical graph ship as separate products with separate prices and a pipeline connecting them; AWS sells Neptune Database and Neptune Analytics as different things and expects you to keep your data in both. Leyline runs as one engine, so a write, a point lookup, and a terabyte aggregate all move through the same system, the same Cypher, and the same copy of your data.

Writes commit in batches at write-ahead durability, built for around a thousand per second per graph with room to grow to ten times that. This isn't a store you load once overnight. The same planner that answers a point lookup also tiers a scan to the fleet above. One engine decides where the work goes.

Built in Rust, just for you.

Serverless means something has to start before it can answer, so the job is to make that something as small as possible. Rust compiles to a machine-native binary: there's no runtime to boot and no JIT waiting to warm up, which is about as short as a cold start gets. A JVM would still be getting ready. Ours is already reading.

And it's Rust the whole way down, not just the hot path. The engine, the importer, compaction, index builds, the fleet workers, and the web service answering your requests are all the same language, so nothing hands off to something slower halfway through.

V3 is still taking shape.

The storage format, the planner, and the fleet protocol are designed but not yet shipped, including an adversarial review that caught the design's own latency budget spending itself twice over before anything got built on top of it. It's written analytics-first, because that's the half that needed redesigning.

It runs today at the scale we run it at: tens of gigabytes, hundreds of millions of edges, measured rather than estimated. A terabyte is what the design is built around and what the fleet protocol exists for, but we haven't stood one up yet. Take that number as where this is going, not where it is.

The transactional half described above already works. The source isn't public yet; when it is, this page will say so. Until then, the architecture itself is documented at the link below, including the parts that don't exist yet.