What Is a Sensitivity Converter?

Why a Raw Sensitivity Number Means Nothing by Itself

If you've ever asked someone what sensitivity they play on and tried to copy the exact number into your own game, you've probably noticed it felt completely wrong. A "0.4" in one game is not the same physical speed as a "0.4" in another — not even close, in most cases. This isn't a bug or a coincidence; every game engine defines sensitivity on its own internal scale, and those scales can differ by a factor of ten or more between titles.

A sensitivity converter exists to solve exactly this problem. Instead of copying a raw number, it translates your actual physical mouse movement — the thing your hand and muscle memory actually learned — from one game's scale into another's, so the feel carries over exactly.

The Physical Constant Underneath Every Conversion

The number a converter actually preserves is called cm/360: the distance, in centimeters, your mouse has to physically travel across your mousepad to turn your in-game camera a full 360 degrees. It's a physical measurement, not a software one, which is exactly why it's the one thing that stays meaningful across any game. If your cm/360 is 40cm in Valorant, and you convert to a cm/360 of 40cm in CS2, your hand makes the exact same motion for a full turn in both games — even though the raw sensitivity numbers on screen look nothing alike.

DPI and sensitivity you already know. Yaw is the piece most players have never heard of: it's a constant built into each game's engine that defines exactly how many degrees the camera rotates per raw mouse count. It's not adjustable in a menu — it's baked into the game itself, and it's the reason the same sensitivity slider produces different speeds in different games.

Where Yaw Constants Actually Come From

Yaw traces back to Quake's original engine code, which defined a default "m_yaw" console variable of 0.022 degrees per count. That exact constant got carried forward, unchanged, through GoldSrc, Source, and Source 2 — which is why CS 1.6, CS:GO, CS2, Half-Life 2, Team Fortress 2, Apex Legends (a modified Source engine), and dozens of other titles all share the identical 0.022 yaw and convert 1:1 with each other at the same DPI and sensitivity. Other engines picked their own constants independently: Valorant's Unreal Engine build uses 0.07, Fortnite uses 0.005555, and Overwatch 2 and the modern Call of Duty titles both converge on 0.0066.

A sensitivity converter's job is simply to know each supported game's yaw value and run the cm/360 formula twice — once to read your current physical distance, once to solve for the sensitivity number that reproduces it in a different game.

How to Actually Use One

1. Find your current DPI in your mouse software (Logitech G Hub, Razer Synapse, or similar), or on a physical DPI indicator/button on the mouse itself.
2. Note your current in-game sensitivity, exactly as shown in that game's settings menu.
3. Select your current game and your target game in the converter — on DCPROSENS's homepage, this is the "Convert From" and "Convert To" dropdowns.
4. Enter your DPI and sensitivity, and read off the converted sensitivity for your target game, along with your cm/360, which should match in both games.
5. Type the new number into your target game's settings, keeping your mouse DPI unchanged — DPI is a hardware setting shared across every game, so it never needs to change as part of a conversion.

What a Converter Gets Right — and What It Doesn't Cover

A yaw-based converter is exact for games with a simple, linear sensitivity model — which covers the vast majority of competitive shooters. A few things sit outside what a straightforward conversion can capture:

• ADS/scoped sensitivity. Most games apply a separate multiplier when aiming down sights or using a scope, on top of your base hipfire sensitivity. This needs its own conversion or manual tuning per game.
• Games with non-linear sensitivity curves. A small number of titles (Minecraft Java is the best-known example) scale mouse input on a curve rather than a straight multiplier, so no single conversion number is exact at every setting — only a close approximation.
• Games without a rotating first-person camera at all. MOBAs, top-down games, and click-to-move titles don't have a yaw constant to convert in the first place, since there's no camera rotation tied to mouse movement — DPI and click precision matter more there than sensitivity conversion.

Why This Matters More Than It Seems

Aim is largely a matter of trained, physical muscle memory — the specific relationship your hand has learned between "how far I move my arm" and "how far my crosshair travels." That relationship is what cm/360 actually measures. Guessing at a sensitivity number when switching games, or copying a pro's raw settings without accounting for your own DPI, effectively resets weeks or months of that trained motion. A proper conversion is the difference between adjusting to a new game's mechanics (unavoidable) and also having to relearn your entire aim from scratch (avoidable).

Common Conversion Scenarios

From → To	Yaw Ratio
Valorant → CS2	× 3.1818 (0.07 ÷ 0.022)
CS2 → Apex Legends	× 1 (identical yaw, 1:1)
Fortnite → Valorant	× 0.0794 (0.005555 ÷ 0.07)
Overwatch 2 → CS2	× 0.3 (0.0066 ÷ 0.022)

These ratios are exact and hold for any DPI — they only depend on the two games' yaw constants, which is exactly why a proper converter (rather than eyeballing "similar-feeling" numbers) is worth the ten seconds it takes to use.

A Worked Example From Scratch

Say you play Fortnite at 800 DPI with a 0.15 sensitivity, and you want your exact equivalent in Overwatch 2. First, calculate your current cm/360 using Fortnite's yaw (0.005555):

Now solve the same formula in reverse for Overwatch 2, using its yaw (0.0066), keeping DPI and cm/360 fixed and solving for the unknown sensitivity:

Entering 0.126 sensitivity at 800 DPI in Overwatch 2 reproduces the exact same 137.1cm physical turning distance you had in Fortnite. This is the entire calculation a converter runs behind the scenes — the tool just does both steps in one action and skips the manual algebra.

How Games Without a Simple Yaw Model Are Handled

Not every game fits the clean linear formula above. A small number of titles — Minecraft Java being the clearest example — scale mouse input through a more complex, non-linear curve rather than a straight multiplier. In these cases, a converter can only offer a close approximation tuned to the sensitivity range most players actually use (commonly the 40–70% slider range for Minecraft), rather than a mathematically exact result at every possible setting. Reputable converters flag these games explicitly rather than presenting an approximation as if it were exact — worth checking for that disclosure before trusting a specific number down to the decimal.

Building Trust in a Converter's Numbers

Because yaw constants aren't published in official patch notes for most games, the values a converter uses have to come from somewhere reliable: reverse-engineered console commands (many Source-engine titles expose m_yaw directly), community-measured data using tools built specifically to detect a game's rotation-per-count ratio, or, for the most well-documented engines, official developer statements. A converter worth trusting should be able to explain where each value came from — treat any tool that can't as offering a rough estimate rather than a verified number, and cross-check important conversions (like a full esports team standardizing settings) against a second independent source.