Reverse engineered from sinking_star.exe (Jai, Thekla). All values are little-endian. The game keeps its saves in %USERPROFILE%\Saved Games\Order of the Sinking Star\:

Saves go through a save thread (campaign_save_thread_proc) that writes _temp_<name> and atomically replaces the target. A .history file is deleted when the level is won (File_Save_Reason.VICTORY).

Notation: str16 = u16 length + UTF-8 bytes, str64 = s64 length + bytes. Pid = u32 entity id, namespace << 20 | serial (namespace 0 = global, 1023 = runtime-spawned, otherwise per level), shown as #ns-serial.

Times called Apollo time are Jai Apollo_Time: a signed 128-bit count of femtoseconds, stored as two s64 (low, high). Wall-clock: FILETIME = (apollo - ((-630480 << 64) + 0xAE1758526CFC8000)) / 10^8.

u32 version, then fields added over versions (reader load_menu_state gates on the version):

Which levels unlock what, and what counts toward towers and 100%, is in RULES.md.

u32  version                     writer 73; loader accepts 70, 72, 73
u32  Settings.level_data_version  mismatch => "World state has been reset, because we changed this level."
s64  BASE_ENTITY_VERSION          25
s64  n; n × { str64 entity type name; s64 type version }   type index used below = position in this table
u32  unknown (0)
s64  next move index
s64  move counter including undone moves
u32  0
u8   n (8); n × undo mip level
undo record                      the current, not yet committed record
u32  active hero Pid
u32  next pid serial, namespace 0
u32  next pid serial, namespace 1023
u32  next pid serial, level namespace

Undo mip level — level 0 has one record per move, level k condenses older history (each record spans 25^k moves, see debug_dump_undo_miplevels):

u16 factor (1 for level 0, 25 above)   u32 capacity (400)
s32 uncondensed count                  s32 index_in_next_that_lines_up (-1 = none)
s64 n; n × undo record

Undo record (bw_put_undo_record):

s64 first move index        u32 move span           u32 active hero Pid
u16 flags (bit 0 = "!" in the debug dump)           u8, u8 unknown
f64 time (seconds into the level)                   f32 unknown (0.6)
s32 × 3 hero grid position after the move
u32 n; n × Move_Transaction           (metadata-serialized, see below)
s8  n (< 128; max 8); n × lily movement group { f32; u8; u32 c, c × 12 bytes; u32 c, c × 16 bytes }
u32 n; n × action { u8 Action_Type; ... }

u16 base version (BASE_ENTITY_VERSION)  u16 entity type version
repeat until end:
  u16 field: index & 0xFFF, bit 0x1000 = field of the entity type, clear = field of Undoable_Entity_Data
  [old value]  (CHANGE only)
  new value
  u8  0xFD

Field indices number every non-constant member of the struct in declaration order, flattening nested structs into their leaf members (position.x, position.y, ...) and skipping #NoSerialize members and the using entity: Entity base. Members carry version notes (@v14, @v1-24); an index list for a given type version contains only the members whose first version is <= that version, which keeps old files readable.

Value encoding (write_entity_field_diff): plain data (ints, floats, bools, enums, fixed arrays) as raw bytes of the member size; strings and resource pointers (*Triangle_Mesh, *Material, *Texture, by name) as str64; dynamic arrays as s64 count + elements.

data/schema.json holds the index lists for Undoable_Entity_Data and all 88 entity types, generated from the Jai type info in the binary by scripts/ida/export_schema.py.

binary_serialize_with_metadata: u16 struct VERSION constant, then each serializable leaf member whose version range contains that version: plain data raw, dynamic arrays as s64 count + elements (struct elements recurse, each with its own u16 version). Version notes on a parent struct are not inherited by its flattened members, so deprecated nested members (XXX_deprecated_visual_error, XXX_deprecated_charm_setup) are still written.

• Move_Transaction (v3): f64 close_time, f64 commit_time, u32 transaction_id, f32 duration, f32 elapsed, u32 flags, s8 lily_transaction_group_index (v3+), s64 n × Single_Move.
• Single_Move (v8, 156 bytes + array): Pid entity_id, Pid manipulator_id, Move_Info (u8 move_type, Vector3 delta, start_position, target, f32 duration, Pid target_mobile_supporter_id, Pid supported_by_id, u32 flags, u16 teleport_values, u8 post_teleport_rectification, f32 theta_cancelled_when_pushed_rate, Vector3 distance_cancelled_when_pushed_rate, f32 time_cancelled_when_pushed), f32 duration_until_physical_move, Vector3 visual_start, visual_end, XXX_deprecated_visual_error, u64 flags, f32 theta_at_start, f32 turning_theta_target, Pid charm walking_support, u8 charm movement_rate, s64 n × 80-byte deprecated Move_Info.

Read by scripts/parse_levels.py. A simp package: a flat archive of 2015 members, data contiguous from 0x40 to the table of contents, which runs to the end of the file.

TOC (at the TOC offset):

char[4] 'enty'
u16     version                  7
s64     BASE_ENTITY_VERSION      25
s64     n; n × { str64 entity type name; s64 type version }   same table as in .history; all 88 types in every level
u32     entity count
count × { u32 Pid; u16 type index; u32 blob length; blob }

The blob is an entity diff blob without the two u16 version words (they come from the header and the type table), in CHANGE form: every field carries the type's default as the old value and the level value as the new value. A field missing from the blob holds the type default (position 0, scale 1, ...). Fields come in index order, Undoable_Entity_Data fields first, then the type's own (bit 0x1000).

Pids are scoped to the level: the save's .history refers to them raw, but the same Pid appears in several levels with unrelated types (84,387 Pids occur in more than one level, 30,202 of them with different types). The namespace is not a level id: 80 namespaces occur, a level mixes many (the overworld mostly 101, 73, 80, 121, 135, 115) and one namespace spans hundreds of levels. #1021-1 is the Level_State in 449 levels. Cross-entity references (unlocked_by_id, extension_of, target_id, map_label_marker_id, ...) resolve inside the same level (226,296 of 226,322; all on the overworld).

Read by scripts/map_data.py for scripts/build_map.py (top-down map). Readers in sinking_star.exe: load_level_paint_and_lightmap_data (vertex_paint.jai, lightmap_data.jai) and parse_compressed_mesh (render/mesh.jai).

Asset header (.compressed_mesh, .texture, .shader): u16, u16, u16, u16 header length, u32 total size (header included), then an LZ4 block of total - header bytes; files whose size equals the total are stored uncompressed. Meshes have a 12-byte header, textures 40, shaders 24.

Per-entity vertex paint, version 6, all fields u32:

'allp'  version 6  entity count  array count
array count × { mesh checksum; n; n × paint }      arrays are shared by entities with identical paint
entity count × { Pid; array index }

A paint value is one vertex's RGBA8 (byte 0 = red). The array replaces the mesh's own vertex colours when its checksum equals the mesh's checksum (all 102,774 overworld entries with a mesh match, with equal vertex counts). The shaders read it as layer weights, not colour: red exposes layer B (blended2, ground_general: weight clamp(r + h * (r + mask - 1)), h = blend_hardness, mask = the MASKS_tex channel), blue attenuates normals.

u32 LOD count (3)   u32 vertex count   u32 checksum   u8, u8, u8 skinned, u8
f32 × 6 bounding box (min xyz, max xyz)   f32, f32   u32   u32 triangle list count (nl)
vertex count × f32 × 3 positions (+ 8 bytes per vertex when skinned; skinned character meshes differ further)
vertex count × 20 bytes (normal, tangent, UV; not decoded)
vertex count × u32 vertex colour (default paint, same layout as all_paint_data)
LOD count × { nl × { u32 material index, u32 index count, u32 first index }
              u32 index count, u32 byte size, u16 format (0 = u16, 1 = u32), indices }
nl × str16 material name

The index buffer of a LOD holds each list twice, the second copy with reversed winding (mirrored placements). Positions are in metres in the entity's space: world = rotate(quaternion) · (scale × p) + position. base.materials[i], when non-empty, overrides material i.

Header bytes 12..: u16 width, u16 height, u16 depth, u16 mips, u8 format, u8, u8, u8. Formats 0 = BC1 and 1 = BC3 are decoded and checked visually, 5 = 4 bytes per pixel (RGBA8); 2 (8-byte blocks, masks) and 3 (16-byte blocks, normal maps) fit BC4 and BC5, and 4 (16-byte blocks, light-probe arrays) is not decoded. Mips follow largest first, laid out like a D3D12 upload: each block row padded to 256 bytes, each mip padded to 512.

A simp package of text materials: # material version 1, then key value lines ("string", (x y z w), numbers, true/false, flag Name). parent "<name>" inherits every key the material does not set. shader picks the shader; the albedo-related keys used by the map:

Entity colours reach the shader as half floats (Entity_Params.entity_color, effect_color). Water is Ocean_Map: grid.corner relative to the position, grid.squares_x/y, ocean_values[i + j × squares_x] (i, j = local square from the corner, the map wraps with the level grid). Value bits: 0 = water, 1 = river polarity, 2..4 = flow Direction (1 E, 2 N, 3 W, 4 S); overworld data has 0, 1, 5, 9, 13, 17. With detect_holes every square is set to water at load and the voxels of each OCEAN_HOLE Wall_Set whose ocean_hole_id names the map clear bit 0 again. The save's OCEAN_CHANGE actions carry the new byte (see RULES.md §8). The water surface is sink below the map's z; sink defaults to -1 (type initializer), and a negative sink means 0.1 (the ocean mesh builder in ocean.jai).

Built by scripts/build_map.py (data/map.json), scripts/build_world.py (data/world.json) and merged by scripts/build_progress.py. Level roles (Required / Optional and the ice gates each level sits behind) are not stored: the viewer computes them from these fields (RULES.md "Level roles"). Layer numbers l are the ground-layer table indices (0 ground, 1 underworld, 2 sky, 3-5 fast-travel map rooms).