How your shell really flies: client vs server reticle

Where your shell goes isn’t decided by your screen — it’s decided by the server, based on where it thinks your gun is pointing. Most of the time your aim circle and the server’s match up, but when you flick right before the shot or hit a lag spike, they drift apart — and the shell lands “outside the circle” you saw, completely legit.

client-side circle (the prediction on your screen) server circle (what the game actually fires from) where the shell landed

1. The perfect shot: it’s all about the circle

In perfect conditions the shell always lands inside the aim circle: RNG picks the point inside it, but hits cluster towards the center. Picture this: your tank is standing still, the gun isn’t moving, the connection is flawless and everything on your screen matches the server.

Fig. 1. Aim circle and hit cloud (schematic: dots generated from the stats in the text). The rings are the radii that contain 50%, 75% and 90% of shells. Denser towards the center, nothing lands past the edge.

In this world everything is simple: aim in, put the reticle on a weak spot — and the rest is just luck inside the circle.

2. You don’t fire the shot. The server does.

Pressing the fire button doesn’t launch anything on your PC: it sends a “fire” command to the server. That command contains neither where your reticle is pointing nor where the shell is supposed to go.

You can see this right in the client code (World of Tanks 2.4.1.0 and Mir Tankov 1.45): a shot is a call to vehicle_shoot() with zero arguments. The aim point is sent by a separate command, vehicle_trackWorldPointWithGun(point) — not when you fire, but constantly, the whole time you move your mouse.

Fig. 2. Who sends what. The aim point goes to the server constantly (about 10 times per second); “fire” is a separate call with no parameters. The shell is born on the server, and the reply comes back after ping + ~87 ms.
  1. For the whole battle the game keeps sending the server the point your mouse is aiming at.
  2. The server turns the turret and gun towards that point by itself, at their traverse speeds, and calculates its own aim circle.
  3. When the “fire” command arrives, the server takes ITS gun position and ITS circle, rolls a point inside the circle and fires the shell. Hit, pen and damage are calculated by the server too.
  4. You only see the tracer and the hit after the server replies. In our measurements over 300+ shots, the confirmation arrives after ping + about 87 ms.

Hence the key point: the reticle on your screen is a prediction. Your PC runs the same calculation and draws where it thinks the gun is right now and how big the circle is. The server reticle (you can turn it on in the game settings) shows where the gun and circle are on the server itself — that is, what the game will actually fire from, just slightly delayed.

3. The real network: three different “nows”

On a real server, what you see and what has already happened on the server run on different clocks. The difference is usually tens of milliseconds, but that’s enough for the circles to drift apart.

Fig. 3. Three clocks. Screen and server both tick every 0.1 s, but not in sync; the server reticle lags 70–85 ms behind. During packet loss (0.3 s here, 0.2–0.5 s in the data) the server gets no new aim points and holds the old one, while your screen keeps moving the circle smoothly. When the connection comes back, the server reticle snaps to catch up.

Packet loss is not rare. In our battles the server “goes silent” for usually 1–3% of the battle time, up to 7% on a laggy evening. Drops last 0.2–0.5 s, sometimes up to 2.4 s. The whole time your screen keeps moving the reticle smoothly and aiming in as if everything was fine.

4. When the server reticle lags or freezes

The shell always lands inside the SERVER circle. If at the moment you fire the server circle isn’t where yours is, or is bigger than yours, the shell can legitimately land outside the circle you saw. This happens in three situations.

Shooting mid-turn (snap shot). Your circle is already on target, but the server one is still catching up. At a 12–13°/s turn, one 0.1 s tick is already 1.2–1.3° — more than a typical fully aimed circle. From one of our battles (108 shots, cross-checked against server-side hits):

Fig. 4. Left: turning right, the server circle trails behind the client-side one. The shell landed inside the server circle but outside the one on screen. Right: the faster you turn before the shot, the fewer hits (data in the table below).
Turn speed before the shot, °/sReticle desync, °Hit rate
under 50.00865%
5–150.6643%
15–301.0240%
over 306.517%

Same battle, by pause length: shots fired while the reticle was still moving hit 22% of the time; with a pause over 3 s — 65%.

The server hasn’t finished aiming in yet. The circle on your screen has already shrunk, but the server still considers the gun not aimed in — for example, because your mouse movement reached it later. The shot goes out of the big server circle.

Lag right before the shot. If the packets with your aim point didn’t arrive, the server gun freezes in its old position or snaps to catch up, and its circle doesn’t shrink the way yours does on screen. You’re aiming with the client-side reticle and you don’t see any of this unless the server reticle is on.

A separate case is auto-aim: there the server drives the gun itself and the client marker is just guessing, so comparing circles in this mode is pointless.

5. Examples from our battles

Out of 5.5k shots in our archive (excluding auto-aim), roughly one in 12 landed outside the client-side circle. Most often after a flick, less often because of lag. All distances below are in angular degrees from the center of your circle; “1.3 R” means “1.3 times further out than the circle edge”, i.e. the shell is outside the circle.

ShotWhat happened before the shotYour circleServer circleShell from the center of your circleResult
For comparison, a clean one: AMX 13 57, North America, 546 mfully aimed, 0.34 s pause, ping 56, normal confirmation0.18°0.14°, 0.09° away from yours0.014° (0.08 R) — almost dead centerpen, 88 HP
Manticore, Poland, 142 mtracking the target at 3.2°/s, fired 16 ms after stopping; lag: confirmation 179 ms at ping 30 (normal ~117)0.24°0.21°, its center right on the edge of your circle (0.24°)0.31° = 1.3 R; inside the server circle — 0.66 Rhit the tracks, 413 HP
SU-122A, Tundra, 716 mbarely moved the reticle for 0.9 s (0.4°/s); lag before the shot1.16°2.0° — the server considered the gun not aimed in (circle 4.5× its minimum)1.47° = 1.3 R; inside the server circle — 0.64 Rfell 72 m short, miss
T-28, Munich, 50 m6.8°/s turn and fired 21 ms later; lag: confirmation 200 ms at ping 831.26°1.99°, its center 2° from yours — the server gun hadn’t finished turning1.55° = 1.2 R; inside the server circle — 0.44 Rbounce off a Luchs
Fig. 5. Three lag shots plotted from measured coordinates (degrees from the center of your circle); each diagram has its own scale (bar on the left). On the Manticore the server circle is offset from the client one. On the SU-122A the circles nearly coincide: the server one is just bigger, the gun isn’t aimed in there (2.0° at the click, 2.3° by the time the shot was processed). On the T-28 the server circle at the moment of “fire” (dotted) sat 2° away from the client one, moved closer by the time the shot was processed (arrow), and the shell landed inside it.

In all three cases the shell landed outside the circle on the player’s screen, but comfortably inside the server one. RNG isn’t broken: the game fired from the gun position the server had. The biggest desyncs come from hard flicks: the four worst shots of one battle, with a 47–49°/s turn, had a 6–9° reticle desync, and all four missed.

6. But what about the server rigging shots?

We found no sign in our data that the server deliberately steers shells away. All the deviation from what the player sees is explained by RNG inside the server circle, multiplied by reticle desync, ping and lag.

What we checkedResult
Does the shell land inside the server circleyes, for 98% of the 2,760 shots where it’s measurable; half of them within 0.26 of the radius from the center. The remaining ~2% are at the limit of measurement accuracy
How often the shell lands outside the client-side circle with a steady reticle (turn under 5°/s)5% (225 of 4,463)
Same with a 5–15 / 15–30 / over 30°/s turn27% / 46% / 63%
Same with a steady reticle: ping under 60 ms / 60 ms and up~3.5% / ~9%
“Rigged days”: 165 battles, 1,407 of my hits and 1,092 on meno link between pen rate and the day. The dip only shows up in lost battles — that’s how the battle went and target choice, not dispersion
Fig. 6a. Share of shells that landed outside the client-side circle. The harder the flick and the higher the ping, the more often it happens.

Bottom line: the harder you turn before the shot and the worse your connection, the more often the shell goes “the wrong way” — from the player’s point of view. From the server’s point of view it landed right in its circle.

Honest caveat: we see what the server sends to the client, not the server code itself, and the sample is a few thousand shots. A subtle bias of a fraction of a percent can’t be ruled out with this data, but you don’t need one to explain what players call the server rigging shots. High ping in our archive is mostly Mir Tankov battles, so part of the difference between pings may come from the client itself.

Does it favor unicums or noobs?

No: shells against strong and weak players land in the server circle the same way. The mod records where in the server circle the shell landed — that’s the server’s actual dice roll, and it isn’t affected by cover, angling or the target’s moves. We compared shots at weak (WN8 around 650) and strong (around 1500) players within the same battle, same tank and same ping, plus battles where our team was clearly stronger or weaker than the enemy. No difference.

What we comparedVs weakVs strongVerdict
Where the shell landed in the server circle (0 — center, 1 — edge), same tanks0.220.20same
Damage per pen vs typical99.4%100.9%same
Pens vs expected for the same tank and zone+0.8 pp−1.6 ppwithin RNG
Hit rate73%62%lower — because of how the opponent plays
Fig. 6b. Against weak and strong players the shell lands in the same spot of the server circle and does the same damage. The bars in each pair are nearly equal.

So why does it feel like you “can’t hit” good players? You really do hit them less, but the shell goes to the same point in the circle: a good player hides more, exposes less and angles armor. We would have noticed if the server pushed shells towards the edge of the circle by even 3% of the radius, or cut damage by 2.5%. Sample: World of Tanks battles, about 800 shots with a known point in the circle and target rating, and about 840 pens; for Mir Tankov this check is still ahead.

7. The tracer is a picture, not the shell

You can’t actually see the shell fly in the game. What we call the tracer is a line your PC draws based on a message from the server. In the client code this is the showTracer call: the server sends the muzzle point, velocity vector, gravity and max range, and the client animates the flight from those.

Fig. 7a. The tracer starts from the barrel as it’s drawn on your screen (if it’s no more than 20 m from the server muzzle point) and smoothly merges into the trajectory the server set.
Fig. 7b. HE of the 100 mm BS-3: 720 m/s in battle and in the server message, 900 m/s in the garage. 720 / 900 = 0.8.

If the server stays silent for long, the client fakes the shot itself — but only the part at your own tank. After the “fire” command it waits half the network delay, but no less than 0.12 and no more than 0.2 s. If there’s no confirmation, the client plays the muzzle flash, sound and gun recoil itself, so the click doesn’t feel “frozen”. No tracer is drawn though: it only appears when the server sends its data. If it never does, there’s no tracer at all, even if the shell hit.

Fig. 7c. What the client does after “fire” if there’s no reply. The 0.12–0.2 s wait window is shown as described in the text; the moment the server reply arrives is schematic.

8. What this means for you

The client-side circle is a prediction; the server one is what the game actually fires from. That’s why TankCoach shows both circles, the point where the shell went, and whether there was lag, on every single shot: so you can tell whether a miss was RNG, you rushing it, or the network.

All numbers in this article come from TankCoach measurements on World of Tanks and Mir Tankov battles (September–October 2026), except the shell distribution inside the circle — those are stats from the Wotstat mod over 125 million shots.

Try it yourself. In Celivalnya the server reticle is shown on every shot — and the breakdown tells you why the shell went where it went.