Weeks 1–4 each had a defined category. Base was the EVM L2 week. Scroll was ZK. Core DAO was EVM-on-Bitcoin. Solana was non-EVM mainstream. Every week, the category defined the field. The question was never "what kind of chain?" It was "which chain best fits this type?" Clear axis, tractable problem.
Week 5 is the Wildcard slot. The brief from day one: the unknown, what's at the frontier right now? No category. No axis. A wide field and an open question, and it turns out the open question is harder to answer than the constrained one.
The field
Six candidates made the shortlist: Monad, TON, AO on Arweave, Fuel Network, Starknet, Stacks. One parallel-EVM (Monad) and one ZK-VM (Starknet — Cairo makes ZK explicit in the language itself, unlike Scroll where it's invisible plumbing). The most exotic option: AO, which runs Lua on Arweave's permanent log storage. Fuel uses strict VM parallelism via access lists in a UTXO model, with Sway as a Rust-inspired contract language. And TON — Telegram-native, actor-model VM, 900 million monthly active Telegram users already inside the access layer.
Two eliminations worth naming
AO on Arweave scored 27/60. That number undersells it. Lua as the contract language, running on Arweave's permanent log storage — the Holographic State model, where the state itself is never stored, only the process logs, and anyone can replay them to derive the current state (they call this Holographic State). An actor-oriented computation model that makes TON look almost conventional. I genuinely wanted to build on it. The problem: no local test framework, documentation that runs dry fast, sparse production examples.
Stacks (Clarity) was the harder cut. Clarity is interpreted, not compiled — which is what makes it fully decidable: no infinite loops, no reentrancy by design. The source publishes on-chain rather than bytecode, so there's nothing to exploit at the compiler level. Genuinely interesting language. But Stacks settles on Bitcoin. Week 3 was Core DAO, which also settles on Bitcoin (different consensus model, same anchor). Two Bitcoin-settled chapters in five weeks is one too many.
The scored finalists
| Chain | Language | Est. Score | One-line verdict |
|---|---|---|---|
| Monad | Solidity (EVM) | 54/60 | Parallel EVM — best rubric ceiling, fourth EVM week |
| Starknet | Cairo | 43.5/60 | ZK in the language, not just the plumbing — strong alt |
| TON | Tact | 43/60 | Actor model + Telegram-native + language new to the series |
| Fuel Network | Sway | 40/60 | UTXO-parallel architecture, thin ecosystem |
| Stacks | Clarity | 39/60 | Interesting language, too much W3 overlap |
| AO (Arweave) | Lua | 27/60 | Best story, tooling not build-week-ready |
Full methodology can be found here.
Why TON, and why not Monad
Monad scored 54/60 — the highest estimate of any candidate in this series. It would have been the easiest build by a long way: same Solidity contract as weeks 1–3, Foundry, MetaMask. The entire tooling delta is adding one RPC URL to the wallet config. The actual frontier story with Monad is optimistic parallel execution and MonadDb — state-heavy apps can see real throughput gains from that architecture. The tip jar doesn't come close to stress-testing it. There's also a practical catch: Monad is still in gated devnet as of this week, so the real friction wouldn't have been the code at all — it would have been getting network access and a working faucet.
That aside, it still didn't win.
Using the Wildcard slot to ship a fourth Solidity week would have answered "what's at the frontier?" with "what you already know." Reasonable answer most weeks. Not for the finale.
Starknet at 43.5/60 was the strongest alternative. Those 0.5 points over TON's 43 come from tooling: Starknet Foundry and Scarb are genuinely mature, closer in feel to the Foundry experience than Blueprint is. TON's score is lower because the tooling is younger and the actor model has a steeper ramp than Cairo does. But this is a Wildcard pick, and that's a narrative call as much as a DX one. TON has things this series hasn't touched: an actor-model VM where every contract is an isolated process and all cross-contract communication goes through async messages — not a pattern layered on top of shared EVM state, a different execution model from the ground up. A language (Tact) that looks like TypeScript and thinks like Erlang. And the chain is literally embedded as the payment layer in a messaging app 900 million people already have on their phones.
Starknet's rubric ceiling is 0.5 points higher. TON's story ceiling isn't close.
What this means for the build
TON isn't a safe pick. The 43/60 estimate is a promise of friction: the async message-passing model is a genuine mental shift from Solidity, TON uses a Bag of Cells (BoC) architecture where state is a tree of cells rather than EVM's flat storage slots (which makes hitting cell size or reference limits a real constraint when storing arbitrary-length strings), and contract verification on verifier.ton.org is more manual than forge verify-contract. If something blocks mid-week, Starknet at 43.5/60 is the fallback — solid tooling, Cairo is genuinely novel, ZK-in-the-language is different enough from Scroll. But the aim is TON.
→ The live app is at https://proof-of-support.pages.dev
→ Scoring methodology for the series: How I'm Scoring the Chains
