Start here

↑ ↓ to move, Enter to openKeyword search
Game internals

The GUObjectArray reader: loaded-tag identities without a scan

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.

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

  1. Module base — Process::module("HaloCampaignEvolved.exe") via a Toolhelp snapshot. ASLR moves the image each launch; every static RVA is added to this.
  2. GUObjectArray — the AOB in signatures/GUObjectArray.lua matches once in .text; its LEA displacement decodes to the array's RVA. UE 5.5 layout: FUObjectArray + 0x10 is the chunked store, Objects (chunk-pointer array) at +0x00, NumElements at +0x14, 64K FUObjectItems (24 bytes each) per chunk; each item's first qword is the UObjectBase*.
  3. 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.
  4. Name pool — no signature ships for it (UE4SS resolves names by calling into the engine, which an external reader can't). So names::find_pool decodes the RIP-relative references out of the FName constructor and the functions it calls (the pool ref sits in GetNamePool, a one-line lea rax,[NamePoolData]; ret), and tests each candidate against a known (id, text) pair. It bootstraps from FName id 0, which is "None" in every UE build — so no oracle is needed. Layout: FNameEntryId = block<<16 | offset, entry at Blocks[block] + offset*2, Blocks at FNamePool + 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 BlamScenarioTagDataAsset is 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 path tag_by_package already 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 ClassPrivate at 74% — tag data sections are zero-dominated, so any mostly-zero memory "matches."
  • Whole-section blam_live::verify scored 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:

measureresult
census-resident tags that also have a UObject366 / 369
ground truth — probed tags verified at the census base252 / 288
control — runs agreeing at a deliberately wrong address0
resident tags whose buffer is reachable from their UObject0 / 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. UObject presence 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.rs read 4 KB of every tag UObject (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), and ObjectFlags is identically distributed in both sets (0x0028000b dominant in each). Predicting residency from the best candidate scored 4–5 % precision — the 4 % base rate, i.e. chance. The UObject carries 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 (see live_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).