RAM discovery is visible to guests.
The bus tracks backing size, total guest RAM, active visible RAM, low-window bounds, and profile ceilings. Guests read those facts through SYSINFO, while IE64 also reads CR_RAM_SIZE_BYTES.
Shared bus machine
Intuition Engine puts IE64, IE32, 6502, Z80, M68K, and x86 on one shared MachineBus. The unusual part is not the CPU count; it is that the CPUs see the same RAM contract, the same MMIO devices, the same audio and video hardware, and the same coprocessor worker path.
caller CPU
-> MMIO register or BASIC command
-> shared MachineBus
-> device, worker, or runtime service
-> response through RAM, ticket, IRQ, or status
A CPU profile selects the instruction set, loader, and visible RAM ceiling. After that first choice, the machine is still MachineBus, SYSINFO, MMIO devices, video sources, audio engines, files, debug state, and coprocessor services.
The bus tracks backing size, total guest RAM, active visible RAM, low-window bounds, and profile ceilings. Guests read those facts through SYSINFO, while IE64 also reads CR_RAM_SIZE_BYTES.
IE64 uses wide registers; IE32 uses compact fixed-width RISC code; 6502 and Z80 use banked and mapped views; M68K uses 68020-class addressing; x86 uses a flat 32-bit guest model.
File I/O, media load, Program Executor, terminal, serial, keyboard, mouse, RTC, clipboard, CPU wait, Voodoo apertures, Bootstrap HostFS, and SYSINFO are exposed as MMIO services.
| CPU view | Programme form | Hardware contract | Preview amd64 execution |
|---|---|---|---|
| IE64 | .ie64, BASIC AOT, IntuitionOS images |
64-bit PC, data, stack, control registers, and optional paged MMU. | JIT-backed, with FPU native/helper paths. |
| IE32 | .iex, .ie32 |
Fixed 8-byte 32-bit RISC-like instruction stream. | Interpreter-only. |
| 6502 | .ie65 |
Byte-oriented code reaches the shared devices through mapped helpers. | JIT-backed. |
| Z80 | .ie80 |
Register-pair and port idioms drive the same memory and MMIO contract. | JIT-backed. |
| M68K | .ie68, EmuTOS, AROS |
68020-class integer code uses absolute bus addresses and profile bridges. | JIT-backed, including 68881-style FPU native/helper paths. |
| x86 | .ie86 |
32-bit flat guest binaries can use the same file, video, audio, and coprocessor devices. | JIT-backed, including x87 FPU paths. |
The register map is the contract. Services are addressed through fixed bus ranges and can be reached by lower-level code without a host API.
SYSINFO publishes RAM and feature bits. File I/O includes the IE64 FILE_DATA_PTR64 extension. Media load, Program Executor, terminal, serial, keyboard, mouse, RTC, clipboard, CPU wait, Voodoo register, texture, fog, and command apertures, Bootstrap HostFS, and a gated host-command helper are mapped as bus services.
AROS adds DOS packet handling, a Paula-style DMA shim into the shared SoundChip, a host socket bridge, clipboard integration, and IRQ diagnostics. EmuTOS uses an Atari MIDI ACIA bridge into the same live-MIDI engine.
EmuTOS, AROS, and IntuitionOS do not get separate machines. Their loader and driver stacks differ, but graphics, input, file, MIDI, and audio work still ends in MMIO registers, mapped bus memory, interrupts, and shared device state.
| Guest | CPU view | Graphics path | Other device paths |
|---|---|---|---|
| EmuTOS | M68K | IE target helpers set VideoChip mode, enable scanout, and write RGBA pixels into direct VRAM. | Keyboard, mouse, terminal, timer IRQs, PSG writes, GEMDOS mapping, Atari MIDI ACIA bridge. |
| AROS | M68K | Profile runtime maps direct VideoChip VRAM; the AROS system-tree build path validates Devs/Drivers/iegfx.hidd, Libs/cybergraphics.library, ScreenMode prefs, and API/direct-hardware rotozoomer executables. |
AmigaDOS packet bridge, Paula-style audio DMA, kernel-ie-m68k-ahidrv, Devs/ahi.device, host socket bridge, clipboard bridge, IRQ diagnostics. |
| IntuitionOS | IE64 | graphics.library requests CHIP and VRAM grants, maps them with SYS_MAP_IO, and opens VideoChip mode 7. |
hardware.resource brokers access to shared CHIP registers and monopoly VRAM grants. |
The IE target gives EmuTOS a direct VideoChip scanout path and PSG register writes through the shared bus. Its helper code writes pixels, clears and fills rectangles, reads keyboard and mouse MMIO, and drives timer IRQ levels 4 and 5.
IE_VIDEO_CTRL 0x000F0000
IE_VIDEO_MODE 0x000F0004
IE_VRAM_BASE 0x00100000
Scanout 640 x 480 RGBA, stride 2560
IE_PSG_BASE 0x000F0C00
The AROS profile gives the guest a 64 MiB direct VideoChip VRAM slice and big-endian VideoChip reads. The system-tree build tracks arch/m68k-ie/hidd/iegfx/*, stages Devs/Drivers/iegfx.hidd, includes Libs/cybergraphics.library, and installs ScreenMode and palette preferences. Filesystem packets cross the same bus through the AROS DOS handler block.
AROS direct VRAM: 0x1E00000 + 0x4000000
AROS gfx driver: Devs/Drivers/iegfx.hidd
AROS_DOS: 0xF2220-0xF225F
audio.device reaches the native SoundChip.The AROS Paula-style DMA shim is the bridge: four guest DMA channels are fetched at 44.1 kHz, converted into SoundChip FLEX DAC writes, and completed with M68K level-3 IRQ signalling. The AROS build path also runs kernel-ie-m68k-ahidrv, validates Devs/ahi.device, and keeps host socket and clipboard access as MMIO bridges rather than special application calls.
CHn: PTR LEN PER VOL
DMACON 0xF22A0
STATUS 0xF22A4
INTENA 0xF22A8
hardware.resource owns the CHIP page and VRAM grant policy. CHIP is shared across clients; VRAM is single-owner. graphics.library waits for that broker, requests both grants, maps the chip register page and framebuffer pages with SYS_MAP_IO, reports one RGBA32 adapter mode, opens 960 x 540 scanout with VideoChip mode 7, and presents registered surfaces.
CHIP PPN: 0xF0
VRAM PPN: 0x100
Mode: 960 x 540 RGBA32, stride 3840
The generic live-MIDI port exposes raw byte stream registers at 0xF0BF4-0xF0BF6. EmuTOS writes an output-only MC6850 ACIA shim at $FFFC04 and $FFFC06, which feeds the same parser. AROS has an ie-m68k CAMD path. No current IntuitionOS MIDI driver path is present in the source tree.
The preview image demo set includes the EmuTOS rotozoomer_gem.prg programme and AROS RotoAPI, RotoHW, RotoAPIc, and RotoHWc executables. The AROS pairs distinguish API-path drawing from direct-hardware access in both assembly and C examples.
The coprocessor service turns IE32, IE64, 6502, M68K, Z80, and x86 cores into bus workers. A caller starts a worker, queues a request, and polls or waits on a ticket. BASIC has named entry points; assembly and C can drive the same MMIO block and mailbox rings directly.
COSTART / COCALL or MMIO
Per-worker mailbox ring
Worker CPU
Response or ticket
COSTART cpuType, "serviceFile"
ticket = COCALL(cpuType, op, reqPtr, reqLen, respPtr, respCap)
COWAIT ticket, timeoutMs
status = COSTATUS(ticket)
COSTOP cpuType
| Worker CPU | Service suffix | Ring role |
|---|---|---|
| IE32 | .iex, .ie32 | Ring-indexed service worker. |
| 6502 | .ie65 | Ring-indexed service worker. |
| M68K | .ie68 | Ring-indexed service worker. |
| Z80 | .ie80 | Ring-indexed service worker. |
| x86 | .ie86 | Ring-indexed service worker. |
| IE64 | .ie64 | Ring-indexed service worker. |
The mk64-ie tree builds build/ie/tnl.ie64, packs it as svc/tnl.ie64 inside mariokart64.ie68, starts that service from M68K game code, and sends T&L batches through the IE64 worker mailbox. The same worker mechanism is exposed to BASIC through COSTART and COCALL.
The sound and display systems are not hidden runtime services. SID, POKEY, PSG/AY, SN76489, TED, Paula-style DMA, SoundChip, SFX, MOD, AHX, WAV, MIDI/MUS, and the video engines are bus-visible device contracts. Guest code, BASIC, IE Mon, and IEScript can all touch the same registers.
The native path is ten FLEX voices plus 32 SFX channels. FLEX is the unified register surface: each voice has frequency, volume, gate/control, duty, sweep, ADSR, waveform select, PWM, noise mode, phase reset, ring modulation, hard sync, and signed 8-bit DAC input. The five oscillator types are square/pulse, triangle, sine, noise, and sawtooth; the noise generator covers white, periodic, metallic, PSG-style, TED 8-bit, and SN76489 15/16-bit white or periodic modes.
FLEX ch0-3 0xF0A80-0xF0B7F
SID2 ch4-6 0xF0C40-0xF0CFF
SID3 ch7-9 0xF0D40-0xF0DFF
SFX ch0-31 0xF2600-0xF29FF
The final mixer renders at 44100 samples per second with global filter, overdrive, reverb, and limiting, but chip timing is not flattened into one generic synth. PSG defaults to 2000000 Hz, SN76489 has 3579545 Hz NTSC and 3546893 Hz PAL clocks, SID uses PAL-style 985248 Hz and NTSC-style 1022727 Hz, TED audio runs at 110840/111860 Hz, POKEY uses Atari PAL/NTSC clocks, and Paula/MOD period math uses 3546895 Hz.
SoundChip/SFX mixer 44100 Hz
AHX song ticks 50/100/150/200 Hz
MOD and Paula periods 3546895 Hz source clock
WAV and MIDI/MUS parsed, scheduled, mixed
| Audio block | MMIO surface | Guest-visible behaviour |
|---|---|---|
| SoundChip and SFX | 0xF0A80 FLEX, SID2/SID3 FLEX windows, SFX ext 0xF2600-0xF29FF |
Ten FLEX synth channels, 32 SFX sample-trigger channels, square/pulse, triangle, sine, noise, sawtooth, nine noise algorithms, ADSR, sweep, PWM, hard sync, ring modulation, signed 8-bit DAC input, global filter, overdrive, reverb, limiter, and block-rendered mixer output. |
| PSG/AY and SN76489 | PSG 0xF0C00-0xF0C0F, PSG player 0xF0C10-0xF0C1C, SN76489 0xF0C30-0xF0C3F |
AY-style tone/noise/envelope registers, PSG-family file playback, SN76489 latch/data writes, ready/status reads, and selectable LFSR mode. |
| SID, TED, POKEY | SID 0xF0E00-0xF0E1C, TED audio 0xF0F00-0xF0F05, POKEY 0xF0D00-0xF0D0A |
SID voice, pulse, ADSR, sync/ring, filter, and model state; TED two-voice sound and DAC mode; POKEY four channels, AUDCTL pairing, distortion modes, and readable polynomial tap. |
| Music and media players | AHX 0xF0B80, MIDI 0xF0BA0, MOD 0xF0BC0, WAV 0xF0BD8, SAP 0xF0D10, TED player 0xF0F10, media loader 0xF2300 |
Pointer, length, control, status, position, subsong, tempo, volume, and loader registers for AHX, MOD, WAV, MIDI/MUS, SID, PSG-family, SAP, and TED data. |
| Paula DMA and live MIDI | Paula 0xF2260-0xF22AF, live MIDI 0xF0BF4-0xF0BF6 |
Four DMA sample channels into SoundChip DACs, completion status, interrupt enable, raw MIDI byte input, active status, and all-notes-off reset. |
The live-MIDI block is a guest-visible byte-stream port on MachineBus. EmuTOS reaches it through an output-only Atari ACIA bridge. AROS has an ie-m68k CAMD driver path. No current IntuitionOS MIDI driver path is present in the source tree.
The compositor runs a 60 Hz schedule, sorts sources by layer, supports scanline-aware rendering, dirty rectangles, frame-generation skipping, retained frame leases, and triple-buffer publication paths in the video engines. Hardware layers carry source dimensions, stride, alpha, visibility, and optional retained leases.
| Video source | Register and memory surface | Guest-visible behaviour |
|---|---|---|
| VideoChip | Registers 0xF0000+, VRAM aperture, direct-VRAM modes |
RGBA32 and CLUT8 modes, copper control, raster bands, blitter copy/fill/line/masked copy/alpha copy/colour expand/scale/memcopy, Mode 7 support, and direct framebuffer scanout. |
| VGA | Registers 0xF1000-0xF13FF, VRAM 0xA0000, text 0xB8000 |
Text mode, Mode 12h, Mode 13h, Mode X, sequencer, CRTC, graphics controller, attribute controller, DAC, palette RAM, planar and chain-4 memory behaviour. |
| TED video | Registers 0xF0F20-0xF0F6B |
40 x 25 text, 320 x 200 bitmap, multicolour text, hardware cursor, border colour, raster line registers, VBlank status, 121-colour TED palette model. |
| ANTIC/GTIA | Registers 0xF2100+ |
Display-list DMA, scanline-aware render path, GTIA colour and priority registers, player/missile buffers, VBI and DLI status. |
| ULA | Registers 0xF2000-0xF2017, VRAM aperture 0xFA000+ |
ZX Spectrum bitmap and attribute layout, border register, flash/bright attributes, auto-increment data port, VBlank status, and optional VBlank IRQ enable. |
| Voodoo | Registers 0xF8000-0xF87FF, texture memory, command stream, fog/table/upload apertures |
Triangle rasterisation, Gouraud colour, Z-buffering, alpha test/blend, texture enable and upload, fog colour/mode, chroma key, clipping, swap buffers, status bits, and 640 x 480 default output. |
Every live part of the machine can be treated as state to inspect, account for, quiesce, snapshot, and restore. The proof spans CPUs, bus memory, sparse backing pages, MMIO devices, video state, audio state, service registrations, and tool hooks.
IE Mon supports CPU-local state snapshots and whole-machine reverse snapshots. Whole-machine snapshots cover registered CPUs, shared bus RAM, sparse backing pages, and versioned device state blobs, with restore failures surfaced instead of silently ignored.
IE_PERF_ACCT=1 enables CPU JIT and interpreter timing, retired instruction counts, subsystem buckets, and JIT deopt reason accounting. The disabled path stays behind a gate before atomic work.
IE64 keeps a 64-bit PC, data, and stack model. JIT helper exits handle high physical addresses and MMU translations by routing the operation through interpreter-equivalent helpers, then resuming only when the architectural state still matches.
Reset and load paths quiesce scripts, compositor, render loops, monitor, media, CPUs, EmuTOS, and AROS, then recreate CPU/profile state, rewire the monitor and Program Executor, and restage configured coprocessor services.
The machine separates CPU execution, a 60 Hz compositor cadence, and a 44.1 kHz audio path. Hot paths use published bus maps, retained video leases, and triple-buffer handoff to reduce unnecessary copies.
IE Mon and IEScript use the same monitor, bus, CPU registry, compositor, and snapshot contracts as the running machine.
It halts the running machine at hardware level, then exposes CPU focus, disassembly, registers, memory, symbols, breakpoints, watchpoints, bus access history, I/O register views, and reverse history across the six CPU families and coprocessor workers.
IE Mon can switch focus between registered CPUs, show and change registers, disassemble around expressions such as pc+$20, interleave source locations when available, single-step, continue, run until an address, and assemble one IE64 instruction at an address.
cpu
r
d /s pc 8
b main+0x10 if R1==$10 && hitcount>2
s
g
SoftICE-style bpm* watchpoints cover byte, word, long, and quad accesses by read, write, or read/write mode. Page guards, access logs, who, bfirst, and trace mmio identify bus activity from recorded access data.
bpmqw $f0000
pg add $f0000 $f0fff rw cpu=current
accesslog on 1024
who wrote $f0004
trace mmio voodoo 16
rs restores the focussed CPU from local step history. rg, rt, tl, and history horizon work with retained whole-machine reverse snapshots covering registered CPUs, bus RAM, sparse IE64 backing pages, and registered versioned device blobs.
history horizon
tl 12
rg
rt PC==$2000
ss checkpoint.ie64state
sl checkpoint.ie64state
io exposes named I/O register views with native-width reads, including audio, video, SYSINFO, wait, Voodoo, MIDI, and other MMIO devices. Trusted .iemonrc files, aliases, macros, scripts, and the IEScript dbg.* API reuse the same monitor command surface.
io all
io sfx
io voodoo
rc list
rc trust .iemonrc
macro frame d pc 8; r
Where IE Mon is interactive, IEScript turns the same machine surfaces into Lua automation: programme launch, terminal input, CPU freeze/resume, MMIO and RAM access, video waits, screenshots, recordings, media control, coprocessors, symbols, and debugger sessions.
.ies files can run from the command line, through Program Executor dispatch, from BASIC with RUN "demo.ies", or from IE Mon with script demo.ies. The runtime executes scripts asynchronously and uses frame and timer waits as synchronisation points.
./bin/IntuitionEngine -script demo.ies
./bin/IntuitionEngine demo.ies
RUN "demo.ies"
script demo.ies
Scripts can wait on compositor frames, pixels, settled frame hashes, or custom visual predicates. The recording module can capture screenshots and video, so a demo or regression can produce both a quick hash and a human-readable frame.
sys.wait_frames(2)
video.wait_stable(3, 120)
hash = video.frame_hash()
rec.screenshot("frame.png")
rec.start_screen("run.mp4")
rec.stop()
IEScript exposes memory and MMIO operations plus high-level modules for audio, video, media, coprocessors, symbols, and regions. The shipped rotozoomer script stages data with mem.write_block, writes VideoChip and blitter registers, and starts MIDI through MMIO.
cpu.freeze()
mem.write_block(texturePtr, texture)
cpu.resume()
video.write_reg(983040, 1)
video.blit_fill(1048576, 320, 200, 255, 1280)
video.blit_wait()
The dbg module opens the monitor, steps, continues, sets breakpoints and watchpoints, reads registers and memory, disassembles, inspects I/O views, queries reverse-history settings, controls trace rings, and snapshots registered devices. Raw RAM access requires an explicit freeze; MMIO access is allowed without freezing.
dbg.open()
dbg.set_bp(0x2000)
dbg.step()
regs = dbg.get_regs()
io = dbg.io("midilive")
snap = dbg.device_snapshot("video")
dbg.close()
IE64 BASIC runs on the IE64 CPU, stores and loads programmes through the machine File I/O block, and can move the same stored lines through interpreter, AOT, standalone image, assembly text, and in-machine assembler paths. It is also a hardware console: typed BASIC can write MMIO, wait for video, drive blitter modes, start music, and call coprocessor workers.
| Path | What BASIC does | Hardware or file surface |
|---|---|---|
| Stored programme | LOAD, SAVE, BLOAD, DIR, and TYPE use the machine disk volume; BLOAD puts raw assets into guest memory. |
File I/O MMIO, including IE64 FILE_DATA_PTR64. |
| Native execution | RUN AOT compiles the stored programme to native IE64 code inside the machine and runs it immediately. |
IE64 AOT path, same visible result contract as RUN. |
| Standalone image | COMPILE "DEMO" writes DEMO.ie64 and a same-name IE64 assembly listing. |
Flat IE64 image plus self-contained assembly text. |
| Assembly round-trip | TRANSPILE writes IE64 source only; ASSEMBLE reads IE64 source and writes a standalone .ie64. |
In-machine assembler at PROG_START. |
| Device control | PEEK8/16/32/64, POKE8/16/32/64, WAIT, VSYNC, BLIT MODE7, SOUND, ENVELOPE, GATE, and SOUND PLAY. |
MMIO registers for video, blitter, audio, media loader, and timing. |
| Worker CPUs | COSTART, COCALL, COSTATUS, COWAIT, and COSTOP reach the coprocessor service block. |
Shared coprocessor MMIO and mailbox rings. |
RUN AOT
COMPILE "name"
TRANSPILE "name"
ASSEMBLE "name"
COMPILE rejects direct-mode-only commands and stored forms that cannot become a standalone image. TRANSPILE is the inspection path. ASSEMBLE is not tied to the stored BASIC programme; it reads IE64 source from the disk volume and emits a flat image.
10 POKE32 &H000F0800,1
20 SOUND 0,440,200,0,128
30 ENVELOPE 0,50,100,200,100
40 GATE 0,ON
50 VSYNC
The same vocabulary can initialise the mixer, configure a FLEX channel, open the envelope gate, wait for video cadence, and then continue into blitter, sprite, tile, Voodoo, file, or media-loader work.
The direct BASIC audio layer includes SOUND, ENVELOPE, GATE, SOUND FILTER, SOUND REVERB, SOUND OVERDRIVE, SOUND NOISE, SOUND WAVE, SOUND SWEEP, SOUND SYNC, SOUND RINGMOD, PSG, SID, POKEY, TED, SOUND PLAY, and raw SFX POKE32 writes.
SOUND PLAY "TITLE.MOD"
SOUND PLAY "INTRO.SID",0
SOUND PLAY "TUNE.AHX",1
SOUND PLAY "SONG.MID"
The build produces ie32asm, ie64asm, ie64dis, ie32to64, and m68kto64 alongside the VM, and the preview image stages the SDK tool bundle with a checksum manifest. IE Mon adds disassembly, memory editing, breakpoints, watchpoints, source locations, reverse history, trace views, and scripted debugger entry points.
make
make headless-novulkan
go test -tags headless ./...
The preview live image stages CPU-folder demos. This gallery is deliberately narrow: staged *.ie* programmes, the staged EmuTOS .prg, AROS rotozoomer executables, and the named BASIC and IES demos from the reference-guide flow.
rotozoomer_basic.basBASIC drives the Mode 7 rotozoomer path directly through hardware-facing commands.
wobble_zoom.basBASIC builds the texture data and runs the wobble zoom flow from the demo-programming chapters.
resonance.basMusic-synchronised BASIC demo that uses MIDI position, Mode 7 texture, raster bands, rails, stars, and scroll assets.
rotozoomer_ies.iesIEScript stages data, writes device registers, and runs the rotozoomer as an automation harness.
rotozoomer.iexIE32 assembly version of the rotozoomer effect, built for the staged demo set.
voodoo_mega_demo.iexIE32 programme for the Voodoo path, staged beside the other CPU-folder binaries.
vga_mode13h_fire.iexIE32 code writes the VGA Mode 13h path for a fire effect.
vga_modex_circles.iexIE32 code uses the VGA Mode X path for the circles demo.
vga_mode12h_bars.iexIE32 code targets VGA Mode 12h for the bars demo.
vga_text_hello.iexIE32 text-mode VGA programme for the staged SDK demo set.
robocop_intro.iexIE32 Robocop intro artefact from the staged showreel build.
rotozoomer_ie64.ie64IE64 assembly version of the rotozoomer, assembled with ie64asm.
mandelbrot_ie64.ie64IE64 Mandelbrot programme assembled with ie64asm.
rotozoomer_68k.ie68M68K version of the shared rotozoomer effect.
ted_121_colors_68k.ie68M68K programme for the TED 121-colour video path.
rotating_cube_copper_68k.ie68M68K rotating cube using the copper presentation path.
voodoo_cube_68k.ie68M68K cube programme for the Voodoo graphics path.
voodoo_3dfx_logo_68k.ie68M68K Voodoo logo programme for the staged demo set.
voodoo_triangle_68k.ie68M68K triangle programme for the Voodoo raster path.
robocop_intro_68k.ie68M68K Robocop intro artefact from the staged showreel build.
rotozoomer_gem.prgEmuTOS GEM rotozoomer built from the SDK assembly source and staged as a .prg.
rotozoomer_z80.ie80Z80 version of the shared rotozoomer effect.
robocop_intro_z80.ie80Z80 Robocop intro artefact from the staged showreel build.
rotozoomer_65.ie656502 version of the shared rotozoomer effect.
ula_rotating_cube_65.ie656502 rotating cube for the ULA video path.
robocop_intro_65.ie656502 Robocop intro artefact from the staged showreel build.
rotozoomer_x86.ie86x86 version of the shared rotozoomer effect, built with NASM.
antic_plasma_x86.ie86x86 programme for the ANTIC plasma path, built with NASM.
RotoAPIAROS assembly rotozoomer through the API drawing path.
RotoHWAROS assembly rotozoomer through direct hardware access.
RotoAPIcAROS C rotozoomer through the API drawing path.
RotoHWcAROS C rotozoomer through direct hardware access.
mariokart64.ie68The mk64-ie Makefile packs an M68K loader, game payload, and svc/tnl.ie64 into build/ie/mariokart64.ie68. The port uses an IE64 T&L coprocessor service for vertex transform work.
The page shows the machine structure; the PDFs and reference-guide bundle hold ISA tables, monitor commands, IEScript APIs, MMIO maps, examples, and the full Mario Kart 64 port case study.
System architecture, bus, CPU, MMIO, runtime, audio, video, and tooling overview.
IE64 64-bit RISC instruction set, addressing, FPU, control registers, timer, privilege, and MMU reference.
IE32 32-bit RISC-like CPU manual with fixed 8-byte instruction format and addressing behaviour.
Machine monitor manual covering debugger commands, breakpoints, watchpoints, reverse history, and scripted access.
Lua automation API for programme control, MMIO, screenshots, recording, frame hashes, waits, and debugger integration.
The full Programmer's Reference Guide bundle. Part VIII is the full game-port case study for the Mario Kart 64 IE port.