The recent Artemis mission has a lot of us of a certain age waxing nostalgic about the glory days of Apollo. Back when the Moon was not just a destination, it was the ultimate engineering challenge.

For many technologists, that nostalgia got another jolt recently when NASA made the actual software that powered the Apollo 11 mission publicly available. The code that ran inside the spacecraft’s guidance computers, the systems that helped navigate astronauts across a quarter million miles of space and land on the Moon, has now been released as public domain.

If you are the sort of person who reads code the way some people read novels, this was catnip.

Curiosity naturally sent a lot of people digging into the repositories. The story was highlighted in a recent Tom’s Hardware article that explained how NASA released the software for both the Command Module and the Lunar Module guidance computers. These programs, known as Comanche for the Command Module and Luminary for the Lunar Module, were preserved through years of archival work and the efforts of the Virtual AGC project.

What they reveal is nothing short of remarkable.

The Apollo Guidance Computer was not powerful by modern standards. In fact, it was barely powerful by the standards of a microwave oven today.

It ran at roughly 85,000 instructions per second. It had about 70KB of storage.

And it had roughly 4KB of RAM.

Four kilobytes.

To put that in perspective, most photos on your phone today are several megabytes in size. Even the simplest modern applications consume memory measured in gigabytes. Your smartwatch probably has more computing power than the system that landed humans on the Moon.

Yet that tiny computer guided astronauts through launch, translunar injection, lunar orbit, descent, and landing.

Looking through the code itself is like opening a time capsule of engineering discipline.

This software was written almost entirely in assembly language. Every instruction mattered. Every byte mattered. There was no room for bloat, no abstraction layers piled on top of other abstraction layers. If you wasted memory, you were literally wasting mission capability.

One of the fascinating parts of the code involves routines used to calculate mathematical functions like sine and cosine. These calculations were necessary for navigation and trajectory control. The engineers implemented these functions in astonishingly compact code because they simply had no other option.

Another famous piece of the system handled the 1201 and 1202 alarms that appeared during the Apollo 11 landing. These alarms indicated that the guidance computer was being overloaded with tasks. Instead of crashing, the software prioritized the most important processes and dropped the less critical ones.

That behavior was not accidental. It was intentional design.

When Neil Armstrong heard the alarms and Mission Control confirmed the landing could continue, they were trusting the judgment of software engineers who had anticipated exactly that kind of situation.

Think about that for a moment. Software written in the 1960s implemented a form of priority scheduling that allowed the computer to recover gracefully under overload conditions.

Today we would call that resilience.

And then there are the comments sprinkled throughout the code. Engineers left notes explaining tricky sections or documenting assumptions about navigation routines. Reading those comments now feels like listening to the voices of the MIT engineers who wrote them more than half a century ago.

For programmers and historians alike, it is a gold mine.

You see how problems were broken down. You see how elegant solutions emerged under tight constraints. And you see just how much thought went into every instruction.

Which brings us to the part that really stops you in your tracks.

They landed on the Moon with 4KB of RAM.

Four kilobytes.

That number almost sounds like a typo today. It is smaller than the icon files on your desktop. It is smaller than the text message history on your phone.

Yet that tiny pool of memory helped guide a spacecraft carrying human beings across 240,000 miles of space and safely down onto the surface of another world.

Looking back at it now, you cannot help but admire the engineering skill and discipline that made that possible.

This was not engineering in an era of abundance. It was engineering in an era of constraints. When memory was scarce, every line of code had to justify its existence. When processing power was limited, algorithms had to be efficient by design.

Those constraints forced a kind of clarity that is sometimes missing today.

Modern developers operate in a world where compute and storage are effectively infinite. If software runs slow, we scale it out. If memory usage grows, we add more RAM. Cloud infrastructure has made it possible to throw resources at problems in ways that Apollo engineers could only dream about.

That abundance has produced incredible innovations. It has also allowed a fair amount of inefficiency to creep into the system.

Looking at the Apollo code reminds us that great engineering is not just about what you build. It is about how precisely you build it.

The engineers who wrote that software knew they were working on the most ambitious project humanity had ever attempted. They did not have the luxury of sloppy design or bloated code. The margin for error was measured in lives.

So they wrote software that was careful, disciplined, and elegant.

The result was one of the greatest achievements in human history.

Seeing that code today does more than spark nostalgia. It forces you to appreciate just how extraordinary the accomplishment really was.

A small group of engineers, working with tools that look primitive by modern standards, created software capable of guiding astronauts safely to the Moon and back.

That is worth remembering.

It is also worth asking a bigger question.

With everything we have today, all the computing power, all the AI tools, all the infrastructure those Apollo engineers could only imagine, how much greater should our adventures be?

If humanity could reach the Moon with 4KB of RAM, imagine what we should be capable of now.