STEP 01 // THE ARENA01/07
The screen is the battlefieldInsert coin and a living peg-board unfolds — its shape carved from a daily AI image. 100 champions drop onto one shared board.
STEP 02 // THE CROWD02/07
Hundreds of sticks. One cabinet.No solo terminal here. Whole crowds pile onto the machine and fight over the very same board, live.
STEP 03 // THE INPUT03/07
Every button is a signed moveAngle, power, timing — each shot becomes a signed command in a public input stream. Pure skill, no hidden dice.
STEP 04 // THE STAKES04/07
Play free — or play for the potEvery match runs the same, stakes or none. Back a game with a wager and the engine pays the winners — it never takes a shot.
STEP 05 // THE ENGINE05/07
The core can't lieOne deterministic engine, native and WASM. Same seed, same signed shots, same result — every single time.
STEP 06 // THE NETWORK06/07
Every classic on the marqueeEach arcade classic becomes its own massive arena on the same engine. One arcade, a hundred games.
STEP 07 // THE PROOF07/07
It replays itselfAnyone can re-run the match through the engine and land on the exact same score. The replay is the audit — outcomes are checked, not trusted.
The deterministic arcade engine
Fun games,massive live arenas.
A deterministic game engine that turns classic arcade games into huge real-time multiplayer battles — hundreds of players in one match — and provable wager games. Every match replays frame-for-frame, so the outcome is audited, not trusted.
- Deterministic replay
- Any player count
- Provable outcomes
Provable outcomes, not trust-me servers.
Most online games ask you to trust a server you can't see. A deterministic engine computes the identical result for every player and replays it frame-for-frame — so a 500-player arena or a head-to-head wager is audited, not asserted.
You take the server's word for it.
Opaque server logic, hidden state and closed settlement mean you can't prove what actually happened.
- Match logic runs where you can't see it
- Desyncs you have no way to prove
- No independent replay of a result
- “Fair” is just a screen that says so
Every player computes the same match.
The same signed inputs run through the same engine and land on the same result — anywhere, any time.
- Identical logic for every player
- Every result has a replay path
- Scales from duels to huge arenas
- Outcomes are verified, not trusted
From inputs to a result anyone can re-run.
Every player's actions are captured as signed frames. Re-run those exact inputs through the engine and you land on the identical outcome — that is the audit. No trusted referee, no hidden state.
- 01Seed
The player list and board freeze, then a public seed sets the arena. Same start for everyone, no re-rolls.
- 02Play
Every shot is a signed input. One deterministic engine runs the match — no hidden dice, no server secrets.
- 03Record
The roster and every signed action are written to a public input codex — one exact record of the match.
- 04Replay
Anyone can re-run the codex through the engine and land on the exact same result.
- 05Verify
The canonical verifier re-checks it natively and in WASM. Both must agree on the outcome.
- 06Settle
The result is final because it's reproducible. Winners are decided by the engine, not a referee.
One engine. Every game becomes an arena.
Ricoshot is the founding proof: a skill-driven physics battle royale, not a reskinned coin flip. New games and rivalry formats run on the same deterministic, auditable engine.
LiveThe founding mass arcade
Ricoshot
A deterministic physics battle royale where up to 100 players aim, build, raid and survive across living peg arenas.
pvepvpteambattle royaleup to 100
Enter the arena ↗
prototypeCo-op community raids
Vault Runners
PvE crews route physics shots through shared vault puzzles and race the global clear clock.
pveteamup to 16
View the roadmap ↗
upcomingCommunity versus community
Rival Grid
Fast seasonal objectives turn participation, wins and team play into normalized rivalry points.
pvpteamup to 64
View the roadmap ↗Your token. Your arena. Shared rules.
The arcade launches on native SOL. Reviewed communities can add isolated token treasuries, season terms, themes and public fee schedules without changing the platform default.
Review gated
Beta Test Community
A paused reference edition proving the arcade can isolate an optional community token and treasury without changing the platform SOL default.
- Funding
- Aligned season
- Match fee
- up to 5%
- Compatibility
- Classic SPL
Communities compete on play, not market cap.
Season points normalize participation, wins and community quests. A token worth one cent and a token worth one dollar can still meet on the same cultural scoreboard.
RankCommunityRivalry pointsParticipationTrend
#1Beta Devnet9,86088%new
#2Next community7,44084%applications
Pick the model. See every unit move.
A community can sponsor a flat season with no match take, or enable an aligned season where the immediate fee can never exceed 5% and longer player locks reduce it.
Player claim choice
Every unit accounted for
Gross result10,000 SOL
- Protocol service fee
- − 500
- Player receives
- 9,500
- Protocol fee co-locked
- 0
Immediate claims stay liquid. The disclosed fee is never tied to whether a particular player wins or loses.
The chain anchors. The replay proves.
We make a narrower, honest claim than trust-me servers: Solana holds custody and commitments, and a deterministic verifier reproduces the massive game that cannot fit inside one transaction. Signed inputs plus one canonical engine rebuild the exact match — natively and in WASM.
Custody and commitments.
- Per-match token vault and frozen roster
- Randomness seed reference
- Codex and settlement roots
- Challenge and claim state
- Recipient-bound settlement leaves
Boards, play and payouts.
- Board generation from the adopted seed
- Every signed player action in the codex
- Native and WASM deterministic simulation
- Score ordering and reward ledger
- The same settlement root committed onchain
Verify a real bundle
Do not stop at a green check.
The public input codex records exactly what was played. The canonical verifier rebuilds the board, re-runs every signed action and confirms the result — natively and in WASM. On-chain, the escrow anchors custody and the settlement root commits the outcome.
Latest replay bundleVERIFY
$ rr verify --replay 7ef5…21ba
- escrow
- ricochet_escrow devnet
- roster_root
- 0xb6c9…21de
- codex_root
- 0xf634…80f7
- settlement_root
- 0x14a2…d998
- challenge_state
- window elapsed
- native / wasm
- matching ✓
Launch a community edition
Turn holders into teammates and rivals.
Choose a game, verify a classic SPL token, pick flat or aligned funding, theme the arena and enter review. The pilot is assisted by design—no permissionless real-token launches while the proof is still on devnet.
Prove the engine, then scale the arenas.
Deterministic core
One engine, signed inputs, frame-for-frame replay and independent native + WASM verification.
Massive arenas
Scale a single match to hundreds of players, with boards sized to the crowd.
More games
New arcade classics and rivalry formats running on the same auditable engine.
Provable wagers
Optional stake-backed matches where the outcome is computed and verified, never trusted.
GG — you walked the whole machine
The cabinet belongs in the arcade.
The cabinet stays in the lineup. Signed inputs, replay and verification stay public — so every match can be re-run and checked, whether anyone is standing in front of it or not.