Not translated yet — showing English.

Prediction & Lag Compensation

Forward prediction and backward compensation, over data that carries its true event time. The client feels instant, the server stays right, and hits are judged in the shooter's timeline.

When to use it

• Input must feel instant under latency while the server stays authoritative: predict forward, reconcile on divergence.
• Hits must be judged in the shooter's timeline: ResolveAt rewinds hitboxes to the reported view tick.
• Aim arcs and landing markers must match outcomes: client and server forecast the same Trajectory.
• Game-critical fields must never roll back: declare what predicts and what waits for the server.
• Rubber-banding needs tuning: per-entity windows, tolerances, and misprediction telemetry.
• Skip it when latency doesn't hurt. Turn-based or slow games run fine on plain Data deltas.

Who does what

At a glance

The word covers three different mechanisms with different authorities and failure modes, and each has its own article:

Four presets, and "no prediction" is one of them.

Turn-based games, strategies and most mobile titles want no prediction at all; declaring it tells the client to show state as it is rather than guess.

The module owns no movement model, no reaction table, no geometry and no history window of its own. Those belong to Locomotion, Collision, Map and Entity respectively. Prediction applies them earlier or reads them backwards; it never declares a second copy.

[Entity("tank")]
[Prediction(ForwardTicks = 8, MaxRewindTicks = 64)]
public class Tank
{
    [Sync, Predicted] public Vector3 Position;                        // rolls back and replays
    [Sync, Predicted] public Vector3 Velocity;

    [Stat(Max = 100), AuthoritativeOnly] public Stat Hp;   // never predicted
}

@Entity('tank')
@Prediction({ forwardTicks: 8, maxRewindTicks: 64 })
export class Tank {
  @Sync() @Predicted() position!: Vector3;                    // rolls back and replays
  @Sync() @Predicted() velocity!: Vector3;

  @Stat({ max: 100 }) @AuthoritativeOnly() hp: Stat;   // never predicted
}

@entity("tank")
@prediction(forward_ticks=8, max_rewind_ticks=64)
class Tank:
    position: Vector3 = sync(predicted=True)                  # rolls back and replays
    velocity: Vector3 = sync(predicted=True)

    hp = stat(max=100, authoritative_only=True)   # never predicted

UCLASS(PSEntity = "tank", PSPrediction = (ForwardTicks = 8, MaxRewindTicks = 64))
class UTank : public UObject
{
    GENERATED_BODY()

    UPROPERTY(PSSync = (Predicted = "true")) FVector3f Position;   // rolls back and replays
    UPROPERTY(PSSync = (Predicted = "true")) FVector3f Velocity;

    UPROPERTY(PSStat = (Max = 100, AuthoritativeOnly = "true")) FPSStat Hp;   // never predicted
};
// declarations compile into the same pushed model — playserv push from the UE project or CI

[Entity("tank")]
[Prediction(ForwardTicks = 8, MaxRewindTicks = 64)]
public class Tank
{
    [Sync, Predicted] public Vector3 Position;                        // rolls back and replays
    [Sync, Predicted] public Vector3 Velocity;

    [Stat(Max = 100), AuthoritativeOnly] public Stat Hp;   // never predicted
}

Lag-compensated resolution answers "where was everyone when this shot was fired":

[After(Projectiles.HitReported)]
public static void Validate(HitReport hit) =>
    hit.ResolveAt(hit.ShooterViewTick);    // rewinds hitboxes, sub-tick interpolated

export const validate = after(Projectiles.hitReported, (hit: HitReport) =>
  hit.resolveAt(hit.shooterViewTick));    // rewinds hitboxes, sub-tick interpolated

@after(projectiles.hit_reported)
def validate(hit: HitReport):
    hit.resolve_at(hit.shooter_view_tick)    # rewinds hitboxes, sub-tick interpolated

Trajectory forecast, shared by server and client (aim arcs, landing markers). The forecast is this module's operation, extrapolated against the map's obstacle set, so both sides draw the same arc from the same inputs:

var arc = room.Prediction.Trajectory(from, velocity, steps: 30);   // collision-aware

const arc = room.prediction.trajectory(from, velocity, { steps: 30 });   // collision-aware

arc = room.prediction.trajectory(origin, velocity, steps=30)   # collision-aware

// collision-aware: the arc the platform itself would walk
Room->Prediction->Trajectories->Get(LaunchPosition, LaunchVelocity, /*Steps*/ 30,
    TPSOnResult<FPSTrajectory>::CreateWeakLambda(this, [this](const TPSResult<FPSTrajectory>& Result)
    {
        if (!Result.HasValue()) { return; }
        DrawArc(Result.Value());
    }));
// co_await support ships later: a built-in SDK coroutine wrapper that respects Unreal's GC and threading.

var arc = room.Prediction.Trajectory(from, velocity, steps: 30);   // collision-aware

The model

Predictability is declared on an aspect — and an aspect changed only by the authority, by rules the client does not have, may not be marked predictable: that is a validation failure at deploy, not a runtime surprise.

What is declared.

What is rewound, and what deliberately is not.

client tick:  apply input locally (predict) → buffer it → send, tick-stamped
server tick:  step the same movement model → authoritative state → delta out
client recv:  authoritative state for tick T → if divergence beyond tolerance:
              rewind to T → replay buffered inputs T+1..now → smooth

Only declared-predicted fields ever roll back; tiny drift is smoothed, real divergence rewinds and replays.

Errors

• A view time beyond the window is a conflict: send a current one.
• A history request beyond the window is likewise a conflict.
• Two declaration defects are caught at deploy: a compensation window larger than the history buffer, and an aspect marked predictable when the client has no rules to predict it by. Neither can reach a live match.
• Two things are not errors, and both are observable. A full input buffer suspends prediction until confirmation rather than discarding inputs silently; and divergence beyond the threshold means the authority's state is accepted as it comes, which is the declared correction and not a fault.

Limits

The numbers arrive with the platform limits chapter; what happens at each ceiling is fixed now.

• The compensation window: beyond it a refusal, never extrapolation.
• The extrapolation window for others: the entity is marked stale and extrapolation stops.
• The unconfirmed-input buffer: prediction is suspended until confirmation; inputs are never discarded silently.
• The depth of history for a rewind: not less than the compensation window, checked at deploy.
• The rate of actions carrying a view time: a rate limit with a deadline.
• Simultaneously predicted entities per client: beyond the cap prediction is not performed, and that is declared degradation rather than a refusal.