Networked Physics

A synchronization technique where each client runs the same deterministic simulation, exchanging only user input commands. All clients must process the same inputs in the same order to achieve identical results. This ensures perfect consistency but is highly sensitive to latency and packet loss, as a single missed input can desynchronize the entire simulation. It is most effective for turn-based games or real-time strategy (RTS) titles where perfect state matching is critical.

A technique that allows a client to immediately apply its own inputs locally without waiting for server confirmation, predicting the outcome to provide instant feedback. The client then reconciles its predicted state with the authoritative state received from the server. This is essential for hiding network latency in fast-paced, real-time games like first-person shooters (FPS). Key challenges include handling prediction errors and rollback when the server's authoritative state differs from the client's prediction.

The server-side process of validating and applying client inputs, then sending authoritative state updates back to clients. Clients use these updates to correct any discrepancies from their local predictions. This often involves:

• Input Buffering: The server queues and processes inputs in a consistent order.
• State Snapshots: The server periodically broadcasts the complete game state.
• Correction & Interpolation: Clients interpolate between authoritative snapshots to smooth visual movement.

A client-side technique for smoothly displaying the positions of other networked entities (like other players). Instead of showing entities at their raw, potentially jittery network-updated positions, the client renders them slightly in the past. It buffers received state updates and interpolates between them to create fluid motion, masking network jitter and packet arrival variance. This is a visual smoothing technique only and does not affect the underlying simulation logic.

A server-side technique that accounts for player latency when resolving time-sensitive actions like shooting. When the server processes a shot command, it rewinds the game state back in time by the player's measured latency to check what the player saw on their screen at the moment they fired. This makes the game feel fair for players with higher ping, as hits are calculated based on their client's view, not the server's current state.

A broad category of techniques where the server periodically sends state updates to clients. Variations include:

• Snapshot Synchronization: Sending complete world state at a fixed rate (e.g., 20 Hz).
• Delta Compression: Sending only the state that has changed since the last update.
• Interest Management: Sending state updates only for entities relevant to a specific client's area (Area of Interest). This reduces bandwidth by filtering unnecessary data.

Using physical location as a parameter for organizing blockchain nodes into shards or consensus groups to optimize performance and relevance.

• Concept: Nodes in the same geographic region form a shard, reducing latency for local transactions and data.
• Benefit: Enables high-throughput, low-latency applications for local services and IoT networks where data locality is critical.

Leveraging physical hardware components as a root of trust for cryptographic operations and consensus participation.

• Key Technologies:
  • Trusted Execution Environments (TEEs): Secure enclaves (e.g., Intel SGX, ARM TrustZone) that protect code and data integrity.
  • Secure Elements: Dedicated chips in devices for key management.
• Application: Used in projects like Space and Time (Proof of SQL) and various validator designs to prevent certain attack vectors.

The deterministic function that defines how the blockchain's global state changes when a new block is applied. It is the core logic of the virtual machine or settlement layer.

• Inputs: Takes the current state and a set of valid transactions.
• Outputs: Produces a new, updated state.
• Examples:
  • Bitcoin's UTXO Model: State is the set of unspent transaction outputs.
  • Ethereum's Account Model: State is a mapping of account addresses to their balance, nonce, storage, and code. This function must be executed identically by all validating nodes.

The specific algorithm nodes use to select the canonical chain when multiple valid blockchains (forks) exist. It is critical for achieving consensus on a single history.

• Longest Chain Rule: Used in Nakamoto Consensus (e.g., Bitcoin). Nodes adopt the chain with the most cumulative Proof of Work.
• GHOST / Greediest Heaviest Observed SubTree: A variant that accounts for uncle blocks to improve security and reduce centralization pressures.
• Finality Gadgets: Mechanisms like Casper FFG in Ethereum 2.0 that provide explicit, cryptographic finality after a certain number of blocks.

The system of rewards and penalties (cryptoeconomics) designed to align the behavior of rational network participants with the security and liveness of the network.

• Block Rewards: Newly minted cryptocurrency given to the miner or validator who successfully creates a block.
• Transaction Fees: Payments users include to prioritize their transactions, awarded to the block producer.
• Slashing: In Proof of Stake systems, the destruction of a validator's staked funds for malicious behavior (e.g., double-signing). These mechanisms secure the network by making attacks economically irrational.