◆Why Layer 2

What a Layer 2 is for

Solana is fast. The pressure is at peak, not at average — and that is a different problem with a different fix.

Solana is fast. The pressure is not average throughput — it is what happens at peak, when demand spikes and everyone competes for the same blockspace at the same moment. These are the failure modes a Layer 2 is meant to absorb.

01The case

Solana does not need a Layer 2. Some apps do.

The sceptics are right that Solana scales on its own, and getting faster is Solana's job, not ours. The case for a Layer 2 is not speed. It is that a chain shared by everyone cannot make a promise to any one app. These are the promises it cannot make, and where Solieum stands on each.

  1. 01Live

    On Solana, you pay for failure

    Solana keeps the fee on a failed transaction for a good reason: it cannot know the outcome in advance, and the fee is what stops spam. So a quarter to a third of non-vote transactions fail, and every one of them pays. A Solieum chain can know the outcome in advance, so it refuses a failing transaction for free.

    The failure rate, measured →
  2. 02Live

    Your users compete with every launch on the network

    Local fee markets help, but your app still shares leaders, bandwidth and blockspace with everyone. When a launch floods the network, transactions are dropped before they reach a block, and no public dataset can even count them. On its own chain, a rush elsewhere does not touch your app.

    What goes wrong at peak →
  3. 03Live

    Ordering on Solana is invisible. Here it is provable

    On Solana, whoever leads the slot orders it, and you get no receipt you can hold. On Solieum every transaction gets a signed receipt naming its position, and a sequencer that promises one position twice can be proven to have done it and loses its bond. For a trading venue, that is a reason to move.

    ADR-0012: bond and slashing →
  4. 04In progress

    The rules become yours

    Solana cannot run a different fee rule, block time or ordering policy for one app. A Layer 2 can: Solieum already runs its own block time, a flat fee and no charge for failure. Each market publishing its own ordering rule, and compliance living in an app's own programs, are decided and not yet built.

    Chains for outside teams are not offered yet.

    ADR-0063: compliance in programs →
  5. 05Planned

    The fees stay in your ecosystem

    On Solana, every fee your users pay goes to Solana's validators. On a chain of your own, the fees are kept by the chain. For a business, this is often the deciding argument: your traffic becomes your revenue.

    Fees are kept today on Solieum's own chains. Chains for outside teams are not offered yet.

    ADR-0017: the revenue model →
  6. 06In progress

    You keep Solana instead of leaving it

    The real alternative to a Layer 2 is rarely staying put. It is leaving for an app-chain or another Layer 1 to get the five points above. Solieum gives you those while your data and settlement stay on Solana, Solana settles disputes, and Solana's own runtime runs your programs.

    What you are trusting today →

What a Layer 2 will not do for you

  • Make Solana faster. That is Solana's own roadmap, and it is working.
  • Keep running if Solana halts. Solieum settles on Solana and inherits its failures: in August 2026, 28.83% of stake went delinquent.
  • Make every transaction cheaper today. The flat fee covers settlement only once a block holds about 705 transactions, or about 452 once the batch rent comes back.
  • Suit every app. If none of the points above hurts you, stay on Solana. The end of this page says when a Layer 2 is the wrong answer.

02Technical

Under the hood

The same case in engineering terms: what each part does, and the figure or record behind it. Figures are devnet measurements, dated, and none is a throughput benchmark.

PartHow it worksFigure or record
ExecutionA fork of Agave's SVM inside a deterministic wrapper. Legacy messages run; a v0 transaction is refused by name.A replay harness compares state roots byte for byte across machines. ADR-0005.
AdmissionEach transaction is executed against the open block's projected state, at the exact position it will take. The block's clock is stamped when the block opens, so the run at seal sees identical inputs.A transaction that passed admission and fails at seal is reported as a determinism defect. ADR-0014.
Ordering receiptAn Ed25519-signed receipt for every admitted transaction: its hash, batch, position and L2 slot.14 ms p50, 19 ms p90 on the gamma devnet chain, 13 Nov 2026, sender on the node's machine. ADR-0004.
BlocksA block every 100 ms when there is work, none when idle.In a block at 96 ms p50 on devnet (13 Nov 2026); 102 ms on a local test validator (26 Oct 2026).
Crash safetyEvery admission is appended to a journal before it is answered; a restart restores the same positions and the same signed receipts, and nothing is signed again.Built in the node. ADR-0024.
Data availabilityEach batch is compressed and published in Solana transactions through the data-availability program, bound to its commitment. Sealing fails if the bytes do not match.53% of raw size; data cost per transaction 522 → 280 lamports (measured on modelled traffic). ADR-0001.
State commitmentOne 32-byte state root per batch carries the whole chain's state to Solana: a sorted-leaf tree now, a sparse tree where insertions must be witnessed.ADR-0007.
SettlementRoots are committed to the settlement program on Solana under bond, then sit in a 48-hour challenge window before they are final.Ordering to root on Solana: 192 s median, 278 s worst (13 Nov 2026, public devnet RPC). ADR-0016.
DisputesA challenger and the proposer bisect the execution trace to one step, and Solana's one-step verifier executes that step to decide.Explicit instruction classes now, an SBF interpreter later. Binding on the gamma devnet chain. ADR-0002, ADR-0008.
Sequencer bondThe receipt-signing key posts a bond on Solana. Two valid receipts for one position, checked by the Ed25519 precompile, take it: a share to the reporter, the rest burned.Slash exercised on devnet against a 0.1 SOL test bond. ADR-0012.
Forced inclusionAn inbox program on Solana that the node drains every block. Deposits enter the same way, as forced entries, so a deposit cannot be censored either.Ceiling at most 24 hours by design. ADR-0004, ADR-0009.
BridgeDeposits are credited only when at least two independent RPC providers agree byte for byte, and only if credited minus withdrawn plus the new amount stays within the vault. Withdrawals are proven from the L2's own block.Checks built 3 Sep 2026. ADR-0010, ADR-0013.
Payout air gapBetween a root becoming final and any payout, a guardian can deny the root, never a named withdrawal; an affected claim is reopened by anyone and proven against a later root.One hour on devnet, 24 hours on mainnet. ADR-0015.
A burst, measured200 transfers with 16 in flight: all admitted in 1.07 s, none refused, none failed, in 8 blocks.One laptop, 13 Nov 2026. Not a throughput benchmark: none has been published.

03Pressure points

What actually goes wrong at peak

The failure rate itself, measured: Solana failed transactions →

  1. 01

    Demand spikes

    Bursts of activity — launches, liquidations, meme-coin cycles — push far more transactions at the network than the steady-state average, and they all arrive at once.

  2. 02

    Networking limits under load

    The transport layer has finite capacity for inbound traffic. Under heavy load, excess transactions are dropped before they are ever considered for inclusion.

  3. 03

    Transactions that never reach the leader

    A transaction that does not arrive at the current block leader in time is not rejected — it simply never lands, which is harder for applications to handle than an explicit failure.

  4. 04

    Slippage expiry

    In volatile markets, a trade can breach its slippage bound while it is still queued. The transaction was valid when signed and invalid by the time it executed.

  5. 05

    Downstream pauses

    When congestion persists, exchanges and custodians have at times paused deposits and withdrawals — the user-visible end of a network-level problem.

04The mechanism

What a rollup changes

  • Execution moves off the base layer

    Transactions are executed on a separate network. The base layer's job changes from executing everything to recording results and adjudicating disputes.

  • Many transactions, one commitment

    Batches are committed as a single state root, so hundreds or thousands of transactions share the cost of one settlement.

  • Security is inherited, conditionally

    A rollup inherits the base layer's security only if its data is published there and an invalid state can be proven wrong. Miss either condition and the inheritance does not happen. Solieum publishes on Solana and has the proof machinery deployed on devnet; the security page tracks where both conditions stand.

  • Tuned for a workload

    A separate execution environment can make choices a general-purpose base layer cannot — different fee rules, different block cadence, different resource limits.

05What you gain

  • Throughput headroom. Bursty workloads get their own lane instead of competing with everything else on the base layer.
  • Lower per-transaction cost. Settlement cost is amortised across a batch, which is what makes sub-cent actions economic.
  • Workload-specific tuning. Fee policy, block time, and limits can be set for one class of application rather than for all of them. Solieum's choices so far: on the rollup, a flat fee paid in SOL with no separate gas token, and a block every 100 milliseconds when there is work on the devnet chains; Solieum's own chains charge their fee in the native coin, SEU.
  • Familiar surface. Same account model, same signing, same program model — so existing Solana knowledge carries over. The node accepts a wallet's own transaction format.

06What you take on

  • Two systems to secure, not one. The Layer 2 has its own contracts, its own operators, and its own bugs. Its security is the base layer's security plus its own — and the weakest link decides.
  • More surface, more to get wrong. Bridges, provers, and sequencers are complex and comparatively new. Most large losses in this category have come from bridge contracts and operator keys, not from the base layer.
  • Movement between networks. Assets and messages crossing between layers need routes that are themselves trustworthy. Every additional hop is another thing to evaluate. On Solieum that route is a bridge program that releases funds only against proofs, with a 48-hour challenge window and a 24-hour air gap on the optimistic path, about three days in total — deployed and initialized on devnet, where the chain still carries the seven days it was created with.

How Solieum addresses each of these →

07Advantages

Fourteen advantages, each checked

What a Solieum chain can promise that a shared base layer cannot, and how far each promise has got. Every card names the decision record it comes from, so none of it rests on our word.

  • Live

    A failed transaction costs nothing

    The node runs your transaction when you submit it, against the exact place it will take in the block, and refuses one that would fail before it is charged. You are answered at once with the program's own error.

    Built in the node. Forced-inclusion entries are the one exception.

    ADR-0014 →
  • Live

    Simulation that is exact, not a guess

    simulateTransaction runs the same execution as a real submission and says so with exact: true. On Solana a simulation is advisory, because nobody knows what will run first; here the answer is the answer.

    Built in the node, on the same code path as admission.

    ADR-0014 →
  • Live

    Ordering you can hold to account

    Every accepted transaction gets a signed receipt naming its batch and position. Two receipts for the same position are a proof anyone can post on Solana, and it takes the sequencer's bond.

    Bond deployed on devnet, and a slash exercised on chain against a test bond.

    ADR-0012 →
  • In progress

    Nobody can lock you out

    If the sequencer ignores you, post your transaction to the inbox on Solana. The chain must include it within a deadline, at most 24 hours by design, or the operator's chain is at fault.

    Inbox deployed on devnet and drained every block. Not yet exercised by anyone outside the team.

    ADR-0004 →
  • Live

    Rebuild the whole chain from Solana alone

    Every batch is published in Solana transactions and bound to its commitment. Anyone can replay the chain from Solana's data without asking the operator for anything.

    Live on devnet. Retrieval beyond Solana's own history needs an archive, still to be published.

    ADR-0001 →
  • In progress

    Solana is the judge, not a committee

    A disputed state root is narrowed down to one instruction, and Solana executes that step to decide. The loser's bond pays the winner. No vote and no multisig decides who was right.

    Dispute program deployed on devnet and binding on the gamma chain, for explicit instruction classes. It enforces nowhere that holds real funds yet.

    ADR-0008 →
  • Live

    Solana's own runtime, not a copy

    A fork of Agave's SVM, wrapped deterministically, so Solana programs behave as they do on Solana. A wallet's own transaction format is accepted, and an unsupported v0 transaction is refused by name rather than with a decoding error.

    Live on devnet. A replay harness compares state roots byte for byte, so the fork cannot drift.

    ADR-0005 →
  • Live

    A fixed, known set of programs

    Each chain runs exactly the programs fixed at its start. There is no deploy instruction, so nobody can slip new code onto a running chain. For a high-assurance app, the code that can run is a short list you can read.

    Built 13 September 2026.

    ADR-0019 →
  • Live

    A bridge that trusts no single source

    The node credits a deposit only when two or more independent RPC providers agree byte for byte, and checks before every credit that the total never exceeds what the vault holds. It answers the 2026 bridge losses, where one attestation was enough to mint unbacked funds.

    Both checks built in the node on 3 September 2026. Pre-audit.

    ADR-0013 →
  • In progress

    A brake that cannot freeze your exit

    The pause stops new deposits and new roots, never a withdrawal already proven: the withdrawal path cannot even read the pause flag. A guardian can deny a bad root before payout, but never one person's withdrawal.

    Pause built. The air gap is deployed on devnet with a one-hour delay; mainnet will use 24 hours.

    ADR-0015 →
  • Live

    Receipts survive a crash

    Every admission is written to a journal the moment it is made. After a restart the same positions carry the same signed receipts and nothing is signed twice, so a receipt in your hand stays true.

    Built in the node.

    ADR-0024 →
  • In progress

    Keys rotate without a redeploy

    The sequencer, bridge admin and data-feed admin keys can each be replaced in place by the key that holds the role. A leaked or retired key is swapped out without moving users to a new program.

    Built and tested, not yet deployed. Decided in ADR-0027.

  • Planned

    Pay the fee in SOL, or in SEU

    The fee is paid in SOL, with no separate gas token. The decided next step lets SEU pay the rollup's fee too, while SOL always still can.

    SOL fees are live on devnet. Paying in SEU is design only: nothing is built.

    ADR-0061 →
  • Planned

    Compliance without a gatekeeper

    An app that needs KYC or allow-lists enforces them in its own programs. The chain itself never decides who may send a transaction or leave, so one app's rules cannot shut anyone out of the rest.

    Decided. No KYC or private-transaction system exists yet.

    ADR-0063 →

08Real uses

Where they add up

No single advantage makes a business. These are the workloads where several meet, with what is still missing named alongside.

  • Token launches and mints

    Thousands race for a fixed supply. The losers are told no in milliseconds and pay nothing, the order is fixed by signed receipts, and anyone the operator shuts out can go through Solana.

    No-fee failures · receipts · forced inclusion

  • Trading venues and market makers

    A maker can prove where the sequencer placed each order, and a quote that would fail costs nothing to try. Exact simulation shows a strategy the outcome before it commits.

    Receipts and bond · exact simulation

    Still missing: The order book program is not wired to the sequencer yet.

  • Games and real-time apps

    A block every 100 milliseconds on its own lane, so a rush on Solana does not stall a move, and a move that is no longer valid is refused free instead of charged.

    Own blockspace · 100 ms blocks · no-fee failures

  • Payments and micro-transactions

    A flat fee, settlement cost shared across a whole batch, and a receipt the payer can hold the moment the payment is accepted.

    Batched settlement · receipts

    Still missing: Not yet a cost claim: the flat fee covers settlement only once blocks hold about 705 transactions, or about 452 once the batch rent comes back.

  • Audit trails for AI and regulated systems

    Records anyone can re-derive from Solana, produced by a short, fixed list of programs, with any compliance rule in the app's own code. AI CONTROL's Trust Chain anchors its decision records here.

    Data on Solana · fixed programs · compliance in programs

    Still missing: AI CONTROL is at stage: Development.

  • Institutions that verify instead of trust

    Replay the chain from Solana yourself, dispute a wrong root with Solana as the judge, and rely on a bridge that cannot mint past its vault or freeze a proven exit.

    Rebuild from Solana · Solana as judge · bridge checks · exit brake

    Still missing: Pre-audit and on devnet: not for treasury-scale funds yet.

Every use case, in full →

09The other side

When a Layer 2 is the wrong answer

Scaling talk is more credible from someone willing to say when not to. If any of these describe you, stay on the base layer.

  • Your volume fits on Solana already

    If you are not hitting fee or contention pain at realistic load, an L2 adds a trust surface and an integration burden for nothing. Solana's base layer is very good; use it until it hurts.

  • You need atomic composability with L1 protocols

    An L2 cannot call into Solana programs synchronously. If your core loop composes with L1 DeFi in one transaction, splitting it across layers breaks the atomicity you rely on.

  • Your users cannot tolerate the exit window

    Market makers and settlement desks that need funds mobile in minutes will find a challenge window intolerable — about three days here, on the optimistic path — and LP fast-exits are a different risk they must underwrite deliberately.

  • You cannot absorb a young platform's risk

    Every L2 is newer, less audited, and less battle-tested than its base layer, this one included: Solieum is on devnet and pre-audit. Treasury-scale funds belong on the most proven layer available until the trust model says otherwise.

If you are still reading

The architecture page shows how the machine fits together. The security page says what you would be trusting today, plainly. The use-cases page is the honest sales pitch — workloads where the trade actually pays.

Building something the base layer can't hold?

Tell us the workload. If Solieum is the wrong answer for it, we would rather say so early than have you find out at launch.