Moving an existing project across

You do not port anything. Name the dialect your source is already written in and assemble it. The rest of this page is how to check that for yourself before you rely on it.

Prove it produces the same bytes

The useful first step is not to switch. It is to build both ways and compare.

acme -f cbm -o theirs.prg main.asm
asm198x --dialect acme --prg main.asm -o ours.prg
cmp theirs.prg ours.prg && echo identical

That is the same comparison the differential suites run, on your source instead of ours. If the files match, nothing about your build has changed except which binary produced it.

The same shape works for the other front doors:

pasmo --bin main.asm theirs.bin
asm198x --dialect pasmo main.asm -o ours.bin
cmp theirs.bin ours.bin

Projects in more than one file

-I adds a directory to the include search path. It is repeatable, and searched in the order given:

asm198x --dialect acme -I src -I lib main.asm -o main.bin

Each dialect keeps its own spelling, because your source already has one. The table is generated from the same declarations the assembler dispatches from, so a dialect that gains an include appears here without anyone remembering to add it:

Dialect	Source file	Binary file
`acme`	`!src`, `!source`	`!bin`, `!binary`
`ca65`	`.include`	`.incbin`
`65816`	`.include`	`.incbin`
`huc6280`	`.include`	`.incbin`
`vasm`	`include`	`incbin`
`lwasm`	`include`, `use`, `incl`, `lib`	`includebin`
`rgbasm`	`include`	`incbin`
`pasmo`	`include`	`incbin`
`sjasmplus`	`.include`, `include`	`.incbin`, `incbin`
`8080`	`include`	`binclude`
`6800`	`include`	`binclude`
`1802`	`include`	`binclude`
`8048`	`include`	`binclude`
`scmp`	`include`	`binclude`
`f8`	`include`	`binclude`
`2650`	`include`	`binclude`
`tms7000`	`include`	`binclude`
`pdp11`	`include`	`binclude`
`tms9900`	`include`	`binclude`
`cp1610`	`include`	`binclude`
`z8000`	`include`	`binclude`

Not implemented means the dialect has the directive and asm198x does not read it — your source is valid and the gap is here. Today there is one: a multi-file pasmo project will not assemble, and it is the thing to check first if that is your project. A dash would mean the dialect has no such directive at all, and nothing here does.

The output your build already expects

If your build ends by wrapping a flat binary into a loadable file, that step may not be needed:

Flag	Produces
`--prg`	A C64 program with its two-byte load address
`--sna`	A 48K Spectrum snapshot — needs `end <addr>` for the entry point
`--gb-rom`	A padded Game Boy cartridge ROM with finalised header checksums
`--exe`	An Amiga hunk executable

Without one of these you get the flat binary, which is what your existing packaging step is presumably already fed.

What might not match

Where we differ lists every known difference, what each one is, and whether it is pending work or a settled position. It is a short list, and reading it is faster than discovering one.

If your source is refused rather than assembled differently, that is not on that list — it is a gap, and worth reporting with the source that triggered it. --message-format=json gives a structured diagnostic if that is easier to attach than a terminal scrape.

Keeping both for a while

Nothing stops you running both assemblers over the same source in CI and comparing bytes, exactly as above. That is what this project does against eight reference assemblers on every change, and it is the cheapest possible way to find out that something moved.