Tessera runs your WebAssembly modules in 300 cities on a runtime that starts from a memory snapshot — microseconds, not seconds. No containers to keep warm, no regions to choose, no cold-start tax on the first request of the day. You push a .wasm file; we put it 12 milliseconds from every user on Earth.
$ tessera deploy ./router.wasm
↑ uploaded 1.2 MB · sha256 verified
↑ AOT-compiled to native · 41 ms
↑ snapshotted · replicated to 300 PoPs
✓ live in 300 cities · 4.6 s
→ https://router.tessera.run
cold start p50 0.8ms p99 3.1ms
invocations 41.2M / min across 300 PoPsRunning in production at engineering teams that count milliseconds
Most edge platforms hand you a stripped-down language and a list of things you cannot do. Tessera runs the full WebAssembly System Interface — threads, sockets, filesystem, clocks — so the binary that runs on your laptop runs unchanged in Frankfurt.
Every module is ahead-of-time compiled to native machine code and snapshotted to a memory image. A new instance restores from that image in under a millisecond — no JIT warmup, no container scheduling, no penalty on the first request of the day. The first user sees the same latency as the millionth.
Sockets, filesystem, clocks, random, and threads — the complete system interface. If your code compiles to WebAssembly, it runs on Tessera without a proprietary shim or a rewritten standard library.
Rust, Go, C, C++, Zig, Swift, AssemblyScript — and Python or JavaScript via component builds. You compile to .wasm; we run it. No per-language runtime to pin a version of and maintain.
Each module receives exactly the capabilities you grant it and nothing else. No ambient access to the host, no shared memory between tenants — isolation enforced at the WebAssembly boundary by the runtime, not by a shared OS process.
Same input, same output, in every PoP. A module that passes on your laptop behaves identically in production, which makes edge code something you can actually test before you ship it.
Measured across the network, under production load
Tessera is a runtime, but it ships like a product. One CLI, one config file checked into your repo, and a console that shows what every module is doing in every city — observability that does not stop at the region boundary.
tessera deploy pushes your module to all 300 cities atomically, in seconds. Roll forward, roll back, or pin a version per region from a single config file in version control.
Every request returns a trace with CPU time, peak memory, and the exact PoP that served it. Find the one slow city before a user files the ticket.
Every deploy is content-addressed and immutable. Roll back to any prior version across the whole network in under a second — no rebuild, no re-upload, no pipeline to wait on.
tessera dev runs the exact production runtime on your machine — same isolation, same WASI surface, same CPU and memory limits. What you debug locally is byte-for-byte what runs at the edge.
When compute lives 12 milliseconds from the user and starts instantly, whole categories of backend work move off your origin and onto the network.
Auth, A/B splits, header rewrites, geo-routing, and rate limits — running at the first hop, before a request ever reaches your origin, in microseconds, in code you control.
Render the right page variant, inject the correct currency, or assemble a feed from edge-cached data with no round trip to a central region. The user sees their version on the first byte.
Tokenize, validate, and batch requests at the edge before they reach an expensive model. Drop the malformed ones, cache the repeats, and trim the origin GPU bill at the door.
Stand up an entire JSON API as a WebAssembly module backed by an edge key-value store. No servers to scale, no region to lose — it lives on the network and starts cold in under a millisecond.
“We were paying for warm containers in five regions just to dodge cold starts. We moved the router to Tessera, deleted the warming cron, and p99 fell from 240ms to 14ms. The runtime simply has no cold-start problem to engineer around.”
“Full WASI was the deciding factor. Every other platform made us rewrite our crypto library against their sandbox. Tessera ran our existing Rust binary unchanged on the first try — that alone gave us back a quarter of roadmap.”
“Production parity sold the team. tessera dev runs the same runtime as the edge, so debugging stopped being guesswork. We catch the PoP-specific bugs on a laptop now, not in an incident channel at 2am.”
Billed per millisecond of execution and per million requests. Nothing for idle time, nothing per region, no minimum spend to reach all 300 cities.
For side projects and prototypes.
For production workloads that scale.
For high-volume and regulated edges.
Every module is ahead-of-time compiled to native code and captured as a memory snapshot. Starting an instance restores that snapshot — there is no language runtime to boot, no JIT to warm, and no container to schedule. Across the network the p50 is 0.8ms and the p99 is 3.1ms, idle or not.
Anything that compiles to WebAssembly with WASI: Rust, Go, C and C++, Zig, Swift, AssemblyScript, plus Python and JavaScript via component builds. You ship a .wasm artifact, so there is no per-language runtime for us to support or for you to pin a version of.
The full WebAssembly System Interface — sockets, filesystem, clocks, random, and threads. Code that links the standard library and runs locally runs on Tessera unchanged. There is no proprietary sandbox API to port your application to.
Isolation is capability-based and enforced by the runtime, not by a shared OS. Each module gets only the capabilities you grant it, runs in its own linear memory, and cannot reach the host or another tenant. The WebAssembly boundary is a tighter seal than an OS process.
Yes. tessera dev runs the identical production runtime on your machine — same WASI surface, same isolation, same CPU and memory limits. A module that behaves locally behaves the same in all 300 cities, so edge code stops being something you can only debug in production.
Traffic fails over to the nearest healthy PoP automatically, with no change on your side. Because every deploy is content-addressed and replicated to all cities, there is no primary region to lose — the network routes around the outage and your module keeps serving.
Compile a module, run tessera deploy, and watch it go live in 300 cities in seconds. Free to start — no card, no sales call, no region to choose.