
Replays & recording · Java · Advanced
How Packet Replays Reconstruct World Chunks and Entities Over Time
Minecraft packet replays do not record raw video frames; instead, they capture the exact network protocol stream sent from the server to the client. By understanding how initial chunk data packets and subsequent block-change deltas interact, you can inspect and reconstruct the 3D world state at any exact millisecond. This guide explores the underlying packet architecture and shows you how to analyze it safely in your browser using the Replay Viewer.
What you need
- A Java Edition packet replay file (typically a .mcpr archive containing recording.tmcpr and metaData.json)
- A backup copy of your replay file before attempting any archive extraction or metadata edits
- Access to the Replay Viewer on our site (all files are processed locally in your browser and never upload)
Step by step
1Back Up and Inspect the Replay Archive Structure
Always create a backup copy of your .mcpr file before altering or extracting its contents. A packet replay file is actually a standard ZIP archive containing a raw binary stream named recording.tmcpr and a configuration file named metaData.json. Checking metaData.json in a text editor reveals the exact protocol version (such as 763 for Java 1.20.1), which dictates the packet IDs used to rebuild the world.
Tip: If you are unsure of your replay's protocol number, open metaData.json and look for the 'protocol' or 'mcversion' key.
2Load the Capture in the Replay Viewer
Open the Replay Viewer tool on our site and select your .mcpr file (or open the extracted folder/zip directly). Because our browser tool runs locally without uploading your file, it immediately parses the recording.tmcpr byte stream in your system's memory. The tool reads the 4-byte timestamp and 4-byte length prefix of every packet to build a sequential timeline index.
3Trace Initial Chunk Generation Packets
Scrub to the very beginning of the timeline (timestamp 0:00) in the Replay Viewer to observe the initial world load. At this stage, the tool processes Play-state packets known as Level Chunk With Light (or Chunk Data in older versions). These packets establish the baseline 16x16x16 block palettes and heightmaps for every chunk within the player's render distance.
Tip: Chunks outside the recording player's original render distance were never sent over the network and will appear as empty void.
4Observe Block-Change Deltas and Entity Interpolation
Advance the timeline in the Replay Viewer to watch how the engine applies delta packets over the baseline chunks. Instead of resending an entire chunk when a block breaks, the stream feeds Block Update and Section Blocks Update packets to mutate specific coordinates. Simultaneously, Add Entity packets spawn mobs and players using unique Entity IDs, while Move Entity Pos packets apply relative coordinate offsets (dX, dY, dZ) every tick.
5Scrub Backward to Understand Keyframe Reconstruction
Click an earlier timestamp on the Replay Viewer timeline after playing forward for several minutes. Because network packets are additive deltas (for example, 'change block at X,Y,Z to air'), the engine cannot simply play a packet in reverse without knowing what block was there previously. To solve this, the Replay Viewer resets to the closest prior state snapshot and rapidly fast-forwards through all intermediate chunk and entity packets up to your chosen millisecond.
Tip: If backward scrubbing takes a moment on long recordings, it is because the browser is recalculating thousands of block and entity deltas from the last keyframe.
How it works
At the binary level, the recording.tmcpr file inside a replay archive is a sequential stream of packets. Each entry consists of a 32-bit integer representing the time elapsed in milliseconds since the recording started, followed by a 32-bit integer indicating the byte length of the packet, and finally the uncompressed packet payload starting with a VarInt Packet ID. Because Packet IDs shift between Minecraft releases, the parser must cross-reference the protocol version in metaData.json to know which ID corresponds to which world action.
World geometry begins with full chunk payloads. In modern Java Edition protocols, the Level Chunk With Light packet contains a serialized byte array of chunk sections. Each 16x16x16 section uses a palette-based bit array (similar to the BlockStates tag in region MCA files) alongside NBT-encoded block entities (such as chests or signs). Once a chunk is loaded into the Replay Viewer's virtual memory, it acts as a mutable canvas.
As time progresses, the server only transmits differences, known as deltas. Single block modifications arrive via Block Update packets, while explosions or rapid mining trigger Section Blocks Update packets that modify multiple coordinates within a 16x16x16 cube at once. If a player walks into newly generated terrain, new chunk load packets are appended to the memory state, while Unload Chunk packets instruct the viewer to drop distant chunks to save RAM.
Entities operate on an even stricter delta system. When an entity enters the player's tracking range, an Add Entity packet assigns it a temporary runtime integer (Entity ID) and an exact starting X, Y, Z position. Subsequent movement packets rarely contain absolute coordinates; instead, they transmit 16-bit relative fixed-point deltas. If the replay parser skipped even a single movement packet while scrubbing, the entity's position would become permanently desynchronized until a rare Teleport Entity packet provided a fresh absolute coordinate.
Common mistakes
- Expecting to see areas of the world that the recording player never visited; packet replays only contain chunks that the server actually transmitted to the client during the session.
- Modifying metaData.json with an incorrect protocol version, which causes the Replay Viewer to misinterpret VarInt Packet IDs and fail to reconstruct the 3D chunks.
- Editing or truncating recording.tmcpr without making a backup first, which breaks the 4-byte length offset framing and corrupts the rest of the timeline.
- Assuming entity NBT data (like villager trades or full player inventories) is visible in a replay; the server only sends visual metadata (such as held items and armor) over the network to prevent cheating.
FAQ
Why do chests appear empty or lack custom contents when I inspect them in a packet replay?
In multiplayer protocol, the server only sends a block entity's visual state (like a chest's facing direction or open lid animation) in the chunk packet. The actual inventory contents are only sent as Window Items packets when the recording player physically opens the container.
Why does scrubbing backward in a replay take longer than scrubbing forward?
Packet streams are strictly forward-moving deltas. To jump backward by ten seconds, the viewer cannot simply undo packets; it must reload the baseline chunk state from the beginning (or the nearest cached keyframe) and re-simulate every block change and entity movement up to that exact timestamp.
Can I export a reconstructed replay state into a playable Minecraft world save?
While the Replay Viewer reconstructs the visual block states in memory, a packet stream lacks server-side data such as world seeds, full entity NBT, unloaded chunks, and loot tables, meaning any exported data only represents a partial surface shell of the world.
Packet replays reconstruct a 3D Minecraft world by sequentially applying timestamped block-change deltas and relative entity movements over initial baseline chunk packets inside our browser-based Replay Viewer.