A chrome roulette ball etched with glowing green Lua code, resting on the number 32 in a wooden wheel
// the house always wins. probably.

Beat the system?
Prove you can… or can't.

0xRoulette is a strategy backtesting platform for developers. The math on the payout table is fixed and negative: no betting system beats a fair wheel, or so they tell us. But a wheel is a physical object, and physical objects have been beaten before. History says so. So write a strategy, backtest it across thousands of spins, forward-test it live against the wheel, and hunt for real-world physics: log outcomes, run the statistics, find the skew, or prove there isn't one.

// what this actually is

Underneath the felt, 0xRoulette is one deterministic simulation engine you can open at three depths. It's a hacker's playground for a single stubborn question: does the house edge have a crack in it, and can you find it? Start by feeling the game lose money in real time, then climb toward the code and go looking for yourself. Same wheel underneath, more instruments the deeper you go.

Game

play

A faithful roulette simulation: full physics, animation, a real betting layout. Place chips, spin the wheel, watch the ball settle. The felt feels exactly like the felt. That's the point: you can't reason about a system you haven't felt lose money.

The Game mode felt: wheel, board, and a live TABLE MATH readout of coverage, win probability, and expected value
// the actual felt, mid-round

Advanced

observe

The lab bench. Hand the wheel to autopilot bots running classic systems, watch the P&L chart and spin history build in real time, and see variance draw its own shape (drawdowns, streaks, the slow bleed of the edge) without staking a chip yourself.

The Advanced mode bankroll history chart, tracking a Martingale autopilot bot's balance bleeding down against the house edge
// an autopilot bot's bankroll, live

Engineer

build

The IDE. Write a strategy in Lua in a Monaco editor, backtest it across thousands of spins in a sandboxed WASM VM, then forward-test the exact same code live, round by round, against the wheel. Deterministic: same seed, same result, every run.

// a taste of engineer mode

The deepest layer, up front: a real strategy, a dozen lines of Lua, wired straight into the wheel. This one's a working Martingale, and it feels unstoppable. Watch it lose.

roulette-strategy.lua: Engineer mode
strategy = {}
local step = 0

function strategy.bet(ctx)
  return { { type = "black", amount = 5 * (2 ^ step) } }
end

function strategy.on_spin(ctx, result)
  step = result.net > 0 and 0 or step + 1
end
-- a working Martingale. feels unstoppable. watch it lose.
The dangling carrot

Every system promises the carrot. Most gambling tools either pretend the math isn't settled or never mention it. 0xRoulette hands you the carrot and the measuring tape: chase the edge as hard as you like; −2.7% per unit on a European wheel is what the long run keeps quietly handing back to a betting system. Martingale feels unstoppable; it just concentrates risk into rare catastrophic events while flashing a high win rate. D'Alembert feels safer; it only smooths the ride. Same negative-EV game, different ways to dress up the same carrot.

But a betting system isn't the only kind of strategy, and a wheel isn't just math: it's a physical object. Real wheels have been beaten before, on the record, by people who did the statistics instead of the superstition. That's the crack worth chasing here: log spins, run the numbers, hunt for real-world physics. Level up your probability instincts, have fun doing it, and either find something real or prove rigorously that there's nothing to find. Both are a win.

Open the simulator · read the physics · see what we're building · the reading list