Macross 6502, an assembler for people who hate assembly language

There are many MOS 6502 cross-assemblers available. Here’s a new one. Or actually a very old one. “Macross”, a very powerful 6502 macro assembler, which was used to create Habitat, Maniac Mansion and Zak McKracken, was developed between 1984 and 1987 at Lucasfilm Ltd. and is now Open Source (MIT license):

Some History

Starting in 1984, a team at Lucasfilm Ltd. was developing one of the first online role-playing games, originally called “Microcosm”, which was released as “Habitat” in 1986 and later renamed to “Club Caribe”. The client ran on a Commodore 64, which conntected to the central server through the Quantum Link network.

The client software was developed on a 68K-based Sun workstation running the SunOS variant of Unix using cross-development tools developed by Chip Morningstar (who was also the Habitat lead): The “Macross” assembler and the “Slinky” linker. They were used on every 6502 (Atari 400/800, Commodore 64, and Apple II) game produced at Lucasfilm Games, from 1984 up until those machines ceased to be relevant to the games market*.

In 2014, The Museum of Art and Digital Entertainment got a hold of

  • the source of the original development tools (Macross/Slinky)
  • the source of the C64 client
  • the source of the server (written in PL/I)
  • lots of documentation and development logs

which originated from an archive created in 1987 in the context of the technology transfer to Fujitsu, which bought all Habitat assets.

Since Macross and Slinky were written for Unix, it was easy to get them compiling with modern compilers (K&R syntax notwithstanding) and running on a modern Unix system. At the time of writing, the code in the official repository has been fixed to compile with clang on OS X. Further fixes and cleanups are very welcome.

Compiling Macross

Enter “make” both in the toplevel directory and in the “slinky” directory, then copy “macross” and “slinky” into your path. There are man files in the “doc” directory that you may want to install as well.

Writing Code

The syntax of Macross source files is very different from modern 6502 cross assembler, and more similar to Commodore’s own “A65” assembler. Here is a small “Hello World” for the C64:

define strout = 0xab1e

    lda #/text
    ldy #?text
    jmp strout

    byte "HELLO WORLD!", 0

As you can see, hex values have to be specified in C notation (binary is prefixed with “0b”), and the operators to extract the low and high bytes of a 16 bit value are “/” and “?”, respectively.

Compile and link the source file like this:

macross -c -o hello.o hello.m
slinky -e -o hello.bin -n -m hello.sym -l 0xc000 hello.o
dd if=hello.bin bs=1 skip=2 count=2 of=hello.prg
dd if=hello.bin bs=1 skip=6 >> hello.prg

The “dd” lines convert Slinky’s output, which is a “standard a65-style object file” (which has a header of FF FF, followed by the start address, followed by the end address) into a C64 .PRG file that is only prefixed by the start address.

Here is a slightly more complex example:

define bsout = 0xffd2

    ldx #0
    do {
        lda x[text]
        cmp #'A'
        if (geq) {
        jsr bsout
    } while (!zero)

    byte "HELLO WORLD!", 0

Macross supports C-style if/else, while and do/while, as well as do/until, where the condition can be one of:

  • zero/equal
  • carry
  • lt/leq/gt/geq
  • slt/sleq/sgt/sgeq
  • positive/plus/negative/minus
  • overflow

…as well as their negated versions.

Also note that the “absolute, x-indexed” addressing mode has a different syntax than commonly used.


Macross has a very powerfull macro language. Here is an example:

org 0xc000

function makeFirstByte(operand) {
    mif (isImmediateMode(operand)) {
    } melse {

function makeSecondByte(operand) {
    mif (isImmediateMode(operand)) {
    } melse {
        freturn(operand + 1)

macro movew src, dst {
    lda makeFirstByte(src) 
    sta makeFirstByte(dst)
    lda makeSecondByte(src)
    sta makeSecondByte(dst)

macro hook_vector index, new, dst {
    ldx #index * 2
    movew x[0x0300], dst
    movew #new, x[0x0300]

define VECTOR_INDEX_IRQ = 10

    hook_vector VECTOR_INDEX_IRQ, irq, return + 1

    inc 0xd020
    jmp 0xffff

The “hook_vector” line will emit the following assembly code:

    ldx #$14
    lda $0300,x
    sta $C01D
    lda $0301,x
    sta $C01E
    lda #$19
    sta $0300,x
    lda #$C0
    sta $0301,x

(The example is a little contrived, since adding the index could have been done at assembly time, but the example nicely demonstrates that macros can preserve addressing modes.)

The file doc/macros.itr contains many useful macros. they are documented in doc/genmacros.itr.

Full Documentation

The complete documentation of Macross is available in the file doc/writeup_6502.itr in the repository. It is in troff format and can viewed like this:

nroff -ms doc/writeup_6502.itr


Macross is a very different approach to 6502 development, and with the source available, I think it’s a viable project that should be continued.

I will happily accept pull requests for compile fixes (GCC, VS, …), cleanups (C99, converting docs from troff to markdown, …) and features (BIN and PRG output, support for more a modern notation, PETSCII, …).

7 thoughts on “Macross 6502, an assembler for people who hate assembly language”

  1. It’s thrilling for me for this stuff to finally see the light of day. One minor correction: Macross was not written as part of the Habitat project. It was a general tool that predates the start of Habitat by a year or two. It was used on every 6502 (Atari 400/800, Commodore 64, and Apple II) game that we produced at Lucasfilm Games, from 1984 up until those machines ceased to be relevant to the games market.

    Macross was my first job assignment at Lucasfilm. They urgently wanted to replace the existing assembler they had been using. That one was written in Lisp — you wrote 6502 code in S-expressions, which looked amazingly weird. It was awesomely powerful, because you could use all of Lisp for a macro language, but it was also awesomely slow. It took about 45 minutes on our VAX 750 to assemble a 16K ROM cartridge game, mainly because doing this took 2 megabytes of RAM but the machine only had 512 kilobytes, so it page swapped horribly. My mission was to create a more conventional looking (and performing) assembler without sacrificing much of the macro programming power they had gotten addicted to, hence Macross.

    In reply to the previous question: There is some code in there for the 68000 version, but it’s incomplete. That version was never finished, because the 68000 machines were powerful enough that you could afford to use a compiled language like C. The cult of fast (a tribe overrepresented in the games industry) argued for a 68000 assembler anyway, and so I started on one, somewhat half-heartedly, but got to abandon the effort once reason prevailed. (Nowadays we laugh that C was once considered a high level language, and the cult of fast people have graduated to whining about the overhead of OO and garbage collection.)

  2. Those *.itr files use troff’s ms macros and should be formatted with nroff -ms writeup_6502.itr, for example, instead of man(1). Using troff would give nice PostScript/PDF. Groff is one source or [nt]roff these days, the Heirloom troff project another. The *.itr might need some clean-up to pass perfectly through these modern versions.

Leave a Comment