I loved Fighter Pilot on the 48K Spectrum, although some of my landings probably counted as ground attacks. Years later, I've been through the code to see how it worked and what a 128K version might have been like.
Fuel really does change the aircraft's mass. The landing limit wasn't quite what I remembered. The real F-15 Eagle has a published ceiling of 65,000 feet, which makes the game's two-byte altitude limit particularly interesting, and a destroyed airfield can come back because the game clears the wrong bit.
Below are the findings, diagrams and things you can try for yourself. Most are about David Marshall's original 48K game. Our 128K additions are marked separately. Trying to add to it has mostly taught me how much he got right with very little room.
About this research
This is a study of the original 48K ZX Spectrum version of Fighter Pilot, written by David K. Marshall and published by Digital Integration in 1983. It covers the Release 2 tape we have been working from.
We had no original source code, design documents or development notes. All we had to work from was the loaded game image: the machine code and data sitting in the Spectrum's memory. We worked backwards from that, disassembling the instructions and watching them run to understand what each part did. The routine names and explanations in this article are ours.
I loved Fighter Pilot on the Spectrum. I remember the sense of having somewhere to fly, and how often I made a mess of getting back onto the runway. When I started wondering what a 128K version might have been like, I wanted to understand what the original was actually doing before changing it.
Some of the questions came from memories of playing it. Others came from people on Reddit who still fly it: does fuel weight affect a glide? What happens if the undercarriage is damaged? Is that 65,000-foot ceiling connected to the largest number you can store in two bytes?
The game is a flight simulator with training, landing practice and air combat. Most of this article is about how that 48K game works: how it moves the aircraft, draws the view and decides whether you've landed or crashed.
We have also made an experimental 128K version. Its HUD, angle-of-attack readout, extra aircraft and landing aids are our additions. I've marked those separately wherever they appear.
The addresses and results refer to the Release 2 tape we've been studying. I've used AI tools to help trace code, write tests and organise the findings. Where a result comes from a prepared test rather than a complete flight, I've said so. The methods and research index are at the end for anyone who wants to check further.
What is loaded into the 48K Spectrum?
The Spectrum has a 16 KB ROM and 48 KB of RAM. Fighter Pilot's tape loads one 49,140-byte image into almost all that RAM, from $4000 to $FFF3. The image contains the screen, game code, graphics and working data together.
Original 48K version. The three blue blocks are RAM; they are not extra 128K banks. Addresses inside each block are landmarks, not boundaries between separate modules. Each block represents 16 KB; the contents listed inside are not drawn to scale.
The display itself lives in RAM. The game prepares the outside view at $E000, then copies it to screen memory at $4000. The cockpit is updated separately. We come back to that when looking at the renderer.
1. Flying the 48K game
I remembered Fighter Pilot being difficult to control, particularly near the ground. A small correction could become a much bigger one, and landing seemed to leave very little room for error. Before making it easier, I wanted to know which parts were deliberate and which parts I had simply remembered badly.
The comments from other players gave us more to investigate. One remembered fuel load making a difference to a gliding landing. Another asked what the game does when the gear is damaged and won't come down. Those are useful questions because they describe something you can try in the game, then follow through the code.
The landing checks gave us some fairly quick answers. Fuel weight took us further into the speed calculation, and the knife-edge comments sent us looking at what the rudder does when the aircraft is banked. The findings below follow those questions through the original 48K code.
What you feel at the controls
ORIGINAL 48K
Controls and flight state
The first thing I wanted to understand was why small corrections could turn into large ones. The control code explains quite a bit of that.
The airborne controls accumulate angular motion. Holding an elevator input produces progressively larger pitch changes; releasing it halves some motion terms. This helps explain why holding a correction can get away from you, while a short press followed by release behaves quite differently.
Pitch, bank and heading have quarter-degree working values and whole-degree instrument values. Heading wraps through 360 degrees. Displayed speed is in knots, altitude in feet, and vertical speed in signed feet per second.
Look up the flight-state addresses
Address
Meaning established in the traced code
$91A1
Displayed airspeed, unsigned word, knots
$91A5
Altitude, unsigned word, feet
$91D0
Vertical speed, signed word, feet/second
$91D2 / $91D4 / $91D6
Displayed pitch / bank / heading
$91E6 / $91E8 / $91EA
Working pitch / bank / heading, quarter degrees
$91BF
Gun ammunition word
$9204
Subsystem damage flags
$9205
Flight failure word
$9208
Accumulated enemy-strike stages
$9211
Includes gear state in bit 0 and airborne state in bit 7
$9212
View and combat flags
The project state map records the evidence for these names. Nearby bytes should not be assumed to have related meanings just because they sit together.
ORIGINAL 48K + OUR 128K COMPARISON
Angle of attack, stalls and knife-edge flight
The original 48K game has no AoA readout. The readout shown in our screenshots was added for the 128K version. What follows separates that addition from the stall and control behaviour we traced in the original.
The nose direction and travel direction can differ because the game adjusts vertical movement separately from pitch. A nose-up aircraft can still be descending.
Our added AoA indication estimates that difference. The original stall check uses speed and flap position, as described below.
The traced stall predicate at $86E7 compares coarse raw speed against a flap-adjusted threshold. Each of the sixteen flap steps reduces that threshold by one raw unit. The original F-15 boundary converts to about 129 displayed knots clean and 119 with full flaps. The manual's 130/120 figures are rounded guidance. Display rounding can put adjacent raw values on the same displayed number even though they fall on opposite sides of the test.
Mass and fuel are not direct inputs to that stall predicate. They still affect the flight leading up to it.
Rudder feeds both heading and pitch when banked. That is the part of the code I'd follow next to investigate the knife-edge flights people remember.
The 128K readout shows estimated nose-versus-travel angle. The game still makes its stall decision using the original speed/flap check.
EXPLANATORY DIAGRAM · 128K AoA ADDITION
Pitch and angle of attack
The original 48K game has no AoA readout. We added an estimate in the 128K version. The diagram below explains how that estimate works.
Pitch is where the nose points relative to the horizon. Flight-path angle is where the aircraft is travelling. In this simplified still-air, side-on picture, their difference is angle of attack.
Try keeping the nose at +8° and moving the flight path from +8° to −3°. The estimated AoA changes from 0° to 11°, although the pitch has not changed.
What this illustrates: α ≈ pitch − flight-path angle. It assumes no wind and treats the aircraft reference line as the nose line. It leaves out wing incidence, sideslip and three-dimensional airflow. The sliders change these two angles independently. The original game uses its separate speed/flap calculation to detect a stall.
What we added: the 128K AoA indication estimates nose versus travel direction from game state. We have not identified an explicit original AoA lift curve. The original vertical-motion and force experiments below show what we have traced and measured.
Once the attitude changes, the game has to decide whether the aircraft climbs or sinks. This is where the distinction between nose direction and actual movement becomes useful.
The original vertical-motion calculation is more specific than “pitch up to climb”. At $8DDA–$8E32 it takes a pitch/speed contribution and adds two negative corrections, one dependent on speed and flaps, the other on bank and speed.
Using the original signed sine-table byte S, positive internal speed v in feet/second, and flap extension f from 0 to 16, the tested calculation is:
Here trunc means truncation towards zero. The rounding is part of the result, not just presentation.
This reconstruction matches 180 original-code cases covering five speeds, three pitches, four banks and three flap settings. At lower speed the negative correction grows. Flaps reduce that correction. Bank adds sink even at unchanged pitch.
The routine assigns vertical speed directly, then uses it to update altitude. The speed correction reaches zero at 1132 ft/s; the stall check lives elsewhere. These tests execute this calculation on its own, with control and stall processing bypassed.
ORIGINAL 48K
Thrust, drag, fuel and weight
Forward acceleration takes thrust minus a combined opposing-force term, then divides by mass. Fuel changes mass, so it changes the divisor in that calculation. This gives us a place to start testing the differences in gliding landings described on Reddit.
The opposing term includes speed and altitude factors, flap and gear effects, and a pitch-dependent weight contribution. Calling the whole quantity “drag” loses that last part.
In the traced airborne path, the altitude factor is 23552 − floor(altitude/4). The speed coefficient is the high byte of 32767 − 8 × raw speed while raw speed is at most 4095, otherwise zero. These are the raw coefficients used by the game. Their physical calibration remains open.
Gear down contributes 528 to the gear term, versus zero when up. Each flap step adds 395 to the flap coefficient before speed scaling. A signed mass × S(pitch)/128 contribution makes nose-up oppose forward motion and nose-down assist it. Another 144 controlled cases check gear differences, pitch/weight signs and reduced resistance with altitude at matched state.
We have not identified moving centre of gravity, fuel-tank positions, moment arms, or separate wing and tail pitching moments in these paths.
Lift, drag and balance: inside the arithmetic
The original separates forward speed from vertical motion. It calculates an opposing force for acceleration, but obtains vertical speed from pitch, speed, bank and flaps through a compact approximation.
These are the two calculations traced in the original code. Forward speed feeds the vertical calculation.
What serves the role of lift?
At $8DDA–$8E32, the game computes vertical speed afresh. Pitch contributes roughly speed × sin(pitch). Below an internal speed of 1,132 feet/second, it adds a negative term (speed − 1132) / (25 + flap extension). Bank adds another downward term, proportional to the magnitude of sine of bank and inversely proportional to speed. Integer division and the original sine table matter.
This produces useful lift-related behaviour: a slower aircraft needs more nose-up attitude to maintain height; flaps reduce the speed-dependent sink; banking increases sink. This branch sets vertical speed directly. Its speed-dependent sink term reaches zero at 1,132 ft/s. Stall detection uses a separate speed/flap check.
Try the original vertical calculation
Each combination below was executed in the unmodified 48K code. The tests run this calculation on its own, with the inputs selected below.
Pitch contribution
Speed sink
Bank sink
Result
Approximate knots are explanatory conversions. The calculation uses the exact internal feet/second values shown. A positive result means climb. Stall and control processing are bypassed in this test; the result is the vertical-speed contribution at the supplied state.
Drag, altitude and climbing weight
The opposing-force calculation at $8BDA–$8C4B contains two speed factors, a speed-dependent coefficient, flap drag and an altitude-dependent factor. The latter is 23552 − floor(altitude / 4); it reduces this part of the resistance as altitude rises. Lowering the gear adds 528 raw force units while airborne. Each flap step adds 395 to a coefficient before the speed scaling.
The same sum includes mass × sin(pitch): nose-up adds resistance; nose-down subtracts it. This is the weight contribution to the opposing sum. The following routine subtracts the complete opposing sum from thrust and divides by mass to obtain a speed-change term. Its physical force units are not established.
Compare an identical forward-speed fixture
raw opposing-force units
Original-code samples at fixed mass 10,000. Negative means this sum assists acceleration, as gravity can in a dive. This is not total aerodynamic drag, pounds of force, or a predicted equilibrium speed.
Centre of gravity, angle of attack and knife-edge flight
Question
What the traced code supports
Does fuel weight matter?
Yes. Fuel plus empty weight updates the mass divisor. The mass also enters the pitch-dependent opposing-force term.
Does fuel move the centre of gravity?
No centre-of-gravity location, fuel-tank position or changing moment arm has been identified in these paths. The identified fuel calculation updates total mass.
Is wing/tail balance calculated?
No separate wing and tail forces or pitching moments have been identified. Controls use accumulated angular changes and attitude-dependent coupling.
Is there angle of attack?
Nose attitude and the resulting travel direction can differ: the sink terms make that possible. An explicit aerodynamic angle-of-attack state, lift curve or alpha-based stall test has not been established. The verified stall trigger compares speed with a flap-adjusted threshold.
Why can rudder affect height when banked?
The rudder branch updates both heading and pitch. Its pitch increment is derived from a bank-dependent term. This provides a code mechanism for the reported knife-edge behaviour; it does not establish a separate fuselage-lift simulation or prove a sustained knife-edge manoeuvre.
These findings narrow the uncertainty: the vertical-speed arithmetic and several force components are now tested directly. Full dimensional calibration, aerodynamic interpretation of every coefficient and complete manoeuvre validation remain open.
OUR 128K CHANGES
We retain these original calculations. Trainers change thrust, mass, stall parameters and control response; the later trainer envelopes add high-speed drag and lower altitude limits. The F-15 airbrake adds an opposing-force term. Autopilot supplies controls. The added aircraft continue to use the original force and vertical-motion calculations.
324 original-code fixtures · Reproduce the probes. Findings updated 28 October 2026.
My memory was that more than 12 ft/s meant a crash. The normal code boundary is 15: −15 ft/s passes the descent check and −16 fails it. Twelve is the upper pitch boundary, which may be where my recollection came from.
Touchdown also checks runway location and condition. At BASE the coarse runway half-width is 100 feet and half-length 2,000 feet. Other conditions include:
Absolute bank below 6 degrees.
Pitch at least zero and below 12 degrees.
Speed below 250 knots.
The appropriate gear condition and remaining inside the runway.
Each check can fail independently. Passing the descent test alone doesn't mean a safe landing.
Damaged gear is a special case. Damage bit 2 at $9204 blocks U from changing the gear state. Attempting U with that fault also sets the descent tolerance to 8 ft/s. The touchdown code treats damaged gear differently from an ordinary gear-up arrival. The gear flag stays where it was; the damage changes how the landing is judged.
Ordinary landings have been flown through the normal controls. For damaged gear, the evidence comes from tests of the blocked control and landing handler with prepared state.
ORIGINAL 48K + OUR 128K COMPARISON
Why the gear takes time to respond
The original U path decrements a counter only when the key is sampled as pressed. After four samples it reloads the counter, toggles the gear flag and changes drag. Releasing early retains the partial count. Holding continuously can eventually toggle it again.
There is no separate mechanical transit state in that path. What feels like gear travelling is a sampled-input delay. Our added amber indications show that pending command; the release latch prevents a held key from repeatedly completing opposite commands.
The original map key uses a similar four-sample repeat scheme. In the tested original sequence, held M toggled on updates four and eight. The 128K version changes this to one toggle per sampled press. Very short taps can still fall between game updates.
ORIGINAL 48K + OUR 128K COMPARISON
The original ILS
The original already has a glideslope calculation. Its coefficient is 1717/32768, equivalent to a slope of about 2.99948 degrees. The aiming point is 100 feet inside the threshold at the five approach ends we checked: BASE north/south, DELTA west and TANGO north/south.
It uses current runway geometry and incoming travel direction, independently of the selected navigation beacon. The marker's centre is x208/y146. Its vertical calculation uses camera height, which is twelve feet above reported altitude. Twenty-five executed cases check centre, high, low, left and right across those five ends. Small distant errors can round to the centre pixel.
The original marker intentionally blinks. That isn't the same fault as our early overlay flicker.
We initially gave gates and autoland slightly different origins and rounding. Research exposed the mismatch. The modern instrument, gates and controller now share runway geometry and the original slope coefficient, with a ten-foot reported-altitude intercept at the threshold. The original ILS remains an independent reference with its original aiming point.
128K addition: native emulator night approach. The original ILS findings above are separate from the added HUD and PAPI shown here.
The real aircraft belongs in this story too. The US Air Force F-15 Eagle fact sheet gives its ceiling as 65,000 feet, matching the approximate figure in the original game manual. That is only 535 feet below 65,535, the largest unsigned value that fits in two bytes. So this is a real aircraft specification sitting very close to a convenient numerical limit.
Displayed altitude is an unsigned 16-bit word. At $8E3C–$8E57, upward overflow selects $FFFF, 65,535 feet, and clears vertical speed and pitch. It saturates instead of wrapping to ground level. A downward step from 65,535 remains valid. There is no clamp at exactly 65,000; a controlled step from 64,999 to 65,001 succeeds.
There is also an explicit nose-up limiter above 54,000 feet:
maximum positive pitch in quarter degrees = 2047 − floor(altitude / 32)
At 65,000 feet this allows four degrees. At 65,503 it allows a quarter-degree. From 65,504 it allows zero. Negative pitch bypasses this limiter.
So the numerical limit is involved, and the ceiling is deliberately constrained as well. We can't infer whether the aircraft specification or the storage format came first in the author's thinking. The boundary tests execute original instructions with prepared values; they are separate from the keyboard-driven climb experiments.
altitude
maximum nonnegative pitch
limit = (2047 − floor(altitude / 32)) / 4 degrees, applied above 54,000 feet. This widget illustrates the traced limiter; it is not a flight simulation.
How the game fits the flying, drawing and combat into memory.
How the program keeps it all moving
ORIGINAL 48K
Getting into the game
Execution begins at $5DC0, decimal 24000. Startup preserves alternate registers through $D403, then calls the title setup at $BB58. The title waits for SPACE by reading port $7FFE. The options code begins at $5FB0, with its input loop at $60D2. ENTER is read from $BFFE.
The mode byte is $6167. Bits 0–3 select landing practice, flying training, combat practice and combat. Bit 5 controls blind landing; bit 4 controls crosswinds and turbulence. Pilot rating is a rotating one-bit selection at $6168. Controller selection is at $67DD.
The keyboard scanner at $6745 reads the eight rows, inverts their active-low bits, and stores the results at $67D5–$67DC. Kempston input is translated into the same input bytes. The rest of the game can therefore consume a common control representation.
ORIGINAL 48K
The main loop and its timing
The flight loop starts at $5EEB. Its work includes input, dynamics at $8531, instruments, world rendering through $6483, enemy handling through $AE4E when enabled, and the view copy at $D417. Gun servicing at $B297 occurs several times within one loop.
At $5F0E it waits against the Spectrum ROM frame counter, then sets a deadline twelve frames ahead. With a 50 Hz frame clock, that gives roughly 4.17 simulation updates a second when the work fits. If drawing takes longer, it can be slower.
Saving CPU time gives us room for more scenery within that wait. Removing the wait would also change the relationship between controls, fuel, weapons and flight updates. In a 25 or 50 fps recording, several video frames can therefore show the same game update.
The motion calculations give us a position and an attitude. Turning those into a view of the runway is another job, with its own approximations.
The world renderer builds a camera matrix, draws the horizon at $953B and draws airfield geometry through $9755. The current cell selects a 35-byte runway template at $A579–$A59B.
Local east and north coordinates used by this geometry are in four-foot units. Airborne camera height is floor(altitude/4)+3. The extra three units put the eye twelve feet above the altitude reference; on the ground the camera-height word is three.
Camera coefficients are signed bytes. The original multiply at $C9CD approximately scales by 1/128, but its carry and rounding behaviour matter. Replacing it with ideal floating-point multiplication can move pixels.
Our relocated calculation is compared directly against the original across all 256 coefficients at eight signed values.
The clipper at $9309 clips the second endpoint. A crossing segment needs both directions checked. The frustum is approximately ±depth/2 horizontally and ±depth/4 vertically. Projection normally centres at x128/y64, with a different low-altitude centre and pitch adjustment below fifty feet.
The outside view is buffered at $E000–$EFFF. $D417 copies 4,096 bytes to $4000, covering the top 128 bitmap rows. The lower 64 cockpit rows are updated separately. That lets us redraw the view while handling the cockpit separately. The benefit comes from the layout already used by the 48K game.
World pointLocal east, north and height
→
Camera transformOriginal signed fixed-point arithmetic
→
Clip and projectDepth, view edges and pixel coordinates
The enemy aircraft is drawn as a software sprite: a bitmap image plotted by the game's Z80 code. The Spectrum has no hardware sprites. The game chooses an aircraft image and works out where to draw it, rather than building the opponent from the same projected line geometry used for scenery.
$AE9E chooses and positions a descriptor using range, relative bearing, height and pitch. There are five groups of five descriptors, with maximum dimensions decreasing from 39×30 to 11×9 pixels. Horizontal position is smoothed.
The target position record includes cell $B5F0, east/north $B5F2/$B5F4 and altitude $B5F6. The movement and manoeuvre branches traced so far are documented in the combat notes.
Guns require airborne state, combat sights and the map off. Ammunition at $91BF starts at 511. Four service calls per loop can spend four rounds per update. Eight projectile slots have lifetimes; the hit test occurs as a round expires.
The traced hit window requires an active enemy, zero coarse range, fine range below 38, and target centre x120–134/y44–57. The fine range is approximately 64-foot units. Certain visual slots are excluded by (slot & 3) == 3.
A hit clears enemy-active bit 0 and sets explosion bit 7 at $B605. It increments only the low score byte at $B609 and sets a forty-update countdown.
The practice target respawns after that countdown without clearing the kill count. A new flight resets ammunition and score.
A normal-input practice attack was replayed in the untouched 48K original and the modified build: the same flight state, ammunition use and kill resulted. Separate boundary tests cover the hit window and gating conditions.
One trap for anyone extending this: $B021 is not a reliable universal “enemy visible” flag. Some early returns leave it untouched. Navigation range bytes are also shared scratch values. You need to know which routine last wrote them and check the coarse range as well as the low byte.
ORIGINAL 48K + OUR 128K COMPARISON
Being shot, airfields and repairs
Subsystem damage and accumulated strikes are separate. The strike byte progresses through 01, 03, 07 and 0F. The fourth strike sets the shot-down failure. A new strike need not produce a new subsystem fault. Combat Practice excludes this damage path.
The verified subsystem flags jam flaps and gear. We haven't established an engine-damage bit from the strike routine. Flaps can also jam after extension at excessive speed without an enemy hit.
Incoming attacks aren't simulated enemy projectiles in the traced rule. An eligible enemy that cannot be drawn advances a counter; exceeding the rating-dependent threshold applies a strike. Drawing it resets that counter. Range and height gate the behaviour. Thresholds are 32, 26, 20 and 12 from Trainee through Ace. The map does not pause an eligible attack.
The enemy can attack airfields. Its target selection proceeds through surviving BASE, DELTA, TANGO and ZULU records. Losing all four sets a failure flag; destruction of the player's current field while on the ground has its own failure.
We found a specific Tango persistence bug. The attack clears bit 1 at $73A7, while Tango's cell occupies bit 4. The destruction count changes, but revisiting the cell reloads its geometry. The 128K patch changes the checked instruction at $B0EC from RES 1,(HL) to RES 4,(HL). A comparison test reproduces the original reappearance and verifies the correction.
Successful landing invokes the original initialisation service while preserving position, cell and heading. It clears damage and strikes, refills fuel and gun ammunition, and leaves the aircraft at the landing field.
The reason I started this was to imagine a 128K version I would have wanted to play. Engine sounds, more to see on the ground, different aircraft and a bit of help getting home all appealed to me. As we worked through the original, the list grew to include weapons, navigation, autoland and a HUD.
I still wanted it to feel like Fighter Pilot. The original flight calculations and landing decisions are underneath the additions, so an autopilot has to fly the aircraft through those same controls. Giving it a destination doesn't make the landing happen by itself. The same goes for the display: having another bank of memory doesn't give the Z80 any more time to draw a tree.
This is where the research became especially useful. We had to understand the original drawing buffer to deal with flicker, preserve its arithmetic to keep scenery in the right place, and measure the cost of the HUD before deciding what would fit. This section covers that work on our 128K version, including the changes we kept and the ones that cost too much drawing time.
Trying to build on it
OUR 128K VERSION · NATIVE EMULATOR CAPTURES
A look at the version we have now
The menu gives a better idea of how far the experiment has grown. You can choose a trainer, set up a flight and look up the controls before taking off. The three cockpit pictures below were taken in night mode, so you can also see how their instrument colours differ.
The new main menu
Aircraft, start field, target, lighting and assistance are selected here. The original author and publisher credits remain visible.
Three aircraft to fly
The prop trainer and jet trainer are unarmed, with different power and approach speeds. The F-15 retains weapons and afterburner. These are the profiles used by our game.
A keyboard page you can refer to
The original flight controls sit alongside the added navigation, weapons, HUD and airbrake keys.
Prop trainer at night
A different aircraft silhouette, prop power indication and dim red instrument outlines. The familiar speed, attitude and altitude instruments stay in place.
Jet trainer at night
The jet trainer has its own silhouette and cyan instrument outlines. Like the prop trainer, it has no weapons or afterburner.
F-15 at night
Green instrument outlines, the fighter silhouette and weapon stores. Compare the aircraft panel on the left with the two trainers.
Captured in ZEsarUX on 30 October 2026 using normal game inputs. These are the modified 128K game screens. Capture record.
A closer look at the changes
Most of the extra information had to fit around the original instruments. These enlarged crops show where it went. All six are from the running 128K game, with the original pixels preserved.
Aircraft and weapons together
The left panel now belongs to the aircraft: heading, silhouette and weapon stores. Here M61 identifies the selected cannon, with its ammunition strip underneath. Destination bearing and range have moved to the right instrument.
An airbrake you can see
The small rectangular panel on the F-15's back shows the added airbrake deployed. Compare its outline with the picture beside it. Keeping the panel cyan avoids recolouring the plane when both share an 8×8 attribute cell.
A destination for the autopilot
BASE S is the selected destination. The added navigation page shows AP NAV inside the instrument. The aircraft panel can now concentrate on aircraft status.
Guidance and autoland in one place
LANDING and AP LAND show the automatic landing phase. The added controller uses the same runway reference as the ILS. We kept the original ILS instrument and put the approach state here, where you are already looking for landing guidance.
The pitch ladder, in the actual game
Three split rungs are spaced ten degrees apart. They move with pitch and turn with bank in 15-degree steps; the centre rung carries the angle. Speed, altitude, heading and our added AoA estimate sit around them. This crop shows the Z80 HUD running in ZEsarUX.
Pick a destination on the map
The added marker highlights the selected beacon near BASE. N cycles destinations, so you can see what the autopilot will fly towards before engaging it. The airfields, mountains and grid are part of the original map.
Native ZEsarUX captures, 30 October 2026. Navigation, landing, aircraft and map images are from the normal-key walkthrough. The airbrake was captured after R input; the banked HUD after O and a bank command. Source images and crop coordinates.
128K HARDWARE · OUR MEMORY LAYOUT
More RAM, but the same address space
The Z80 still has only 64 KB of addresses. The 128K machine gives it eight 16 KB RAM banks, but they cannot all appear in that address space at once. The extra memory is useful because we can choose which bank the CPU sees at $C000–$FFFF.
Our version starts with the original game's three RAM regions in banks 5, 2 and 0. Banks 5 and 2 stay in place during normal paging. The upper window changes when we call an added routine. Selecting bank 4 does not copy its contents over bank 0: bank 0 is still there, temporarily out of view.
Original 48K machine
$0000–$3FFFSpectrum ROM
$4000–$7FFFLower RAM · screen and game
$8000–$BFFFMiddle RAM · code and state
$C000–$FFFFUpper RAM · helpers and view buffer
Our 128K version: CPU view
$0000–$3FFF48K BASIC ROM selected
$4000–$7FFFBank 5 · original lower RAM
$8000–$BFFFBank 2 · original middle RAM
$C000–$FFFFBank 0 · original upper RAM and compositor
Choose a bank to put in the upper window:
Bank 0 is visible. The original upper RAM and its drawing buffer are available to the CPU.
All eight physical RAM banks
Bank 0Original upper RAM, outside-view buffer and added compositor
Bank 1Added menu, AY sound and loading routines
Bank 2Original middle RAM; fixed at $8000
Bank 3No allocated payload in this build
Bank 4Added scenery, guidance and flight services
Bank 5Original lower RAM and visible screen; fixed at $4000
Bank 6Demo recordings and aircraft/key reference pages
Bank 7Black screen used during title transitions
The map shows normal 128K paging, not the extra all-RAM modes of the +2A/+3. The controls demonstrate bank visibility; they do not execute the game. Bank contents are listed by purpose, not by occupied size.
This is why the stack matters. If a routine switches out the bank holding its return address, it cannot simply return as though nothing changed. Our bridges use a suitable stack while paging and restore bank 0 before returning to the original game. The scenery code also pages bank 0 briefly to draw into its buffer.
The screen selector is separate from this CPU window. The display hardware can read the screen in bank 5 or bank 7. Our flight display uses bank 5; bank 7 hides title construction behind black. We do not alternate those screens for every flight update.
The screen keeps reading while the game keeps writing
The display hardware, the ULA, fetches pixels and colours from screen RAM as it produces the TV picture. The active picture is scanned from left to right, one row after another. Border and blanking periods surround it. A PAL Spectrum repeats this at roughly 50 pictures a second.
The game doesn't calculate fifty new views a second. Its ordinary flight loop is paced at about 4.17 updates a second, so the display reads the same picture many times between updates. When the CPU does change screen RAM, the ULA may already be partway through reading it.
The scan is in the world view. Rows above the line have already been read for this picture.
Slowed-down diagram of active-picture rows only. It omits border timing, retrace and individual memory-fetch timing. The drawing is illustrative, not a captured raster trace. The 120/8/64 split is our modified layout; the original copies the upper 128 rows and updates the lower 64 separately.
Where our flicker came from
Early versionCopy the original scene to the visible screen → draw our trees and buildings on top.
Current versionDraw the original scene and our additions in the buffer → copy the completed view to the screen.
In the early version, the ULA could read the scene after a tree had been erased but before it was redrawn. The next finished screenshot still looked correct. Preparing the whole view first removes that gap.
The final copy still takes time. If it overlaps the scan, one displayed picture can contain data read before and after the update. Colours and cockpit instruments have separate writes too. A scan that overlaps these writes can still show tearing.
There is another wrinkle: Spectrum bitmap addresses are interleaved within each 64-row third. Copying consecutive bytes with LDIR does not move down the screen in scanline order. The orange line follows the display scan. The CPU's copy follows that interleaved memory layout.
OUR 128K ADDITIONS
What the 128K work taught us
Adding to the game made several of these details matter in ways they had not during the initial reading. A rounding difference could move scenery; a lost interrupt could change the pacing; a correct final screenshot could hide flicker.
The original RAM remains mapped through banks 5, 2 and 0. Added menu/audio code uses bank 1, scenery and controllers use bank 4, and reference pages share bank 6 with demo data. Bank 7 supplies the black title transition screen.
The current build loads from tape or snapshot; all resources stay in RAM during play.
Paging isn't just a matter of choosing a bank. Code must restore the original bank before returning through the game's stack. Longer drawing work also needs ROM interrupts to keep the frame clock running. IY must point at the ROM system variables while those interrupts run. Losing ticks during an apparently faster routine can make the game slower.
Early scenery drew after the bare outside view had been copied to the screen. Completed screenshots looked right, but trees and buildings disappeared between copy and redraw. Instruction-level observation caught it. Current composition draws the additions into the view buffer before copying. That keeps the trees in the prepared view. The ULA can still read screen RAM partway through the final copy, so tearing remains possible. Colours and cockpit instruments have separate writes.
To fit the raster code, flight temporarily borrows title-only memory at $BB58–$BFFF and restores the original bytes on title entry. Repeated flight/menu journeys and guarded stacks check that lifecycle.
Optimisation has mostly meant doing less duplicate work: shared coordinate products, cached projected vertices, cached unchanged cockpit content and shared map-marker shapes. The tank-rendering pass measured an 8.2–9.0% improvement in its standard ground-attack benchmark and saved 125 bytes in bank 4. The measurements use the same ground-attack scenarios and inputs before and after the change.
The HUD ladder exposed an error in our own memory estimate. An area thought to be free already contained map code and pixel tables. Sharing map-marker shapes made the ladder fit, leaving 256 bytes in that compositor reservation. The ladder costs time: the measured busy night final dropped from about 3.17 to 2.99 updates per emulated second. Ordinary daytime HUD scenarios stayed near 4.17.
The AY silence problem was another useful lesson. Our simulated register writes were correct, but the exported Z80 snapshot hadn't set the AY-present flag in header byte 37, bit 2. ZEsarUX used that flag to disable AY. Correcting the snapshot header fixed desktop playback.
OUR 128K ADDITIONS
Additions, rather than original discoveries
Our prop and jet trainers are authored profiles. Missiles, bombs, tank missions, autopilot, autoland, PAPI lights, extra scenery, water outlines, night colours, HUD and estimated AoA are additions. They run alongside the original flight model in our modified build.
Reduced thrust alone didn't give sensible trainer envelopes. Extra high-speed resistance and lower nose-up limits were needed. The reported climb heights are where each aircraft settled under the recorded control sequence. Other inputs or fuel loads can give different results.
Tanks are stationary and don't return fire. Water is decorative. Missile guidance and bombing assistance are simplified. Autoland has a tested operating envelope. The title music experiment was removed to recover space; current presentation is silent, with AY effects in flight.
We also looked at Tomahawk, the Apache helicopter simulator. Its scenery and cockpit gave us ideas for the 128K version, using screenshots and the manual as references. We wrote the added routines for Fighter Pilot.
128K addition: the real in-game pitch ladder. This is a native emulator capture, not a Blender overlay.
The main speed and vertical-motion calculations are traced. The remaining work includes calibrating their coefficients, following the rest of the angular-control and enemy-manoeuvre branches, and documenting terrain boundaries and the full world-coordinate representation.
We haven't identified an original AoA lift curve, moving centre of gravity, separate wing/tail pitching moments or a fuselage-lift calculation in the paths examined. Those findings apply to the routines covered here. The added AoA readout also needs calibration before it could serve as a stall-margin indication.
I would still like to follow those paths further, particularly the control behaviour behind the knife-edge reports and paired glides at different fuel loads. Those are better questions now that we know which parts of the calculation to watch.
Looking through the code has given me more respect for David Marshall. The original gets a lot of recognisable flying behaviour from calculations small enough to follow instruction by instruction. Even a modest addition has made us work for space and drawing time.
If you remember a particular behaviour in the original, I would be interested in it. The questions about fuel and damaged gear were worth following, and there may be others we have missed.
I've kept the detailed notes because a result is much more useful when someone else can check how you got it. The address of a routine, the values supplied to it and the exact comparison often matter more than a screenshot that looks convincing.
Each note says whether we supplied values to an isolated routine or flew through the normal controls. All testing so far has used emulators. We have yet to test on a physical Spectrum. Some retain earlier ideas that we later corrected; the main article uses the later findings.
Methods and reference notes
RESEARCH NOTES
How the evidence was collected
The tape's FPC block contains 49,140 bytes loaded at $4000–$FFF3. It includes graphics, data, working memory and instructions. Disassembling every byte as code gives nonsense in places.
We traced execution through startup, menus and flight, then added labels and code boundaries as individual routines were understood. Both SkoolKit and an independent sjasmplus assembly reproduce all 49,140 original bytes exactly. That checks the extraction and reassembly byte for byte. Routine names and interpretations are checked separately through the execution tests below.
There are three useful kinds of checks in the project:
Small tests that execute original instructions with controlled inputs. These establish things like the exact landing boundary or the result of a multiplication.
Complete flights driven through ordinary keyboard inputs. These check that the pieces still work together, including landing, firing, restarting and changing modes.
Native ZEsarUX recordings and captures. These check the desktop experience separately from the simulated tests.
Later timing tests include interrupts and ULA contention. The first extraction traces did not. We have not verified the modified game on physical Spectrum hardware.