Appendix A — Glossary

Every term is defined in place at first use in the chapters; this is the index. (introduced in Ch N) marks the chapter that defines it; also lists later chapters that rely on it. Anchors are lowercase-hyphenated term names, e.g. [SIMD group](glossary.md#simd-group).

104 norm-boundary groups

the three separated-norm families (+51 entry +52 post-attention +1 post-FFN) of the +196-closure serving gap; their fusion is rejected for breaching the 1e-4 logprob contract (Ch 19)

131,072-position limit

MUSE_MAX_CONTEXT, the model’s per-slot context ceiling; NoPE planes are allocated at exactly this capacity (Ch 22)

4-byte read-back

the GPU-resident greedy chain’s alternative: read only the argmax result slot per token (dflash_argmax_results, u32::MAX = fail-closed nonfinite flag) (Ch 21)

95.5/4.5 payload split

at depth, the 13 NoPE planes carry ≈95.5 % of a handoff’s bytes and the 39 SWA rings ≈4.5 %; why the wire economy is a NoPE economy (Ch 22)

accelerator lease

the flock on /tmp/ferrite.gpu.lock held by a GPU process for its lifetime; the same file discipline on both the Mac and the GX10 (Ch 28; also Ch 38)

AcceleratorPermit

the RAII guard returned by scheduler acquire; dropping it releases the accelerator and wakes the next waiter (Ch 34)

AcceleratorScheduler

the one Mutex+Condvar owner of the shared Metal queue; decode selected first, cyclic fairness (Ch 2)

acceptance rate

accepted proposals ÷ drafted proposals; gated per-request over a recent 8-round window with a 0.25 floor (Ch 8)

access pattern

what memory a kernel reads, in what order, how much; “where the bandwidth story lives” (Ch 6)

accounting-invariant metric

a timing column defined identically across engines (wall time at 131,008 is one; short-output decode is not) (Ch 38)

Activations pool

the per-sequence GPU buffers of Table 10.2, allocated once, reused every token, zero hot-path allocation (decode.rs:897) (Ch 10)

adjacent lease window

measuring two lanes back-to-back under one held accelerator lease so drift between them is bounded by seconds (Ch 38)

a diagnostic run under forced 100% acceptance (the distributed lane’s 110.59 tok/s standard trace) that proves the pipeline’s plumbing while proving nothing about throughput; never citable as serving performance. (Ch 33; also Ch 40)

ALPN

Application-Layer Protocol Negotiation: the protocol name agreed inside the TLS handshake; the data plane’s is exactly muser-kvpack-v2 (Ch 30)

anchor flip

the J0 operator revision that retired Muser’s self-referential production hash and made llama’s own bytes the exactness gate (Ch 38)

append

the fail-closed ring reservation: position must equal origin_logical+len, else CacheDiscontinuity (Ch 15)

append-only evidence volume

muser-receipt://, where receipts are immutable (created by exclusive temp+fsync+rename, never replaced) and records journal O_APPEND (Ch 39)

append_batch

the chunked ring reservation; overflow advances both origins by the evicted count and returns which source rows remain live (Ch 23)

argmax

the reduction returning the index of the largest element; the winning index is itself the token id, so greedy decoding needs no softmax (Ch 21)

arithmetic ABI

the pinned agreement in op order, reduction tree, and materialization dtype across vendors’ math (e.g. CUDA’s serial 128-dim attention reduction vs Metal’s 32-lane tree) (Ch 29)

arithmetic intensity

a workload’s FLOPs per byte read; decode’s is ~3.2, fixed by the model format (Ch 1)

asymmetric auth model

keyless loopback inference, bearer-or-dashboard management, cookie+CSRF+Origin mutations, authenticated-everything on LAN — security posture chosen by where you bind (Ch 37)

asymmetric quantization

two numbers per block (scale + min); handles blocks not centered on zero at the cost of the extra stored min (Ch 5)

atomic seal bundle

the final-campaign output: all lanes freshly rerun into a hidden directory, fsynced, then exposed with one rename; failure exposes nothing (Ch 39)

attention

the only cross-token mixer: each token’s Query scores against past Keys (softmax-weighted) and pulls a weighted sum of Values (Ch 9; also Ch 16)

attention route ladder

per-layer kernel selection: llama-pinned vec / splitk / ferrite-interleaved, gated by llama_vec_rows/llama_swa predicates (decode.rs:5646-5657) (Ch 10)

attention scale

1/√head_dim = 1/√128 ≈ 0.0884 applied to Q·K scores, independent of the folded qk_scale_factor (config.rs:279-281) (Ch 9)

attention-output gate

Muse Glimmer’s learned per-channel multiplier: attn_out[i] ← attn_out[i] · σ(gate_proj[i]), applied in attention space before o_proj (Ch 17)

attn_dim / kv_dim

query space n_heads×head_dim = 4,096 vs KV space n_kv_heads×head_dim = 256 (config.rs:268-273) (Ch 9)

bandwidth

how fast memory can hand bytes to the GPU, measured GB/s; the budget that governs decode (Ch 1)

batch-width boundary

the token-count at which the projection kernel changes; a floating-point reduction-order boundary kept llama-exact (Ch 13)

begin/finish_dflash_verify_suffix

the Mirror-SD split: run the verify block to a capture layer synchronously, submit the suffix layers + LM head without waiting (decode.rs:3298, 3635) (Ch 10)

bit-exactness-over-throughput

the disposition that keeps the 104 separated norm boundaries because their available fusion changes logprobs beyond contract (Ch 35)

bitrate

bits per weight of a stored format: payload bits plus header bits ÷ block size (Ch 5)

blit

a GPU block-copy executed via a blit command encoder rather than a compute kernel (Ch 3)

block

a small contiguous group of weights sharing one scale (and optionally a min); the unit of local quantization (Ch 5)

bound inventory

every queue in the server has a number (64 MiB bodies, 30 s timeouts, 256 connections, 64 admissions, 64-deep streams, 64 sessions); overflow is a status code, never a hang (Ch 37)

boundary-token hold-back

the receiver decodes the final prompt token locally, so KV ships for prompt − 1 tokens (one NoPE token = 13,312 B less payload) (Ch 26)

bounded-logit policy

a qualification contract mode (bounded-drift) in which greedy tokens must be bit-exact while full-logit drift must fit sealed bounds (native lane: max < 11.0, mean < 1.25), declared in the frozen identity and checked per sample and per summary. (Ch 32)

BPE tokenizer (merge-order aware)

GGUF byte-pair encoding respecting merge priority; vocab 202,048, identity bound by a metadata SHA-256 (Ch 9)

cache hit (economics)

an authenticated restore and-committed install; session continuations and fresh disaggregated prefills never count (Ch 25)

cached frequency table

the powf-built [head_dim/2] θ table uploaded once; kernels do one multiply, no pow (Ch 14)

CacheDiscontinuity

the fail-closed error when a KV append position is not exactly origin_logical + len (decode.rs:265-284) (Ch 10)

calibrated gate

a tolerance derived from a measured second quantization (Q6-vs-kquant disagreement) rather than chosen; used for the deep-ladder content controls so no threshold can be accused of convenience. (Ch 32)

canonical JSON

recursively key-sorted, compact JSON encoding shared by the Rust and Python sides so both compute identical bytes to hash and MAC (Ch 30)

carried frontier

the target-selected token held un-evaluated between speculative rounds; its explicit witness geometry prevents publishing state whose KV rows do not exist yet. (Ch 33)

causal mask

the rule forbidding a query from seeing keys at later positions (Ch 9)

chat shift unit

the atomic replay unit of context shift: a user message plus everything attached to its turn (assistant calls, tool results, images) (Ch 23)

chat template

the GGUF-embedded Jinja-style prompt renderer; pinned at exactly 7,167 bytes with its own SHA-256 (Ch 9)

codebook

the small table of allowed values a quantized index selects from; 4 bits select 16 entries (Ch 5)

command buffer

the “tape”: a recorded sequence of GPU instructions handed to the GPU in one shot at commit (Ch 2)

command-buffer amortization

the whole 52-layer token recorded onto one concurrent encoder, committed once per token (decode.rs:5448-5458) (Ch 10)

companion tensors

the bound .nvfp4_scale, .nvfp4_scale2 (and optional .nvfp4_input_scale_inv) tensors every NVFP4 weight matrix must carry, validated fail-closed at load (Ch 7)

comparator golden

the pinned llama.cpp byte artifact that gates exactness (since J0: the complete 808,192-byte f32 logit row, SHA-256 fc37487b…) (Ch 38)

compute command encoder

the recorder that writes dispatches onto a command buffer (Ch 2)

concurrent dispatch

an encoder (MTLDispatchType::Concurrent) that may overlap dispatches with no dependency between them (Ch 2)

concurrent dispatch set

multiple independent kernels encoded in one closure so the GPU may overlap them (Q/K/V/gate) (Ch 13)

consumer (receiver)

the process that accepts authenticated KV over Handoff V2 and decodes; today the Mac Metal engine (Ch 27)

content-local sensitivity

a quality exceedance confined to one content class at one depth (docs@65,536: 15.134% vs 13.339% top-token gate) that did not replicate cross-document; published, not capped. (Ch 32)

content-sensitive envelope

the published form of the NVFP4 quality result: gates are content- and depth-local, and the docs@65,536 exceedance is part of the claim (Ch 40)

context geometry

the enrolled sink+window shape (DFlashContextGeometry) bound to the draft’s digest; receivers must never infer it locally (Ch 8)

ContextPolicy (`Shift`/`Error`)

the server-owned context-overflow policy; the engine has no shift op (Ch 23)

counted-warmup convention

the disagg cells’ protocol of one uncounted warmup handoff before five counted reps; part of the claim, not a footnote (Ch 27)

CPU-side exact acceptance

speculative tokens accepted/rejected on the CPU against the target’s full distributions (verify_full_speculative_mt_ordered, sampling.rs:1033) (Ch 10)

cross-vendor arithmetic ABI

the pinned set of reduction orders and materialization dtypes that lets CUDA-produced logits match Metal bit-for-bit; what the wizard’s one-ULP chase (attempts 10–31) had to version. (Ch 32)

cross-vendor library

the strict-f32 recompile of muse_reference + nvfp4 whose arithmetic matches CUDA’s scalar boundaries for remote-parity routes (Ch 4)

CSRF

cross-site request forgery: a hostile page makes the victim’s browser send a cookie-authenticated request; countered by exact-Origin matching plus a constant-time token on mutations (Ch 37)

current-token bypass

reading the current token’s K/V as f32 from the activation buffers instead of the f16 plane; ferrite rung only (Ch 16)

cyclic slot rotation

fairness by ascending sequence-ID order resuming after the last-served ID, implemented identically at both scheduler levels (Ch 34)

D2H gather

the producer-side device-to-host copy of each computed KV layer into pinned host memory on a fenced CUDA side stream, ahead of the TLS send (Ch 29)

DC offset

a block mean far from zero; halves a symmetric grid’s effective precision, the case min+offset exists for (Ch 5)

decode

generating tokens one by one after the prompt has been read; the bandwidth-bound regime (Ch 1; also Ch 10)

decode-aware chunk shrinking

prefill boundaries collapse from 512 rows to 64 the moment any decoder queues, capping decode’s worst-case wait at one small interval (Ch 34)

decode-over-prefill priority

the scheduler rule that any waiting decode outranks all prefill: prefill acquires only when no decode is queued (Ch 34)

DecodeBatcher (250 µs rendezvous)

the server-side decode-step coalescer: request threads keep slot ownership while one elected runner waits ≤250 µs to pack up to four rows (disabled at parallel=1) (Ch 34)

delta handoff

a handoff armed on an exact held prefix so only the suffix crosses the wire; admission requires 256-aligned cut, nonempty suffix, exact held tokens (Ch 26)

delta witness

the receiver’s record of the observed (role, layer, start, count) segment stream, re-checked against the span schedule at prepare time on deferred delta handoffs (Ch 30)

dequantize

reconstruct an approximate value from a stored index: scale × index + min (or a float-LUT lookup) (Ch 5)

detached generation

a full replacement state built alongside live decode; swapped in only after the handoff seal validates (Ch 10; also Ch 30)

deterministic tiebreak

strictly-greater comparison so equal logits keep the lower index, matching the CPU first-maximum convention; load-bearing for byte-identical diffs (Ch 21)

DFlash

Muser’s five-layer kquant draft assistant, fed pinned target hidden states via a 33,280→6,656 fc projection (Ch 8; also Ch 10)

disaggregated prefill

splitting inference across machines by role: a producer prefills the prompt into KV, a consumer receives it and decodes (Ch 27)

dispatch

the four-line unit of GPU work: bind kernel, bind buffers, set constants, launch N threadgroups (Ch 2)

dispatch gap (+196)

the reconciled 760-vs-564 closure delta (104 norm-boundary + 39 SWA staging + 52 KV-publication + 1 copy); every cheap removal changes bits (Ch 10)

dispatch ladder

the ordered kernel choices per (dtype, token-count) in encode_quantized_matmul, kept source-pinned against llama.cpp (Ch 6)

divergence penalty

the serialization CUDA applies when threads of one warp take different branches (Ch 29)

documentation truth pass

the audit genre that re-reads claim-bearing documents against implementation and retained receipts (Ch 39)

dot product

the multiply-and-add pairing of two equal-length vectors into one scalar; the atom under every weight matrix (Ch 5; also Ch 13)

down projection

the FFN exit matvec W_down · ffn_mid ([19968→6656]); carries both Q4_K (74.76 MB) and Q6_K (109.03 MB, +45.8 %) tensors on the release artifact (Ch 19)

draft model

the small model that proposes tokens cheaply for a large target to verify; pure overhead that pays when its guesses are accepted (Ch 8)

draft trace

the deterministic per-round proposal list (draft_token_trace) that qualification compares exactly (Ch 8)

DRAM

dynamic RAM, the machine’s main system memory (96 GB on the decode Mac) (Ch 3)

drift envelope

the measured max/mean absolute full-logit (and KV) deltas between two engines’ outputs on a fixed fixture (native vs exact: 7.270581/1.040619 at 32 tokens; 10.884401/1.233789 at 2,048/256); deterministic but nonzero, and published as part of the claim. (Ch 32)

dual EOS

two end-of-generation control tokens (EOS 200,001 + EOT 200,008) merged into one stop set (Ch 9)

dual-eps fused tail

muser_fused_norm_residual_rms_norm_32sg: residual add + post-norm (eps 1e-8) + next norm (eps 1e-5) in one kernel; produces the next sub-block’s normed input (Ch 10)

dual-eps tail

the fused dispatch computing post-norm (eps 1e-8) + residual add + next pre-norm (eps 1e-5) in one kernel (Ch 12)

durable reservation

the write + fsync + rename + directory-fsync dance that persists a generation before any live engine state is published or the ACK leaves (Ch 30)

durable reserve pattern

the crash-safe commit sequence write-temp + fsync + rename + directory-fsync used by the replay ledger; its directory-fsync tail is why operational state must live on the internal disk, never the evidence volume. (Ch 31)

E2M1

the 4-bit float codebook: 1 sign + 2 exponent + 1 mantissa; values ±{0, 0.5, 1, 1.5, 2, 3, 4, 6} with relative spacing (Ch 7)

E4M3FN

the 8-bit float block scale: finite-only (NaN at 0x7f/0xff), max magnitude 448, exponent bias 7 (Ch 7)

Earley recognizer

the chart parser behind the grammar matcher: keeps every ambiguous parse stack alive and consumes tokens byte-wise, accepting partial UTF-8 sequences (Ch 21)

EEE (Energy-Efficient Ethernet)

the link’s low-power idle mode (LPI); on this lane’s burst schedule it produced retransmission blackouts quantized at 6.42 ± 0.03 s, so EEE-off is the enrolled link invariant. (Ch 31)

effective read rate

bytes-per-token × measured tokens-per-second (~594 GB/s for kquant decode); derived from measured throughput, not a spec (Ch 1)

embedding

a learned lookup table with one row per vocabulary token; “embedding a token” means reading its row (Ch 11)

embedding table (`token_embd.weight`)

the [hidden_dim × vocab_size] GGUF tensor, Q4_K (3,744 B/row) or F16 on Muser’s lanes (Ch 11)

encode_batch_hidden_range

the batch/serving encoder over a row range; mirrors encode_token’s op sequence (decode.rs:3858) (Ch 10; also Ch 36)

encode_token

the legacy single-token 52-layer Metal graph; teacher-forced benchmark and phase-profile route (decode.rs:5515) (Ch 10)

encrypted session envelope

the on-disk bundle format: Postcard bytes sealed with XChaCha20Poly1305 under a MUSER-SESSION-V3 magic, 0700 directory, atomic private write (Ch 37)

EOG exclusion

masking the request’s end-of-generation tokens inside the argmax reduction only, leaving stored logits byte-identical for logprob and session uses (Ch 21)

epsilon (ε)

the tiny constant inside the square root keeping the denominator positive; 1e-5 from the GGUF on Muse Glimmer (Ch 12)

exact speculative acceptance

Muser’s CPU-side verify_full_speculative_mt_ordered contract: full target distributions plus the pinned RNG stream, gated by all-logit-row comparators (Ch 21)

exact-token gate

a performance rep counts only if the two engines produced byte-identical tokens; divergent outputs mean different work, not different speed (Ch 38)

ExactIdentityV1

the compatibility namespace binding model, revision, adapter, tokenizer, chat-template, and context-policy identities; any difference is a miss (Ch 24)

exit 75

the producer’s fail-closed death code (EX_TEMPFAIL) on any engine-touched error; a dead producer is recoverable, a degraded one is not (Ch 28)

f16

IEEE 754 16-bit float (“half”): 1 sign + 5 exponent + 10 mantissa bits, ~3 decimal digits, range 2⁻¹⁴ to 65,504 (Ch 5)

f32

IEEE 754 32-bit float: 1 sign + 8 exponent + 23 mantissa bits, ~7 decimal digits (Ch 5)

fail-closed

refusing to proceed when a required ingredient is missing (e.g. Q6_K without the metallib aborts load) rather than silently substituting (Ch 4; also Ch 39)

Fallback B

the shipping disposition: native NVFP4 serves plain decode, speculation stays kquant-only, and producer_mode: native refuses DFlash at startup (Ch 7; also Ch 40)

falsification ledger

the recording device that lists each hypothesis with its evidence class and verdict (the frontier’s 14-attempt disposition table; the dispatch-gap reconciliation), so rejected designs teach instead of haunting. (Ch 33)

falsified-hypothesis ledger

the closing record of what was measured and rejected, each entry carrying hypothesis, experiment, receipt, verdict, and what the rejection preserves (Ch 40)

fast-math

a compiler contract allowing NaN/Inf assumptions and FP reordering for speed; ON for the serving library, OFF for cross-vendor parity (Ch 4)

fast-math library

Muser’s main runtime-compiled shader library, built with fast math on for speed at the token-boundary parity gate (Ch 29)

feature contract

release/feature-contract-v1.json, the frozen scope/hardware/policy file that (with findings and the lock) constitutes the campaign identity (Ch 39)

FFN (feed-forward network)

the per-token “thinking” sub-block; Muse Glimmer’s is SwiGLU at width 19,968 (Ch 9; also Ch 18)

findings register

release/findings-v1.json, the zero-waiver defect list; release requires zero open findings (Ch 39)

fingerprint

a record of what actually ran (e.g. the metallib’s SHA-256), derived from resolved state, not an env-var echo (Ch 4)

five-rep mean

the campaign’s unit of evidence: five counted repetitions after the stated warmup convention, reported as mean with coefficient of variation (Ch 38)

flash_contiguous

the prefill route predicate (origin 0, no wrap, fits capacity) that admits the direct store-then-attend routes before any staging (Ch 36)

FLOP

one floating-point operation (a multiply or an add); the unit of arithmetic budget (Ch 1)

fma

fused multiply-add, a·b+c with one rounding; the per-element dequant instruction of the 4r2s fallback (Ch 13)

footprint table

one-slot / four-slot KV bytes at 2k/32k/131k depth (0.191/0.518/1.827 GB per slot, decimal); topology-derived allocation, never peak RSS (Ch 22)

forward_decode_group

packed decode: 1..=4 sequences’ tokens in one concurrent encoder, one commit, one wait (decode.rs:4869) (Ch 10)

forward_into

the serving entry that routes one token to the batch graph and multi-token input to chunked prefill (decode.rs:2077) (Ch 10)

four unary nodes

the serving soft cap as llama.cpp builds it: ×scale, ×1/20, tanh, ×20 as separately published kernels, chosen so public bytes match the comparator (Ch 20)

full-distribution read-back

the serving route’s per-token copy of all 202,048 logits (~789 KiB) to the CPU, the price of exact sampling, grammar re-rolls, and speculative acceptance (Ch 21)

function constant

a per-PSO compile-time value ([[ function_constant(N) ]]) that specializes one source into many kernels (Ch 4)

fused gate+up route

ffn_q4k_gate_up_silu_4r2s, the opt-in (MUSER_FERRITE_FFN_GATE_UP) single-kernel SwiGLU widening; opt-in because its rounding differs from llama.cpp’s node graph (Ch 18)

gamma (γ)

the learned per-channel weight applied after normalization; re-learns the shape the norm flattened (Ch 12)

gate activation buffer

the separate 16 KiB σ(gate) tensor an unfused gate would materialize; Muser’s in-place kernel avoids it (Ch 17)

gather

reading many table rows at once indexed by an id array; decode’s embedding is a gather of batch width 1 (Ch 11)

GBNF

llama-style grammar format (Backus–Naur with charsets and token terminals) used for structured-output constraints (Ch 21)

GEMM

general matrix × matrix; the prefill-shape of every projection (Ch 10; also Ch 13)

generation number

the per-handoff monotonically increasing counter; admission requires strictly above the ledger’s committed high-water mark, and generation 0 is refused outright (Ch 30)

ggml kargs

llama.cpp’s packed C struct of tensor extents/strides (ne00, nb01, …) its Metal kernels take instead of scalars (Ch 13)

GGUF

the on-disk model-file format Muser reads: a small header plus weight tensors packed end to end (Ch 1; also Ch 9)

GPU

a processor built for ten thousand easy things at once; the unit of work is the thread (Ch 2)

GpuBuffer

Muser’s f32 activation buffer type: one shared MTLBuffer plus a length, with checked CPU slice access (Ch 3)

GpuBytes

Muser’s raw-byte buffer type, the only one that can carry the GGUF mmap (_mmap keeps the mapping alive) (Ch 3)

GpuByteView

a checked (buffer, offset, len) slice of a GpuBytes; the per-tensor weight handle kernels receive (Ch 3)

GpuHalfBuffer

Muser’s f16 (binary16) buffer type; kept distinct so an F16 KV plane can never be indexed as F32 (Ch 3)

GQA (grouped-query attention)

32 query heads share 2 KV heads (16:1); shrinks KV bytes 16× vs full multi-head (Ch 9)

GQA fan-in (32:2, 16:1)

32 query heads share 2 KV heads; kv_head = head/16; the KV read is 16× smaller than full MHA (Ch 16)

grammar rejection sampling

run the ordinary sampler first, check the winner against the grammar, re-roll with a mask only after rejection; the rejected draw still advances every RNG (Ch 21)

greedy decoding

always emitting the highest-scoring token; deterministic, hence the only policy the exact-token parity gate can diff (Ch 21)

grid

the entire launch: how many threadgroups; always shaped like the output (Ch 2)

growing plane

the NoPE regime where capacity is max_context, the ring never wraps, and origin_logical stays 0 (Ch 15)

GX10 (GB10)

the lab’s ASUS DGX Spark-class node: aarch64 host + NVIDIA GB10 GPU, prefill/storage node only, never a decode destination (Ch 28)

Hadamard product

element-wise vector multiply (a ⊙ b)[j] = a[j]·b[j], no cross-coordinate mixing (Ch 18)

half-bit embedding

decoding eight E2M1 codes as f16 bit patterns scaled by 2⁻¹⁴ and folding 2¹⁴ into the block scale; MLX-lineage trick (Ch 7)

half-split (NEOX) pairing

RoPE convention pairing x[i] with x[i+head_dim/2]; Llama-family convention, wrong for this checkpoint (Ch 14)

Handoff V2

the authenticated mTLS + HMAC-sealed tile transport from the GX10 producer (Part VI) (Ch 10; also Ch 24, 30)

hardware-aware token tree

the one surviving distributed-speculation experiment: spend otherwise-idle GX batch arithmetic covering near-miss branches, admitted only through a preregistered emitted-tokens-per-node screen against the 107.9 bar. (Ch 33)

hazard tracking

Metal’s automatic dependency ordering between dispatches touching the same buffer; Muser keeps it on (tracked) plus explicit barriers (Ch 3)

head-major layout

[kv_head][capacity][head_dim] storage keeping each KV head’s history contiguous; the NoPE plane’s layout (Ch 15)

head_dim

the width of one attention head’s Q/K/V vectors; 128 here, read from attention.key_length (not hidden/n_heads = 208) (Ch 9)

heads_per_kv

n_heads / n_kv_heads = 16 query heads served by each KV head (config.rs:274-276) (Ch 9)

HMAC

keyed hash-based message authentication code: a cryptographic tag computed over a message with a shared secret key — anyone holding the key can compute it, nobody without the key can forge it (Ch 30)

HMAC-sealed manifest

the terminal SealManifestV2: an HMAC-SHA256 tag over the canonical-JSON core binding the begin manifest, every segment descriptor, and the entire payload stream (Ch 30)

hmac_epoch

the counter-space version for the HMAC key id; re-enrollment mints a new epoch so a regenerated PKI starts a disjoint ledger space (Ch 30)

honesty tags

per-field labels on telemetry and claims: measured / target / mock (metrics schema) plus [precedent-7B-ferrite] and [roadmap] in the claims legend (Ch 39)

hybrid postmortem

the measured rejection record for aggressive norm fusion: logprob max error 3.197e-4 over contract, first divergence one f16 ULP in layer-1 V (Ch 19; also Ch 35)

Idempotency-Key replay

a retry of the same key+revision+request-digest returns the cached completion instead of generating again; the same key on a different request is a conflict (Ch 37)

inert guard

the discipline (honest skips, ambiguity refusal, load-time aborts) that keeps an unset flag from masquerading as an enabled one (Ch 4)

input_scale_inv

the optional scalar whose presence selects W4A4 arithmetic; must pair with muser.activation_precision=nvfp4 or the load fails (Ch 7)

installed payload

the measured goodput of a handoff: payload bytes over the producer’s TCP_INFO.busy_time, the campaign’s only trusted wire clock. (Ch 31)

integer-dot producer

the MUSER_NVFP4_EXACT=1 producer mode whose NVFP4 arithmetic is deterministic by integer construction; a verification anchor that is never served (“Verification only” in the lane matrix). (Ch 32)

integer-exact contraction

decoding E2M1/E4M3FN as Q1/Q9 integers so the block dot is an order-free i64 sum with a fixed 2⁻¹⁰/2⁻²⁰ denominator (Ch 7)

interleaved (GPT-J) pairing

RoPE convention pairing adjacent dimensions 2i and 2i+1 (vs half-split “NEOX”); the pinned checkpoint’s convention (Ch 9)

interleaved (NORM) pairing

RoPE convention rotating adjacent pairs (x[2i], x[2i+1]); Muse Glimmer’s convention (Ch 14)

interleaved A/B

measuring both engines in the same session, rep by rep, so machine-state noise is common-mode and cancels in the ratio (Ch 38)

INVALID_WRONG_REASON

the label for a run that failed for reasons outside its hypothesis; retained, named, and not retried into a verdict (Ch 40)

JIT compilation

compiling shader source at runtime (new_library_with_source) rather than loading a prebuilt library (Ch 4)

kernel

the per-thread program: one function every thread in a launch runs once over its own data slice (Ch 2)

kquant

llama.cpp’s K-quant family of block-quantized integer formats; Muser’s reference-lane weights, mixed per tensor (Ch 6)

KV cache

the store holding every visible past token’s K and V per layer so attention never recomputes them (Ch 15)

KV plane

one layer’s f16 key+value buffers with explicit ring metadata; live planes zero-fill by design (Ch 3)

KV publication

the store dispatch that makes the current token’s K/V visible to attention; a split closure per layer in production (Ch 15)

KV ring

the fixed 2,048-row token-major KV plane of each SWA layer; bounded at 2 MiB per layer forever (Ch 9)

KV row cost (1,024 B)

2 KV heads × head_dim 128 × 2 B f16 × (K+V): what one layer pays to cache one token; identical for both layer classes (Ch 22)

KV store + memory barrier

the vec-route pattern: store the K/V row, memory_barrier_with_resources, then attend (Ch 10)

kvpack

the vendored format/protocol family that saves, seals, verifies, and restores exact KV state; “exactness is the product; speed is the consequence” (Ch 24)

launch-claims register

docs/launch-claims.md, the table every piece of launch copy must be checked against; a number with no row does not ship (Ch 39)

layer (block)

one copy of the repeating unit: norm → attention → sandwich-norm residual → norm → FFN → sandwich-norm residual; Muse Glimmer has 52 (Ch 9)

layer exit tail

the second fused dual-eps kernel per layer: residual += post_norm(delta) at ε 1e-8, then next layer’s input = rms_norm(residual) at ε 1e-5 (Ch 19)

LayerNorm

normalize by subtracting the mean and dividing by the standard deviation; two reductions (Ch 12)

LayoutClassV2

a compact layer-class declaration (from..until step except, kv_heads, dtype, window_tokens) in a begin’s layout table (Ch 24)

leaf pin

rejecting any peer certificate whose leaf SHA-256 is not one of the enrolled digests, even when it chains to the trusted CA (Ch 30)

ledger-volume gate

the receiver’s bind-time refusal to run when its replay-ledger directory shows a >100 ms reserve-pattern tail (the 2026-08-18 evidence-volume lesson, enforced in code) (Ch 30)

legs_valid / leg_errors

the stage-5 gate that separates infrastructure failure from correctness results; a timeout can no longer publish as a cache mismatch (Ch 25)

link invariant

a link-level setting a measurement or claim is enrolled under (here: EEE off on the 10GbE path), shipped as production guidance rather than re-derived per run. (Ch 31)

llama-pinned kernels

PSOs loaded from the prebuilt llama.cpp metallib (MUSER_GGML_METALLIB) so arithmetic matches the comparator bit-for-bit (Ch 10)

llama_vec_rows predicate

vec-route eligibility: metallib present, len>0, capacity≥32, and contiguous (unwrapped or full ring) (Ch 16)

LM head

the final output.weight [6656 × 202048] projection to logits; a separate tensor from the embedding (untied) (Ch 9)

LM head (unembedding)

the largest matvec in the engine, output.weight [6656→202048] Q5_K ≈ 924.6 MB read once per token; the inverse role of the embedding (Ch 20)

local-prefill fallback

the engine’s complete Mac-local prefill path, used whenever the producer is unavailable; makes the producer a TTFT SPOF, never a correctness SPOF (Ch 27)

lockstep MAC

the fused-FFN pattern where one x load feeds both the gate and the up accumulator (and two rows) before touching memory again (Ch 18)

logprob

the natural-log probability the model assigns a token, read off the softmaxed distribution; the exactness contract bounds normalized-logprob error (1e-4 in the dispatch-gap rejection) (Ch 35; also Ch 38)

logit

one raw f32 score per vocabulary token, before any probability or bound; Muse emits 202,048 per token (Ch 20)

logit scale

the 0.196116 (= 1/√26) multiplier applied to logits BEFORE the soft cap; GGUF metadata muse-glimmer.logit_scale, not a code constant (Ch 9)

logit_scale

the 0.196116 multiplier applied to logits before the cap, read fail-closed from GGUF metadata muse-glimmer.logit_scale (numerically 1/√26) — not a code constant (Ch 20)

logits

raw per-vocab-entry scores, [202,048], before scale/cap (Ch 9)

M16 NVFP4 batch route

the W4A4 quantized-activation GEMM taken by 16-row NVFP4 chunks with 64-aligned inputs (opt-out MUSER_NO_M16_N32) (Ch 36)

marginal KV cost

the per-token bytes added past the window: 13,312 B/token (13 NoPE layers only) vs 53,248 B/token below 2,048 — exactly 13/52 (Ch 22)

mask/blk block classifier

llama’s flash_attn_ext_blk skip/partial/dense tile bytes, prepared once per chunk and shared by every full-attention layer, making the pinned causal kernel cheap on the masked triangle (Ch 36)

matvec

matrix-by-vector multiply: one dot product of a weight row against the input vector per output element; decode’s every projection (Ch 6; also Ch 10)

matvec / GEMV

matrix × vector multiply, the one operation decode performs over and over; ~2 FLOPs per weight element (Ch 1; also Ch 13)

max-subtraction

subtracting the row max before exp; algebraically exact, prevents overflow to inf/NaN (Ch 16)

maximal coupling

the speculative acceptance rule accept if rng ≤ min(p/q, 1) with a residual-corrected resample on rejection, which makes the output marginal exactly the target’s regardless of draft quality. (Ch 33)

memoryBarrierWithScope

the explicit barrier Muser plants between dispatch groups on a concurrent encoder, delimiting real graph dependencies (Ch 2)

Metal

Apple’s API for programming its GPUs: the MSL shading language, a host API, and a memory model (Ch 2)

MetalContext

Muser’s long-lived GPU state: device, queue, and the three kernel libraries (Ch 2)

MetalKvPlane

one layer’s K+V f16 buffer pair plus explicit ring metadata: capacity, len, origin_logical, origin_physical, head_major (decode.rs:182) (Ch 10; also Ch 15)

metallib

an MTLLibrary serialized to disk; loading it skips the frontend compiler entirely (Ch 4)

metallib pin

loading llama.cpp’s own prebuilt Metal library (MUSER_GGML_METALLIB) so comparator kernels run bit-identically instead of being re-expressed; fingerprinted by SHA-256 in every route identity (Ch 29)

MetalShared

one executor per accelerator: context, kernels, mmap’d weights, scheduler; shared by all slots (decode.rs:958) (Ch 10)

MetalSpeculativeCheckpoint

transactional KV protection: NoPE planes rewind metadata only; SWA planes retain the ≤16 rows a block may overwrite (decode.rs:213-226) (Ch 10)

min

the offset where an asymmetric block’s codebook starts; value = scale × index + min (Ch 5)

min+offset

the asymmetric-quantization trick: spend one extra stored number per block to place the grid exactly where the data lives (Ch 5)

Mirror-SD

the split-graph speculative verify overlap: execute the target through a capture layer synchronously, submit the remaining layers and LM head without waiting, and accept no result until the pending suffix completes (begin/finish_dflash_verify_suffix). (Ch 33)

miss control

the unrelated-prompt leg that must stay slow for a warm-hit claim to be valid; proof of reuse, not cache-forever (Ch 25)

mmap

mapping a file’s bytes directly into the process address space, lazily, page by page (Ch 3)

mock

the honesty tag for a field with no backing measurement; the dashboard renders it unavailable and historical Ferrite results are never inserted as live Muser metrics (Ch 39)

MSL

Metal Shading Language, the C++ dialect kernels are written in (Ch 2)

Mt19937

the in-tree bit-for-bit reimplementation of libc++’s std::mt19937 (llama.cpp’s sampler RNG), so seeded results are stable across engines and Rust releases (Ch 21)

MTLBuffer

Metal’s handle to a range of GPU-addressable memory (Ch 3)

MTLCommandQueue

the queue command buffers come from; created once at startup (Ch 2)

MTLDevice

the handle to the (one, system-default) GPU; allocates memory and compiles shaders (Ch 2)

MTLLibrary

a bundle of compiled kernel functions addressable by name; the middle compile stage (Ch 4)

mTLS (mutual TLS)

Transport Layer Security with both sides presenting certificates; Handoff V2 is TLS 1.3-only with an exact ALPN and pinned leaf certificates (Ch 30)

MuseConfig

the fully-resolved hyperparameter set parsed fail-closed from GGUF metadata; every field cited, no silent defaults (config.rs:106) (Ch 9)

MuseIdentity digest

one SHA-256 over all eight Muse identity dimensions; scopes the resident radix so a wrong identity is structurally unreachable (Ch 24)

MuseLayerKind

SlidingRope / FullNoPe enum; uses_rope() is true iff sliding (config.rs:55-70) (Ch 9)

MUSER_FERRITE_FFN_GATE_UP

opt-in (default OFF) fused ffn_q4k_gate_up_silu_4r2s FFN; opt-in because the pinned baseline packet regressed with it (decode.rs:980-983) (Ch 10)

muser_scale_softcap_inplace

the fused tail kernel: ×logit_scale then tanh soft cap in one pass over the logits row (muse_reference.metal:15) (Ch 10)

native lane

the product lane: Mac decodes NVFP4 weights directly, FP16 KV, F16 LM head, remote NVFP4 prefill (Ch 7)

natural-text cell

a real-corpus measurement standing alongside the synthetic matrix since the half-window bug; cross-engine outputs may diverge, so speed stands without an exactness gate (Ch 38)

negative fixture

a known-bad implementation retained to guard a contract (the 104-group fusion whose logits changed) (Ch 40)

nibble

four bits, values 0–15; two pack into one byte, low nibble first in every format in this book (Ch 5)

nonloopback bind gate

the server refuses to listen on a non-loopback address unless a TLS certificate, a mode-0600 key, and a mode-0600 API-key file are all supplied (Ch 37)

NoPE

the 13 full-attention layers ({3,7,…,51}) with no positional rotation at all; layer % 4 == 3 (Ch 14)

NoPE (FullNoPe)

full causal attention with NO positional rotation at all; the 13 layers at indices 3,7,…,51 (Ch 9)

NoPE growing plane

the 13 full layers’ head-major KV plane that grows to max_context; rows are position-free bytes (Ch 9)

NoPE tiles during prefill

the transfer schedule streaming the 13 position-free NoPE tiles (~6.5 MiB per 512 tokens) while CUDA prefill runs (schedule.rs:1-21) (Ch 10)

norm epsilon (ε)

the small constant under the RMS square root; 1e-5 from the GGUF for every norm except the two post-norms (Ch 9)

norm-boundary fusion

merging separated norm-boundary dispatches; rejected in Muser’s campaign for breaching logprob tolerance (Ch 12)

normalization

any op that pins a vector’s magnitude to a predictable band so deep stacks of multiplies don’t drift (Ch 12)

notarial vs non-notarial

sealed, independently reproducible release evidence versus unsealed engineering evidence; everything in the 2026-08 campaign is seal_eligible: false (Ch 39)

nr0 / rows_per_group

output rows each threadgroup reduces in the pinned matvec kernels; 2 for Q4_K/Q6_K, 1 for Q5_K (Ch 13)

NVFP4

NVIDIA’s 4-bit float weight format: E2M1 payloads, one E4M3FN scale per 16 values, one f32 scale2 per tensor; exactly 4.5 bits/weight (Ch 7)

Nvfp4ProducerMode

receiver config enum Exact | Native selecting the producer’s numeric contract; modes keep separated cache identities (Ch 7)

o_proj (output projection)

the matvec mixing the 32 gated attention heads (4,096 wide) back into the 6,656-wide residual stream; Q4_K [4096→6656] per layer (Ch 17)

one-button wizard

muser node add / dashboard Add node: preflight, pinned deploy, SHA-verified model placement, TLS+HMAC enrollment, daemon start, and the three-handoff qualification recipe (Ch 30)

one-row batch graph

the serving decode route: forward_batch with token_count = 1, chosen because it dispatches the exact pinned llama kernels (decode.rs:2085-2091) (Ch 10)

one-shot bandwidth hit

a per-token (not per-layer) weight read, like the LM head’s 924.6 MB: a flat slice of the budget, never a 52× multiplier (Ch 20)

online softmax

the running (max, sum, accumulator) formulation that never materializes the score array; rescales by exp(old−new) (Ch 16)

operational state

replay ledgers, sockets, locks: state that must live on the internal disk because the evidence volume’s fsync tail poisons TTFT (Ch 39)

OPERATOR REVIEW REQUIRED

the register tier for evidence-backed proposed wording that stays dead until the owner approves it, even if its reproduction gate passes (Ch 39)

origin_logical / origin_physical

the ring’s logical start vs its physical slot; placement is never derived from absolute position (Ch 10; also Ch 15)

overhead

the per-block header bytes (scales, mins) amortized over the block’s elements; what block size trades against local range (Ch 5)

pacing pin

the producer-side SO_MAX_PACING_RATE socket cap that deliberately holds the sender under line rate (8 Gbps against a ~9.4 Gbps path) so the kernel smooths the handoff’s bursts; fail-closed in both the readback and the receipt validator. (Ch 31)

pack

kvpack’s append-only durable container: 4 KiB header ‖ canonical manifest ‖ 4 KiB footer, commit written last, published by atomic rename (Ch 24)

packed decode group

forward_decode_group: 1..=4 ready decode rows from distinct slots packed into one concurrent encoder, one commit, one wait — one weight pass (Ch 34)

page alignment

new_buffer_with_bytes_no_copy requires page-aligned pointer and length; Apple Silicon pages are 16 KB (Ch 3)

page fault

the OS trap that pulls a chunk of a mapped file into memory on first touch (Ch 3)

parameter

one learned number inside the model, tuned during training; a 30B model holds ~30 billion (Ch 1)

parity ledger

the append-only campaign ledger (docs/goal-parity-ledger-2026-08.md) whose entries record hypothesis, change, exactness gate, verdict, and receipt paths (Ch 38)

partials `[M, S, O]`

the per-workgroup online-softmax state (max, denominator, weighted values) a reducer merges (Ch 16)

PCIe

the bus connecting CPU and discrete GPU; the memcpy path unified memory eliminates (Ch 3)

permutation-invariance

raw attention’s property of producing the same scores under token reordering; why position must be injected (Ch 14)

PhaseProfiler closures

the one-command-buffer-plus-wait units the dispatch gap counts; profiling closures, not raw Metal dispatches (Ch 10; also Ch 2, Ch 35)

pinned metallib (`MUSER_GGML_METALLIB`)

the prebuilt llama.cpp kernel library loaded as binary provenance for parity (Ch 13)

pinned vec per-query prefill

short chunks (<20 queries) run llama’s own vec flash kernel once per query row with exact visible prefixes, reusing the upstream PSO and reduction order (Ch 36)

positional encoding

any scheme baking token order into the vectors before attention, which is permutation-invariant without it (Ch 14)

post_norm_eps

the 1e-8 epsilon of the two sandwich post-norms; a llama.cpp graph constant, NOT GGUF metadata (config.rs:28) (Ch 9)

post_norm_eps (1e-8)

llama.cpp’s hard-coded epsilon for the two sandwich post-norms; not carried in the GGUF (Ch 12)

pre-decoded scales

decoding all 8 sub-block scale/min pairs once per super-block so the inner loop uses constants (Ch 13)

precise::cos / precise::sin

Metal’s per-call high-accuracy trig, used at RoPE’s large angles despite fast-math compilation (Ch 14)

prefill

reading the prompt (many tokens at once, weight rows reused); the compute-friendly regime (Ch 1; also Ch 10)

PREFILL_BATCH_TOKENS / MAX_TEACHER_FORCED_TOKENS

the 512-row idle-prefill chunk that shrinks to 64 rows once a decode waits (decode.rs:53-54) (Ch 10)

prefix_cut

the delta boundary lifted from raw JSON beside the typed begin manifest (the typed protocol drops unknown keys); 0 means full transfer (Ch 26)

PREPARED/staged-render/WAL/activation/ACK

the V2 research protocol’s durable verification transaction (fsynced commit WAL before idempotent renderer activation); implemented and fault-tested locally, deliberately unwired from serving. (Ch 33)

preregistered bar

a performance threshold fixed before the deciding runs (e.g. ≥ 99.151 % IID per-edge acceptance; the 200 ms GPU verifier gate) (Ch 40)

producer

the process that runs prefill and ships the KV; a role, not a machine (today: the resident vLLM NVFP4 process on the GX10) (Ch 27)

producer mode (exact/native)

the producer’s two lanes: native = tensor-core NVFP4 fast path; exact = integer-dot verification producer; selected by the Python-only MUSER_NVFP4_EXACT flag, recorded receiver-side as Nvfp4ProducerMode (Ch 28)

provenance.json

the vendored-tree manifest (schema muser.vendored-source.v1): upstream commit/tag/tree, per-file SHA-256 map, and recorded patches (Ch 24)

PSO

pipeline state object: one library function lowered all the way to machine code for this specific GPU; what set_compute_pipeline_state binds (Ch 4)

PsoCache

Muser’s in-process name→PSO registry; panics on an unregistered name rather than falling back (Ch 4)

public-logprob tolerance

the parity contract the legacy fused single-token graph breaches; the reason serving refuses it (Ch 10)

Q4_K

144 bytes per 256 elements (4.5 bits): two f16 super-scales, 8× 6-bit packed sub-scales/mins, 128 bytes of nibbles; min+offset (Ch 6)

Q5_K

176 bytes per 256 elements (5.5 bits): Q4_K plus a 32-byte high-bit plane (Ch 6)

Q6_K

210 bytes per 256 elements (6.5625 bits): signed 6-bit codes split across ql/qh planes, 16 int8 sub-scales, f16 super-scale last (Ch 6)

QK-norm

per-head RMSNorm (over each 128-vector) applied to Q and K before RoPE; eps 1e-5 (Ch 9; also Ch 14)

qk_scale_factor

≈3.87 scalar broadcast into every Q-norm weight by the converter; folded gain on top of 1/√128 (Ch 9)

qk_scale_factor (≈3.87)

the uniform Q-norm gain the converter synthesized; folded into Q, independent of the 1/√128 softmax scale (Ch 14)

QkNormProbe

load-time verification that q/k norm tensors are the converter’s constant broadcasts; aborts on a learned norm (loader.rs:98-138) (Ch 9; also Ch 14)

qualification recipe

the identity-declared check a node must pass to become healthy: exactly three ordered 2,048/256 handoffs, exact tokens under the lane’s logit policy (bounded for native/text; exact full logits plus DFlash trace for the combined lane) (Ch 30; also Ch 32)

Keyboard shortcuts

How to Write an Inference Engine