Exile on the PicoComputer 3

Exile is not a rendering problem. It is a simulation problem, and the simulation is documented

Thrust was a small game with one big idea, and the port was cheap because everything that made it hard on a 6502 could be deleted. Exile is the opposite shape. Its rendering tricks — the circular screen buffer, the self-modifying sprite plotter, the raster interrupt that paints the water — are all deletable too, and the PicoMite's tile engine draws its world in one call. But the thing that made Exile a masterpiece is the thing that cannot be deleted: a physics kernel that treats every one of sixteen live objects the same way, a creature model with moods, stimuli, line of sight and memory, and a world that is a pure function of its coordinates. That is where the port's effort goes, and it is where the risk is.

The good news is that the whole of it is written down. The level7 disassembly annotates every routine and every table; Tom Seddon made it buildable; Jon Saffron transcribed the landscape generator into C#; and the 2026 bbcexile.com rebuild has re-implemented it bit-identically in TypeScript, validating whole frames against a 6502 interpreter. There is no guessing to do about how Exile works. There is a great deal of transcription to do.

Three measurements were made for this review, before any BASIC was written, because each one changes the design:

• The world needs 413 distinct tiles. Not 65,536 and not 64. Running every square of the planet through the generator gives 436 distinct combinations of tile type, orientation and palette, 413 once identical sprites are merged, 15 of them empty. At our 32 × 32 pixels that is 205 KB of tileset, which does not fit one of the PicoMite's three flash image slots but fits comfortably in two.
• Tiles are in front of objects 98.4% of the time. Exile's famous per-pixel priority flag, which lets creatures hide inside bushes and rock, turns out to be almost a constant: 392 of the 413 tile variants are made entirely of priority pixels and only 6 contain any non-priority pixel at all. So the renderer does not need a two-pass priority scheme. Draw the objects, then draw the tiles over them with black transparent. That is the original's picture, and it costs one TILEMAP DRAW.
• The game runs at 25 Hz. The main loop is free-running, but the player's replot waits for two vertical syncs, so nothing in Exile ever updated faster than 25 times a second. Our frame budget is therefore 40 ms, not the 33 ms Thrust had, and the simulation can run in lockstep with the display: one tick, one frame, no accumulator.

What the PC3 gives us

The number to keep in mind is the last one. Exile ticks sixteen objects and thirty-two particles, each with more logic than a Thrust limpet gun, and the frame it has to fit is only seven milliseconds longer. The renderer will be cheap; the interpreter is the budget.

Five subsystems, all reverse-engineered

Exile shipped as about 26 KB of 6502 and data. The level7 disassembly of the standard version runs to 8,528 instructions (8,796 for the enhanced version) against 4,937 for Thrust, so the game is 1.7 times Thrust's code, and considerably more than that in behaviour, because Exile's code is table-driven and self-modifying where Thrust's is plain.

Exile by the numbers

Every square of the planet, counted

Jon Saffron's ExileWorldGenerator is a line-by-line C# transcription of the 6502 landscape generator, the object-data overrides and the palette logic, with the sprite sheet and its tables. Compiled without its Windows Forms shell and driven from a small console harness (kept in Bas/exile_tools/census/), it walks all 65,536 squares and reports what a port has to store and draw. The two images in this document are rendered by the same code; the lower part of the header image is the caves the player first drops into.

Squares	Count	Share
Rock and slopes	38,341	58.5%
Open (of which windy)	26,213 (1,308)	40.0%
Features: nests, bushes, pipes, mushrooms, columns	802	1.2%
Spaceship structure	180	0.3%
Hand-mapped	1,024	1.6%
Carrying a tertiary object	439	0.7%

Rock is earth, stone, their slopes, quarters and halves; open includes the placeholder types that resolve to doors, switches and transporters.

Tile variants: 413, in two flash slots

A TILEMAP tile index has to stand for one exact set of pixels, and Exile recolours the same sprite by position: stone changes palette every 16 rows, earth every 32, bushes pick one of four schemes from a position hash, mushrooms are red on floors and blue on ceilings. So the question is how many distinct (sprite, flip, palette) combinations the planet actually uses, and the answer is not the worst case of 64 types × 4 orientations × 34 palettes but 413.

Two tilemaps share one map: indices 1–287 live in slot 1 and the rest in slot 2, each map holding zero where the other has the tile, and both are drawn every frame. TILEMAP DRAW skips zero cells, so the second draw costs only the tiles it owns.

Priority: draw the tiles last

The plotter's rule is that an object pixel never lands on a priority pixel. Taking every one of the 413 variants through its palette and counting pixels by group gives 100,773 priority pixels against 1,611 plain ones. 392 variants are all priority, 3 are all plain, 3 mixed, 15 blank. The six with plain pixels are the water-stone tile in Triax's lab and a few spaceship fittings.

So the original's picture is reproduced almost exactly by ordering rather than by masking: fill the background, draw the objects, then draw the tilemap with colour 0 transparent so that objects show through the black of the tunnels and are covered by rock, bushes and pipes. The six exceptions can be drawn before the objects from a third, tiny tilemap, or ignored; either way there is no per-pixel test and no second copy of the tileset. This is the measurement that makes the renderer cheap.

Architecture

Units: keep Exile's, map to the screen at the end

A square is 16 × 32 BBC pixels, a position is a square number and a 256th of a square, so there are 16 fractions to a pixel across and 8 down. Keep all of that as integers in MMBasic — one 64-bit integer per axis holding square × 256 + fraction — and the physics transcribes line for line. The screen mapping is applied only when drawing: one BBC pixel is 2 × 1 of ours, so a square is 32 × 32 pixels and world pixel (x, y) lands at (2x − camX, y − camY). Do not be tempted to rescale the constants; the same lesson as Thrust's elliptical angle tables applies to Exile's "very approximate" angle-to-vector routines, which are 256-step tables with known errors that the game was balanced against. Copy the tables, not the trigonometry.

Screen: 8 × 7½ squares and a panel D4

The enhanced BBC view is 8 squares wide and 8 tall; the standard version showed 8 × 4. At 32 × 32 a full 320 × 240 would show 10 × 7½, and it was the first recommendation, on the grounds that the BBC had no status display. The decision went the other way once the cost of the view size was understood: Exile spawns from a nest and promotes a turret when its tile is plotted, and demotes objects 4 or 12 squares off screen, so the visible area governs how many of the sixteen primary slots are alive, and each live creature is the most expensive thing in the tick. A 256 × 240 view plots 60 squares, the enhanced version's 64 near enough; 320 wide would plot 75. The 64-pixel panel beside it carries what the BBC could not afford, energy, the weapon and its charge, the pockets, and it is drawn once into the framebuffer and never cleared, so it costs nothing per frame. worldview.bas has the layout.

Timing: 25 Hz lockstep D6

The main loop increments a frame counter, updates every object, runs the events, and goes round again; the only pacing is that replotting the player waits until two vsyncs have passed. So the tick was 25 Hz on a quiet screen and slower on a busy one. Gravity is +1 per tick, inertia is −1 every sixteen ticks on a counter offset per object slot so that not everything settles on the same frame, water drag is ×⅞ every four ticks, the wind tiles rotate once in 64 ticks. None of that survives rescaling. Run one tick per frame at 40 ms, and if the interpreter cannot keep up on a busy screen the game slows down exactly as the original did.

The world: generate offline, load once D7 D1

The generator is a pure function, so the whole map can be produced on the PC and shipped as a file: 65,536 cells of tile-variant index, 128 KB as 16-bit values, plus a parallel byte per square of tile type for the game logic (obstruction profile, handler, wind, water). A Python port of get_tile is a day's work and is checked square-for-square against the C# generator, which is itself checked against the game. Generating on the board is out: the routine is a few hundred BASIC statements per square, and 65,536 squares would take minutes.

Getting the file into a TILEMAP was the one thing the firmware could not do when this review was drafted: TILEMAP CREATE reads exactly cols × rows values from DATA, and 65,536 DATA values are more than program memory. That is now closed. TILEMAP LOAD file$, id, flashSlot, tileW, tileH, tilesPerRow reads a plain text file — width, height, then the tile numbers, with comments and any mix of separators — through the same allocation as CREATE, and a 256 × 256 map takes 476 ms on the PC3. So gen_world.py writes one .map file per tilemap slot and the game loads them at start. The windowed-map fallback that this section used to describe is no longer needed.

Doors opening, nests emptying, switches thrown and mushrooms picked are single-cell changes and go through TILEMAP SET in either scheme. Tile collision uses the game's own obstruction profiles, eight heights per tile type, looked up from the per-square type byte; the tile engine's attribute collision is a convenience for the quick tests, not the physics.

Objects: a third slot and BLIT FLASH D5

An object is drawn as a sprite in the palette its type table gives it, flipped horizontally to face left and vertically when hanging or swimming inverted. The 112 non-tile sprites total 10,842 BBC pixels; rendered at 2 × 1 in every palette an object type uses and in all four flips, the sheet is about 90 KB, inside one slot. Each object then costs one BLIT FLASH a frame with colour 0 transparent, sixteen a frame at most, no buffer bookkeeping. The alternative, a least-recently-used cache of the 64 RAM sprite buffers keyed by (sprite, palette) with mirroring from SPRITE SHOW's rotation argument, halves the storage and adds a cache; it is the fallback if the sheet does not fit.

Water and wind

Water is not tiles. Four waterlines by x-range (starting at columns 0, &54, &74 and &A0, at rows &CE, &DF, &C1, &C1) with desired levels that make Triax's lab flood and drain. On the BBC a raster interrupt turns colour 0 cyan for one scanline and blue beneath. For us it is two BOX fills into the background before the objects — black above, blue below, a cyan line at the surface — and the tiles' transparent black lets it show through exactly where the original showed it. Wind is particles and an acceleration on objects in windy squares; both come straight from the tables.

Particles: pixels, as in Thrust

Thirty-two slots, eleven types, each new particle seeded from its type's row of lifetime, speed, colour, flags and randomness, optionally inheriting the parent object's velocity or acceleration. Double-height ones are two pixels; the "plotted on foreground" flag means drawn after the tiles. PIXEL and a two-pixel BOX into the framebuffer, as Thrust does.

Arithmetic across the slots

Exile keeps one table per field, sixteen entries each, and so should we, because that is the layout MATH works on. MATH C_ADD, C_SUB, C_MUL and C_DIV combine two integer arrays element by element, MATH ADD and SCALE apply a constant, MATH SHIFT divides or multiplies by powers of two, MATH SET clears, and C_AND, C_OR and C_XOR work on flag arrays; all of them also accept structure member arrays with a stride, so an object table declared as a structure array is not ruled out, only slower. What they cannot do is anything conditional per element: the ±64 velocity cap, the inertia on the one object whose turn it is, support and collision. So the integration step is seven MATH calls, including the cap through MATH CLAMP a(), lo, hi, b(), which was added to the firmware for this (14 µs for sixteen elements, integer or float, structure members included), and the particles are four calls and a respawn loop. Measured, integration falls from 2.8 ms in a loop to 0.23 ms, and the particles from 2.8 to 0.7. Only the one inertia object per tick and the respawns stay as per-element code.

The object update: in C, checked against the game D8

Phase 3 measured a faithful player kernel at 9.8 ms a tick in BASIC and 0.1 ms as a CSUB, the same transcription in C and the same 2,384-tick check. The physics and the behaviours of all sixteen slots go into that CSUB, called once a tick with the state array, the packed tables and the 64 KB world array (the arithmetic is 8-bit and the tables are bytes, so the translation is mechanical). BASIC keeps what it is good at: reading keys, drawing the frame with TILEMAP and BLIT, stepping the sound envelopes, and the game's events. Two build rules learned: no jump tables (a switch wants a libgcc helper the blob cannot have, so armcfgen.py now compiles with -fno-jump-tables), and no writable statics, so the state lives in the argument array.

Creatures: tables first, behaviours second

The port's largest single body of work. The walking kernel and its seven walking types, the mood machine, the stimulus table, target selection and directness, line of sight and the remembered target all transcribe as data plus one shared routine; that is most of what makes the creatures feel alive. Then the per-type behaviours, about forty routines of ten to eighty instructions each, become SUBs dispatched with SELECT CASE on type. OPTION CACHE SUB and OPTION TRACECACHE, which paid for themselves in Elite, apply here.

Sound D2

The BBC's ENVELOPE has three pitch sections and a four-phase amplitude curve; Exile's envelopes are arbitrary lists of stages with nested loops, stepping every vsync, on frequency and volume independently. So the game does what the original interrupt did: it steps the envelope tables itself, two vsync steps a frame, and issues each step as PLAY BBC SOUND &H10 + ch, -loudness, pitch, 1, a flushed 50 ms note that replaces the last one and falls silent by itself if the program stops writing. The frequency value goes through the original's four-range table to a chip period, then to the nearest BBC pitch unit; that rounding is at most half a unit, 12 cents, and on the teleport sound, the worst case with its 120-cycle warble, it could not be heard against an exact-frequency reference. The 208-byte envelope table and the 49 four-byte sound blocks transcribe as data, as Thrust's did. The seven speech samples are extracted to WAV by Tom Seddon's script and go through PLAY WAV.

Input, saving, determinism

Thirty-nine actions on KEYDOWN; Exile's worst case is thrust, aim, fire and the booster together, inside the six-key limit. The BBC save is a dump of the state, so ours is the object lists, the tertiary state bytes, the waterlines, the player's kit and the teleport memories to a file. Keep the original's four-byte random number generator so that a bug seen on the board can be reproduced on the PC.

Program size

Thrust's 4,937 instructions became 1,245 lines of BASIC plus generated data. Exile's 8,528 are branchier and table-heavier, so expect three to four thousand lines of code with almost no DATA, because the map, the tiles and the sprites live in files and flash. Loaded with crunching that is within the 144 KB, but it will be the largest program yet on the board, and CHAIN with VAR SAVE is the fallback if it is not.

The physics kernel, in numbers

Everything in this table is from the level7 listing or the bbcexile physics chapter and is what the BASIC must reproduce. It is the equivalent of Thrust's table of divisors: get these right and the game feels like Exile.

What we deliberately do not port

Phases

What could go wrong

Data pipeline

Bas/exile_tools/
    census/              this review's harness: Program.cs, README.md, the two images   (done)
    exile-disassembly.txt   the level7 listing - fetched, NOT vendored
    exile6502.py         loads the listing into a 64 KB image; a 6502 that runs its routines   (done)
    gen_world.py         the planet from the game's own code; maps, type bytes, variants; --check  (done)
    gen_tiles.py         399 variants -> two slot BMPs, contact sheets, previews                (done)
    render_window.py     a 320 x 240 reference view for checking the board's screenshots      (done)
    gen_tables.py        51 tables -> tables.bas DATA under labels; every table -> tables.json  (done)
    gen_objects.py       object sheet for slot 3: 213 sprite-palette pairs x 4 orientations   (done)
    test_objects.py      objview.bas + a reference picture; 0 pixels differ on the board       (done)
    ../exile/worldview.bas   phase 2: the planet on the PC3, scrolling, screenshots            (done)
    gen_objects.py       object sheet BMP + coordinate table; --png contact sheet
    gen_tables.py        particles, walking types, type flags, obstruction profiles, angles, sounds
    gen_sound.py         49 sound blocks, the envelope table, samples -> WAV
    out/                 generated .bas fragments, BMPs, verification images
    exile_code.bas       the game without generated data          (phase 2 on)
    build.py             glue, writing ../exile.bas                 (phase 2 on)

The listing and the disc image stay out of the tree for the same reason Thrust's did. The C# generator is MIT-licensed and could be vendored, but the census README shows how to fetch and build it in three commands, which is enough.

Sources

• level7.org.uk: Exile (Standard version) disassembly and the Enhanced version — the annotated listings this review is built on: every table, every routine, the technical notes at the top.
• tom-seddon/exile_disassembly — the buildable form of the above, plus samples.py for the speech and a sprite viewer.
• JonSaffron/ExileWorldGenerator — the C# transcription of the landscape generator, palettes and sprite sheet; the census harness runs on it. MIT.
• bbcexile.com — Exile rebuilt bit-identically — the 2026 TypeScript reconstruction and its chapters on the landscape, the graphics and the physics, which read as design documents.
• Exile tribute: the story of the game's development — Peter Irvin on the generator, the graphics tools and the creature strategy code.
• Wikipedia: Exile (1988 video game) — provenance; Superior Software, 1988; the standard and enhanced versions.
• onaretrotip: My Top 15 BBC Micro Games — the video that prompted this review.
• docs/Thrust_Port_Plan.html, docs/Elite_Port_Plan.html, docs/TILEMAP_User_Manual.md, docs/PLAY_BBC_User_Manual.md — our own precedents and the engine facts.