Terms the plan and the phase documents use without stopping to explain them. Each entry says what the term means for Glint.

AAPCS64. The Arm 64-bit procedure call standard: which registers carry arguments and results, and which a function must preserve. EFI and ELF code on aarch64 both follow it, so no thunk is needed there.

ACPI. The tables a PC's firmware uses to describe its hardware (interrupt controllers, timers, devices). On x86_64, Glint reads ACPI where it would read a devicetree on Arm.

ACPI tables: FACS, MADT, MCFG, XSDT, WAET. More of the tables a PC's firmware installs. The FACS is the firmware control structure the FADT points to; the MADT lists the interrupt controllers (local APICs and IOAPICs); the MCFG says where PCI Express configuration space is mapped; the XSDT is the 64-bit form of the RSDT; and the WAET tells a guest that its emulated clock and power-management timer need no workarounds. QEMU's q35 installs all but the XSDT. A Linux guest on x86 needs Glint to supply an XSDT, FADT, FACS, DSDT, MADT and MCFG (6.5).

ACPI tables: RSDP, RSDT, FADT, DSDT, AML. The RSDP is the root pointer firmware installs; it leads to the RSDT (or XSDT), a list of the other tables. The FADT describes fixed hardware and points to the DSDT, which describes devices in AML, a bytecode language. Glint checks the tables' checksums and searches the DSDT for one device, without interpreting AML (slice 2.4b).

AllocatePages, FreePages. The UEFI boot services that hand out and take back whole 4 KiB pages. AllocatePages(Type, MemoryType, Pages, Memory) returns the address of the pages, and FreePages(Memory, Pages) gives them back. In hosted mode the firmware answers; in native mode Glint's page-frame allocator answers from the same system-table entries (3.1).

APIC, LAPIC, IOAPIC. The x86 interrupt controllers. Each CPU has a local APIC (LAPIC), which also provides its timer. The IOAPIC routes device interrupts to CPUs.

autoconf.h. The header Zephyr's build writes from Kconfig: one CONFIG_* macro per enabled option, with disabled booleans left undefined. Glint writes it from a short checked symbol table instead (slice Z.6).

Backend thread. A Glint thread that serves one emulated device's virtqueues and sleeps when idle.

Backtrace. The chain of calls that led to a fault, printed in a crash report.

Balloon. A virtio device a guest uses to hand memory back to the hypervisor on request.

bb-imager-rs (BeagleBoard Imaging Utility). BeagleBoard.org's Rust flashing tool, which programs the Zepto through its BSL over UART or I2C.

BeagleConnect Zepto. A one-inch Beagle microcontroller board (TI MSPM0L1117) with QWIIC and mikroBUS connectors, the first Track S target. Mainline Zephyr supports it as beagleconnect_zepto.

Block entry. A page-table entry above the last level that maps a whole aligned block instead of pointing to a table of 512 page entries. Glint's tables have four levels, numbered as Arm numbers them, level 0 at the root to level 3 at the pages, and a level-2 block maps 2 MiB. Glint's builder writes one wherever a range covers such a block, so all of RAM costs a few table pages (3.2).

BLOCK_IO. The UEFI protocol for reading and writing disk blocks. Glint uses its shape for every block provider: firmware, Zephyr driver or Linux guest.

Bounded buffer. A fixed-size queue shared by a producer and a consumer, each waiting when it is full or empty. Hailperin uses it as the model a virtqueue follows.

BQ2. bootstrap-qcow2, the Crystal-first build environment whose toolset is the only one Glint's build may use.

BSL (bootstrap loader). The loader in an MSPM0 chip's ROM. Holding BSL_INVOKE (PA18 on the Zepto) high during reset runs it instead of the flash image, and it then writes flash over UART or I2C. Being in ROM, it cannot be erased.

Buffer cache. In-memory copies of disk blocks, one per block, written back when changed.

Build devicetree, machine class. A machine class is a family of machines that share the same devices at the same addresses, such as QEMU virt or a BeaglePlay. Its build devicetree is the devicetree Glint compiles Zephyr's drivers against, taken from upstream data with at most a small overlay (Z.3). At boot Glint checks that the firmware's description matches it, and otherwise stays hosted (2.6; principle 6 in PLAN.md).

BusyBox, initramfs. BusyBox is a single small program providing the usual Unix commands. An initramfs is a small file system loaded into memory with the kernel. Together they give a Linux guest a shell without a disk.

Check-in. A commit in Fossil, the version-control system Glint is kept in. Each slice is one check-in, whose comment states its claim, passage, demonstration and size.

/chosen, stdout-path. The devicetree node that carries choices firmware made for the OS, and its property naming the console device. Glint follows it to find its UART (slice 2.4a).

Cleave::* types. Parts of cleave that Glint uses: Cleave::Dts and Cleave::Dtc (devicetree source and compiler), Cleave::Fdt (reading and writing devicetree blobs), Cleave::Kconfig, Cleave::Fat16 (writing FAT images), Cleave::Elf and Cleave::GlyphParser.

Cluster chain. In FAT, the linked list of disk clusters that holds one file, followed through the file allocation table.

Compatible. The devicetree property that names what a device is, as a list of strings from most to least specific, such as "arm,pl011", "arm,primecell". Drivers, Zephyr's included, are matched to devices by it.

compat/zephyr. The seam through which Zephyr C code is compiled into Glint: Zephyr's headers, Glint's generated headers, and Crystal implementations of the Zephyr API the drivers call. See Track Z.

Configuration table. The list of (GUID, pointer) pairs in the EFI system table through which firmware passes the devicetree, ACPI and SMBIOS tables. It survives ExitBootServices.

ConIn, ConOut. The firmware console's input (SIMPLE_TEXT_INPUT) and output (SIMPLE_TEXT_OUTPUT) protocols, reachable from the system table.

Cortex-M0+, ARMv6-M, Thumb. The small Arm core in the Zepto, its architecture version, and the 16-bit instruction set it runs. Crystal reaches it with --target arm-none-eabi --mcpu cortex-m0plus --mattr +thumb-mode.

CPUID leaf. One query of the x86 CPUID instruction, chosen by the number in EAX (the leaf), such as 0x80000001, whose ECX bit 2 reports AMD's SVM. A hypervisor also answers a leaf of its own to identify itself to a guest.

CPU_ON, SYSTEM_OFF, SYSTEM_RESET, VERSION. PSCI calls that start a CPU, power the machine off, reset it, and report the PSCI version. Glint makes CPU_ON itself to start secondary CPUs, and answers all four when a guest makes them.

__crystal_malloc64. The function Crystal's compiled code calls to allocate an object when the program defines it, with __crystal_malloc_atomic64 and __crystal_realloc64; when it does not, the compiler calls C's malloc instead. Crystal's own prelude implements them with its garbage collector. Glint's image had neither them nor malloc, so no class could be instantiated in the image until 3.4's heap defined them.

CurrentEL. The Arm register that reports the exception level the CPU is running at.

DCO (Developer Certificate of Origin). A short statement a contributor certifies by adding a Signed-off-by: line, saying they have the right to submit the contribution. See CONTRIBUTING.md.

.decode files, decodetree. Compact descriptions of instruction encodings, and QEMU's generator that turns them into C decoders.

Demonstration ladder, rung. The four levels at which a slice can be shown working: specs on Linux against the fake firmware (rung 1), checks of the built image files (rung 2), a boot under the project's QEMU and U-Boot (rung 3), and real hardware (rung 4). See Development method in PLAN.md.

Derivation. The record of a glyph parse: one line per pass, showing the glyph string after each rule is applied.

Device table, init runner. Glint's replacement for Zephyr's linker-sorted device list: a generated C array of the Zephyr devices built into an image, and the Crystal code that calls each one's init and records the result (slice Z.8).

DEVICE_DT_GET. The Zephyr macro that yields the struct device defined for a devicetree node. Glint's generated device table is a list of them (Z.8).

Devicetree (DT), FDT, DTB. A data structure describing hardware on Arm boards. Firmware passes it to Glint as a flattened devicetree blob (FDT or DTB). Glint reads it to find devices, and generates one for each guest.

Devicetree macros, devicetree_generated.h. Zephyr drivers read the devicetree only at compile time, through DT_* macros defined in devicetree.h over a generated header, devicetree_generated.h, that holds one macro per node and property fact. Zephyr's doc/build/dts/macros.bnf specifies their names. Glint generates the header in Crystal (Z.3–Z.5).

Direct map, identity mapping. Mapping every page at a virtual address equal to its physical address. xv6 calls it "direct mapping". Glint's own tables are an identity mapping (3.2a, 3.2b), because every pointer Glint holds at the exit is already a physical address.

DisconnectController, driver binding. UEFI's way of detaching a firmware driver from a device and attaching another. In hosted mode, Glint uses it to replace a firmware driver with its own.

DMA. Direct memory access: a device reading or writing memory itself, without the CPU. Unless an IOMMU limits it, a device can reach any memory.

dmesg. The Linux command that prints the kernel's boot and driver messages.

Double fault, triple fault. On x86, a double fault (vector 8) is raised when the CPU fails while delivering another exception, for example because the stack it pushes the frame onto is unmapped. If the double fault cannot be delivered either, the CPU shuts down (a triple fault), and QEMU or a PC resets. Glint delivers vector 8 on its own IST stack so that a stack overflow is reported instead (3.3).

Driver domain. A guest whose job is to drive real devices for the rest of the system. Xen calls its driver domain dom0. Glint's Linux guest plays this role for devices only Linux can drive.

dtc. The devicetree compiler, which turns devicetree source into a DTB. cleave provides a Crystal replacement for it.

EBBR, SystemReady. Arm standards for firmware that boots generic operating systems through UEFI with a devicetree or ACPI. They are what let Glint carry no board-specific code.

EFI system partition (ESP). The FAT-formatted disk partition firmware loads EFI applications from. Glint's images live there as EFI/BOOT/BOOTAA64.EFI and EFI/BOOT/BOOTX64.EFI.

EFI, UEFI. The Unified Extensible Firmware Interface: the firmware standard Glint boots from and imitates. Boot services (memory allocation, protocols, events) exist until ExitBootServices is called; runtime services (clock, variables, reset) remain afterwards.

EFI_ACCESS_DENIED, EFI_INVALID_PARAMETER, EFI_OUT_OF_RESOURCES. EFI_STATUS values: a request refused because of what is already there (Glint's page-table builder uses it for an overlapping mapping), a request with a bad argument (such as an unaligned address), and a request that needs more memory than is left.

EFI_NOT_READY. The EFI_STATUS a call returns when it has nothing yet, such as ReadKeyStroke with no key waiting. Glint's console polls past it.

EFI_MEMORY_RUNTIME. The memory-map attribute bit that marks a range the firmware's runtime services still use after ExitBootServices, code, data or device registers. Glint keeps every such range mapped at its physical address (3.2a).

EFI_STATUS. The result type of every UEFI call: 0 for success, a value with the high bit set for an error (such as EFI_NOT_FOUND), and other values for warnings. Glint's providers return it whatever stands behind them, and Track Z maps Zephyr's errno values onto it (Z.9).

EFI_SUCCESS. The status value 0, which an EFI application returns to say it finished normally.

EFI_UNSUPPORTED. The EFI_STATUS meaning a call is not provided. Native mode's system table answers every boot service Glint does not provide with it (2.5).

EISA ID. The compressed seven-character identifier, such as PNP0501, that ACPI uses for a device's _HID. It is stored in four bytes, which is the form Glint looks for in the DSDT (2.4b).

EL0, EL1, EL2, EL3 (exception levels). Arm privilege levels: user programs run at EL0, an OS kernel at EL1, a hypervisor at EL2, and the secure monitor (TF-A) at EL3. Glint needs to start at EL2 to be a hypervisor. x86's ring 3 is the counterpart of EL0.

ELF. The object and executable format of Linux and most Unix systems. Glint's images are linked as ELF and then given a PE32+ header, so that firmware can load them (slice Z.1).

ELR, FAR, VBAR. Arm exception registers: ELR_ELx holds the address to return to, which for an undefined instruction is the faulting instruction; FAR_ELx holds the faulting data or instruction address, set only by aborts and a few other classes; VBAR_ELx holds the base of the exception vector table.

eret, VMRUN. The instructions that enter a guest: eret returns from EL2 into an EL1 guest on Arm, and VMRUN starts an SVM guest on AMD x86.

errno. The C convention of numbering error causes (EIO, ENOTSUP, …). Zephyr functions return them negated, and a device's init_res holds one as a positive number.

ESR. The Arm Exception Syndrome Register (ESR_EL1 or ESR_EL2), which records why an exception was taken: an exception class in its top bits and class-specific detail below. Glint's panic report decodes it (2.7a).

ESR_EL2, HPFAR_EL2. Arm registers that describe a trap taken to EL2: the cause and details (ESR_EL2) and, for a second-stage fault, the guest-physical page (HPFAR_EL2).

Exception stack; SP_EL0, SPSel. A stack kept only for taking exceptions, so a fault caused by a broken stack can still be reported. On Arm each exception level has its own stack pointer, SP_ELx, and can also run on SP_EL0, chosen by PSTATE.SPSel; an exception always switches to SP_ELx. From 3.3 Glint runs on SP_EL0 and keeps SP_ELx for exceptions, set up by the stack switch in boot/crt0.S. On x86 the same stack is reached through the TSS's IST1.

ExitBootServices. The UEFI call by which an OS takes the machine over from firmware. After it, firmware drivers and boot services are gone.

Final memory map. The memory map read last, just before ExitBootServices succeeds, whose map key the exit used (2.6). It is the only map that describes the machine as Glint owns it after the exit, and Phase 3 builds its allocator and page tables from it.

FAT. The File Allocation Table file system, used on the EFI system partition.

Fibers, spawn, Channel. Crystal's lightweight concurrency: spawn starts a fiber (a cooperatively scheduled task), and a Channel passes values between fibers.

Fidelity. Tanenbaum's requirement that a program behave the same on a virtual machine as on bare hardware. Glint uses it as the acceptance test for its guest ABI.

Free list. A list of free blocks threaded through the blocks themselves, each free block holding the address of the next. xv6's page allocator keeps one; Glint's heap keeps one per size class (3.4), while its page allocator keeps a table of free ranges in its own image instead (3.1).

fw_cfg. QEMU's channel for passing configuration and files to firmware.

GDT. The x86 Global Descriptor Table, which defines the code and data segments the IDT's entries refer to. Glint loads its own after leaving boot services, since the firmware's lives in memory that becomes free.

GetMemoryMap. The UEFI boot service that returns the machine's memory map, including which regions are free. It must be called before ExitBootServices.

GIC, vGIC. Arm's Generic Interrupt Controller. The vGIC is its virtualization support, which lets Glint inject interrupts into a guest.

Glyph. In the glyph parser, a single reserved Unicode character standing for one token or reduced rule. A line is parsed by rewriting its string of glyphs one rule at a time.

gmodule. The small part of GLib that loads shared libraries. QEMU requires it alongside GLib's core.

Guard page. An unmapped page left below a stack, so that a stack overflow faults at once instead of silently overwriting the memory below. Glint leaves one below each of its two stacks, the main stack and the exception stack (3.3).

Guest-physical address. An address a guest believes is physical. Glint's second-stage tables translate it into a real physical address.

GUID. A 128-bit identifier. UEFI names every protocol with one.

Handle; LocateProtocol, HandleProtocol. In UEFI, a handle stands for a device or other object, and protocols are attached to handles. LocateProtocol finds the first instance of a protocol by GUID. HandleProtocol gets a protocol from a given handle.

HAT connector, NRST. The Raspberry Pi-style 40-pin header the BeagleY-AI shares; the Zepto plugs into it for UART and I2C. NRST is the MSPM0's reset line.

Heap, size class. The heap is the allocator for objects smaller than a page, built on whole pages from AllocatePages (3.4): in native mode Glint's own page allocator answers, and in hosted mode the firmware, whose pages are EfiLoaderData. A size class is one of the fixed block sizes, powers of two from 32 to 2048 bytes, that a request plus the block's 16-byte header is rounded up to; larger requests take whole pages.

Hosted, native, hypervisor modes. Glint's three run modes; see Run modes in PLAN.md.

HVC, SMC, VMMCALL. Instructions a guest uses to call its hypervisor (HVC on Arm, VMMCALL on AMD x86) or the secure firmware (SMC on Arm).

.hx files. QEMU source files holding its command-line option and monitor command tables.

I2C master protocol (UEFI PI). The I2C interface defined by the UEFI Platform Initialization specification. Glint uses its shape for I2C on every target, whoever provides it.

ID_AA64MMFR0_EL1. The Arm register that reports the CPU's memory model, including PARange, the largest physical address it supports. Glint copies it into TCR and VTCR_EL2, where a 4 KiB granule caps addresses at 48 bits even when it reports 52 (3.2a, 3.5).

IDT. The x86 Interrupt Descriptor Table: the list of handlers the CPU jumps to on each trap or interrupt.

Image, bzImage. The file formats of a Linux kernel built for arm64 (Image) and x86 (bzImage). Both contain an EFI stub, so firmware, or Glint, can start them as EFI applications.

init_res. The field of a Zephyr device's state that holds the result of its init function, as a positive errno or 0. Glint's init runner sets it as Zephyr's own does (Z.8), and device_is_ready reads it.

INIT-SIPI. The x86 sequence that starts a secondary CPU.

Interchangeability catalogue. docs/interchangeability.md, produced in Phase 13: every component marked essential or replaceable, with the seam it sits behind.

Interrupt cells. The numbers in a devicetree interrupts property that identify one interrupt. Their count and meaning are set by the interrupt controller, through its #interrupt-cells property; for an Arm GIC there are three: the type (SPI or PPI), the number and the trigger flags. Track Z's generator adds them in Phase 6 (6.3).

IOMMU, SMMU. A memory-management unit for devices, which limits what memory a device can reach with DMA. SMMU is Arm's name for it. Without one, a device passed to a guest could write anywhere.

ISC, privilege ID. TI's Initiator-Side Security Controls tag every bus initiator (a CPU cluster, a DMA engine) with a privilege ID that firewalls check.

IST, TSS. The 64-bit x86 Task State Segment holds, among other things, up to seven Interrupt Stack Table (IST) pointers. An IDT gate that names an IST entry makes the CPU switch to that stack before delivering the exception. Glint's TSS gives the double fault an IST stack of its own (3.3).

Kconfig, .mak device lists. Kconfig is the configuration language Linux, U-Boot, Zephyr and QEMU use to declare build options and their dependencies. QEMU's configs/devices/*/*.mak files list the devices each machine starts from.

KVM, TCG. QEMU's two ways to run a guest: KVM uses the host CPU's virtualization (fast, same architecture only), and TCG emulates the CPU in software (slower, any architecture).

Late binding. Patching addresses and interrupts into Zephyr driver instances at boot, from the firmware's description, for drivers whose instances differ between machines only in those. It would let one build serve every machine of that shape. The plan leaves it for later (principle 6).

libfdt. The C devicetree library from the dtc project, which QEMU links against.

List registers. The vGIC registers through which a hypervisor places pending virtual interrupts for a guest.

Lock order. A single agreed order in which locks must be taken, so no two threads can each hold a lock the other needs. Glint records it in Phase 7 (7.3) and audits it in Phase 12 (12.4).

Lost wakeup. A race in which a thread decides to sleep, the event it waits for happens before it is asleep, and it then sleeps forever.

LP64, LLP64. Data models for 64-bit C. Under LP64 (Linux, ELF targets) long and pointers are 64 bits; under LLP64 (Windows, *-unknown-windows) long is 32 bits. Zephyr assumes LP64, which is why Glint builds ELF.

MAIR, TCR, SCTLR; normal and device memory. Arm registers that shape translation at an exception level: MAIR_ELx lists the memory types a descriptor can name by index, TCR_ELx sets the granule, address sizes and how table walks are cached, and SCTLR_ELx.M turns translation on. Normal memory may be cached and accessed out of order; device memory (such as Device-nGnRE) is accessed exactly as the program says, which device registers need (3.2a).

Map key. The value GetMemoryMap returns to identify the current memory map. ExitBootServices fails unless it is given the key of the latest map.

MCUboot. A common open-source bootloader for microcontrollers. The Zepto does without it, relying on the ROM BSL instead.

Memory barrier. An instruction that stops the CPU or compiler from reordering memory accesses across it.

Memory types (UEFI). Each memory-map descriptor has a type. EfiConventionalMemory is free. EfiBootServicesCode and EfiBootServicesData belong to firmware until ExitBootServices, then become free. Glint counts all three as usable (slice 2.3), though it hands out boot-services memory only once it no longer runs on firmware's stack and page tables (3.1). EfiLoaderData is memory an EFI application allocated for itself, such as Glint's preloaded files (2.9).

Meson. The Python-based build system QEMU and GLib use, which Glint replaces with build data written in Crystal.

Microsoft x64 calling convention. The rules for passing arguments in registers that UEFI uses on x86_64. Code called by firmware, or calling it, must follow them.

Microsoft-ABI thunk. A small function that converts between the System V calling convention of Glint's ELF code and the Microsoft x64 convention UEFI uses, on x86_64 only.

MMIO. Memory-mapped I/O: device registers that appear at physical addresses.

MOS4, MOS5. Tanenbaum and Bos, Modern Operating Systems, 4th and 5th editions.

MPL-2.0. The Mozilla Public License 2.0, Glint's licence: changes to Glint's files are shared back and notices kept, while combining with other code is allowed.

MSPM0. TI's family of Cortex-M0+ microcontrollers. The Zepto uses the MSPM0L1117 (16 KiB RAM, 128 KiB flash).

MemAttr, S2AP. Fields of an Arm stage-2 descriptor. MemAttr gives the memory type directly (normal or device), where a stage-1 descriptor names an entry in MAIR, and S2AP gives the guest's read and write access, where a stage-1 descriptor has AP (3.5).

mycpu. xv6's function that returns the current CPU's private state. Glint's per-CPU state plays the same role.

NBD. Network Block Device: a simple protocol for reading and writing a disk over a byte stream.

Nested virtualization (nested KVM). Running a hypervisor, such as Glint, inside a virtual machine that itself runs on a hypervisor, such as Linux KVM. It is how Glint's VMX path can be tested on an Intel host.

NPT, EPT, stage-2 tables. Second-level page tables that translate a guest's "physical" addresses into real ones: NPT on AMD, EPT on Intel, stage-2 on Arm.

NS16550. Zephyr's driver and devicetree compatible for the PC-style 16550 UART. On QEMU q35 Glint uses it by I/O port.

NVMe. A standard interface for PCIe solid-state disks. Zephyr v4.4.2 has a driver for it, and QEMU emulates one.

OCX. Ollama-Codex, the workbench Glint is developed on, whose four virtues (Clarity, Loose Coupling, Demonstrability, Parsimony) every slice is judged by.

OpenOCD. An open-source debugger that drives a chip's debug port, used on the testbench over SWD.

Ordinal. In Zephyr's devicetree macros, a number given to each node so that every node comes after its parent and after the nodes it depends on through phandles. Glint orders its device table by it (Z.5, Z.8).

Overlay. A small devicetree fragment that changes or adds properties of an existing tree. Glint uses one to relabel QEMU virt's UART as arm,sbsa-uart in its build devicetree (Z.3).

Page frame, page-frame allocator. A page frame is an aligned 4 KiB page of physical memory. Glint's page-frame allocator (3.1) hands them out through AllocatePages in native mode, from the final memory map. Withheld ranges are usable ranges it does not yet hand out, because the firmware's page tables may still lie in them (until 3.2a or 3.2b loads Glint's own); the page pool is 32 pages in Glint's .bss that it hands out meanwhile, for Glint's own tables.

PE32+. The executable format UEFI loads (the 64-bit Windows format). Subsystem 10 marks an EFI application. The .reloc section lists the addresses to fix up so firmware can load the image anywhere.

PE base relocations, DIR64. The .reloc directory of a PE image lists the places to adjust when the image is loaded at an address other than its preferred base. DIR64 entries add the difference to a 64-bit value; padding entries do nothing. Glint's guest loader applies these two kinds and refuses any other (3.6).

Phandle. A number by which one devicetree node refers to another, such as a UART's clocks property naming its clock node.

Pinctrl. Pin control: the devicetree properties (pinctrl-0 and others) and Zephyr API that set which function each pin of an SoC serves. Glint avoids it while firmware has already set the pins (What Track Z leaves).

PL011, 16550. The standard UARTs (serial ports) on Arm virt machines and on PCs.

PNP0501. The ACPI hardware ID (_HID) of a 16550-compatible PC serial port. Its _CRS (current resource settings) gives the I/O port and IRQ.

Poll mode. Driving a device by repeatedly reading its status register, with no interrupts. Glint's Zephyr console runs this way until Phase 6.

Popek and Goldberg; sensitive instructions. The 1974 condition for a CPU to be virtualizable: every sensitive instruction (one that behaves differently in kernel and user mode) must be privileged, so that it traps. x86 failed it until VT and SVM.

Port I/O. The x86 device address space reached with in and out instructions, separate from memory. A guest's port accesses cause VM exits.

Preload. The step every native boot takes before leaving boot services: reading the files it will need from the ESP into memory of its own, so they survive the exit (2.9).

Prelude. Crystal's always-loaded standard library. Glint replaces it with a minimal one (prelude/) that needs no garbage collector or C library.

Priority inversion, convoy. Problems with blocking locks: a preempted lock holder delays more important waiters (priority inversion), or makes threads queue up behind it (convoy).

Proportional share. A scheduling policy that gives each guest a configured fraction of CPU time.

Provider. Anything that implements a protocol behind Glint's platform interface. The plan's Concept counts four kinds on real targets (firmware, a Zephyr driver, the Linux guest, Zephyr standing in for EFI); the fake table used in specs is a fifth, used only for testing.

PSCI, SMCCC. Arm's standard calling conventions. PSCI is for CPU power (start a CPU, power off, reset), and SMCCC is for calls to firmware or a hypervisor. A Linux guest uses them, through HVC, to talk to Glint.

QEMU virt, q35. The emulated Arm and x86 machines Glint is tested on.

qemu_cortex_m0. Zephyr's emulated Cortex-M0 board, used for Track S before hardware.

QMP, QAPI. QEMU's control protocol (QMP) and the JSON schema language (QAPI) its code is generated from.

QWIIC. A 4-pin connector standard for I2C devices, present on the Zepto.

ranges. The devicetree property that says how a bus's child addresses map to its parent's. Track Z's generator adds it in Phase 6 (6.8).

reg, reg-shift. reg is the devicetree property giving a device's register addresses and sizes (or, for an io-mapped NS16550, its I/O port). reg-shift says how far apart the registers of a 16550-style UART are, as a power of two.

Region-based firewall. A TI K3 bus firewall in front of a target such as DDR memory, allowing or denying accesses to programmed address regions by privilege ID. It is a possible coarse substitute for an IOMMU.

RIP, CR2. x86 registers in a fault report: RIP is the faulting instruction's address (for an invalid opcode, the faulting address), and CR2 is the address that caused a page fault, valid only for vector 14.

Round-robin, run queue. The simplest scheduling policy, running each ready thread in turn, and the queue of ready threads it serves.

RuntimeServices. The table of UEFI runtime services in the system table: variables, time, reset and virtual-address mapping, as far as the firmware provides them. Unlike boot services, it remains after ExitBootServices, and Glint's native system table keeps the firmware's pointer to it (2.5).

SBSA UART (arm,sbsa-uart). The subset of the PL011 that Arm's Server Base System Architecture defines, with baud rate and format left to firmware. Zephyr's PL011 driver in this mode keeps what U-Boot set up.

SetVirtualAddressMap. The UEFI runtime service an OS calls to tell the firmware the virtual addresses at which it has mapped the runtime services. Glint never calls it, so the runtime services keep running at their physical addresses, which Glint's tables map one to one (3.2a).

Scan code. In UEFI's EFI_INPUT_KEY, the number that identifies a key with no character, such as an arrow or a function key; keys that have a character carry it as UnicodeChar with a scan code of 0.

Shadow page tables. An older technique in which the hypervisor maintains a combined copy of the guest's page tables. Glint does not use it; it uses second-stage tables instead.

Shards, shard.yml. Crystal's package manager and its project file, which names a project's dependencies and executables.

SIMPLE_FILE_SYSTEM. The UEFI protocol for opening a FAT volume and reading or writing its files.

SMCCC function number. The number in a register that says which service an HVC or SMC call asks for, for example PSCI's SYSTEM_OFF.

SMCCC hypervisor UID. The identifier a hypervisor returns when a guest asks, through SMCCC, which hypervisor it is running on.

SoC. System-on-chip: the single chip holding a board's CPU and peripherals.

SPCR. The ACPI Serial Port Console Redirection table, which names the console UART. QEMU builds one for Arm virt but not for x86 q35.

spec_helper.cr. The file that Crystal specs load first, holding setup shared by every spec.

SPI (Arm interrupt type). Shared Peripheral Interrupt: a GIC interrupt from a device that can be routed to any CPU, as distinct from a PPI, private to one CPU. (Not the SPI serial bus.) QEMU virt's UART raises SPI 1.

Split-ring virtqueue. The virtio queue layout with separate descriptor, available and used rings, each written by one side only.

_Static_assert. A C11 declaration that stops compilation when a constant expression is false. Glint's specs use it to check, at compile time, values that Zephyr's macros produce from generated headers (Z.4) and the size of long (Z.1).

svc, syscall. The instructions a user program uses to make a system call: svc on Arm, syscall on x86.

SVM, VMX. AMD's and Intel's x86 virtualization extensions. QEMU's emulator models SVM but not VMX.

SWD. Serial Wire Debug: Arm's two-wire debug port (SWDIO, SWCLK), on PA19/PA20 on the Zepto.

__syscall. The Zephyr marker on a function declaration that makes it a system call. Without Zephyr's user mode, each such call is a plain wrapper around z_impl_<name>, which Glint generates (Z.7).

Syscall stubs, z_impl_. Zephyr declares many functions as system calls and expects generated wrapper headers. Without Zephyr's user mode, each wrapper simply calls the implementation, named z_impl_<name>. Glint generates these stubs (slice Z.7).

System table. The structure UEFI hands an EFI application at entry, with pointers to the console, boot services, runtime services and configuration tables.

System V ABI. The calling convention of ELF code on x86_64 (arguments in rdi, rsi, rdx, …), used by Glint's Crystal and C. UEFI uses the Microsoft x64 convention instead, so calls between them cross a thunk.

TF-A, BL31. Arm Trusted Firmware-A, the secure firmware on the Beagle boards. Its runtime part (BL31) provides PSCI.

TLB. Translation lookaside buffer: the CPU's cache of recent address translations. It is why page tables are rarely walked in practice.

trace-events, nop backend. QEMU's tracepoint definitions, and the tracing back end that compiles them to nothing.

TRM. Technical Reference Manual: a chip vendor's full hardware documentation.

TSL. Test-and-set lock: an atomic instruction that sets a value and returns its old value, the basis of spinlocks.

TTBR0_EL2, TTBR0_EL1, CR3, VTTBR_EL2. Registers that hold the address of the top-level page table: Glint's own on Arm (TTBR0_EL2 when it runs at EL2, TTBR0_EL1 when it runs at EL1 without virtualization) and on x86 (CR3), and a guest's second-stage table on Arm (VTTBR_EL2).

U-Boot standard boot. U-Boot's mechanism for finding something to boot without a script: it scans the available disks for, among other things, an EFI application at the standard ESP path, and starts it. It is how glint-run's boots reach Glint.

UCS-2. The 16-bit character encoding UEFI uses for its strings (CHAR16), which covers the Unicode basic multilingual plane. Glint's console converts it to bytes for a UART (Z.9).

vCPU. A virtual CPU that a guest runs on. In Glint, each vCPU is a thread.

Verdicts: merge, annotate and merge, resubmit. The three verdicts a reviewing run gives a slice (docs/WORKFLOW.md). Merge: all four virtues hold, and the slice is merged as it is. Annotate and merge: only small changes are needed (wording, a comment, a name), and the reviewer makes them and merges. Resubmit: a virtue fails in a way that changes behaviour or structure, and the slice goes back to its writer with what must change.

VHE, split-mode hypervisor. VHE (Virtualization Host Extensions, Armv8.1) lets a kernel run at EL2 directly. The A53 cores in AM62x and AM67A lack it, so Glint at EL2 is a split-mode hypervisor: a small EL2 part plus code running at lower levels.

vhost-user. A Linux and QEMU convention for running a virtio device's back end in a separate process. It is one option for Linux serving devices back to Glint.

Virtio device types. Virtio defines console, block (blk), network (net), socket (vsock), entropy (rng) and other device types over the same virtqueue mechanism.

Virtio status handshake. The sequence of status-register writes by which a guest discovers, configures and starts a virtio device.

Virtio, virtqueue, virtio-mmio. The standard interface for virtual devices. A virtqueue is a shared ring of buffers between guest and device. Virtio-mmio is its register-based transport, used on Arm virt.

virtio-pci, PCI host bridge. Virtio devices presented on an emulated PCI bus, as x86 guests expect. The host bridge is the minimal PCI configuration space through which a guest finds them.

VM exit. The moment a guest stops and control returns to the hypervisor, with a recorded reason (a trap, a page fault, an I/O access, an interrupt).

VMCB. The AMD SVM Virtual Machine Control Block: the memory structure holding a guest's state and the hypervisor's settings for it, including interrupts to inject.

vsock. A virtio device that gives a guest and its host a socket-like byte stream without a network.

VTCR_EL2, nested CR3. The registers that shape and name a guest's second-stage tables: on Arm VTCR_EL2 gives their granule, starting level and address sizes, beside VTTBR_EL2, which holds their root; on AMD x86 the VMCB's nested CR3 field holds the root of the nested page tables. 3.5 computes them and Phase 4 loads them.

Watchdog timer. A UEFI timer, armed by firmware for five minutes when it starts a boot option, that resets the machine unless the program turns it off with SetWatchdogTimer. Glint turns it off early on every boot (slice 2.2).

-Werror. The compiler option that turns every warning into an error. Track Z compiles Zephyr's drivers with it, so a header Glint generates wrongly fails the build instead of passing with a warning; -Werror=<name> promotes one warning only.

WFI, HLT. The Arm and x86 instructions a CPU executes when it has nothing to do. When Glint traps them, an idle guest stops consuming CPU.

Write-ahead log, commit record. A log in which an update is written before it is applied. The commit record marks the update complete, so recovery can tell finished updates from unfinished ones.

xHCI. The standard USB host-controller interface. Glint drives it itself, and owns the whole USB tree behind it.

XN, PXN, UXN, NX; AP[2]; EFER.NXE, CR0.WP. Permission bits in page-table entries. On Arm, AP[2] makes a page read-only. Execute-never depends on the translation regime: at EL2 (with HCR_EL2.E2H clear) one XN bit (54) stops execution and AP[1] is RES1; at EL1, PXN (53) stops EL1 from executing a page and UXN (54) stops EL0. On x86 the NX bit (63) stops instruction fetches, but only once EFER.NXE is set, and ring 0 obeys read-only pages only once CR0.WP is set. Glint sets them in 3.3b.

xv6's memory functions: walk, mappages, walkaddr, copyin, copyout, loadseg, kfree. In xv6's kernel/vm.c, walk finds the entry that maps an address, creating tables as needed, and mappages installs a range of mappings; Glint's builder offers the same two calls (3.2). walkaddr turns a user address into a physical one, and copyin and copyout copy across that boundary page by page, as 3.5's translate lets Glint do with guest memory. loadseg in kernel/exec.c copies a program segment into a process's address space (3.6b). kfree in kernel/kalloc.c frees a page and fills it with junk (3.1).

YAML bindings. Zephyr's files describing which devicetree properties each kind of device has.

Zephyr build tools. The Python programs Zephyr's own build uses: edtlib and gen_defines.py (devicetree to C header), Kconfiglib (configuration, with extensions such as rsource and $(dt_*)), gen_syscalls.py and gen_offset_header.py. Glint replaces the ones it needs with Crystal.

Zephyr kernel objects. The API Zephyr drivers are written against: k_thread (threads), k_sem (semaphores), k_mutex and k_spinlock (locks), k_msgq (message queues), k_work (deferred work), k_timer (timers), and struct device with the DEVICE_DT_* macros that declare devices from the devicetree. compat/zephyr implements them in Crystal.