What should a save file actually look like?

JSON.stringify on a 50,000-entity save — 4,553,047 bytes — took 16.5 ms, one entire frame at 60 fps. That is the number people quote, and it is the least important thing measured here. The same save in a columnar binary layout was 1,007,228 bytes and 3.9 ms. But when a v2 build loaded v1 saves, JSON returned silently wrong data on two of three schema changes and threw on none, and the packed binary silently misread every entity when a field was removed. The format that survived all three is the one nobody writes: tag-length-value.

Hardware: Apple M3, 16 GB, macOS 26.4.1 (build 25E253). Node v23.5.0, built-ins only — no packages, no engine, no GPU, no network. gzip is zlib.gzipSync at Node's default level 6; timings are medians of 5–11 runs under normal desktop load. This is JavaScript on a laptop. C# in Unity has its own allocator and GC and will give different absolute milliseconds — the ratios and the failure modes transfer. Byte counts are exact and reproduce from the seed.

The game state, from mulberry32(1234), in two variants — early game: 20 inventory items, 200 world flags, 6 quests, 400 entities, 12 unlocked; late game: 240 items, 4,000 flags, 180 quests, 50,000 entities, 600 unlocked. An item is {itemId, slot, count, durability, enchant}; a flag is a boolean under a string key; a quest is {questId, stage, objectives[1..5]}; an entity is {id, type, x, y, z, hp, state}, with type and state as strings from eight-value enums and hp in a Uint16.

The short answer

• JSON crosses the 60 fps frame budget at about 4.5 MB. 50,000 entities stringified in 16.5 ms against a 16.67 ms budget; 55,000 took 18.5 ms. A packed binary layout of the same state was 3.9 ms and did not cross until past 200,000 entities.
• Gzipping the JSON cost five times more than producing it. zlib.gzipSync on the 4.5 MB save took 78.2 ms — 4.7 dropped frames — to save 3.5 MB. Compression, not serialisation, is what stalls an autosave.
• A worker thread does not remove the cost, because structured clone runs on your thread. postMessage(state) blocked the main thread for 10.35 ms, 61% of what stringifying cost. Packing to an ArrayBuffer and transferring it blocked 4.28 ms; the transfer itself was 0.019 ms.
• The schema change nobody tests is the one that corrupts saves. Renaming hp to health in JSON left 2,000 of 2,000 entities with health === undefined and threw nothing. Removing one u8 field from a packed binary layout misread 2,000 of 2,000 hp values: hp[0] read as 56,689 against a truth of 42,764.
• Writing to a temp file and renaming is free, and it is the fix. Write in place: 0.36 ms. Write temp + rename: 0.24 ms — faster. A simulated crash 60% through an in-place write destroyed the previous save; the same crash with temp + rename left all 50,000 entities loadable.

Which save format is smallest and fastest?

Late-game state, 50,000 entities, each format in its own Node process so peak RSS is not contaminated by the others. "State only" is the high-water mark after building the object graph, before serialising.

The early-game save, 400 entities, where every option is fine:

Gzipped JSON is 1,029,443 bytes; the hand-packed binary is 1,007,228 — a 2% difference. If disk size is your only concern, gzipSync(JSON.stringify(s)) is already as good as hand-packing. The binary layout's win is not bytes, it is the 17x faster serialise and 9x faster parse.

Gzip dominates everything else. 78.18 ms to compress the JSON against 16.56 ms to produce it — the compressor costs 4.7x the thing being compressed. Compressing the binary was cheaper at 20.90 ms only because there is a quarter as much to feed in. Same effect as on the wire in gzip or brotli for a JSON API.

TLV looks like a bad deal on these axes and is one — 4,052,550 bytes, slowest parse, highest peak memory. Hold that thought.

At what size does saving drop a frame?

The budget is 16.67 ms for a 60 fps frame and a synchronous save spends it in one go. Entity count swept, everything else at late-game size:

The crossing is at roughly 4.5 MB of JSON, or 50,000 entities. Below it a synchronous JSON.stringify is invisible; above it every autosave is a visible hitch. The packed binary buys 4x headroom and only approaches the budget at 200,000 entities.

Two fixes. Chunking across frames works and costs nothing extra:

Sixteen chunks put the worst frame at 1.05 ms and left the total unchanged at 15.48 ms. Slicing the entity array does not make the work bigger, it spreads it. What you pay is that the world can mutate between chunks, so you need a snapshot or a write barrier.

The worker thread is where expectations break. postMessage(state) is supposed to hand the problem to another thread. It does not: structured clone serialises the object graph synchronously on the sending thread.

Handing raw state to a worker removed 6.7 ms of 17.05 and made total latency three times worse. Packing to a transferable buffer first is the version that works. The binary layout's real payoff is not disk size — a Uint8Array can leave the thread for nothing, and a plain object cannot.

What happens when v2 loads a v1 save?

This is the part nobody measures. I wrote v1 saves, evolved the schema, and ran a v2 loader against them with no version check — the situation you are in the first time you forget one. 2,000 entities, every value checked against the truth.

The binary rows are the opposite of the folklore. A packed layout is immune to renames — there are no names in the file, so calling the sixth column health changes nothing. What it cannot survive is a change to the record's size. Adding or widening a field made the file too short and threw: loud and immediate, the good outcome. Removing a field made it too long, the length check passed, every column after it shifted by 2,000 bytes, and all 2,000 entities loaded with plausible wrong hp values. That is a save the player keeps playing.

JSON is the reverse: it survives added and removed fields and dies on renames and retypes, quietly. e.health on an object that has hp is undefined, not an error. e.hp.cur on a number is undefined, and summing those gives NaN rather than a stack trace. Nothing in the JSON path can tell you which version wrote the file, because JSON has no version.

TLV detected all three, which is what its 4x size buys. Every field carries a tag and a length, so an absent field is observably absent, an unknown tag can be skipped, and a field whose length contradicts its expected type is caught before it is read — the same reason Protocol Buffers ships tag numbers rather than names.

The fix is not a format. It is a version integer in the first four bytes and a migration chain. All ten rows above become recoverable once the loader knows which schema it is looking at.

What does the migration chain cost at load?

A three-step chain on the 50,000-entity save — v1 adds facing, v2 renames hp to health, v3 retypes it to {cur, max}:

Migrations are cheap — except the one everyone writes. e.health = e.hp; delete e.hp; cost 14.38 ms, roughly doubling the load, and reproduced at 13.35, 13.78 and 18.10 ms across four runs. delete makes V8 abandon the object's hidden class for dictionary mode, 50,000 times. Rebuilding each entity as a fresh literal with the new name does the same work in 0.68 ms — 21x faster. One keyword's difference. The same hidden-class effect appears in parsing a 200 MB JSON file.

What if the game crashes mid-save?

Truncation is easy to survive and almost everyone already does. Cutting each save at 99.9% of its length:

Every format caught it, each for its own reason: JSON has syntax, gzip has a length and CRC in its footer, my binary and TLV headers carry explicit lengths. A binary format with no length field is the one that fails. Zero-padding a truncated save back to full length — what a pre-allocated or sparse write looks like — made it load silently. A CRC32 caught it every time.

The hand-rolled version costs 13% of a frame; the native one is free. In Unity that means System.IO.Hashing.Crc32, not a for loop.

The real bug is not truncation, it is the write:

Temp-then-rename was consistently faster than writing in place — 0.24 ms against 0.36 ms across three independent runs of nine — because writing a fresh file avoids truncating and re-extending the existing one, and rename on the same filesystem is a metadata operation. Then the crash test: write a good save, write 60% of a new one, stop.

• In place: the previous save is gone. Load throws truncated: header says 1007212 payload bytes. The player has nothing.
• Temp + rename: the partial bytes sit in slot1.sav.tmp, the real file is untouched, and it loads with all 50,000 entities intact.

There is no trade-off: the atomic version is the fast version. fsync costs 3.6 ms and buys survival of a power cut rather than a process crash.

Do incremental autosaves pay off?

Twenty autosave ticks with 1% of entities changing per tick — a plausible 30-second slice of play:

The delta is 1.04% of the bytes and 6% of the CPU, and load barely notices: replaying all twenty deltas onto the base added 0.97 ms to a 3.18 ms load. Finding the changes is cheap too — a field-by-field diff of all 50,000 entities took 0.21 ms and found the 499 that moved, so this needs no dirty-flag plumbing. Full save on a slow cadence, deltas between: the same chunk-and-patch shape that made storing a big tilemap streamable.

What to actually build

Gzipped JSON with a version integer, written to a temp file and renamed, until your save passes about 4 MB. It is 2% larger than a hand-packed binary and takes an hour. Add the migration chain on day one, and rebuild objects rather than delete-ing fields.

Past 4 MB, pack the hot bulk — entity transforms, world-flag bitsets — into typed arrays behind a length-and-CRC header, and keep the sparse parts as tagged fields so schema changes stay detectable. Never rely on position alone, and treat a removed field as the dangerous change, not an added one.

Check it yourself

One file, Node 18 or newer, built-ins only, about 40 seconds. It generates the state, compares four formats, finds the frame-budget crossing, runs the schema migrations, truncates a save and tests both write strategies, then deletes the ./saves directory it creates.

node savebench.mjs

The full script is reproduced below; save it as savebench.mjs.

// savebench.mjs — node savebench.mjs   (Node 18+, built-ins only)
import zlib from 'node:zlib';
import fs from 'node:fs';

const FRAME = 16.67;
const P = (v, n) => String(v).padStart(n);
const ms = (fn, r = 7) => { const t = []; for (let i = 0; i < r; i++) { const a = process.hrtime.bigint(); fn(); t.push(Number(process.hrtime.bigint() - a) / 1e6); } t.sort((x, y) => x - y); return t[r >> 1]; };
const rng = (seed) => { let a = seed >>> 0; return () => { a = (a + 0x6D2B79F5) >>> 0; let t = a; t = Math.imul(t ^ (t >>> 15), t | 1); t ^= t + Math.imul(t ^ (t >>> 7), t | 61); return ((t ^ (t >>> 14)) >>> 0) / 4294967296; }; };

const TYPES = ['npc', 'enemy', 'chest', 'door', 'pickup', 'spawner', 'trigger', 'prop'];
const STATES = ['idle', 'patrol', 'chase', 'dead', 'open', 'locked', 'used', 'hidden'];

function makeState({ inv, flags, quests, ents, unlocked }, seed = 1234) {
  const r = rng(seed), ri = (n) => Math.floor(r() * n);
  const inventory = []; for (let i = 0; i < inv; i++) inventory.push({ itemId: ri(2048), slot: i, count: 1 + ri(99), durability: ri(1001), enchant: ri(65536) });
  const worldFlags = {}; for (let i = 0; i < flags; i++) worldFlags['flag_' + i] = r() < 0.37;
  const qs = []; for (let i = 0; i < quests; i++) { const o = []; for (let j = 0, n = 1 + ri(5); j < n; j++) o.push(ri(50)); qs.push({ questId: 10000 + i, stage: ri(12), objectives: o }); }
  const entities = new Array(ents);
  for (let i = 0; i < ents; i++) entities[i] = { id: i, type: TYPES[ri(8)], x: Math.round(r() * 4e5 - 2e5) / 100, y: Math.round(r() * 4e4 - 2e4) / 100, z: Math.round(r() * 4e5 - 2e5) / 100, hp: ri(65536), state: STATES[ri(8)] };
  const unl = []; for (let i = 0; i < unlocked; i++) unl.push(ri(4096));
  return { saveVersion: 1, playerName: 'Aurelia_the_Unready', playTimeSeconds: 84321, inventory, worldFlags, quests: qs, entities, unlocked: unl };
}
const SMALL = { inv: 20, flags: 200, quests: 6, ents: 400, unlocked: 12 };
const LARGE = { inv: 240, flags: 4000, quests: 180, ents: 50000, unlocked: 600 };

// ---- packed binary: columnar entities, bitset flags, length + crc header ----
const a4 = (n) => (n + 3) & ~3;
const CT = (() => { const t = new Uint32Array(256); for (let n = 0; n < 256; n++) { let c = n; for (let k = 0; k < 8; k++) c = c & 1 ? 0xEDB88320 ^ (c >>> 1) : c >>> 1; t[n] = c >>> 0; } return t; })();
const crc32 = (b) => { let c = 0xFFFFFFFF; for (let i = 0; i < b.length; i++) c = CT[(c ^ b[i]) & 255] ^ (c >>> 8); return (c ^ 0xFFFFFFFF) >>> 0; };

function binSer(s) {
  const name = Buffer.from(s.playerName, 'utf8'), keys = Object.keys(s.worldFlags), nF = keys.length, fB = Math.ceil(nF / 8);
  const nE = s.entities.length;
  let qB = 4; for (const q of s.quests) qB += 8 + q.objectives.length * 2;
  const entB = 4 + a4(nE * 4) + a4(nE) + nE * 12 + a4(nE * 2) + a4(nE);
  const invB = 4 + s.inventory.length * 12, unlB = 4 + s.unlocked.length * 2, metaB = 8 + name.length;
  const buf = Buffer.alloc(16 + 8 + a4(metaB) + 8 + a4(invB) + 8 + a4(4 + fB) + 8 + a4(qB) + 8 + a4(entB) + 8 + a4(unlB));
  const dv = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
  dv.setUint32(0, 0x53545343, true); dv.setUint32(4, s.saveVersion, true);
  let o = 16; const sec = (t, l) => { dv.setUint32(o, t, true); dv.setUint32(o + 4, l, true); o += 8; return o; };
  let p = sec(1, metaB); dv.setUint32(p, s.playTimeSeconds, true); dv.setUint32(p + 4, name.length, true); name.copy(buf, p + 8); o = a4(p + metaB);
  p = sec(2, invB); dv.setUint32(p, s.inventory.length, true); p += 4;
  for (const it of s.inventory) { dv.setUint16(p, it.itemId, true); dv.setUint16(p + 2, it.slot, true); dv.setUint32(p + 4, it.count, true); dv.setUint16(p + 8, it.durability, true); dv.setUint16(p + 10, it.enchant, true); p += 12; }
  o = a4(p);
  p = sec(3, 4 + fB); dv.setUint32(p, nF, true);
  for (let i = 0; i < nF; i++) if (s.worldFlags[keys[i]]) buf[p + 4 + (i >> 3)] |= 1 << (i & 7);
  o = a4(p + 4 + fB);
  p = sec(4, qB); dv.setUint32(p, s.quests.length, true); p += 4;
  for (const q of s.quests) { dv.setUint32(p, q.questId, true); dv.setUint16(p + 4, q.stage, true); dv.setUint16(p + 6, q.objectives.length, true); p += 8; for (const v of q.objectives) { dv.setUint16(p, v, true); p += 2; } }
  o = a4(p);
  p = sec(5, entB); dv.setUint32(p, nE, true); p += 4;
  const ids = new Int32Array(buf.buffer, buf.byteOffset + p, nE); p += a4(nE * 4);
  const ty = new Uint8Array(buf.buffer, buf.byteOffset + p, nE); p += a4(nE);
  const xs = new Float32Array(buf.buffer, buf.byteOffset + p, nE); p += nE * 4;
  const ys = new Float32Array(buf.buffer, buf.byteOffset + p, nE); p += nE * 4;
  const zs = new Float32Array(buf.buffer, buf.byteOffset + p, nE); p += nE * 4;
  const hp = new Uint16Array(buf.buffer, buf.byteOffset + p, nE); p += a4(nE * 2);
  const st = new Uint8Array(buf.buffer, buf.byteOffset + p, nE); p += a4(nE);
  for (let i = 0; i < nE; i++) { const e = s.entities[i]; ids[i] = e.id; ty[i] = TYPES.indexOf(e.type); xs[i] = e.x; ys[i] = e.y; zs[i] = e.z; hp[i] = e.hp; st[i] = STATES.indexOf(e.state); }
  o = a4(p);
  p = sec(6, unlB); dv.setUint32(p, s.unlocked.length, true); p += 4;
  for (const u of s.unlocked) { dv.setUint16(p, u, true); p += 2; }
  o = a4(p);
  dv.setUint32(8, o - 16, true); dv.setUint32(12, crc32(buf.subarray(16, o)), true);
  return buf.subarray(0, o);
}
function binDe(buf, checkCrc) {
  const dv = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
  if (dv.getUint32(0, true) !== 0x53545343) throw new Error('bad magic');
  const len = dv.getUint32(8, true);
  if (16 + len > buf.length) throw new Error(`truncated: header says ${len} payload bytes, file has ${buf.length - 16}`);
  if (checkCrc && dv.getUint32(12, true) !== crc32(buf.subarray(16, 16 + len))) throw new Error('crc mismatch');
  const out = { saveVersion: dv.getUint32(4, true) }; let o = 16;
  while (o < 16 + len) {
    const tag = dv.getUint32(o, true), l = dv.getUint32(o + 4, true); let p = o + 8;
    if (tag === 5) {
      const n = dv.getUint32(p, true); p += 4;
      const ids = new Int32Array(buf.buffer, buf.byteOffset + p, n); p += a4(n * 4);
      const ty = new Uint8Array(buf.buffer, buf.byteOffset + p, n); p += a4(n);
      const xs = new Float32Array(buf.buffer, buf.byteOffset + p, n); p += n * 4;
      const ys = new Float32Array(buf.buffer, buf.byteOffset + p, n); p += n * 4;
      const zs = new Float32Array(buf.buffer, buf.byteOffset + p, n); p += n * 4;
      const hp = new Uint16Array(buf.buffer, buf.byteOffset + p, n); p += a4(n * 2);
      const st = new Uint8Array(buf.buffer, buf.byteOffset + p, n);
      const es = new Array(n);
      for (let i = 0; i < n; i++) es[i] = { id: ids[i], type: TYPES[ty[i]], x: xs[i], y: ys[i], z: zs[i], hp: hp[i], state: STATES[st[i]] };
      out.entities = es;
    }
    o = a4(o + 8 + l);
  }
  return out;
}

const C = {
  'JSON': [s => Buffer.from(JSON.stringify(s), 'utf8'), b => JSON.parse(b.toString('utf8'))],
  'JSON + gzip': [s => zlib.gzipSync(Buffer.from(JSON.stringify(s), 'utf8')), b => JSON.parse(zlib.gunzipSync(b).toString('utf8'))],
  'Packed binary': [binSer, b => binDe(b, false)],
  'Binary + gzip': [s => zlib.gzipSync(binSer(s)), b => binDe(zlib.gunzipSync(b), false)],
};

console.log('=== 1. format comparison ===');
for (const [label, prof] of [['early game', SMALL], ['late game', LARGE]]) {
  const s = makeState(prof);
  console.log(`\n${label}: ${prof.ents} entities, ${prof.flags} flags, ${prof.inv} items, ${prof.quests} quests`);
  console.log('format             bytes   ser_ms  parse_ms');
  for (const [n, [ser, de]] of Object.entries(C)) {
    const b = ser(s); de(b);
    console.log(`${n.padEnd(16)}${P(b.length, 9)}${P(ms(() => ser(s)).toFixed(2), 9)}${P(ms(() => de(b)).toFixed(2), 10)}`);
  }
}

console.log('\n=== 2. where does the save drop a frame? (16.67 ms) ===');
console.log('entities  json_bytes  json_ser_ms  bin_ser_ms');
for (const n of [5000, 10000, 30000, 50000, 55000, 100000]) {
  const s = makeState({ ...LARGE, ents: n });
  const jb = C['JSON'][0](s).length;
  const j = ms(() => C['JSON'][0](s), 5), b = ms(() => binSer(s), 5);
  console.log(P(n, 8) + P(jb, 12) + P(j.toFixed(2) + (j > FRAME ? ' *' : '  '), 13) + P(b.toFixed(2) + (b > FRAME ? ' *' : '  '), 12));
}

console.log('\n=== 3. what a v2 loader does to a v1 save (no version check) ===');
const t2 = makeState({ ...LARGE, ents: 2000 });
const W = { u8: 1, u16: 2, u32: 4, i32: 4, f32: 4 };
const pack = (es, sc) => { const st = sc.reduce((a, [, k]) => a + W[k], 0); const b = Buffer.alloc(8 + es.length * st); b.writeUInt32LE(es.length, 4); let o = 8; for (const [nm, k] of sc) for (let i = 0; i < es.length; i++) { const v = es[i][nm] ?? 0; k === 'u8' ? b.writeUInt8(v & 255, o) : k === 'u16' ? b.writeUInt16LE(v & 65535, o) : k === 'f32' ? b.writeFloatLE(v, o) : k === 'i32' ? b.writeInt32LE(v | 0, o) : b.writeUInt32LE(v >>> 0, o); o += W[k]; } return b; };
const unpack = (b, sc) => { const n = b.readUInt32LE(4), st = sc.reduce((a, [, k]) => a + W[k], 0); if (8 + n * st > b.length) throw new Error(`file is ${b.length} B, v2 schema needs ${8 + n * st} B`); const out = Array.from({ length: n }, () => ({})); let o = 8; for (const [nm, k] of sc) for (let i = 0; i < n; i++) { out[i][nm] = k === 'u8' ? b.readUInt8(o) : k === 'u16' ? b.readUInt16LE(o) : k === 'f32' ? b.readFloatLE(o) : k === 'i32' ? b.readInt32LE(o) : b.readUInt32LE(o); o += W[k]; } return out; };
const num = t2.entities.map(e => ({ id: e.id, type: TYPES.indexOf(e.type), x: e.x, y: e.y, z: e.z, hp: e.hp, state: STATES.indexOf(e.state) }));
const V1 = [['id', 'i32'], ['type', 'u8'], ['x', 'f32'], ['y', 'f32'], ['z', 'f32'], ['hp', 'u16'], ['state', 'u8']];
const v1b = pack(num, V1);
const cases = [
  ['add field  facing:f32', [...V1, ['facing', 'f32']], 'hp'],
  ['rename     hp -> health', V1.map(f => f[0] === 'hp' ? ['health', 'u16'] : f), 'health'],
  ['widen      hp u16 -> u32', V1.map(f => f[0] === 'hp' ? ['hp', 'u32'] : f), 'hp'],
  ['drop field type:u8', V1.filter(f => f[0] !== 'type'), 'hp'],
];
for (const [n, sc, fld] of cases) {
  let v; try { const r = unpack(v1b, sc); const bad = r.filter((e, i) => e[fld] !== num[i].hp).length; v = bad ? `SILENTLY WRONG (${bad}/${r.length} hp)  hp[0]=${r[0][fld]} truth=${num[0].hp}` : `correct (the file has no field names)`; } catch (e) { v = 'THREW: ' + e.message; }
  console.log(`binary  ${n.padEnd(26)} ${v}`);
}
const js1 = JSON.stringify({ entities: num.map(e => ({ id: e.id, hp: e.hp })) });
const je = JSON.parse(js1).entities;
console.log(`JSON    ${'add field  facing'.padEnd(26)} FIELD MISSING (${je.filter(e => e.facing === undefined).length}/${je.length})  facing[0]=${je[0].facing}`);
console.log(`JSON    ${'rename     hp -> health'.padEnd(26)} SILENTLY WRONG (${je.filter(e => typeof e.health !== 'number').length}/${je.length} health undefined)`);
let sum = 0; for (const e of je) sum += e.hp.cur;
console.log(`JSON    ${'retype     hp -> {cur,max}'.padEnd(26)} SILENTLY WRONG (no throw, total hp = ${sum})`);

console.log('\n=== 4. cost of the migration chain at load ===');
const big = makeState(LARGE), bigJ = Buffer.from(JSON.stringify(big), 'utf8');
const PJ = () => JSON.parse(bigJ.toString('utf8'));
const base = ms(PJ);
console.log(`JSON.parse alone                          ${base.toFixed(2)} ms  (${bigJ.length} B)`);
for (const [n, f] of [
  ['v1->v2 add field e.facing = 0', s => { for (const e of s.entities) e.facing = 0; }],
  ['v2->v3 rename with delete e.hp', s => { for (const e of s.entities) { e.health = e.hp; delete e.hp; } }],
  ['v2->v3 rename by rebuilding obj', s => { s.entities = s.entities.map(e => ({ id: e.id, type: e.type, x: e.x, y: e.y, z: e.z, health: e.hp, state: e.state })); }],
  ['v3->v4 retype hp -> {cur,max}', s => { for (const e of s.entities) e.hp = { cur: e.hp, max: 65535 }; }],
]) { const t = ms(() => { const s = PJ(); f(s); return s; }); console.log(`  + ${n.padEnd(38)} ${P(t.toFixed(2), 6)} ms  (+${(t - base).toFixed(2)} ms)`); }

console.log('\n=== 5. a save truncated mid-write ===');
for (const [n, [ser, de]] of Object.entries(C)) {
  const b = ser(big), cut = b.subarray(0, Math.floor(b.length * 0.999));
  let v; try { const r = de(cut); v = `LOADED, no error (${r.entities ? r.entities.length : 0} entities)`; } catch (e) { v = 'threw: ' + e.message.slice(0, 48); }
  console.log(`${n.padEnd(16)} kept 99.9%  ${v}`);
}
const bin = binSer(big), padd = Buffer.alloc(bin.length); bin.subarray(0, Math.floor(bin.length * 0.999)).copy(padd);
let a, bb;
try { binDe(padd, false); a = 'LOADED SILENTLY'; } catch (e) { a = 'threw'; }
try { binDe(padd, true); bb = 'threw'; } catch (e) { bb = 'threw (' + e.message + ')'; }
console.log(`binary, zero-padded back to full length:  without crc -> ${a}   with crc -> ${bb}`);
console.log(`crc32 pure JS  ${P(bin.length, 9)} B  ${ms(() => crc32(bin)).toFixed(2)} ms` + (zlib.crc32 ? `   |  zlib.crc32 native ${ms(() => zlib.crc32(bin)).toFixed(3)} ms` : ''));

console.log('\n=== 6. writing the file ===');
fs.mkdirSync('./saves', { recursive: true });
const T = './saves/slot1.sav', TM = T + '.tmp';
const ways = {
  'write in place': b => fs.writeFileSync(T, b),
  'write in place + fsync': b => { const fd = fs.openSync(T, 'w'); fs.writeSync(fd, b); fs.fsyncSync(fd); fs.closeSync(fd); },
  'write temp + rename': b => { fs.writeFileSync(TM, b); fs.renameSync(TM, T); },
  'write temp + fsync + rename': b => { const fd = fs.openSync(TM, 'w'); fs.writeSync(fd, b); fs.fsyncSync(fd); fs.closeSync(fd); fs.renameSync(TM, T); },
};
for (const [n, f] of Object.entries(ways)) { f(bin); console.log(`${n.padEnd(30)} ${P(ms(() => f(bin), 9).toFixed(2), 6)} ms`); }
fs.writeFileSync(T, bin);
const part = bin.subarray(0, Math.floor(bin.length * 0.6));
let fd = fs.openSync(T, 'w'); fs.writeSync(fd, part); fs.closeSync(fd);
try { binDe(fs.readFileSync(T), true); console.log('crash in place    -> loaded'); } catch (e) { console.log('crash in place    -> UNREADABLE, previous save gone: ' + e.message.slice(0, 40)); }
fs.writeFileSync(T, bin);
fd = fs.openSync(TM, 'w'); fs.writeSync(fd, part); fs.closeSync(fd);
try { const g = binDe(fs.readFileSync(T), true); console.log(`crash temp+rename -> loaded, ${g.entities.length} entities intact`); } catch (e) { console.log('crash temp+rename -> UNREADABLE'); }
fs.rmSync('./saves', { recursive: true, force: true });
console.log('cleaned ./saves');

On the M3 above, node savebench.mjs prints:

=== 1. format comparison ===

early game: 400 entities, 200 flags, 20 items, 6 quests
format             bytes   ser_ms  parse_ms
JSON                39981     0.17      0.16
JSON + gzip          9814     0.59      0.21
Packed binary        8492     0.10      0.03
Binary + gzip        7293     0.14      0.06

late game: 50000 entities, 4000 flags, 240 items, 180 quests
format             bytes   ser_ms  parse_ms
JSON              4553047    17.04     17.39
JSON + gzip       1029443    78.23     22.43
Packed binary     1007228     6.24      0.92
Binary + gzip      779391    20.17      4.29

=== 2. where does the save drop a frame? (16.67 ms) ===
entities  json_bytes  json_ser_ms  bin_ser_ms
    5000      538822       1.87        0.47
   10000      980154       3.52        0.86
   30000     2766875       9.99        2.30
   50000     4553047      16.50        3.85
   55000     4999679      18.53 *      4.10
  100000     9018913      32.45 *      7.27

=== 3. what a v2 loader does to a v1 save (no version check) ===
binary  add field  facing:f32      THREW: file is 40008 B, v2 schema needs 48008 B
binary  rename     hp -> health    correct (the file has no field names)
binary  widen      hp u16 -> u32   THREW: file is 40008 B, v2 schema needs 44008 B
binary  drop field type:u8         SILENTLY WRONG (2000/2000 hp)  hp[0]=56689 truth=42764
JSON    add field  facing          FIELD MISSING (2000/2000)  facing[0]=undefined
JSON    rename     hp -> health    SILENTLY WRONG (2000/2000 health undefined)
JSON    retype     hp -> {cur,max} SILENTLY WRONG (no throw, total hp = NaN)

=== 4. cost of the migration chain at load ===
JSON.parse alone                          16.17 ms  (4553047 B)
  + v1->v2 add field e.facing = 0           17.02 ms  (+0.85 ms)
  + v2->v3 rename with delete e.hp          30.55 ms  (+14.38 ms)
  + v2->v3 rename by rebuilding obj         16.86 ms  (+0.68 ms)
  + v3->v4 retype hp -> {cur,max}           16.91 ms  (+0.74 ms)

=== 5. a save truncated mid-write ===
JSON             kept 99.9%  threw: Unterminated string in JSON at position 4548493
JSON + gzip      kept 99.9%  threw: unexpected end of file
Packed binary    kept 99.9%  threw: truncated: header says 1007212 payload bytes, fi
Binary + gzip    kept 99.9%  threw: unexpected end of file
binary, zero-padded back to full length:  without crc -> LOADED SILENTLY   with crc -> threw (crc mismatch)
crc32 pure JS    1007228 B  2.23 ms   |  zlib.crc32 native 0.033 ms

=== 6. writing the file ===
write in place                   0.36 ms
write in place + fsync           3.85 ms
write temp + rename              0.24 ms
write temp + fsync + rename      3.63 ms
crash in place    -> UNREADABLE, previous save gone: truncated: header says 1007212 payload b
crash temp+rename -> loaded, 50000 entities intact
cleaned ./saves

The byte counts are exact and match on any machine. The milliseconds will not, and they differ by up to 30% from the tables above because this script measures every format in one process, sharing one heap and one GC, where the tables used one process per format. The ordering, and section 3, are the findings.