What is "Luminary"?

AGC software family treeLuminary is name of the mission software which was run on the Apollo Guidance Computer (AGC) installed in the Lunar Module (LM) in all of the later missions, Apollo 10 through 17.  Actually, the title of this web-page and this section, "Luminary", is a bit of a misnomer, since we don't limit ourselves to just Luminary. On this page we present all versions of AGC software targeted for the Lunar Module that we can get our hands on.  The earliest such software had names like Retread, Aurora, Sunburst, and Sundance.  Similarly, there were different programs used for the AGC installed in the Command Module (CM), and you should consult the Colossus page for information about those.

In order to be loaded into the AGC — actually, to be converted to the "core ropes" within the AGC — it was necessary to "assemble" the Lunar Module's software source code into binary machine language, using a computer program originally called YUL, and eventually superseded by a program called GAP

In the context of the Virtual AGC project the process is somewhat different, since you don't have one of the computers on which YUL originally ran, and hence cannot run YUL yourself; nor do you (presumably) have an AGC on which to run the assembled program.  You will instead be able to assemble the Lunar Module source code by using the yaYUL program, and then load it into the yaAGC simulation, both of which we provide to you.

If you'd like to see a more comprehensive but less LM-centric overview of all the available AGC software source code and the manufactured core ropes, you might want to look in the section of our Document Library dedicated to AGC software listings.  The diagram to the right (click to expand) attempts to show the interrelationships between every AGC software version (Luminary, Colossus, or otherwise) and every AGS software version, along with the documentation (Program Change Requests, memos, etc.) documenting the changes.  It covers literally thousands of versions and is therefore very big!

Available and Particularly-Desired Lunar Module Software Versions

Actually, there are a lot of Lunar Module program versions we don't have, and won't ever have.  For example, the reason Luminary 69 is called 69 is because of the 68 versions preceding it, all of which have now vanished with the wind ... we presume.  The same goes for the documentation associated with the software, so we only have incomplete snapshots at various points in time, and in the table below I've made an effort to associate important version-specific documentation with the software version.  However, in case of Luminary, we have an additional very important resource that I haven't bothered to link in on a version by version basis, but which you can nevertheless consult.  I refer to the so-called LUMINARY Memos, a collection of 250+ internal Instrumentation Labs covering many aspects of the Luminary development process, including extensive descriptions of revision-to-revision changes.  Instead of trying to isolate which memos are specific to which of the many program revisions, I'll just recommend that you browse the memo collection yourself as you see fit.

Mission LM Number Mission
LM Program Revision
Source Code
Other Mission-Specific Documentation
Syntax-highlighted, hyperlinked,  HTML

Scanned page images
As you've seen elsewhere on this site, there where two major versions of the AGC, the Block I and Block II models.  While there was never any Block I code for the Lunar Module, there was certainly Block I code for the Command Module, and at some point a transition was made both from writing Block I code to writing Block II code ... but also from writing CM code to writing LM code, and Retread marks that transition point!  It's the veritable Missing Link of AGC code, which is particularly à propos since in fact the YUL development system employed for AGC development didn't sport a linker.  (Joke!  Feel free to ignore.)

Syntax-highlighted, hyperlinked,  HTML Retread 50 is unusual software, not of itself perhaps, but due to the way we acquired it.  We do not have any assembly listing for it (scanned or otherwise), nor has it been reconstructed from problem reports and speculations about how it might differ from the closely-related RETREAD 44 software above.

Syntax-highlighted, hyperlinked,  HTML N/A
Aurora 88 (along with Aurora 85) was the standard G&N checkout software for the LM.  While we have no contemporary listing of Aurora 88 source code, we do have a dump of physical Aurora 88 rope-memory modules, courtesy of collector Steve Jurvetson (thanks, Steve!).  The details, including some nice photos, can be found in the Aurora 88 README in our software repository.  In addition to performing the dump, Mike Stewart has also reconstructed source code for it, the assembly of which naturally matches the dump.

There are a few features of particular interest about Aurora 88, vs other AGC software versions in our collection:
  1. It has a lot of code for the LEM Optical Rendezvous System (LORS). LORS was a rejected alternative to the Rendezvous Radar (RR) system  used in the flown missions.  If I recall correctly, LORS was attractive in the sense that it meant the RR equipment could be omitted from the LM, being replaced instead by the LEM Optical Tracker System (LOTS).  But the software required more memory in the core rope than the RR did, and so LORS had to be rejected due to memory shortage.  As far as we're aware, there are no other surviving listings of LORS code, and for a long time we thought it only existed in unavailable engineering versions of AGC software such as BATMAN. But the LORS code in Aurora 88 appears to be fully functional.  You can put Aurora into LORS mode with VERB 66 ENTER. After that, you can exercise the three LORS verbs 70, 71, and 72. None of them do much without a LOTS simulation hooked up, but verb 71 (LOTS self-test) is the most interesting. Its operation is fully described in document XDE34-T-53, "Preinstallation G&N Testing of the Lunar Excursion Module Optical Rendezvous System". Mike provides some additional comments in the reconstructed source code for the LOTS INTERFACE and LOTS TRACKING modules.
  2. Aurora 88 is by far the patchiest AGC code we have.  A "patch" in this case refers to AGC software changes that were too big to fit into the AGC memory banks hosting the software routines needing the patching; the "patch" would therefore be stored at the end of a different memory bank, and the routine being patched would treat the patch itself similar to the way it would treat a callable subroutine.  In Aurora 88, fully 50% of the memory banks have such end-of-bank patches, relative (presumably) to Aurora 85.  Indeed, a few of these memory banks have 6+ patches.  That's a lot of patches!  In a couple of cases, the end-of-bank patches themselves ran out of memory, and those patches had to be be continued in still other memory banks.
  3. Because Aurora 88 is non-flight code, some of this patching activity was carried out in a more casual fashion than would normally be welcomed in a higher-reliability situation.  For example, sometimes newer patches were just plunked atop earlier but now obsoleted patches, and because it was convenient in some ways to avoid changing the lengths of the patches, unused areas at the ends of the newer patches were simply padded by NOOP (no-operation) instructions.  In some places, patches which were no longer being used were altered by replacing seemingly-random instructions — probably not really random, of course! — by NOOP instructions.  In particular, see the IMU PERFORMANCE TESTS 2 module.
If you've never run our other Aurora-like program (DAP Aurora 12) before, you may be a bit confused by what happens when you run Aurora 88.  Since after all it is checkout software, the first thing you are presented with is the error log (i.e., an automatic V5N31E).  You can find reference cards here, but for example you could perform a memory-bank check using V56E, advancing from one bank to the next with V33E, and eventually terminating the banksum check before trying something else with V34E.
DAP Aurora
Syntax-highlighted, hyperlinked,  HTML

Scanned page images
Don Eyles, one of the AGC developers who you may know as the hero of Apollo 14, has contributed the hardcopy of this program from his personal collection.

Now, for years I had presented this program here as "Aurora 12".  That would make it a very early revision of the Aurora program, and that would be somewhat of a mystery.

Syntax-highlighted, hyperlinked HTML

Scanned page images
This program, SUNBURST rev 37, otherwise known as SHEPATIN rev 0, is an early revision of the SUNBURST program, not used in any mission.  The scan was taken from Don Eyles's personal copy, for our Internet Archive collection, and financially sponsored by Peter McDermott.

Apollo 5
Syntax-highlighted, hyperlinked  HTML

Scanned page images
Document Library
Apollo 5 was an unmanned mission to test the LM, and as such it had a working AGC, though at certain points in the mission the ground controllers bypassed the AGC (which hadn't been planned for), using the AGS instead for some maneuvers.  The mission itself was not entirely successful.

Super Job
Syntax-highlighted, hyperlinked, HTML

Scanned page images
This program, Super Job, is a very unusual offering, in that it is AGC code not written by the MIT Instrumentation Lab, but rather by the Raytheon Company.  Of course, sub-contractors from Raytheon, A.C. Electronics, and others, were used to help write the "regular" AGC programs as well, but this program is entirely written by Raytheon. In fact, we found program listing hidden in an Appendix of a Raytheon report (volume 1 and volume 2) concerning a potential "auxiliary memory" system for the AGC.

Apollo 9
Syntax-highlighted, hyperlinked HTML of Sundance306ish
(reconstruction phase 2)
Document Library Executive summary:  This is a program we have and yet don't have.  I say we do, but there are legitimate grounds for disagreement, and you may need to decide for yourself whether or not you agree with me.  At any rate, we do have software that allows you to fly Apollo 9 missions.  Read on, for more details!

Apollo 10
Luminary 1
Syntax-highlighted, hyperlinked  HTML

Scanned page images
Document Library
This seems to have been the first Luminary revision targeted at the Apollo 10 mission, and seems additionally to have been the first revision of Luminary for which core-rope modules were manufactured.  In other words, it was the first non-developmental revision of Luminary and the first released for manufacturing.

Nevertheless, it ended up not being flown in the mission.  (Instead, see Luminary 69/2 below.)

The version we have here is from Don Eyles's private collection, as scanned by, and financially sponsored by our Onno Hommes.
069/2 Syntax-highlighted, hyperlinked,  HTML We do not have any scans of the Luminary 69 Rev. 2 software used in the Apollo 10 Lunar Module.  But that software can be reconstructed with confidence, and that's what's presented here!  For simplicity, we'll refer to it simply as LUM69R2, and the revision for which we actually have scans (see the item above) as LUM69.  The reason for calling it "LUM69" rather than continuing to call it "LUMINARY" is that originally it was branched off of LUMINARY at LUMINARY 69, so that development for Apollo 11 could continue with LUMINARY 70, LUMINARY 71, and so forth, while separate development for Apollo 10 continued with LUM69 rev 1 and LUM69 rev 2.  In other words, strictly speaking, this is not LUMINARY 69 rev 2 — there's no such thing! — but rather LUM69 rev 2.  And if we had contemporary printout of the program, the tops of the pages would say "REVISION 002 OF PROGRAM LUM69".

Apollo 11
Luminary 1A
Syntax-highlighted, hyperlinked,  HTML Document Library Luminary 96, 97, and 98 were the initial development revisions of the Apollo 11 code.  We do not have physical program listings for any of them, but their source code has been reconstructed from other available data, and we are confident that these reconstructions are correct.

Syntax-highlighted, hyperlinked,  HTML
Syntax-highlighted, hyperlinked,  HTML
Syntax-highlighted, hyperlinked,  HTML One of the original AGC programmers, Allan Klumpp, kept a copy of Luminary 99 Rev 0 (or 99/0 for short), since donated to, having been told that it was the version that flew on Apollo 11.  Unfortunately, that turns out not to have been the case, but it was indeed the first revision of Luminary released for manufacture for Apollo 11 ... by which I mean that its core-rope memory modules were actually manufactured, though not flown.

Syntax-highlighted, hyperlinked,  HTML

Scanned page images (copy 1), plus replacement pages 1472 and 1473

Scanned page images (copy 2)
This is the AGC software version that was flown in the Apollo 11 Lunar Module.  By the way, strictly speaking I don't think this program is LUMINARY, but instead had been branched off from the main branch of LUMINARY source code (..., LUMINARY 97, LUMINARY 98, LUMINARY 99, LUMINARY 100, ....) at LUMINARY 99.  This new branch of code was called "LMY99" rather than "LUMINARY", so that's why at the tops of the pages of the assembly listing you see that it's listed as "PROGRAM LMY99" rather than "PROGRAM LUMINARY", and that's why the revision level is listed as 001 rather than 099.  This kind of trick allowed development for Apollo 12 to continue with LUMINARY 100, LUMINARY 101, and so on, while development for Apollo 11 continued with LMY99.

Page images have been taken from a hardcopy from the Charles Stark Draper Historical Collection, MIT Museum, and then converted to source code by a team of volunteers.

Apollo 12
Luminary 1B
Syntax-highlighted, hyperlinked  HTML

Scanned page images
Document Library
This is from the hardcopy in Don Eyles's private collection, as scanned at (sponsored by Ron Burkey, me).  Unfortunately, the printout is pretty faint, and pp. 217-220, 226 are entirely missing.  But we've worked around the missing pages and have been able to completely reconstruct them.

Apollo 13
Luminary 1C
Syntax-hilighted, hyperlinked,  HTML
Document Library

Luminary 130 was the first software release whose ropes were manufactured for the Apollo 13 LM.  There were several subsequent releases due to bug fixes, so it never actually flew.

We do not have a physical assembly listing for Luminary 130, but it has proven possible to reconstruct the source code with complete confidence (thanks, Mike Stewart!).

The reason this is possible is that we have a scan of a Luminary 131 assembly listing, plus LUMINARY Memo #129 describing the differences (all minor) between 130 and 131, thus making it possible undo those changes.  Finally, the recently-uncovered engineering drawing 2021152 lists all of the memory-bank checksums for Luminary 130, thus making it possible to verify that the modified code has the proper memory-bank checksums.
Syntax-highlighted, hyperlinked,  HTML

Scanned page images
This is the second Luminary release whose ropes were manufactured for Apollo 13, but it was not the revision eventually flown in the mission. Unfortunately, for over a decade, I said here that it was the revision actually flown.  Niklas Beug was sharp enough to notice what I was not, namely in the table from document R-700 shown at the top of this very web-page that what we have is the first version (December 1969) of Luminary 131, but that subsequent versions were released in January and February 1970, and it was the latter of which that was flown.

On our wish list
This is the third Luminary release whose ropes were manufactured for Apollo 13, but it was not the revision eventually flown in the mission. 

In calling it revision 131/9, I am really using shorthand for "LUM131 rev 9".  How LUMINARY 131 somehow morphed into LUM131 rev 9 is a fairly complex story, so rather then tell it twice, I'll refer you to the entry for the fourth and final release below.
Syntax-highlighted, hyperlinked,  HTML This is the fourth and final Luminary release whose ropes were manufactured for Apollo 13, and it was the revision eventually flown in the mission.  By referring to it as LUMINARY 131/1, I'm playing loose with the facts.  In reality, it was "LM131 rev 1" and strictly speaking isn't even a revision of LUMINARY at all.

Syntax-highlighted, hyperlinked,  HTML

Scanned page images
ZERLINA was an off-the-main branch AGC program, by Don Eyles, which experimentally developed a number of proposed improvements to Luminary.  Some of these improvements were actually incorporated in later versions of Luminary ... but also, many were never used, even where they were demonstrably better, due to the need to avoid unnecessary risks — changing software is always a risk! — as the Apollo program approached its end. For example, I believe that improved methods for increasing the positional accuracy of the landing were explored in it, partially due to some ideas of astronaut John Young, who flew Zerlina in the LM simulator.

Apollo 14
Luminary 1D
Syntax-highlighted, hyperlinked,  HTML Document Library Luminary 163 and Luminary 173 were the first and second revisions of Luminary targeted for the Apollo 14 Lunar Module.  Their core-rope modules were manufactured, but they were not actually flown in the mission.  (See Luminary 178 below.)

No contemporary program listings for Luminary 163 and 173 are known to us, but the programs have been reconstructed with a high degree of confidence.  You should consult Mike Stewart's notes on the reconstruction (see issues #1098 and #1099 in our software repository) to understand the reconstruction process and the differences from software version to software version.  Regarding confidence, however, the important point to note in these (and in all such) reconstructions is that in addition to matching the documented version-to-version changes, the memory-bank checksums of the reconstructed software match those of the manufactured core-rope modules as listed in MIT/IL engineering drawing 2021152N.  However, things like program comments and page numbering, which do not affect the contents of the rope memory, may differ from those of the true program listings.
Syntax-highlighted, hyperlinked,  HTML
Syntax-highlighted, hyperlinked,  HTML This is the actual flight program for the Apollo 14 Lunar Module.

Luminary 1E
On our wish list
Document Library AGC developer Allan Klumpp retained a copy of Luminary 209, based on the belief that it had flown on Apollo 17.  Unfortunately, this turns out not to have been the case, and it was really Luminary 210 that flew (see below).  But that doesn't invalidate the value of Luminary 209.  We'd still like to scan it and present it for you here!

As it turns out, the printout was donated to before we could get access to it, nor do we have access to it today, but perhaps we'll be able to scan it some day.
Apollo 15
Luminary 1E 210

Syntax-highlighted, hyperlinked,  HTML

Scanned page images

Document Library Luminary 210 is what flew on Apollo 15-17.  The scan we have is taken from AGC developer Don Eyles's collection, as scanned by, and financially sponsored by our Jim Lawton.  Thanks, Jim!

Apollo 16
Document Library
Apollo 17
Document Library

Source Code and Binary

You can obtain both the source code and (independently derived) binary code for each of the software versions mentioned by installing Virtual AGC on your computer.  The files are contained within a subdirectory named after the software version (such as "Luminary131").  The more important files supplied are these:

Source code for major subdivisions of the Luminary program.
Organizer which treats all of the other assembly-language files (*.agc) as include-files, to form the complete program.
Human-readable form of the Luminary binary executable, as an octal listing.
Binary executable created from binsource (octal listing) file.

In other words, to create a Luminary binary executable rather than using the one provided with yaAGC (such as Luminary131.bin), one simply needs to assemble the file MAIN.agc.  Typically, if all files remain organized the way they are in the yaAGC distribution tarball, the sequence of steps for doing so (from a command-line prompt) would be something like this:

cd Luminary131
../yaYUL/yaYUL --force MAIN.agc >Luminary131.lst

The listfile (Luminary131.lst) so produced is a bit more manageable than scans of the original printouts, in that it is a hundredth the size and you can perform text-searches on it.  The binary so produced, MAIN.agc.bin, should be byte-for-byte identical to the binary (Luminary131.bin) provided with the yaAGC distribution.  Therefore, the following Linux command should reveal no differences between the two:

diff -s MAIN.agc.bin Luminary131.bin

(Replace "diff -s" with "fc /b" in Windows.) 

Technically speaking....

A point which may not be completely appreciated is that Luminary131.bin was not created from the assembly-language source files.  Therefore, the byte-for-byte equivalence mentioned above actually has some significance.  In fact, both the assembly-language source code and Luminary131.bin (or Luminary131.binsource) come from separate readings of the original Luminary assembly listing scan, so their equivalence provides an important check on validity.  (See below.)  The file Luminary131.bin was created from the human-readable/editable ASCII file Luminary131.binsource by means of the program Oct2Bin, with the following steps:

cd Luminary131
./Oct2Bin <Luminary131.binsource
mv Oct2Bin.bin Luminary131.bin

Admittedly, few people are likely to perform any processing of this kind unless contributing a new version of the Luminary code to the Virtual AGC project.


Validity of the Luminary 131 Source Code and of the Binary (Apollo 13)

I believe that the core-rope image (which is what is needed to actually run the Luminary software in the yaAGC CPU emulator) I've provided for Luminary 1C (build 131) is 100% accurate.  If you're not willing to take my word for that, and if the discussion in the preceding section doesn't convince you, an extended discussion of proofing and validation of the core-rope appears in the description of the Colossus software.

Validity of the Luminary 099 Code (Apollo 11)

The Luminary 099 page images became available after the Colossus 249 and Luminary 131page images had already been converted to source-code files, and prior to any other missions becoming available.  The conversion technique was very abbreviated compared to that of Luminary 131, as follows:

The binary thus produced by yaYUL is supplied in the source tree and used for regression testing.

Validity of the Other Versions

Well, it's much the same as what's above, so I'm not going to keep describing the same steps over and over again.  Suffice it to say that we verified them all using the same standards.

This page is available under the Creative Commons No Rights Reserved License
Last modified by Ronald Burkey on 2023-07-13.

Virtual AGC is hosted