Published experiments, with receipts.

Housekeeping, not a feature: the running text on Home, Research, Physics, About, and Support was hitting the container's edge on tablet widths, so the narrow-content column went from 840px to 900px. Small, but it's the kind of thing that quietly signals "nobody proofread this on a real screen," and that's not the register we want.

The other two are link hygiene. TrainingSharks (our sister project, same engine-first build, pointed at a game that's actually beatable with skill) now gets a reciprocal footer link; it already linked here. And the session-summary footnote on /play, which previously only stated the fixed theoretical return, now closes with the same nudge toward the reading list that the marketing pages already carry. Anyone who lands straight on /play and never scrolls a marketing page was missing the one honest ask this project makes. Now they see it exactly once, in the same dry parenthetical voice as the rest of the stat panel.

Eight small additions, one goal: put the house edge on screen in real time instead of leaving it implied. The live table read-out (derived straight from the engine's own payout resolver, not a re-derivation) shows coverage, true win probability, and expected value per spin for whatever's on the felt right now: drop $25 on a dozen and a street and watch the EV go red before you spin, not after. The hot/cold heat map does the companion job for the physical half of the thesis: a confidence-scaled tint per pocket, with an in-app note that on this fair RNG a hot run is variance, not signal, the same distinction Jagger's scratch-marked wheel and Ethier's 1982 sample-size math draw on the Physics and Research pages, now sitting on the board itself instead of only in the prose.

The rest is scaffolding for the same honesty: a shareable run seed (?seed= in the URL, one deterministic sequence per seed, manual and auto spins both routed through it) so a result can be handed to someone else and reproduced exactly; a ten-step guided tour that replaces the old bank auto-open for first-timers; a session summary with net P&L, peak, max drawdown, and streaks for the spins since page load; and saved bet templates so testing a layout twice doesn't mean re-clicking it twice. None of it moves the edge. All of it makes the edge harder to look away from.

Shipped the first pass of the metrics that make variance legible instead of a feeling: maximum drawdown, the time-to-ruin distribution, and terminal-bankroll spread across a backtest. These are the numbers that separate "feels safe" from "is safe." Martingale posts a gorgeous win rate and a fat left tail; the drawdown metric is where that tail finally shows up on screen instead of ambushing you on spin 200.

The math underneath is old and settled. The gambler's-ruin problem, worked out in full in Feller's Introduction to Probability Theory, Vol. 1, gives the exact probability that a bankroll hits zero before it reaches a target when every bet carries negative expectation. We don't just trust it; the deterministic engine simulates the same setup and we check the empirical curve against the closed form. They agree. That agreement is the whole reason to keep the engine reproducible.

The autopilot personas now run four textbook progressions side by side (Martingale, D'Alembert, Fibonacci, and Labouchère), each with its own live P&L. None of them beats the wheel; that was never the experiment. The experiment is watching how differently they lose. Martingale bets the farm to claw back a nickel. D'Alembert bleeds slowly and smoothly. Labouchère hides its risk inside a list you have to read twice. Same −2.7% expectation, four completely different variance signatures.

This is the point Richard Epstein makes in The Theory of Gambling and Statistical Logic, still the classic catalog of the field: every betting system is a re-parameterization of one fixed edge. You can move the risk around (front-load it, smear it out, disguise it), but the integral under the curve doesn't move. Seeing that on four synchronized equity curves is more convincing than any paragraph, including this one.

Started the real design work on wheel-bias modeling, the feature that turns "hunt for real-world physics" from a slogan into something you can do here. Before writing a line of it, we did the statistics homework: how many spins does it actually take to prove a wheel is biased? Ethier's 1982 paper in the Journal of the American Statistical Association, "Testing for Favorable Numbers on a Roulette Wheel," works out the sample sizes, and they are humbling. Detecting a single over-represented pocket at any honest confidence level takes thousands to tens of thousands of logged spins. Joseph Jagger's clerks in 1873 weren't being thorough for sport; that's simply the sample size the math demands.

The other half of the record isn't bias at all: it's physical prediction. Small and Tse showed in Chaos (2012) that clocking a real wheel's initial position and velocity yields roughly an 18% edge with a hidden clicker: the modern, peer-reviewed descendant of the Eudaemons' shoe computer. Both halves, persistent bias and single-spin prediction, are getting instrumented here. Neither is a promise that you'll win. Both are a promise that it'll be a fair fight against real math.

The simulator existed before the brand did. This week we gave it a name, 0xRoulette, and a face: a light/dark themed site, a research notebook (this page), and the honest business scaffolding every public tool needs. Privacy, terms, affiliate disclosure, consent-gated analytics. Nothing about the engine changed; we just stopped hiding it behind a single unlabeled page.

The thesis is unchanged: roulette is a fixed negative-EV game, and over the long run no strategy has closed the gap on the house edge. We take the carrot seriously enough to test it honestly, and to report exactly where, and how, it slips out of reach. What we study is variance, the shape of the chase, not a phantom edge we promise you'll find.

The backtest kernel runs in a dedicated Web Worker with a 30-second watchdog, so a strategy looping over thousands of spins never blocks the UI and a wedged run can't poison the next. Two independent seeded PRNGs drive each run: a pocket RNG for spin outcomes, and a separate strategy RNG exposed to Lua as ctx.rng(), seeded by (seed ^ 0x9e3779b9) so a strategy's own randomness can't accidentally correlate with the wheel.

Reproducibility is the feature that makes results comparable across strategy iterations. math.random is nil'd inside the sandbox specifically to force the deterministic path.