Deep dive: Orange trail, rolling with rollups

At a glance

How the Orange Trail app works

The user flow

Orange Trail is a real-time multiplayer provable game, sequenced and verified on Hyli, and proven by SP1.

Every single action taken by players is sequenced directly on Hyli.

Players move along a board game. Each turn, they bet a certain amount of $ORANJ, and sometimes a mini game starts. This minigame is a crash game where players choose when to cash out before the rocket explodes. The winner of the Orange Trail game wins $VIT − vitamins.

The board game

Each day, you bet however much $ORANJ you want, spin the wheel, and face one of three outcomes: nothing happens, a random event occurs, or you trigger a mini-game that runs as its own rollup.

Your action and its outcome are always proven either directly within the board game smart contract or via the dedicated mini-game rollup.

Thanks to Hyli’s pipelined proving, the front end behaves optimistically: it lets you continue playing instantly while proofs are generated in the background.

Once ready, proofs are verified onchain and the result is sent to the main app contract to update your score. At the end of the game, your Hyli wallet’s balance is updated to reflect your game result.

Mini-games and the Crash game

Orange Trail includes one mini-game so far, called the Crash game.

You place a bet in $ORANJ on the main board contract, which then triggers the Crash game, a separate smart contract that simulates a rocket launch. Every time you open the Crash game, a rollup is created; it stops existing when the game is over. And for the user, it’s completely invisible!

The rocket begins climbing, and the longer you wait to cash out, the higher your potential reward. But if you wait too long, the rocket crashes, leaving you with nothing at all.

Since the crash moment must remain unpredictable, the backend plays the role of game master to generate a random crash time. Neither the players nor the chain decides it, preventing manipulation or deterministic exploits.

What makes this interesting isn’t just the gameplay, it’s the architecture.

The Crash game runs as a dedicated rollup, separate from the board. It computes results off-chain, generates a proof with SP1, and then submits that proof to the board contract to update scores.

This seamless interaction between contracts is powered by Hyli’s native cross-contract composability. With it, there are no bridges or syncing logic; instead, there are direct state updates with verified proofs.

Both the board and the Crash rollup are proven using SP1, with proofs generated through our partner network, Succinct.

What Hyli brings: contract calls and smooth UX

Cross-contract calls

Orange Trail consists of multiple smart contracts: one for the main board and others for mini-games, such as Crash. A mini-game can trigger, execute, and send back results to the main board seamlessly, thanks to Hyli’s native cross-contract composition.

On a legacy Layer 1, this would be painful. You’d likely need to write the whole system in Solidity, with tightly coupled code, or deploy a separate zk rollup for mini-games and bridge back to the main app. Here, the rollup is born and removed as mini-games are launched. There is no setup work at all, only good vibes.

On Hyli, things just work.

This opens up extensibility: anyone could write a new mini-game that plugs into the board and affects the shared game state (provided we accept the update to the board game itself). Just follow the interface, generate a proof, and you're in!

Pipelined proving for real-time play

Neither would the game as a whole: each player is involved in several actions over the 10 turns, and each of these actions is proven. With several concurrent players, you quickly scale into hundreds of interactions in just a few seconds! On a legacy Layer 1, this would be prohibitively expensive and far too slow.

On top of that, the Crash game is time-sensitive and would not work on a legacy blockchain.

Hyli decouples proof generation from user interaction using pipelined proving.

Whenever a player spins the wheel, takes an action, or plays a mini-game, the front end executes optimistically. You don’t wait for a proof, you just see the result. In the background, a proof is generated, and once ready, it’s verified onchain to settle the result for good.

This approach allows Orange Trail to handle many concurrent players betting on a seconds-long mini-game. You get the speed of Web2 with the trust of verifiable computing: this is what Hyli enables, and the Internet we are building for.

Fun fact: we were inspired by Mario Party to create the Orange Trail game in our first internal hackathon. That’s why the subdomain name is still the original name, « degen party »!

The Hyli testnet is live! You can explore the Orange Trail at hyli.fun if you have an invite code or start building your own mini-game right now.