We’re sharing a live public demo of the first based L3 appchain — now running on testnet. You can try it here: https://frontend.l3testnet.spire.dev/
This post breaks down what it is, why it matters, and where we’re headed next.
A “based L3” is an appchain that is sequenced by underlying L2 — no centralized sequencer, no additional trust assumptions. This enables something powerful: synchronous composability with L2, just like a smart contract on L2.
In this demo, the based L3 appchain is synchronously reading data from its L2. This may seem simple, but the implications are significant. As an example, our demo utilizes oracle data from L2 at no cost while still gaining the benefits of running an appchain.
In the future, based L3s can natively tap into liquidity and users on L2. Furthermore, users can access L3 directly from L2 without bridging assets. The typical problem of appchains is isolation, but synchronous composability will solve this.
Not for based L3s!
Compared to common L3s today, based L3s offer lightweight operations. As L2 handles sequencing, there’s no need for a centralized sequencer. This dramatically reduces DevOps overhead.
In addition, based L3s won’t even need an additional explorer. Transactions are visible and verifiable via L2 — just like a smart contract on L2.
As you can see, based appchains break the traditional trade-offs. You get the benefits of appchains (scalability, customization, sovereignty) while still maintaining composability and lightweight deployment.
With this demo, we’ve reached synchronous composability level 1 — synchronous reading from L2.
Soon we aim to reach higher levels of synchronous composability where using a based L3 feels indistinguishable from a smart contract on L2 — both for users and developers.
L3 reads L2
This can saves appchains millions of dollors of infrastructure costs. For example, oracle, explore, sequencer devops cost.
L2 reads L3
L3 can natively tap into liquidity, smart contracts, and users on L2.
L2 <> L3 <> L3 reads and writes
Users can interact with L3 directly from L2 without needing to bridge assets — eliminating the bridging user experience friction.
We will apply features of this technology to work between L2 and L1. This means the demo isn’t just about L3s. It previews an onchain world where millions of appchains operate in sync and are secured by a single unifying network: Ethereum.
Try out the demo of based L3. If you're interested in building appchains or based rollups, come talk to us!
Live demo: https://frontend.l3testnet.spire.dev/
Today, we share a live public demo of the first based L3 appchain. This is a landmark moment for Spire as we demonstrate the future of Ethereum rollups: synchronous composability.
https://frontend.l3testnet.spire.dev/
The demo shows a based L3 appchain synchronously reading data from its L2. This may seem simple, but the implications are significant. It previews an onchain world of millions of appchains operating in sync and secured by a single unifying network: Ethereum.
Launching an appchain is often prohibitively expensive. With Spire, however, builders can easily deploy their own L3, inheriting the composability of its underlying L2 and toolings of the Ethereum ecosystem. This means no expensive oracles, custom explorers or bespoke infrastructure. Just out-the-box deployment saving millions of dollars.
Compared to traditional L3s / appchains, Spire unlocks: ✅ synchronous composability ✅ lightweight deployment ✅ customizability Developers can achieve the scalability and customization of their own appchain while accessing the liquidity and users of the underlying L2 — with the simplicity of deploying a smart contract on L2.
We are proud to share this small but significant step in the path towards a unified Ethereum. Stay tuned over the coming months as we release examples of higher levels of synchronous composability and the first production based L3 appchain.
For more in depth information about this demo, visit the Spire blog. https://paragraph.com/@spire/a-live-demo-of-synchronous-composability