YouTuber and orbital mechanics expert Scott Manley has successfully landed a virtual Kerbal astronaut on the Mun, the in-game moon of Kerbal Space Program, using a ZX Spectrum home computer equipped with just 48KB of RAM. The demonstration, shared on February 2, 2026, stitches together 1980s-era BASIC programming, a serial adapter, a Python script, and a modern PC running the actual game to pull off a feat that most players struggle to accomplish with hardware thousands of times more powerful.
The result is less a practical flight computer and more a proof of concept that raises a genuine question: how little computing power do you actually need to guide a spacecraft to a safe touchdown?
How a 1982 Home Computer Talked to a Space Sim
The ZX Spectrum, released by Sinclair Research in 1982, was designed for home productivity and simple games. It has no networking stack, no USB ports, and no meaningful floating-point performance. Connecting it to a modern space simulation required a chain of adapters and translation layers that Manley assembled piece by piece.
At the hardware level, the link relied on the ZX Interface 1, an RS-232 serial adapter originally sold as an accessory for the Spectrum line. RS-232 is a decades-old standard for point-to-point serial communication, and the Interface 1 gave the Spectrum a way to send and receive data bytes over a physical cable. Manley used this link to pipe commands from BASIC code running on the Spectrum to a Python script on a separate, modern machine.
That Python script served as a translator. It received simple serial instructions from the Spectrum, reformatted them, and forwarded them into Kerbal Space Program through kRPC, an open-source mod whose official documentation describes it as a tool that lets external programs control KSP. The kRPC protocol supports Python clients and multiple communication options, which made it the natural bridge between a decades-old serial stream and a modern physics sandbox.
The Spectrum itself never ran Kerbal Space Program. It could not. The game requires gigabytes of RAM and a GPU. Instead, the Spectrum acted as a remote flight controller, issuing throttle, staging, and orientation commands while the heavy simulation work happened on the PC. It functioned like a 1980s mission control terminal sending instructions to a spacecraft it cannot simulate locally but can still influence in real time.
BASIC Code as a Flight Computer
What makes this demonstration striking is not just the hardware gap but the software constraint. Sinclair BASIC, the programming language built into the ZX Spectrum, is an interpreted language with limited variable types and slow execution speed. Writing a guidance algorithm in it means working without modern conveniences like efficient math libraries, real-time debugging tools, or even reliable floating-point precision at the scale orbital mechanics demands.
Manley’s approach, as described in secondary reporting, involved writing BASIC routines that calculated when to fire engines, how long to burn, and when to cut thrust for a controlled descent. The Spectrum sent these decisions over the serial cable as simple command strings. The Python intermediary then translated each string into the appropriate kRPC call, which adjusted the virtual rocket’s behavior inside KSP in near-real time.
The latency in this chain is worth thinking about. Serial communication over RS-232 at typical Spectrum baud rates is slow by any modern standard. Each command takes measurable time to travel from the Spectrum to the PC, get parsed by Python, reach kRPC, and finally affect the simulation. Landing on the Mun requires precise timing of retrograde burns and altitude checks. The fact that Manley pulled it off despite these delays suggests either careful pre-calculation of burn windows or a tolerance for imprecise but good-enough guidance, echoing how early real-world space programs operated with limited onboard computing and significant communication delays.
In practice, the BASIC program did not need to solve the full n-body problem or perform complex numerical integration. Kerbal Space Program’s simplified physics and predictable orbits allow a flight computer to work with a smaller set of parameters: vertical speed, altitude, fuel remaining, and engine thrust. By polling telemetry through kRPC and reacting with simple rules (burn when descending too fast, throttle down near touchdown, keep the lander upright), the Spectrum could act as a minimalist autopilot rather than a complete mission planner.
Emulation or Original Hardware?
One detail that complicates the story is whether the Spectrum in the demonstration was original silicon or an emulated replica. According to coverage from Tom’s Hardware, the setup involved a Spectrum environment that communicated over serial to Python while also describing the lander as being driven by “1980s hardware.” These two framings sit in tension and leave room for interpretation.
If the Spectrum was fully emulated on a modern machine, the achievement remains impressive as a software exercise, but the romance of actual vintage chips doing the work fades. If the BASIC code ran on a real Z80 processor with real 48KB of RAM, and only the serial-to-kRPC bridge lived on modern hardware, the claim of pushing period hardware to its limits holds up more strongly. The available reporting does not resolve this ambiguity cleanly, and readers should treat the “1980s hardware” framing with some caution until Manley or independent testers clarify the exact configuration.
This distinction matters because the appeal of the project rests on constraint. Running BASIC in an emulator on a machine with abundant memory and clock speed is a different kind of challenge than running it on hardware where every byte counts and every clock cycle is precious. Both are interesting, but they tell different stories about what vintage computing can actually do: one is about compatibility and preservation, the other about raw capability under strict limits.
Why kRPC Makes This Possible
The unsung enabler of the entire project is kRPC. Without it, there would be no straightforward way for an external program to read telemetry from, or send commands to, Kerbal Space Program. The mod exposes the game’s internal state, including vessel position, velocity, fuel levels, and control inputs, through a network-accessible API that can be reached from languages like Python.
Because kRPC supports Python clients directly, Manley did not need to write custom low-level networking or reverse-engineer the game’s internals. The Python script on the modern PC simply imported the kRPC library, connected to the running game, and translated serial input into API calls. This architecture means that, in theory, any device capable of sending structured commands over a serial or network link can act as a controller for KSP, whether that device is a ZX Spectrum, a calculator, or a microcontroller board.
kRPC also allowed the Spectrum to receive feedback rather than just issue blind commands. By querying the vessel’s altitude, vertical speed, and fuel reserves, the BASIC program could adapt mid-descent instead of relying solely on precomputed burn times. That closed loop between telemetry and control is what turns a simple script into a rudimentary flight computer, even if the underlying logic is far simpler than what modern guidance systems use.
What It Says About Old Computers, and About Games
Manley’s Mun landing highlights an often-overlooked fact: many tasks we think of as “computationally heavy” are only intensive because we expect high fidelity, rich graphics, and constant user interaction. Stripped down to the essentials (reading a few numbers, performing basic arithmetic, and issuing discrete commands), even a 48KB home computer can contribute meaningfully to a complex simulation.
At the same time, the project underlines the flexibility of modern games when opened up by tools like kRPC. Kerbal Space Program was not designed with 1980s hardware in mind, yet its modding ecosystem makes it possible to bolt on everything from external autopilots to full mission control consoles. By inserting a ZX Spectrum into that loop, Manley turned a familiar game into a testbed for retro-computing experiments.
Whether or not the Spectrum in this case was purely original hardware, the demonstration invites others to push the idea further: could an 8-bit machine plan an entire mission, from launch to landing, with minimal assistance? How much autonomy can you squeeze out of a few kilobytes of code? And where is the line between a fun stunt and a genuinely informative exploration of the limits of early home computers?
For now, the answer is at least this: with some clever BASIC, a serial adapter, and a modded copy of Kerbal Space Program, a machine designed when human lunar landings were still a recent memory can help guide a tiny green astronaut safely down to the surface of an imaginary moon. That alone is enough to make the project more than a nostalgia trip. It is a reminder that ingenuity often matters more than raw processing power.
More from Morning Overview
*This article was researched with the help of AI, with human editors creating the final content.
