The live-mode census finds loaded tags by sweeping ~13 GB of the game's memory
for their bytes. This is the other half of the picture the research note
live_tag_locating.md pointed at: reaching UE's own
tables so "what is loaded" is a bounded pointer chase, not a sweep.
It works, end to end, verified against the shipped build
(…Meteorite-2607-CU3, UE 5.5.4) in mission a30. New code lives in
crates/blam-live: objects.rs (the object table), names.rs (the name
pool), and module-base lookup in sys.rs.
Update 2026-10-21: the build lock had read …Meteorite-2607-CU4 since
2026-08-18 (commit 0b02b919), so the CU3 label above is probably carried
forward; see build_lock.md.
The chain, all signature-resolved
- Module base —
Process::module("HaloCampaignEvolved.exe")via a Toolhelp snapshot. ASLR moves the image each launch; every static RVA is added to this. GUObjectArray— the AOB insignatures/GUObjectArray.luamatches once in.text; itsLEAdisplacement decodes to the array's RVA. UE 5.5 layout:FUObjectArray + 0x10is the chunked store,Objects(chunk-pointer array) at+0x00,NumElementsat+0x14, 64KFUObjectItems (24 bytes each) per chunk; each item's first qword is theUObjectBase*.- Walk — one read per chunk plus one per live object for its header
(
ClassPrivate +0x10,NamePrivate +0x18,OuterPrivate +0x20). 291,671 elements, 263,374 live, in about a second. - Name pool — no signature ships for it (UE4SS resolves names by calling
into the engine, which an external reader can't). So
names::find_pooldecodes the RIP-relative references out of theFNameconstructor and the functions it calls (the pool ref sits inGetNamePool, a one-linelea rax,[NamePoolData]; ret), and tests each candidate against a known(id, text)pair. It bootstraps fromFNameid 0, which is"None"in every UE build — so no oracle is needed. Layout:FNameEntryId = block<<16 | offset, entry atBlocks[block] + offset*2,BlocksatFNamePool + 0x10, entry header{bIsWide:1; hash:5; len:10}.
Verified: the pool was found at rva 0xd418e80 from the "None" bootstrap
alone, and 135/135 bridge-supplied tag names resolved byte-identically. A
known object's class pointer matched the game bridge exactly.
The catch: "object exists" is not "data resident"
GUObjectArray lists 9,147 tag-asset objects under /Game/Tags/. The
census finds 369 with resident data. So nearly every tag in the catalog has
a live UObject whose bulk data is unloaded — the object existing says
nothing about whether its data section is in memory to poke. GUObjectArray
alone over-reports the editable set by ~25×.
That means the reader does not replace the census for "which tags can I live-edit right now." What it does give, instantly and exactly:
- Level detection. Exactly one
BlamScenarioTagDataAssetis loaded under/Game/Tags/— a30's — so the level is read directly from its package name. No fingerprinting, no ambiguity, and correct where the census's scenario-fingerprint fallback was noisy. - A full identity index. Every present tag asset, name resolved and mapped
to the catalog via
Catalog::tag_by_package(the package name is the cooked pathtag_by_packagealready parses). Useful for browse/"present in this build's session," distinct from "data-resident."
Settled: the buffer is not reachable from the UObject
tests/residency_probe.rs answers this properly, and the answer is no.
Method matters here, because two earlier attempts produced convincing-looking false positives:
- Comparing a fixed 512-byte window scored
ClassPrivateat 74% — tag data sections are zero-dominated, so any mostly-zero memory "matches." - Whole-section
blam_live::verifyscored a deliberately wrong address at 72%. It works inside the census only because candidates arrive there already established by high-entropy run agreement; as a standalone discriminator it is worthless.
The metric that works is the census's own: several unique high-entropy 48-byte runs reproduced at exactly the file's relative spacing. With it:
| measure | result |
|---|---|
census-resident tags that also have a UObject | 366 / 369 |
| ground truth — probed tags verified at the census base | 252 / 288 |
| control — runs agreeing at a deliberately wrong address | 0 |
resident tags whose buffer is reachable from their UObject | 0 / 288 |
The ground-truth row proves the probe detects a real buffer when one is there,
and the control proves it does not fire on noise. So the negative is real: for
tags known to be resident, the data buffer is not in the UObject's first
1 KB, nor one pointer hop from any pointer-shaped field in it. The tag-asset
UObject is a name-and-class shell; the parsed buffer belongs to a separate
Blam-side structure, as docs/live_tag_locating.md found from the other
direction (scattered per-tag records, no dense table).
Where this meets the census — now wired (tag editor 0.16.0)
Update 2026-10-21: superseded for pokes. Since tag editor 0.18.0 (first
tagged in 0.20.0, PR #95) the census reads the simulation's own tag table, which
gives every loaded tag's root exactly and skips the sweep; the sweep stays only
for a build that neither a measured profile nor the code anchors describe. The
"different and larger hunt" below did find a tag-cache root, the loader's
FPackageId map (blam_live::cache), but it holds only about a tenth of the
resident buffers and now runs only when the table cannot be read; the table is a
separate structure, found 2026-09-05. See tag_table_and_string_ids.md.
apps/tag-editor/src-tauri/src/present.rs puts the reader in front of the
census. Arming live mode calls live_probe (reader only): the level and the
present count land in about a second with no sweep. The census runs the reader
as its first phase, so its level is the object table's exact answer; the
scenario fingerprint and reference-graph guess survive only as the fallback
for a build whose globals do not resolve. The two globals' RVAs are cached per
build and re-validated on every reattach by ObjectTable::validate — each
object carries its own slot index in InternalIndex, which a stale offset
cannot fake (a plain element-count range check was fooled in testing).
Measured: cold attach ~0.4 s, walk ~1.0 s, warm reattach ~2 ms.
Combining them was the prize, with one hypothesis eliminated along the way:
- Identity and level: use the reader. 366 of 369 resident tags have a
UObject, so coverage is effectively complete, and exactly one scenario object is loaded — instant, exact level detection. - Pokeable: still the sweep.
UObjectpresence is necessary but not sufficient (9,147 present vs 369 resident), and the buffer is not reachable from the object. - Residency flag — tested, and there is none.
tests/residency_flag.rsread 4 KB of every tagUObject(9,139 of them, 366 census-resident) and, per class so layout differences cannot masquerade as signal, looked for any u32 field or single bit whose value distribution separates resident from merely-present. Across the 18 classes holding both kinds, no field separated in more than 1 class (mean separation ~0.2, i.e. noise), andObjectFlagsis identically distributed in both sets (0x0028000bdominant in each). Predicting residency from the best candidate scored 4–5 % precision — the 4 % base rate, i.e. chance. TheUObjectcarries no load-state for its bulk data at all; that state lives entirely in the Blam-side per-tag records. So "present" can never be narrowed toward "pokeable" from the object graph, and the sweep's fingerprint set stays as it is. What would shrink it is the Blam tag-cache root (seelive_tag_locating.md), which is a different and larger hunt.
The reader ships as #[ignore]d live tests documenting each layer
(objects::tests::walk_live_object_table, names::tests::discover_name_pool);
they need the game running and MJOLNIR_EXE set, and the name-pool test also
MJOLNIR_NAMES (bridge-supplied <hex addr>\t<name> lines it checks the
resolved names against).