At Spire, we're building the Based Stack — letting apps spin up their own based rollup L2s / appchains.

As rollup ecosystems evolve, a new frontier is emerging — L3s built on top of existing L2s. This post explores how Spire’s approach, which combines shared settlement and coordinated sequencing, can extend beyond L2s, enabling rollups to function as synchronous execution environments. This architecture extends beyond traditional rollup sequencing models, offering faster, customizable intra-block execution while remaining backward compatible with existing L2 rollups.

The Challenge: Islands in the stream of fragmented liquidity

Current rollup architectures create isolated liquidity islands, where appchains operate independently with separate sequencers and settlement layers. This fragmentation leads to:

• Capital inefficiency – Liquidity pools are confined to individual appchains, reducing capital utilisation.

• Delayed execution – Cross-rollup transactions require bridging or asynchronous settlement, introducing latency and reducing DeFi composability.

• Fragmented price discovery – Markets across different rollups lack synchronization, creating inefficiencies in pricing and execution.

• Cross-domain execution risk – Transactions spanning multiple appchains must be executed optimistically, increasing the likelihood of failure with the loss of atomicity.

These inefficiencies make it challenging to build low-latency, high-frequency applications that require synchronous settlement and atomic execution across multiple chains.

Spire solves this problem by introducing shared settlement and coordinated sequencing, eliminating liquidity islands and enabling seamless intra-block composability.

The Spire Solution: Shared Settlement + Coordinated Sequencing

Spire extends sequencer design by introducing (1) Shared Settlement + (2) Coordinated Sequencing:

1. Shared Settlement: Multi-Appchain Execution in a Single Sequencer Batch

Instead of settling transactions in isolated rollup environments, Spire enables shared sequencing across L3 appchains.

• Appchains submit transaction bundles to a shared sequencer rather than operating in isolation.

• Batch execution enforces synchronous composability, ensuring all transactions within a batch either execute atomically or revert.

• Optimistic atomicity allows users to receive preconfirmations for execution before final settlement.

This architecture preserves independent appchain logic while leveraging L2 settlement guarantees, reducing fragmentation and improving execution reliability.

2. Coordinated Sequencing: Dynamic Transaction Ordering for Customisable Execution

Spire enables programmable sequencing, allowing transactions to be dynamically ordered within a batch.

• Optimistic atomic execution ensures interdependent transactions execute in the same batch.

• Custom priority rules let appchains control ordering, execution fees, and failure handling.

• Sequencer marketplaces allow applications to select execution models that optimize for cost, latency, or MEV strategies.

These mechanisms enhance intra-block composability, delivering low-latency, deterministic execution across L3s.

Forward Sequencing: Optimistic Atomic Execution for Preconfirmations

A key innovation in Spire is forward sequencing, which enables execution preconfirmations. L3 sidecars can commit to transaction inclusion before final L2 settlement. Users receive execution guarantees based on real-time fee estimation and state simulation. Sequencers dynamically adjust execution order to minimise contention and optimise gas fees.

This model unlocks optimistic execution guarantees that reduce execution risk while maintaining synchronous composability.

The Spire Tooling & API Ecosystem

To support next-gen modular execution, Spire provides:

• Extensible Sequencer Architectures – Customizable sequencing for L3 appchains.

• Composable EVM Execution – Full EVM compatibility for cross-appchain transactions.

• Preconfirmation APIs – Transaction simulation and execution guarantees.

• Optimistic Settlement Models – Seamless integration with L2 rollups and sidecars.

Redefining Rollup Execution

Spire’s shared settlement + coordinated sequencing model transforms how appchains interact, offering:

• Atomic execution across appchains

• Low-latency composability with deterministic ordering

• Preconfirmations for faster execution and reduced risk

• A marketplace of sequencers for customizable transaction processing

We're building the next generation of modular execution infrastructure and invite app developers to explore the L3 Based Stack. If you're looking to launch an appchain, join us in shaping the future. Send a DM on X or an email to get started!