How CS2 Actually Calculates Output Float (The Post-2024 Formula)

Since an October 2024 update, CS2 calculates trade-up output float with a normalized formula: each input float is first normalized within its own skin's float range, the ten normalized values are averaged, and that average is projected onto the output skin's range. A calculator that instead averages the ten raw input floats directly, the way some older tools still do, produces a wrong wear-tier prediction whenever any input has a narrow or offset float range, which is common.

Test this formula against exact input floats with the CS2 trade-up calculator, which implements the normalized formula, or browse live trade-ups priced against landed float rather than a wear-tier midpoint.

The Two-Step Formula

Each input float is first normalized to a 0-to-1 scale relative to its own skin's minimum and maximum float:

n_i = (f_i - min_i) / (max_i - min_i)

The ten normalized values are averaged, and the average is projected onto the output skin's own float range:

f_out = avg(n) * (max_out - min_out) + min_out

The Old Way Was Wrong

Before the October 2024 update, some calculators simply averaged the ten raw input floats and projected that raw average straight onto the output skin's range, skipping the per-input normalization step entirely. Any calculator still doing this today gives wrong wear-tier predictions for outputs whose float range is narrow or does not start at 0.00, because raw floats from inputs with different ranges are not directly comparable, and averaging them without first normalizing throws away the information needed to project correctly onto the output.

Worked Example

Take two hypothetical inputs, both sitting at the same raw float of 0.06, but with different float ranges. Input A has a range of 0.00 to 0.08. Input B has a range of 0.00 to 1.00. The output skin has a range of 0.00 to 0.50.

Normalizing each input against its own range: A gives n_A = (0.06 - 0.00) / (0.08 - 0.00) = 0.75. B gives n_B = (0.06 - 0.00) / (1.00 - 0.00) = 0.06. Averaging the two normalized values: avg(n) = (0.75 + 0.06) / 2 = 0.405. Projecting onto the output range of 0.00 to 0.50: f_out = 0.405 * (0.50 - 0.00) + 0.00 = 0.2025, which is Field-Tested.

Now the wrong way: average the two raw floats directly, (0.06 + 0.06) / 2 = 0.06, and project that straight onto the output range without normalizing first: 0.06 * 0.50 = 0.03, which is Factory New. Two inputs at an identical raw float of 0.06 produce a correct output of 0.2025 (Field-Tested), but a naive raw-average calculation predicts 0.03 (Factory New), an entirely different condition and, on most skins, a dramatically different price. The gap exists because Input A's narrow 0.00-to-0.08 range makes its 0.06 float sit at 75% of its own range, a fact the raw-average method never accounts for.

Why This Matters for Capped-Float Contracts

This is exactly why capped-float contracts, ones deliberately built to land a Factory New or Minimal Wear output rather than whatever the collection happens to weight toward, are calculable in advance rather than a matter of luck. Because the formula is fully deterministic given exact input floats and both skins' ranges, you can work backward from a target output float, solve for the maximum average adjusted float that still lands under a condition boundary, and select inputs that hit it. None of that backward-solving works if the underlying formula being solved is the wrong one.

What Our Calculator Does

The CS2 trade-up calculator implements the normalized formula exactly as described here: per-input normalization against each input's own range, averaged, then projected onto the output skin's range. On the live trade-up boards, every priced contract is valued against its landed float, the specific number this formula produces for that exact set of inputs, not a wear-tier midpoint or an assumed "typical" float for the condition. A contract priced off a midpoint can be meaningfully wrong in either direction; a contract priced off the landed float is priced off the number the game will actually produce.

FAQ

How does CS2 calculate output float in a trade-up?

Each input float is normalized against its own skin's float range, the normalized values are averaged, and the average is projected onto the output skin's float range: f_out = avg(n) * (max_out - min_out) + min_out.

Is CS2 trade-up output float just the average of the input floats?

No. The raw input floats are not averaged directly. Each one is first normalized to its own skin's range, and only the normalized values are averaged before being projected onto the output range.

When did CS2 change the trade-up float formula?

An October 2024 update put the current normalized formula in place. Before that, some calculators averaged raw input floats without normalizing first, which produces incorrect wear-tier predictions for skins with narrow or offset float ranges.

Do some CS2 trade-up calculators still get the float formula wrong?

Yes. A calculator that averages raw input floats and projects the raw average directly onto the output range, skipping per-input normalization, will misstate the output condition whenever an input's float range is narrow or does not start at 0.00.

Published 2026-07-06 by CSAlpha Team.