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.
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.
- The aim circle is the boundary the shell will land inside. Its size is the gun’s dispersion multiplied by penalties for hull movement, turret traverse and the shot itself. While you sit still and don’t move the reticle, the circle shrinks to its minimum over the aim time — that’s being “fully aimed in”.
- The point inside the circle is random, but not uniform. According to stats from the Wotstat mod over 125 million shots (World of Tanks and Mir Tankov — the curves are identical): half of all shells land within 0.37 of the circle radius, three quarters within 0.57, and 90% within 0.77.
- In perfect conditions the shell never leaves the circle. Dispersion is clipped at the edge.
- After that the shell follows its own trajectory (velocity, gravity), and pen is rolled separately with its own RNG (±25% of the listed value in World of Tanks).
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.
- For the whole battle the game keeps sending the server the point your mouse is aiming at.
- The server turns the turret and gun towards that point by itself, at their traverse speeds, and calculates its own aim circle.
- 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.
- 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.
- Your PC. The game recalculates the gun and circle in ticks, roughly 10 times per second (we measured a 100–129 ms interval). The UI interpolates in between for smoothness, so the circle at the moment you click can be up to 0.1 s “old”.
- The server. Also runs on ~0.1 s ticks. The server reticle lags behind the client-side one by 70–85 ms on average, almost regardless of ping: it’s set by the tick rate, not the network.
- The network. Commands and aim points reach the server with a delay, and the reply comes back after ping + ~87 ms. And when packets get lost or arrive in a burst, the server temporarily loses fresh data on where you’re aiming.
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):
| Turn speed before the shot, °/s | Reticle desync, ° | Hit rate |
|---|---|---|
| under 5 | 0.008 | 65% |
| 5–15 | 0.66 | 43% |
| 15–30 | 1.02 | 40% |
| over 30 | 6.5 | 17% |
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.
| Shot | What happened before the shot | Your circle | Server circle | Shell from the center of your circle | Result |
|---|---|---|---|---|---|
| For comparison, a clean one: AMX 13 57, North America, 546 m | fully aimed, 0.34 s pause, ping 56, normal confirmation | 0.18° | 0.14°, 0.09° away from yours | 0.014° (0.08 R) — almost dead center | pen, 88 HP |
| Manticore, Poland, 142 m | tracking 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 R | hit the tracks, 413 HP |
| SU-122A, Tundra, 716 m | barely moved the reticle for 0.9 s (0.4°/s); lag before the shot | 1.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 R | fell 72 m short, miss |
| T-28, Munich, 50 m | 6.8°/s turn and fired 21 ms later; lag: confirmation 200 ms at ping 83 | 1.26° | 1.99°, its center 2° from yours — the server gun hadn’t finished turning | 1.55° = 1.2 R; inside the server circle — 0.44 R | bounce off a Luchs |
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 checked | Result |
|---|---|
| Does the shell land inside the server circle | yes, 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 turn | 27% / 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 me | no 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 |
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 compared | Vs weak | Vs strong | Verdict |
|---|---|---|---|
| Where the shell landed in the server circle (0 — center, 1 — edge), same tanks | 0.22 | 0.20 | same |
| Damage per pen vs typical | 99.4% | 100.9% | same |
| Pens vs expected for the same tank and zone | +0.8 pp | −1.6 pp | within RNG |
| Hit rate | 73% | 62% | lower — because of how the opponent plays |
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.
- The start of the tracer is moved to the barrel as drawn on your screen, if the barrel is in view and no more than 20 m from the server muzzle point. After that the line smoothly merges into the server trajectory. That way the tracer doesn’t hang in mid-air when your tank sits slightly differently on screen and on the server. There’s also a rule with a 50 m threshold in the client, but it only applies when watching replays.
- Tracer speed is whatever the server sent. It matches the shell velocity in the client’s gun description: for the HE of the 100 mm BS-3 it’s 720 m/s both there and in the server message. The garage lists 900 m/s for the same shell: in battle shells fly at 0.8 of the “garage” velocity. So the tracer isn’t lagging behind the shell — the garage number is inflated.
- No tracer doesn’t mean no shell. The tracer is drawn only if the server message arrived and the client is showing the battle world at that moment. For 4.6% of our shots neither a tracer end nor an explosion ever arrived. For unspotted targets the tracer end doesn’t always arrive: in one battle there were 5 tracer ends for 13 hits known from the battle results.
- The fire command doesn’t get lost — it gets late. Server method calls go over a reliable channel with retransmission: if a packet is lost, it’s sent again and arrives, just later. And the server fires from whatever gun position it has at the moment the command arrives. Our data has shots for which the client never got a confirmation, yet the server counted them — up to a pen that killed the target.
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.
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.
- Turn on the server reticle in the game settings — you’ll see what the server sees, not just the prediction.
- After a turn, let the server catch up: 2–3 ticks, i.e. 0.2–0.3 s. Right before the shot keep your turn under 12–13°/s.
- When lagging (yellow or red connection indicator, tanks rubberbanding) don’t fire right after putting the reticle on target: wait for the server circle to settle and shrink.
- Shooting at a moving target — track smoothly, don’t snap onto it right before clicking: with smooth tracking the server gun follows yours with a constant small lag.
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.