JJoche Ojeda.NET · XAF · AI · architecture
Aug 25, 202610 min read/2026/08/25/from-elo-to-trueskill/

From Chess to Xbox: The Rating System Behind the Match

EloTrueSkillRating SystemsBayesianMatchmakingXbox

Every Elo limitation is a TrueSkill feature.

There's a story that gets repeated in game-dev threads: "Xbox Live uses the Elo equation to calculate experience points." It's a tidy sentence, and almost every word of it is wrong.

Elo isn't an experience-points system. Xbox's experience points (Gamerscore) don't use Elo. And the skill system Xbox does use for matchmaking isn't Elo either — it's TrueSkill, a system Microsoft Research built precisely because Elo couldn't do what a game console needed.

So let's take the real journey: from a physicist scoring chess games in 1960, to the algorithm deciding who you get matched against on Halo. It's a great arc, because every weakness in Elo turns out to be something TrueSkill was designed to fix.

First, let's clear the table.

Three systems people keep confusing

System What it measures Can it go down? What Xbox uses it for
XP / Gamerscore time and effort you've put in No — it only accumulates Achievements, leveling
Elo your skill relative to one opponent Yes (chess — not Xbox)
TrueSkill relative skill, with teams, many players, and a measure of confidence Yes Matchmaking

XP is a one-way ratchet. You earn it by showing up; it never drops. Gamerscore is the purest version — every achievement is worth a fixed number and you simply add them up. There's no clever equation here, and there's certainly no Elo.

Elo and TrueSkill are the opposite kind of number. They measure how good you are compared to everyone else, they're roughly zero-sum, and they can fall. That's the family we're interested in — and the reason people reach for Elo when they actually want XP (or the other way around) is worth its own warning: if you want a leveling curve, a rating that drops when you lose will feel like punishment for playing. Pick the tool for the job.

With that sorted, here's Elo.

Elo: the entire system in two formulas

Arpad Elo was a physics professor and a strong chess player who, in the 1960s, replaced the chess federation's ad-hoc rating scheme with something grounded in statistics. The whole thing runs on two equations.

1. What do we expect to happen? Before the game, Elo predicts your chance of winning from the rating gap alone:

E_A = 1 / (1 + 10 ^ ((R_B − R_A) / 400))

That's a logistic curve. The two magic constants are pure convention: base 10 and the 400 are chosen so that a 400-point gap means 10-to-1 odds. Equal ratings give E_A = 0.5 — a coin flip.

2. What do we do about the result? After the game, nudge the rating toward reality:

R_A′ = R_A + K · (S_A − E_A)

where S_A is the actual result — 1 for a win, 0.5 for a draw, 0 for a loss — and K is the step size. That's it. That's the whole system.

A worked example

Say you're rated 1600 and your opponent is 1400 — a 200-point gap.

E_you = 1 / (1 + 10 ^ (−200/400))
      = 1 / (1 + 10^−0.5)
      = 1 / (1 + 0.316)
      ≈ 0.76

Elo expects you to win 76% of the time. Now watch what the update does, using K = 20:

  • You win (the expected result): 1600 + 20 · (1 − 0.76) = 1600 + 4.8 = 1604.8. A small reward — you were supposed to win.
  • You lose (an upset): 1600 + 20 · (0 − 0.76) = 1600 − 15.2 = 1584.8. A big hit — the system is surprised, so it corrects hard.

Your opponent moves by the same amounts in the opposite direction. Beating someone you were expected to beat earns almost nothing; losing to them costs a lot. That asymmetry is the intelligence of the system.

The K-factor is the whole personality

K decides how much each game matters. It's the one knob, and it's a genuine trade-off:

  • High K → the rating reacts fast to new results, but it's jumpy and noisy.
  • Low K → the rating is stable and hard to move, but slow to recognize that you've improved.

Chess federations paper over this by tiering K: something like 40 for newcomers (learn fast), 20 for the middle, 10 for masters (already well-measured, keep it steady). Hold onto that idea — "we wish K could adapt to how well we already know a player" — because it's exactly the seam TrueSkill pulls on.

Where Elo breaks

Elo is beautiful for what it was built for: one human versus one human, over and over, forever (chess). Point it at a modern console shooter and four cracks appear immediately.

  1. It's strictly 1v1. Elo has no native concept of a team, a 2v2, or a 16-player free-for-all. You can bolt on hacks (average the team ratings, run pairwise comparisons) but they're all patches on a model that fundamentally sees two players.

  2. A single number hides confidence. A brand-new player placed at 1500 and a grizzled veteran who's settled at 1500 over 500 games look identical to Elo. But you know far more about the veteran. Elo has nowhere to store "how sure am I about this rating?"

  3. The cold-start problem. Because of #2, a new player's rating is basically a guess for dozens of games. During that stretch they're mismatched — stomping people or getting stomped — while Elo slowly walks their number to where it belonged all along.

  4. K is a manual knob you'll get wrong. Tiering K by rating is a crude fix. What you actually want is for the step size to depend on how well you already know this specific player — big steps when you're unsure, tiny steps once they're pinned down. Elo can't express that.

Now read those four again as a wishlist. That wishlist is TrueSkill.

TrueSkill: every limitation, answered

In 2006 three Microsoft researchers — Ralf Herbrich, Tom Minka, and Thore Graepel — published TrueSkill for exactly this problem: rating players fairly on Xbox Live, where matches are teams, parties, and quick sessions, and where a new player needs a fair match fast. Here's how it dismantles each of Elo's four problems.

Skill is a bell curve, not a number

This is the whole idea. TrueSkill doesn't store one number for your skill; it stores a Gaussian — a bell curve N(μ, σ):

  • μ (mu) — its best guess for your skill.
  • σ (sigma) — how uncertain it is about that guess. Wide curve = "we're not sure yet." Narrow curve = "we've got you pinned."

A new player starts wide. Microsoft's defaults are μ = 25 and σ ≈ 8.33 (that's 25⁄3). As you play, μ homes in on your true skill and σ shrinks. That single addition — carrying your uncertainty around with you — is what answers limitation #2, and it makes the other three fall over too.

Your shown rank is deliberately pessimistic

If TrueSkill only showed μ, a lucky newcomer would rocket up the leaderboard on a tiny sample. So the number you actually see is conservative:

rank = μ − 3·σ

It subtracts three standard deviations of doubt. A fresh player (μ=25, σ=8.33) ranks at 25 − 25 = 0 — the system flatly refuses to brag on your behalf until it's seen enough to be sure. As σ shrinks with every game, that penalty melts away and your rank climbs toward your true μ. Uncertainty isn't just stored; it's charged for.

The step size becomes automatic (goodbye, K-factor)

Here's the payoff for limitation #4, and it's the most elegant part. Look at the 1v1 update — this is the real thing, not a caricature:

# A player is a Gaussian: (mu, sigma)
# Microsoft's default constants:
MU0    = 25.0
SIGMA0 = MU0 / 3         # ≈ 8.33   starting uncertainty
BETA   = SIGMA0 / 2      # ≈ 4.17   per-game performance noise ("luck")
TAU    = SIGMA0 / 100    # ≈ 0.083  slow skill drift, per game

function updateTrueSkill1v1(winner, loser):
    # 1. let old ratings breathe: nudge uncertainty up a hair
    winner.sigma = sqrt(winner.sigma^2 + TAU^2)
    loser.sigma  = sqrt(loser.sigma^2  + TAU^2)

    # 2. total uncertainty in THIS matchup (both players + game luck)
    c = sqrt(2·BETA^2 + winner.sigma^2 + loser.sigma^2)

    # 3. how surprising was the result?
    t = (winner.mu − loser.mu) / c
    v = pdf(t) / cdf(t)        # pdf, cdf = standard normal density & cumulative
    w = v · (v + t)

    # 4. move each mean — scaled by that player's OWN uncertainty
    winner.mu += (winner.sigma^2 / c) · v
    loser.mu  −= (loser.sigma^2  / c) · v

    # 5. shrink each uncertainty — we just learned something
    winner.sigma *= sqrt(1 − (winner.sigma^2 / c^2) · w)
    loser.sigma  *= sqrt(1 − (loser.sigma^2  / c^2) · w)

    return winner, loser

Ignore the Greek for a second and look at step 4. Each player's μ moves by an amount scaled by their own σ². That's the trick:

  • New player, big σ → big update. The system happily rewrites a rating it isn't confident in.
  • Veteran, small σ → tiny update. One weird game barely budges a rating that's earned its precision.

TrueSkill's "K-factor" isn't a knob you set — it's σ²/c, computed fresh every game from how well the system already knows each player. That's exactly the tiered-K wish from the Elo section, except it's continuous, automatic, and per-player. And it's why TrueSkill converges in a handful of games where Elo needs dozens: σ starts big (fast learning) and self-tightens (stability) with no human tuning.

(That v/w pair in step 3 is the one bit of real math: it comes from a truncated Gaussian — the belief "the winner's performance landed above the loser's." Solving a whole match of these at once is done with Bayesian message-passing on a factor graph. That machinery is a paper of its own; the takeaway is that a result updates a belief, and the belief carries its own confidence. See Herbrich et al., 2006, and move on.)

Teams and free-for-alls come for free

Limitation #1 falls out of the Gaussian model almost as a bonus, because Gaussians add:

  • Teams: a team's performance is the sum of its members' skill curves — means add, variances add. A 3-player team is just one bigger Gaussian. Uneven teams (2v3) are handled honestly instead of hand-waved.
  • N players / free-for-all: a final standing of "1st, 2nd, 3rd, 4th…" is just a chain of pairwise facts — "player 1 finished above player 2," "player 2 above player 3," and so on — each one a truncated-Gaussian update like the 1v1 case. An eight-player deathmatch is seven ordered comparisons.

Elo needed bolt-ons to fake this. TrueSkill treats a 4v4 with a party of friends as the normal case, because that's the case it was born to solve.

The through-line

Elo's problem TrueSkill's answer
1v1 only Gaussians add → teams and N-player fall out naturally
One number hides confidence Carries σ, an explicit uncertainty, per player
Cold start: slow to place new players Big initial σ → large early updates → placed in a handful of games
K-factor is a manual knob Step size is σ²/c, computed per player, per game

Stand back and the shape is clear. Elo answered a 1960s question — how do we fairly rank chess players who face each other one-on-one for years? — and answered it so well it's still running. Xbox Live asked a different question: how do we drop a new player, in a party of three, into a fair 4v4 within their first few matches? Same DNA, harder problem. TrueSkill's move was to stop pretending it was certain — to carry its own doubt around and let that doubt do the work.

So the next time someone tells you Xbox uses "the Elo equation for XP," you've got the real story: XP just adds up, the matchmaker runs TrueSkill, and the line from one to the other is a thirty-year lesson in what a rating is actually for.

Further reading: Herbrich, Minka & Graepel, "TrueSkill™: A Bayesian Skill Rating System," NIPS 2006 (Microsoft Research).