What Importing a CS2 Crosshair Code Actually Changes

Someone hands you their code, you paste it into the crosshair menu, and what you get is almost their crosshair. A touch bigger, maybe. Or it pulses when you move and theirs sat still. Or you scope the AWP and the crosshair in the scope is the one you have always had.

None of that is a bug. A crosshair share code sets a fixed list of console variables and is silent about everything else, and the parts it stays silent on keep whatever value you were already running.

Want the list for a specific code? Paste it into the CS2 Crosshair Code Decoder and it prints every cl_crosshair* line the code sets.

A code is 21 console commands and nothing else

Importing a code, whether through the settings menu or by pasting the decoded commands into the console, comes down to running a block of cl_crosshair* assignments. The reference implementation this site's decoder is transcribed from expands a valid code into exactly 21 of them.¹ Style, size, thickness, gap, the fixed gap, the outline and its thickness, the centre dot, the T shape, the colour preset and the custom RGB, the alpha and its toggle, the deployed-weapon gap toggle, the follow-recoil flag, and the four convars that shape a dynamic crosshair's split. That is the whole set. The byte-level detail of how those 21 values fit into 18 bytes is its own article; what matters here is the edge of the list.

Everything outside those 21 assignments is left alone. That is where an imported crosshair usually goes wrong. The code sets the values it carries and says nothing about the rest, so anything you had tuned outside the list stays exactly as you left it, sitting next to a crosshair that was built around different numbers.

The style number is the same integer and a different crosshair

cl_crosshairstyle rides in three bits of the code, which is room for the values 0 through 7. The number goes in and comes back out unchanged. What the number draws is the part that moved.

CS:GO's menu offered five styles, 0 to 4. CS2's offers six, 0 to 5, with a "Legacy" option at 5 that has no CS:GO equivalent, so the numbering could not have stayed put. A given number does not select the same draw mode across the two games, and the third-party command lists do not even agree with each other on what to call styles 1, 2, 3 and 5, because Valve has never published the mapping. The share-code article goes into why.

So a code from the CS:GO era, or one exported by a builder site that still uses CS:GO's numbering, can drop you onto a style that behaves differently than it did for the person who made it. If the imported crosshair blooms when you move and the one you were copying stayed locked, or sits rigid where you expected it to open up, the style value is the first thing to check. The decoder prints it as a plain number; hold it against whatever you normally run.

Three places the format runs out of room

Most crosshairs survive a round trip through a code with every value intact. A few do not, and it is always the same three spots, where a setting has been pushed past what its slot in the 18 bytes can hold.

What the format can hold for each field, measured against the codec rather than the game.

Setting	What the code carries	What happens past that
cl_crosshair_dynamic_splitdist	0 to 7 (three bits)	a wider split has nowhere to go; the low three bits are kept and the rest is dropped
cl_crosshair_dynamic_splitalpha_innermod cl_crosshair_dynamic_splitalpha_outermod cl_crosshair_dynamic_maxdist_splitratio	one nibble each, value times ten	rounded to one decimal: 0.35 stores as 0.3
cl_crosshairsize, cl_crosshairthickness, cl_crosshairgap	one byte of tenths	above 25.5 the value wraps instead of clamping

The split distance is the one most likely to bite. It sits in three bits, so the code can only say 0 through 7. The default is 7, which is why most crosshairs are unaffected, but a dynamic crosshair tuned with a wider split loses that tuning the moment it becomes a code, and the code it produces is still valid.¹

The size ceiling is covered at length in the share-code article. A code from a crosshair builder that let you drag the size slider past 25.5 arrives with a correct checksum and describes a crosshair a fraction of the size you set, and nothing in the import flags it.

What a code never carries

Some crosshair settings are not in the format at all, so a code cannot change them no matter what it holds.

The big one is your scoped crosshair. cl_crosshair_sniper_width and the sniper-crosshair toggles are not among the 21, so importing a pro's code leaves your AWP and Scout crosshair exactly as you set it. That is almost always what you want, and occasionally a surprise when someone assumes a code carried everything and their scoped aim feels untouched because it was.

Two smaller ones sit outside the format for the same reason. The crosshair flipping to an X over a teammate is cl_crosshair_friendly_warning, and what you see while spectating is cl_show_observer_crosshair; neither is in a share code. The cl_crosshairgap_useweaponvalue toggle is carried, but the per-weapon gap values it switches to are not, so a code can turn that behaviour on without bringing the numbers behind it.

None of that is a hole in the format so much as where its authors drew the line. A share code is the cl_crosshair family without the parts that belong to a scope, a teammate marker or a spectator view rather than the crosshair you aim down.

cl_crosshair_recoil exists only in CS2

The bit that holds "follow recoil" is read by decoders for both games, but the CS:GO encoder never set it.¹ So a code shared before CS2 existed, or one produced by a tool that still targets CS:GO, carries cl_crosshair_recoil 0. If you run a crosshair that rides up with the spray pattern and an imported code flattens it back down, that flag being absent from the source is the reason.

Crosshair sharing shipped in a CS:GO update in April 2020, described in three sentences as a spectator feature for copying another player's crosshair off the scoreboard.² The follow-recoil control came years later with a different game, and the format absorbed it without a version bump, which is why an old code and a new one look identical and behave differently on that one setting.

Read the code before you run it

Applying a code is fast and mostly safe, and the one habit worth keeping is looking at the list first. The decoder prints the 21 cl_crosshair* lines a given code will set. That list is the complete set of changes. The style number and the size are the two worth a glance before you apply; everything else about your crosshair, including the parts that make an import feel slightly off, is staying exactly where it is.