Apollo-11

Product Introduction

1. Definition: The Apollo-11 GitHub repository is a digital archive and historical preservation project. It contains the complete, original assembly language source code for the Apollo 11 Guidance Computer (AGC) used in both the Command Module (Colossus 2A, Comanche055) and the Lunar Module (Luminary 1A, Luminary099). It is a critical piece of computational heritage and aerospace history.
2. Core Value Proposition: This repository exists to preserve, democratize access to, and facilitate the study of one of the most significant software engineering achievements in history. It solves the problem of historical software obsolescence by providing a version-controlled, community-maintained transcript of the code that enabled the first manned moon landing, serving developers, historians, educators, and enthusiasts.

Main Features

1. Complete Source Code Transcription: The repository hosts the verbatim assembly source code for two distinct AGC programs: Comanche055 (Command Module) and Luminary099 (Lunar Module). The code is stored as plain-text .agc files, meticulously transcribed from digitized images of the original hardcopy listings from the MIT Museum. This includes all comments, specifications, and even the original "CONTRACT_AND_APPROVALS" page signed by Margaret H. Hamilton and other MIT/NASA leads.
2. Historical Fidelity and Verification: A core feature is its commitment to accuracy against the primary source scans. The repository actively welcomes pull requests to correct any discrepancies between the transcription and the original scans, making it a living, peer-reviewed historical document. This ensures the digital copy is as faithful as possible to the 1969 original.
3. Modern Toolchain Compatibility: While the source code is historical, the repository is structured for modern development practices. It includes configuration files (.editorconfig, .markdownlint.yml) and package management (package.json) to support contemporary code analysis and tooling. This bridges the gap between 1960s aerospace software and 21st-century software engineering workflows.

Problems Solved

1. Pain Point: The physical degradation and inaccessibility of historical technical documents. Original Apollo guidance computer source code existed on paper listings, vulnerable to loss, damage, and being locked away in archives, making serious study or public appreciation difficult.
2. Target Audience: Software Engineers & Computer Scientists interested in the origins of real-time, fault-tolerant, and human-rated software. Historians of Technology & Space Exploration seeking primary source material. Educators & Students in computer science and engineering disciplines. Open Source Enthusiasts & Hackers inspired by iconic projects.
3. Use Cases: Academic Research into early software engineering practices and constraints (e.g., memory optimization for 36-bit words in 2K of RAM). Educational Demonstration of foundational concepts in real-time systems and assembly programming. Historical Preservation as a canonical, easily forkable digital artifact. Community Analysis where contributors can annotate, explain, and deconstruct the code's functionality.

Unique Advantages

1. Strengths & Limitations (Pros & Cons):

   • Pros: Unprecedented public access to a monumental piece of software history. Serves as an unparalleled educational resource for low-level programming and systems design. Fosters a collaborative community for historical verification and annotation. Released into the public domain, enabling unrestricted use.
   • Cons: The code itself is not directly executable on modern hardware without a specialized emulator like Virtual AGC. It is a historical snapshot, not an actively developed software library with modern features or support. Understanding it requires knowledge of 1960s computer architecture and assembly language.

2. Key Alternatives & Differentiation:

   • Physical Scans/PDFs: Some institutions host scanned PDFs of the original listings. This repository differentiates by providing machine-readable, searchable, and diff-able text files integrated into Git, enabling modern study techniques that static scans cannot support.
   • Virtual AGC Project: Virtual AGC is a complementary project focused on emulating the AGC hardware and assembling/running the code. This Apollo-11 repository is the canonical source code provider for such emulation projects. They are symbiotic; one supplies the software, the other the execution environment.
   • Books and Secondary Analyses: While books provide analysis and context, this repository is the primary source. It allows users to conduct their own first-hand analysis rather than relying solely on interpreted summaries.

Frequently Asked Questions (FAQ)

1. Can I compile and run the Apollo 11 guidance computer source code? Yes, but not natively on a modern PC. You need a specialized emulator and assembler like Virtual AGC (or the yaYUL assembler mentioned in the repo) which simulates the original Apollo Guidance Computer's unique hardware architecture (15-bit words, core rope memory).

2. What programming language is the Apollo 11 source code written in? It is written in Assembly Language (specifically AGC assembly) for the Apollo Guidance Computer. It is not a high-level language like C or Python; it uses mnemonic opcodes and operands that directly correspond to the processor's instruction set.

3. Is the Apollo 11 code in the public domain? Yes. The source code in this repository is a transcription of work created by NASA under a U.S. government contract. As such, it is considered public domain material, free from copyright restrictions, as indicated by the repository's LICENSE.md file.

4. What's the difference between Comanche055 and Luminary099? Comanche055 is the software for the Command Module (CM), which remained in lunar orbit. Luminary099 is the software for the Lunar Module (LM), which descended to the moon's surface. They are different codebases with distinct functions tailored to each spacecraft's role in the mission.

5. How accurate is this transcription compared to the original Apollo 11 code? The transcription aims for maximum fidelity, digitized from original MIT Museum hardcopies. The repository maintainers actively encourage community contributions to fix any discrepancies, making it a self-correcting, high-accuracy historical record.