Shared bus machine

One machine, six CPU views.

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.

Six CPU idioms, one bus IE64, IE32, 6502, Z80, M68K, and x86 programmes enter through different loaders, then meet the same MachineBus and device map.
Hardware is the API Audio chips, video systems, files, input, wait, Program Executor, and guest bridges are fixed MMIO blocks with bus-visible addresses.
CPUs can call CPUs BASIC, assembly, and C can start worker CPUs through the coprocessor service and exchange requests through mailbox rings.
caller CPU
  -> MMIO register or BASIC command
  -> shared MachineBus
  -> device, worker, or runtime service
  -> response through RAM, ticket, IRQ, or status

One shared bus, six CPU idioms.

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.

MachineBus

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.

Architecture PDF

CPU views

Six instruction idioms share one contract.

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.

IE64 ISA and IE32 ISA

Guest-visible services

Runtime services are hardware blocks.

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.

Service map

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.

MMIO is the public hardware surface.

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.

Universal service blocks

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.

SYSINFO FILE_DATA_PTR64 MEDIA EXEC WAIT VOODOO BOOT_HOSTFS

Profile-specific bridges

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.

AROS_DOS AROS_AUDIO_DMA AROS_HOST_SOCKET IRQ_DIAG AtariMIDIACIA

Guest drivers terminate at the shared bus.

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.
EmuTOS

Atari-facing code writes IE registers.

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
AROS graphics and filesystem

AROS sees IE graphics as a driver target.

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
AROS audio, AHI, socket, clipboard

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
IntuitionOS

Native IE64 graphics goes through resource grants.

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
MIDI path split

Live MIDI is shared, but guest access differs.

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.

Driver-level demos

The staged guest programmes cover both API and direct hardware paths.

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.

Demo gallery

A CPU can be a device for another CPU.

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.

Request path

Caller CPU 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, .ie32Ring-indexed service worker.
6502.ie65Ring-indexed service worker.
M68K.ie68Ring-indexed service worker.
Z80.ie80Ring-indexed service worker.
x86.ie86Ring-indexed service worker.
IE64.ie64Ring-indexed service worker.
Case study

Mario Kart 64 IE sends transform and lighting work to IE64.

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.

Mario Kart 64 case study

Audio and video stay on the shared bus.

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.

IE-native audio

SoundChip is the native subtractive synth.

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
Clocking and sample paths

Different chips keep their own clocks.

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.

Live MIDI

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.

Compositor fabric

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.

The whole machine is debugger state.

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.

Reverse debugging and snapshots

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 Mon PDF

Observability

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 high-memory correctness

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.

IE64 ISA PDF

Lifecycle

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.

Timing

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.

Tool hooks share runtime state

IE Mon and IEScript use the same monitor, bus, CPU registry, compositor, and snapshot contracts as the running machine.

IE Mon and IEScript

IE Mon is the hardware monitor.

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.

Execution control

CPU state is readable and writable.

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
Bus diagnosis

Watchpoints operate on memory and MMIO behaviour.

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
Reverse history

Backtracking covers CPU and device state.

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
Device views

The monitor reads hardware as named register groups.

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

IEScript is the repeatable control plane.

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.

Launch paths

A script can be the programme or the harness.

.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
Visual checks

Frame hashes, screenshots, and recordings are scriptable.

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()
Hardware automation

Lua can drive the same MMIO devices as guest code.

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()
Debugger API

Scripts can inspect and steer IE Mon without parsing text.

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 is an in-machine development environment.

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.

Native build path

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.

Hardware from BASIC

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.

BASIC can drive the full audio fabric.

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"

SDK and debug tools

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 demos exercise the same bus from different languages.

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.bas

IE64 BASIC

BASIC drives the Mode 7 rotozoomer path directly through hardware-facing commands.

Screengrab placeholder: rotozoomer_basic.bas
YouTube slot pending

wobble_zoom.bas

IE64 BASIC

BASIC builds the texture data and runs the wobble zoom flow from the demo-programming chapters.

Screengrab placeholder: wobble_zoom.bas
YouTube slot pending

resonance.bas

IE64 BASIC

Music-synchronised BASIC demo that uses MIDI position, Mode 7 texture, raster bands, rails, stars, and scroll assets.

Screengrab placeholder: resonance.bas
YouTube slot pending

rotozoomer_ies.ies

IEScript

IEScript stages data, writes device registers, and runs the rotozoomer as an automation harness.

Screengrab placeholder: rotozoomer_ies.ies
YouTube slot pending

rotozoomer.iex

IE32

IE32 assembly version of the rotozoomer effect, built for the staged demo set.

Screengrab placeholder: rotozoomer.iex
YouTube slot pending

voodoo_mega_demo.iex

IE32

IE32 programme for the Voodoo path, staged beside the other CPU-folder binaries.

Screengrab placeholder: voodoo_mega_demo.iex
YouTube slot pending

vga_mode13h_fire.iex

IE32

IE32 code writes the VGA Mode 13h path for a fire effect.

Screengrab placeholder: vga_mode13h_fire.iex
YouTube slot pending

vga_modex_circles.iex

IE32

IE32 code uses the VGA Mode X path for the circles demo.

Screengrab placeholder: vga_modex_circles.iex
YouTube slot pending

vga_mode12h_bars.iex

IE32

IE32 code targets VGA Mode 12h for the bars demo.

Screengrab placeholder: vga_mode12h_bars.iex
YouTube slot pending

vga_text_hello.iex

IE32

IE32 text-mode VGA programme for the staged SDK demo set.

Screengrab placeholder: vga_text_hello.iex
YouTube slot pending

robocop_intro.iex

IE32

IE32 Robocop intro artefact from the staged showreel build.

Screengrab placeholder: robocop_intro.iex
YouTube slot pending

rotozoomer_ie64.ie64

IE64

IE64 assembly version of the rotozoomer, assembled with ie64asm.

Screengrab placeholder: rotozoomer_ie64.ie64
YouTube slot pending

mandelbrot_ie64.ie64

IE64

IE64 Mandelbrot programme assembled with ie64asm.

Screengrab placeholder: mandelbrot_ie64.ie64
YouTube slot pending

rotozoomer_68k.ie68

M68K

M68K version of the shared rotozoomer effect.

Screengrab placeholder: rotozoomer_68k.ie68
YouTube slot pending

ted_121_colors_68k.ie68

M68K

M68K programme for the TED 121-colour video path.

Screengrab placeholder: ted_121_colors_68k.ie68
YouTube slot pending

rotating_cube_copper_68k.ie68

M68K

M68K rotating cube using the copper presentation path.

Screengrab placeholder: rotating_cube_copper_68k.ie68
YouTube slot pending

voodoo_cube_68k.ie68

M68K

M68K cube programme for the Voodoo graphics path.

Screengrab placeholder: voodoo_cube_68k.ie68
YouTube slot pending

voodoo_3dfx_logo_68k.ie68

M68K

M68K Voodoo logo programme for the staged demo set.

Screengrab placeholder: voodoo_3dfx_logo_68k.ie68
YouTube slot pending

voodoo_triangle_68k.ie68

M68K

M68K triangle programme for the Voodoo raster path.

Screengrab placeholder: voodoo_triangle_68k.ie68
YouTube slot pending

robocop_intro_68k.ie68

M68K

M68K Robocop intro artefact from the staged showreel build.

Screengrab placeholder: robocop_intro_68k.ie68
YouTube slot pending

rotozoomer_gem.prg

EmuTOS GEM programme

EmuTOS GEM rotozoomer built from the SDK assembly source and staged as a .prg.

Screengrab placeholder: rotozoomer_gem.prg
YouTube slot pending

rotozoomer_z80.ie80

Z80

Z80 version of the shared rotozoomer effect.

Screengrab placeholder: rotozoomer_z80.ie80
YouTube slot pending

robocop_intro_z80.ie80

Z80

Z80 Robocop intro artefact from the staged showreel build.

Screengrab placeholder: robocop_intro_z80.ie80
YouTube slot pending

rotozoomer_65.ie65

6502

6502 version of the shared rotozoomer effect.

Screengrab placeholder: rotozoomer_65.ie65
YouTube slot pending

ula_rotating_cube_65.ie65

6502

6502 rotating cube for the ULA video path.

Screengrab placeholder: ula_rotating_cube_65.ie65
YouTube slot pending

robocop_intro_65.ie65

6502

6502 Robocop intro artefact from the staged showreel build.

Screengrab placeholder: robocop_intro_65.ie65
YouTube slot pending

rotozoomer_x86.ie86

x86

x86 version of the shared rotozoomer effect, built with NASM.

Screengrab placeholder: rotozoomer_x86.ie86
YouTube slot pending

antic_plasma_x86.ie86

x86

x86 programme for the ANTIC plasma path, built with NASM.

Screengrab placeholder: antic_plasma_x86.ie86
YouTube slot pending

RotoAPI

AROS executable

AROS assembly rotozoomer through the API drawing path.

Screengrab placeholder: RotoAPI
YouTube slot pending

RotoHW

AROS executable

AROS assembly rotozoomer through direct hardware access.

Screengrab placeholder: RotoHW
YouTube slot pending

RotoAPIc

AROS executable

AROS C rotozoomer through the API drawing path.

Screengrab placeholder: RotoAPIc
YouTube slot pending

RotoHWc

AROS executable

AROS C rotozoomer through direct hardware access.

Screengrab placeholder: RotoHWc
YouTube slot pending

mariokart64.ie68

M68K game port with IE64 worker

The 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.

Screengrab placeholder: mariokart64.ie68
YouTube slot pending

The manuals carry the full register-level detail.

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.

architecture.pdf

System architecture, bus, CPU, MMIO, runtime, audio, video, and tooling overview.

IE64_ISA.pdf

IE64 64-bit RISC instruction set, addressing, FPU, control registers, timer, privilege, and MMU reference.

IE32_ISA.pdf

IE32 32-bit RISC-like CPU manual with fixed 8-byte instruction format and addressing behaviour.

iemon.pdf

Machine monitor manual covering debugger commands, breakpoints, watchpoints, reverse history, and scripted access.

iescript.pdf

Lua automation API for programme control, MMIO, screenshots, recording, frame hashes, waits, and debugger integration.

Programmer's Reference Guide contents

  1. Part I - Intuition Engine BASIC
  2. Part II - Programming Graphics
  3. Part III - Programming Sound and Music
  4. Part IV - BASIC to Machine Language
  5. Part V - Input / Output Guide
  6. Part VI - Whole-Machine Project
  7. Part VII - Demo Programming
  8. Part VIII - A Full Game Port Case Study
  9. Appendices A to L - abbreviations, character codes, MMIO maps, tables, opcode references, symbol index, errors, memory map, block diagrams, and index.