â The o2 Architecture (Built On FuelVM)
This level of performance comes from how the system is designed.
o2 is built on Fuelâs architecture using parallel execution to handle trading activity efficiently at scale.
At its core is a fully on chain central limit order book (CLOB) enabling
Real price discovery and precise order placement instead of simplified swap mechanics.
Under the hood, the system is structured across multiple layers
Sway based smart contracts, a dedicated data layer, execution layer, and user interface
Working together to support high frequency interaction without bottlenecks.
Charts are powered by TradingView giving traders a familiar and
Precise interface while maintaining full on chain transparency.
1
7
43
â Introducing o2
o2 is built from the ground up for one purpose.
spot trading done right.
Itâs a fully on chain exchange designed for high frequency environments
Powered by FuelVM and capable of handling serious trading load without breaking performance.
Today, that system has already processed $957.4M in volume
1
9
69
Apr 16
Progress you can use > progress you can promise.
Most execution layers are already near their ceiling. Fuel's technology isn't.
Ignition runs at 600 TPS today.
The FuelVM hits 21,000 TPS per core.
On an 8-core machine that's 150,000 TPS.
Built to scale. Proven to ship. â˝ď¸
9
11
56
3,052
Apr 11
First, understand what @fuel_network is.
⢠$81.5M raised
⢠150,000 TPS target
⢠Parallel execution via FuelVM
⢠EigenDA integration incoming
This isnât just another L2.
This is the infrastructure DeFi has been waiting for.
And Reactor is its killer app.
1
2
70
Feb 12
1ď¸âŁ @AltiusLabs & the Modular Execution Era
At Altius Labs, the focus is simple but powerful: building modular execution layers that give blockchains more scalability, flexibility, and freedom for developers.
This shift is quietly reshaping how Web3 infrastructure works. Letâs break it down đ
2ď¸âŁ Why Execution Layers Matter
Traditional (monolithic) blockchains handle execution, consensus, and data all in one place.
That works⌠until it doesnât.
You hit limits on scalability and flexibility.
Modular blockchains separate these roles.
The execution layer where smart contracts actually run becomes its own focused system.
And that changes everything.
3ď¸âŁ What Modular Execution Unlocks
When execution is modular, Web3 infra can:
⢠Scale across multiple rollups
⢠Create specialized environments for gaming, DeFi, identity, etc.
⢠Support different programming languages and ecosystems
Execution stops being the bottleneck â it becomes a service layer optimized for performance.
4ď¸âŁ The Modular Stack (Simple View)
Think of it like this:
⢠Execution Layer â Runs contracts & processes transactions (rollups)
⢠Settlement Layer â Finality & security (Ethereum)
⢠Data Availability Layer â Stores transaction data (Celestia)
Instead of one overloaded chain doing everything, each layer focuses on what it does best.
Result?
More scalability. More flexibility. More freedom for builders.
5ď¸âŁ Virtual Machines (VMs) â The Engine Behind It All
VMs define how smart contracts are written and executed.
Different ecosystems use different VMs:
⢠EVM â Solidity, massive ecosystem (Arbitrum, Optimism, Base, zkSync)
⢠WASM â Rust, Go, C (Cosmos, Polkadot, Starknet)
⢠Custom / Multi-VMs â FuelVM, Polygon CDK, Arbitrum Stylus
The future likely isnât one VM.
Itâs multi-VM rollups, where developers choose what fits their app best.
6ď¸âŁ Why Modular Execution Is So Important
⢠Scalability through specialization
⢠Faster innovation for specific industries
⢠Developer freedom to choose language, VM, and fee model
⢠Shared security liquidity without sacrificing flexibility
Itâs about building infrastructure that adapts
instead of forcing apps into one rigid system.
7ď¸âŁ Where Altius Labs Comes In
Altius helps projects:
⢠Design high-performance execution layers
⢠Build custom or multi-VM architectures
⢠Connect rollups with secure settlement data layers
⢠Optimize for gas, latency, security, and dev experience
Whether itâs an appchain, zk-rollup, or WASM-based system, they help teams navigate the modular stack properly.
8ď¸âŁ The Bigger Picture
Smart contract platforms are becoming faster, cheaper, and more specialized.
With multi-VM support and modular execution, applications arenât locked into one ecosystem anymore. They can move where users are.
Thatâs the future Altius is building
a world where execution is modular, portable, and designed for real-world scale.
2
2
25
215
Great to see the Rise Progress.
Youâre right about one thing: performance is the constraint, and you wonât get this level of execution on the EVM.
But you'll get it on the FuelVM with @o2dotapp.
CEX-grade execution, fully onchain:
- 0 gas fees
- 1 bp maker / taker
- Native fast bridge with 0 fees across Ethereum, Base, and Fuel Ignition
Already live for a month.
3
25
172
Feb 4
đĄ Como a FuelVM estabelece um novo padrĂŁo de engenharia para escalabilidade em Ethereum?
No Ethereum, a verdadeira disputa nunca foi entre L1s e L2s, mas sim entre quem consegue redefinir como a execução funciona.
Depois de anos tentando esticar a EVM alÊm de seus limites originais, a conta da escalabilidade chegou com rollups que crescem mais råpido do que a execução consegue acompanhar.
Ă nesse ponto de inflexĂŁo que a Fuel aparece, nĂŁo como âmais uma L2â, mas como o primeiro runtime realmente projetado para o ecossistema modular:
â A FuelVM foi construĂda do zero para execução paralela, extraindo o mĂĄximo da CPU e permitindo que mĂşltiplas transaçþes rodem simultaneamente.
â O modelo UTXO reorganiza como o estado ĂŠ acessado, reduzindo contenção e abrindo espaço para throughput mais alto.
â Sway, a linguagem nativa, oferece previsibilidade e segurança de engenharia que devs esperam de ambientes modernos de alto desempenho.
Esse conjunto forma algo raro no ecossistema atual: um runtime completo, coerente e preparado para a modularidade que Ethereum estĂĄ adotando.
Enquanto a indĂşstria ainda tenta escalar a EVM por fora, a Fuel reescreve a lĂłgica por dentro como um novo standard de runtime que precisa extrair o mĂĄximo de paralelismo e previsibilidade.
A pergunta que todo dev começa a fazer agora nĂŁo ĂŠ mais âqual L2 ĂŠ mais rĂĄpida?â, mas âqual runtime vai definir o futuro do Ethereum?â
A FuelVM provou que escalabilidade, enfim, voltou a ser engenharia.
1
1
2
43
I believe most people are grossly misinterpreting this either due to not having much reading comprehension, general ignorance, and/or cognitive dissonance.
Firstly, paths change and this plasticity is imperative. Were it not for this there would be no innovations. Ethereum's combined dynamism and diversity of opinions are invaluable. ETH is anti-stubborn.
I also believe there is confusion in the understanding of what "scaling" is actually defined as. In this context of ETH scaling, it can be broken down into TX cost, finality, and throughput.
L2s were originally envisioned with the intent of drastically reducing the TX cost and throughput (the latency of txs is also "reduced" to the end-user, but the finality is extended as there is a larger window before the batch of txs is finalized on ETH, that is the whole concept of a "rollup") without sacrifices to decentralization or security. This they actually do (particularly ZK-Rollups using ETH blobs), at least in theory, however, they have not in practice.
Instead, as @_Enoch (first vocal name that came to mind) and several others have been emphasizing for years, we have not seen an "actual" L2 with a proper exit window, no security council, and smooth interop.
So since L2s have been failing to advance and properly serve their users and the Ethereum community, they do not fit the former "Sharded Ethereum" vision. We do not have any mature Stage 2 L2s, and that is a major executional blunder. Scaling ETH via L1 vs L2s isn't inherently flawed in theoretical differences, but rather executional differences.
And since the L1 is scaling, that means that L2s will be mostly irrelevant for scaling (aside from hyper fast and scaled rollups and the tradeoffs that ensue), though rollups have more value than scale itself, so this is not the death of rollups themselves, but definitely many of the rollups today if they don't evolve.
That is not to say the rollup-centric vision was all a waste of time and effort. There have been countless advances and developments around both ZKPs and rollup designs as a result of this former vision.
Without diving too deep, Rollups and ZKPs are useful beyond scaling. We have seen alt-VMs (like @SwayLang FuelVM), privacy layers (like @aztecnetwork and @RAILGUN_Project), function specific appchains (@LC), and much more. The point being, rollups themselves are useful for purposes beyond scaling which would unlikely be explored were it not for having ventured down the rollup-centric roadmap. And when implemented properly, with the guarantees and inheritance of ETH, they will still play a vital role in the ETH ecosystem; a crucial part of The World Computer.
More centralized and fallible systems will continue to exist on Ethereum, but only where they make sense, rather than blanketing the current L2s we have as the only way forward for ETH.
And finally to dispel some naysayers:
To the people which were blindly touting "scaling the L1 like Solana" several years ago, blind L1 "scaling" is just centralization. Solana is unreliable, it goes down, it is centralized, and does not have any of the strong guarantees that Ethereum has. If ETH sacrificed everything in favor of chasing "Solana-level scale", ETH would be valueless, and not The World Computer.
Additionally, why do you think in face of this rollup centric vision was the L1 able to scale? This is because of the decentralization of the long-term Ethereum vision, roadmap, and workforce. There is no unified view held by everyone, development happens based on different opinionated directions simultaneously, and that is beautiful.
Just have a look at ethresear.ch/ and you will be able to determine why ETH is different. I think people are so accustomed to the common practice that development only happens by a few individuals in a centralized corporate entity, that such a decentralized novel collaborative structure is entirely alien.
Rollups were not a waste of time or useless, rather corporations took over in place of cypherpunks. When we become the very thing we despise, of course it won't work and that is precisely why this narrative shift makes sense.
Death to centralization larping as decentralization, insecurity larping security, and corpos larping as cypherpunks.
Feb 3
There have recently been some discussions on the ongoing role of L2s in the Ethereum ecosystem, especially in the face of two facts:
* L2s' progress to stage 2 (and, secondarily, on interop) has been far slower and more difficult than originally expected
* L1 itself is scaling, fees are very low, and gaslimits are projected to increase greatly in 2026
Both of these facts, for their own separate reasons, mean that the original vision of L2s and their role in Ethereum no longer makes sense, and we need a new path.
First, let us recap the original vision. Ethereum needs to scale. The definition of "Ethereum scaling" is the existence of large quantities of block space that is backed by the full faith and credit of Ethereum - that is, block space where, if you do things (including with ETH) inside that block space, your activities are guaranteed to be valid, uncensored, unreverted, untouched, as long as Ethereum itself functions. If you create a 10000 TPS EVM where its connection to L1 is mediated by a multisig bridge, then you are not scaling Ethereum.
This vision no longer makes sense. L1 does not need L2s to be "branded shards", because L1 is itself scaling. And L2s are not able or willing to satisfy the properties that a true "branded shard" would require. I've even seen at least one explicitly saying that they may never want to go beyond stage 1, not just for technical reasons around ZK-EVM safety, but also because their customers' regulatory needs require them to have ultimate control. This may be doing the right thing for your customers. But it should be obvious that if you are doing this, then you are not "scaling Ethereum" in the sense meant by the rollup-centric roadmap. But that's fine! it's fine because Ethereum itself is now scaling directly on L1, with large planned increases to its gas limit this year and the years ahead.
We should stop thinking about L2s as literally being "branded shards" of Ethereum, with the social status and responsibilities that this entails. Instead, we can think of L2s as being a full spectrum, which includes both chains backed by the full faith and credit of Ethereum with various unique properties (eg. not just EVM), as well as a whole array of options at different levels of connection to Ethereum, that each person (or bot) is free to care about or not care about depending on their needs.
What would I do today if I were an L2?
* Identify a value add other than "scaling". Examples: (i) non-EVM specialized features/VMs around privacy, (ii) efficiency specialized around a particular application, (iii) truly extreme levels of scaling that even a greatly expanded L1 will not do, (iv) a totally different design for non-financial applications, eg. social, identity, AI, (v) ultra-low-latency and other sequencing properties, (vi) maybe built-in oracles or decentralized dispute resolution or other "non-computationally-verifiable" features
* Be stage 1 at the minimum (otherwise you really are just a separate L1 with a bridge, and you should just call yourself that) if you're doing things with ETH or other ethereum-issued assets
* Support maximum interoperability with Ethereum, though this will differ for each one (eg. what if you're not EVM, or even not financial?)
From Ethereum's side, over the past few months I've become more convinced of the value of the native rollup precompile, particuarly once we have enshrined ZK-EVM proofs that we need anyway to scale L1. This is a precompile that verifies a ZK-EVM proof, and it's "part of Ethereum", so (i) it auto-upgrades along with Ethereum, and (ii) if the precompile has a bug, Ethereum will hard-fork to fix the bug.
The native rollup precompile would make full, security-council-free, EVM verification accessible. We should spend much more time working out how to design it in such a way that if your L2 is "EVM plus other stuff", then the native rollup precompile would verify the EVM, and you only have to bring your own prover for the "other stuff" (eg. Stylus). This might involve a canonical way of exposing a lookup table between contract call inputs and outputs, and letting you provide your own values to the lookup table (that you would prove separately).
This would make it easy to have safe, strong, trustless interoperability with Ethereum. It also enables synchronous composability (see: ethresear.ch/t/combining-pre⌠and ethresear.ch/t/synchronous-c⌠). And from there, it's each L2's choice exactly what they want to build. Don't just "extend L1", figure out something new to add.
This of course means that some will add things that are trust-dependent, or backdoored, or otherwise insecure; this is unavoidable in a permissionless ecosystem where developers have freedom. Our job should make to make it clear to users what guarantees they have, and to build up the strongest Ethereum that we can.
2
4
21
1,080
30 Days of Building with @StorkOracle - The "Real Eggs Challenge" Edition
Day 22 (Post B) - âThe Flock Welcomes FuelVM!â
FuelVM joining the Stork ecosystem is another step toward supporting high-performance on-chain environments with data that can keep up.
FuelVM is built with a strong focus on execution speed and parallelization, which raises the bar for the infrastructure around it â especially data. For applications running on Fuel, low latency and reliable updates arenât optional; theyâre foundational.
By integrating with Stork, builders in the FuelVM ecosystem gain access to real-time, verifiable data feeds designed for live market conditions. This alignment makes it easier to build applications that fully leverage Fuelâs performance without being constrained by slower data layers.
Welcoming FuelVM into the flock reflects a shared direction:
faster chains, more demanding applications, and data infrastructure built to match that pace.
30 Days of Building with @StorkOracle - The "Real Eggs Challenge" Edition
Day 22 (Post A) - "STORK IS FIRST IN DERIVATIVES DATAâ
Stork wasnât the first oracle to ever touch derivatives - but it was among the first to design its data infrastructure specifically around derivatives-grade requirements.
Derivatives markets expose the hardest problems in on-chain data: high volatility, constant price updates, tight latency constraints, and zero tolerance for stale feeds. Many oracle systems adapted to these needs later. Stork prioritized them early.
Instead of treating derivatives as an extension of spot markets, Stork built for continuous usage, high-frequency updates, and performance under real market pressure. That focus is reflected in where Stork is used today - especially across perpetual DEXs and live trading environments.
In that sense, âfirstâ isnât about who arrived earliest.
Itâs about who took derivatives data seriously from the start and built infrastructure to match.
That design choice continues to shape how Stork is used - and why it shows up where data demands are highest
1
2
132
Jan 11
. @o2dotapp | A Fully Onchain DEX Powered by Fuel.
o2 exchange is a high-performance, fully decentralized trading platform built on the @fuel_network, designed to scale real trading activity without compromising security or decentralization.
Fuel isnât just the base layer here. Itâs the reason o2 works the way it does.
---
â Why Fuel, not just another L2?
Fuel flips the usual EVM assumptions.
Instead of forcing trades through a single execution lane, Fuel runs transactions in parallel. For a DEX, that matters more than almost anything else.
o2 benefits directly from this:
⢠Parallel transaction execution
⢠FuelVM optimized for trading workloads
⢠State minimization that keeps execution predictable
⢠A cleaner developer surface that avoids hacky workarounds
This isnât theoretical throughput. It shows up in real trading conditions.
---
⥠o2 Architecture:
@o2dotapp is designed as a fully onchain system, not a hybrid.
⢠Fully onchain order execution
⢠Secure-by-design architecture
⢠Native bridge support for assets
⢠Optimized execution paths
⢠Infrastructure designed to scale with usage, not incentives
That last point matters.
---
⢠What the Numbers Say:
You can usually tell whether a DEX is real by looking at the volume distribution.
o2âs metrics look organic.
⢠30d DEX volume: $76.47M
⢠7d volume: $25.25M
⢠24h volume: $3.46M
⢠Cumulative volume: $83.65M
⢠TVL: $1.04M
No emissions-driven spikes. Just steady participation.
---
⣠Competition Breakdown:
First Breath (Dec 15â22) Ended
⢠$10,000 USDC prize pool
⢠102 traders
⢠$17.91M in volume
Second Breath (Dec 22âJan 2) Ended
⢠$10,000 USDC prize pool
⢠111 traders
⢠$32.29M in volume
Third Breath (Jan 2â12) Live
⢠$10,000 USDC prize pool
⢠96 traders
⢠$28.09M in volume
Participation stayed consistent. Volume didnât evaporate after the first round. Thatâs usually a good sign.
---
⤠The Bigger Picture:
o2 isnât trying to reinvent trading.
Itâs validating a more fundamental idea on Fuel.
⸠High-frequency onchain trading without congestion
⸠Parallel execution in real production conditions
⸠A clean path toward scalable DeFi infra
⸠A blueprint for future trading apps on Fuel
â â â
⼠Quick Take:
Build on Fuel â execute in parallel â scale onchain trading â attract real users â prove infra in production.
@o2dotapp Exchange isnât a promise. Itâs a working example of Fuelâs thesis playing out live.
4
3
14
426
. @0xMiden VM is not EVM. Itâs not Move. Itâs not FuelVM.
Itâs a from scratch, Rust native, recursion first, STARK optimized machine built for local execution.
Key facts:
> 100Ă faster encryption than PLONK/R1CS (public benchmarks)
> Memory model almost identical to WebAssembly â devex actually good
> Full Rust â Miden Assembly compiler lands v0.13
> MASM (assembly) is human-readable and debuggable
> Native support for recursive proofs â cheap aggregation
Write your contract once, deploy it public or private with zero changes.
No circuit rewriting, no different languages.
Private notes = the most powerful primitive in all of crypto right now.
Think Bitcoin UTXO Zcash shielded Move objects combined:
> Each note is a bearer instrument
> Has a consumption script (P2ID, multisig, timelock, SWAP, HTLC, etc.)
> When spent â nullifier is revealed to prevent double spend
> All inputs/outputs/serial numbers stay forever off chain
> Delivery happens over any side channel (v0.12 just shipped Nethermind routing layer)
You can send private notes via Signal, Telegram, Tor, or in person QR exactly like physical cash.
And because scripts are Turing complete, you can build DEX orders, private OTC desks, payroll, anything.
This is the reason people say
â @0xMiden feels like a completely new blockchain â.
70
71
327
Jan 8
Experience fully onchain seamless trading on o2, powered by FuelVM â˝ď¸
and weâre just getting startedâŚ
Most DeFi infrastructure is built around accepted tradeoffs.
Read how o2.app approaches performance, transparency and fully onchain design đ
paragraph.com/@o2dotapp/perfâŚ
3
119
19 Dec 2025
Blockchain performance isnât just about Transaction per second.
Itâs about how transactions are executed.
See how these two virtual machines work.
EVM and FuelVM
EVM
Execution: Sequential
Language: Solidity
Gas fees: Volatile
Design age: Old
Modularity: Limited
Scalability: Constrained
FuelVM
Execution: Parallel
Language: Sway
Gas fees: Predictable
Design age: Modern
Modularity: Native
Scalability: High
1
2
5
96
16 Dec 2025
Experience a blazing fast, fully onchain trading experience on @o2dotapp powered by the FuelVM â˝ď¸
1/8
o2.app is built to do one thing exceptionally well:
deliver CEX-level trading performance without giving up self-custody.
A real order book. Real speed. Real ownership.
Fully onchain.
2
61
16 Dec 2025
Thanks to @fuelvm for a great Christmas party @BlindOwlBrewery. Congrats to #Cassi on her 10th workiversary!
2
108
10 Dec 2025
Viraz is one of the most sincere devs I have met in the industry. With intricate knowledge of the EVM and his background of working on a cutting-edge alt vm, which is the FuelVM... Viraz would be a great pick for anyone looking for a core engineering hire.
Poach him fast.
1
4
1,246
Ethereum scaling is many L2s want to solve, and @fuel_network solves this by pushing boundaries to avoid the pitfalls some L2s face
more insights from @Rubyto
Fuel Network is an Ethereum L2 building a scaling solution that leverages rollup technology, with the mainnet currently live
Fuel does not rely on the EVM for scaling but uses the fuelVM, which is used to process multiple transactions simultaneously
Fuel network has its DEXs built on it, like ReactorDEX, an AMM, and the o2otapp, an order book (still being built)
Fuel recently integrated the EigenDA to handle data storage separately, letting Fuel focus on fast execution
The major focus is on applications requiring high speeds and low costs, which Ethereum struggles with
5
2
23
544