Does a Martingale on dozens work?

How Dozen Martingale is played

1. Bet on the third dozen (25–36), starting at one unit.
2. After a loss, stake the smallest whole number of units whose 2:1 win covers all losses since the last win plus one unit.
3. After a win, return to one unit.

What 20,000 sessions show

Sessions that finished ahead were up $201.90 on average; sessions that finished behind were down $837.90. 22.2% of sessions ended because the next stake no longer fit the bankroll or the table limit.

Because a dozen pays 2:1, the stake only needs to grow by about 1.5× per loss instead of 2×. The catch is that a dozen loses 25 of 37 spins, so long losing runs are far more common than on red or black. Ten or more misses in a row happen regularly.

The median session lasted 70 spins. The median longest losing run was 9 spins in a row (the worst of 20,000 was 12), and one session in ten put at least $350 on the table in a single spin.

European versus American wheel

The same 20,000 seeds, replayed on a double-zero wheel. The second zero roughly doubles the edge to $5.26 per $100 wagered. Measured return goes from −$2.55 to −$5.10 per $100, and the mean session from −$29 to −$61.

The code that produced these numbers

This Lua is the strategy as Engineer mode runs it, inside the same sandbox and kernel. A test in the repository replays it against the bulk generator on fixed seeds and fails the build if the two ever disagree by a single dollar.

-- Dozen Martingale: bet one dozen and raise the stake after each loss so the next 2:1 win recovers everything.
-- Session rules shared by every 0xroulette.com/systems page:
-- $5 unit, $500 table max, walk away at +$200, and stop the moment
-- the next stake can't be covered by the bankroll or the table limit.
local UNIT, TABLE_MAX, TARGET = 5, 500, 200

local THIRD = {}
for n = 25, 36 do THIRD[#THIRD + 1] = n end
local down

local function reset() down = 0 end

local function place(ctx)
  local units = math.ceil((down + UNIT) / (2 * UNIT))
  return { { type = "dozen", pockets = THIRD, amount = UNIT * units } }
end

local function settle(result)
  if result.net > 0 then down = 0 else down = down - result.net end
end

-- Shared wrapper: enforces the session rules around place/settle.
strategy = {}
local start, stopped

function strategy.setup(ctx)
  start, stopped = ctx.bankroll, false
  reset()
end

function strategy.bet(ctx)
  if stopped or ctx.bankroll >= start + TARGET then
    stopped = true
    return {}
  end
  local bets, stake = place(ctx), 0
  for _, b in ipairs(bets) do
    if b.amount > TABLE_MAX then stopped = true end
    stake = stake + b.amount
  end
  if stake > ctx.bankroll then stopped = true end
  if stopped then return {} end
  return bets
end

function strategy.on_spin(ctx, result)
  if not stopped then settle(result) end
end

Session rules

Limitations

One bankroll, one unit size, one table limit, and one walk-away target. A bigger bankroll or a higher limit moves where a progression breaks; it does not change the return per dollar wagered. Spins are fair and independent, as on a correctly functioning wheel or a certified RNG. Physical wheel bias is a separate question, covered on Physics.

Related

• Does the Martingale system work?
• Does betting on two dozens work?
• Does the Grand Martingale system work?
• All 20 systems, compared on the same seeds