Start here

↑ ↓ to move, Enter to openKeyword search
Game internals

The simulation's tag table and string-id registry

Build
2026.08.11.1121610.2-Rel-i343-Meteorite-2607-CU4 (Steam)
Date
2026-09-05
Code
crates/blam-live/src/tagtable.rs, crates/blam-live/src/stringid.rs, crates/blam-live/examples/tagtable_probe.rs, mjolnir live

Rendered from the repository, where it is written as the work happens: it keeps its history, and a status line above says when it describes a design rather than something shipped.

Build: 2026.08.11.1121610.2-Rel-i343-Meteorite-2607-CU4 (Steam) Date: 2026-09-05 Code: crates/blam-live/src/tagtable.rs, crates/blam-live/src/stringid.rs, crates/blam-live/examples/tagtable_probe.rs, mjolnir live

HaloSimulation_tag_release.dll keeps two tables that answer, without a memory sweep, the two questions live mode has always had to ask: which tags are loaded and where each one's root element is, and which string id names the running game knows. Both hang off globals in the module. This note records where they are on the current build, how they are laid out, and what was measured against them in the running game. It supersedes the sweep-first account in live_tag_locating.md.

Summary

QuestionAnswer on CU4
Where is every loaded tag's root?the tag instance table, pointer at tag-DLL RVA 0x0182D1E8; 7,055 tags in A30, every root resolving, bytes matching the shipped tag
Which string ids does the game know?the registry at RVA 0x013574C0; 64,293 names in A30, dumped to defs/hce/string-ids.json
What does a resolved tag reference hold?group four-CC, an encoded offset to the referenced tag's own path string, the path length, and the handle `generation << 16
Does tag_is_active say whether a tag is loaded?no — it returns false for a loaded weapon; the HS compiler's not a loaded tag error does
Do tag_reload_force / tag_load_force do anything?reload works and relocates the tag; load-force is inert
Is there a debug menu behind DebugMenuSettings?yes, a pause-menu panel "Show Tag Debug Names" plus a type legend; its overlay does not render in the shipping build

The tag table — pointer-chase, no scan

Two globals, RVAs into HaloSimulation_tag_release.dll (hash C8C14440…3BF7, build_lock.md):

GlobalRVAWhat it holds here
tag table pointer0x0182D1E8pointer to a table object whose header begins with the ASCII label tag instance
segment table0x02C2CCC016 × u64 segment bases; segments 1, 14 and 15 were populated (14 is inside the DLL image itself)

Table object: +0x20 element size (0x30), +0x2c maximum (32,767), +0x44 high-water, +0x48 used, +0x50 entry array, +0x58 allocation bitset. At the frontend the table is empty; in A30 it held 7,055 tags (E10: 6,054). Per 0x30-byte entry: +0x00 u16 salt, +0x04 big-endian group four-CC, +0x10 pointer to the NUL-terminated tag path (objects\weapons\rifle\ assault_rifle\assault_rifle, backslashes, no extension), +0x18 the root block descriptor {count, encoded data offset, encoded definition offset}. The handle a tag reference holds in the resident copy is salt << 16 | index.

An encoded offset is segment = enc >> 28, address = segment_base + enc * 4. This is the arena + 4 * words rule blam-live had been deriving per tag (live_tag_locating.md), with the missing half: the arena is a segment base, and the top nibble names which. Root data sat in segment 1, root definitions in segment 14 (the DLL's own static definition tables).

Cross-check against the shipped tag (mjolnir data --group weapon --tag 'assault_rifle\assault_rifle'): the live root's first 12 bytes and the scalars at +492 (flags 00 04 00 00), +496 (secondary flags 80 02 00 00) and +584 (heat warning threshold 1.0) are byte-identical to the file. Every one of the 7,055 entries had a resolvable root address.

Consequence: the 13 GB census sweep is no longer needed to answer "what is loaded" or "where is this tag's root". mjolnir live tags lists the table; poke and the tag editor's live mode read it first and keep the sweep for a build without a profile.

The string-id registry

Six globals, all resolving:

GlobalRVAValue in A30
storage (name bytes)0x01357490pointer; used = 4,004,392 bytes
storage used0x01357498u64
strings (per-id char* table)0x013574A0[0]="", [1]="default", [2]="reload_1"
count0x013574A864,293 (2,678 at the frontend)
mapping hash table0x013574C0header buckets 1,046,528 · max 523,264 · value size 4; buckets at +0x38 (8 bytes each), nodes 0x1c bytes: key u64 +0, next +0x10, storage offset u32 +0x18
builtin table0x0082F0A02,678 × 16 bytes: u32 id, char* at +8

Walking every chain yielded 64,293 (id, name) pairs (chains of at most 3) with all 2,678 builtin ids present; fork_d = 0x1677, warthog_d = 0x17D2. The 62,683 ids in set 0 equal 1068 + (64,293 - 2,678): the builtin ids carry set bits in the high half, every later registration is sequential from 1068. Names register as tags load, so one mission's set is a lower bound for another's. The dump is the novel-string-id validator this project lacked (see iostore_packaging.md, a string-id hazard): a mod may reference a string id only if the running build registers it. It is committed as defs/hce/string-ids.json; mjolnir live string-ids --find <name> asks the running game directly.

The console's tag commands

defs/hce/console.json (CU4) lists tag_is_active, tag_load_force, tag_unload_force and tag_reload_force as live functions, not stubs (the three *_force commands carry flags 4, tag_is_active flags 0), and dump_loaded_tags as a stub. mods/MJOLNIRBlamConsole reaches them. Measured in A30:

CommandResult
tag_is_active objects\weapons\rifle\assault_rifle\assault_rifle.weaponcompiles; returns false although the tag is in the tag table
same path without .weapon, or with forward slashescompiler error not a loaded tag (at character 15)
tag_is_active levels\halo1\solo\b40\b40.scenario (not loaded in A30)compiler error not a loaded tag
tag_reload_force objects\weapons\rifle\assault_rifle\assault_rifle.weaponok; the tag's root data moved from 0x238F7E5E640 to 0x239108DF900, same handle 0xE24A00D6, same bytes
tag_load_force objects\vehicles\covenant\ghost\ghost.vehicle (Ghost is not loaded in A30)ok, but the tag table stayed at 7,055 entries and the compile oracle still said not a loaded tag two probes later

So the HS compiler's tag-literal resolution is a loaded-tag oracle: a tag literal (<path>.<group>, backslashes) compiles only when the tag is in the loaded set. tag_is_active itself answers false for a loaded, in-use weapon, so "active" means something other than "loaded". The tag table walk is the better oracle anyway: exact, instant, no console needed.

tag_load_force has no observable effect in the release build: console.json gives it and tag_unload_force the same evaluator address (0x1b1bb0), distinct from the shared stub, so it is most likely a second "accept a string, do nothing" body.

tag_reload_force is real and live: the tag was re-read and re-relocated in place, its handle unchanged. That is the primitive a hot-reload needs; what it re-reads is the mounted container, which the game holds open, so feeding it new bytes is the open question. It is also why a remembered root address must be re-verified against the tag's own scalars before a write.

The debug menu

The settings object /Script/Meteorite.Default__DebugMenuSettings exists in A30 with three *Shipping flags false and three *NonShipping flags true; setting the Shipping flags true at runtime changed nothing visible in the pause menu, so the gate is not re-read there. The widget itself is already instantiated: W_BlamDebugMenu (class UBlamDebugMenuWidget, Blueprint /Game/_Prototypes/SynchronizationTestContent/Widgets/W_BlamDebugMenu) sits collapsed inside WBP_PauseMenu's overlay. Forcing it visible (SetVisibility(4)) draws a small "Debug Menu · Show Tag Debug Names" checkbox and a "Tag Types" legend of twelve coloured checkboxes (biped, control, crate, creature, effect scenery, equipment, giant, machine, projectile, scenery, vehicle, weapon) — W_BlamGameStateObjectDebugMenu. It is an in-world tag-name overlay, not a command console. Calling SetShowTagDebugNames(true, [0..11]) on the live widget succeeds and ticks every type, but no label appears over any object in A30 — the overlay's drawing is compiled out of the shipping build along with the rest of the debug draw.

A brand-new tag package loads by name

Measured 2026-09-05, same session. mjolnir new-tag cloned the marine's collision model under a path the game never shipped — /Game/Tags/objects/characters/marinf/marinf-collision_model, same-length rename surgery on the donor's wrapper, the body untouched — into its own _P container carrying its own ContainerHeader (blam_pack::build_addition), and mjolnir pack repointed the marine model tag's collision model reference at objects\characters\marinf\marinf. No import-map change anywhere: nothing declares the new package as a dependency.

After a relaunch into A30 the table held 7,056 tags, one more than before, and slot 21 was coll objects\characters\marinf\marinf, allocated right after the marine's model (slot 20). The model's resident root reads its collision reference as 'coll' · name pointer · 0x20 · 0xE1890015 — the new tag's handle. The game played normally.

So, for tags:

  • the runtime tag registry is enumerated from the mounted containers, not a fixed list;
  • a mod container's own ContainerHeader registers its packages — the store reads it;
  • a tag reference resolves by name, on demand, with no hard import required;
  • a tag reference in the resident copy is {group four-CC, pointer to the path, path length, handle}.

This is the door the new-scenario work found closed for scenario packages (new_scenario_loading.md): the refusal there is specific to how a scenario is opened, not to new packages as such. Update 2026-10-21: that door opened on 2026-09-11 (58def73b): a new codename starts once it is cooked into DT_Scenarios as a row, with a ScenarioList handle on the campaign asset (crates/blam-pack/src/scenario.rs).

A tag reference in the resident copy

Measured 2026-09-07 in A30, on the assault rifle's root element (crates/blam-live/src/tagtable.rs, LiveTag::reference_bytes).

A reference field is sixteen bytes on disk and sixteen resident; the loader rewrites two of its four words in place:

WordOn diskIn the running game
+0group four-CC, reversed (effe), or 0xFFFFFFFF when unsetunchanged
+4zeroencoded offset to the referenced tag's path string
+8path lengthunchanged
+120xFFFFFFFFhandle, generation << 16 | index

The second word is an encoded offset in the same scheme as a block descriptor's — segment = enc >> 28, address = segment_base + enc * 4 — and the address it names is exactly the +0x10 name pointer of the referenced tag's own table entry, not a copy. So objects\weapons\fx\weapon_ready, referenced twice by the rifle (ready effect and weapon power-off effect), carries the same word 0x113ECB98 in both, resolving to one string in segment 1. An unset reference points at a shared empty string (0x113EA75C in that session) and keeps 0xFFFFFFFF in both the group and the handle.

The rifle's own reads, file against resident:

FieldFileResident
ready effect65666665 00000000 1f000000 ffffffff65666665 98cb3e11 1f000000 1f0193e2
pickup sound21646e73 00000000 2c000000 ffffffff21646e73 f4cb3e11 2c000000 2e01a2e2
ready damage effect (unset)ffffffff 00000000 00000000 ffffffffffffffff 5ca73e11 00000000 ffffffff

0xE2A2012E is slot 0x12E generation 0xE2A2 — the table entry for sound\weapons\battle_rifle\battle_rifle_ammo.

Consequence: references poke. Given a target the game has already loaded, all sixteen bytes can be built from its table entry, so pointing a reference somewhere else is an ordinary write rather than a rebuild. That is what the tag editor now does (live::Live::reference_bytes, Job::reference), for a field in the root element and for one inside a block element alike. Two things it cannot do, and refuses rather than guesses:

  • the target must be loaded. A handle is a slot in the live table; there is no way to invent one for a tag the game has not read. mjolnir live tags lists what is available.
  • the walk goes stale. tag_reload_force and a level change re-slot tags, so the one entry a write is about to name is re-read (TagTable::entry) and the generation taken from that read, not from the cached walk.

Clearing a reference live writes 0xFFFFFFFF into the group and the handle and zero into the length, and leaves the path word as it stands — the one place a poked field differs from what the loader would have written, and nothing reads a path whose group says there is no target.

Verified end to end by apps/tag-editor/src-tauri/tests/live_poke_e2e.rs (poke_a_reference_through_the_editor_path): the bytes the field held before the write are the old target's resident form and the bytes after are the new target's, both rebuilt independently from the table. And behaviourally in A30: with barrels[0].projectile pointed at objects\vehicles\covenant\banshee\weapons\banshee_dual_cannon\projectiles\banshee_dual_cannon_bolt, the assault rifle fires banshee plasma bolts, and reverts on the next poke.

Adding a build

The RVAs above belong to one tag module. On a game update: hash the new HaloSimulation_tag_release.dll, re-measure the eight globals (the label tag instance at the table object and the registry header 00f80f00 00fc0700 04000000 are the anchors to confirm against), and add a Profile in crates/blam-live/src/tagtable.rs. Until then the sweep runs. Superseded 2026-09-07 by the next section: until then the four code anchors derive the profile, and the sweep runs only when they cannot (an anchor that does not match exactly once).

Finding the globals without a measurement (2026-09-07)

A game update moves the eight globals. Rather than re-measuring them by hand, blam_live::tagtable::derive_profile recovers them from the module on disk through four anchors — instruction shapes that refer to a global through a RIP-relative displacement, with the displacement wildcarded and decoded at run time (signatures/README.md lists them). On CU4 every anchor matches once and the derived profile equals the measured one RVA for RVA (anchors_reproduce_the_measured_profile). attach tries the measured profiles first and the anchors second; only when an anchor fails to match once does live mode fall back to the sweep. The string-id registry's five other globals are at fixed offsets from its storage pointer, so one anchor covers them.

The registry also serves offline: defs/hce/string-ids.json (the A30 dump) ships in blam_live::stringid::shipped, and the tag editor and mjolnir set refuse a string-id edit naming anything outside it unless told to proceed — the game rejects a whole tag over one unregistered id. And a string id in a tag's root element pokes live: the editor resolves the name through the running game's registry and writes the id where the engine keeps it.