RGBDS, TASM (Table ASseMbler, not Turbo ASseMbler), ADVancedGBIDE, ISAS, and the assembler
which is provided with GBDK. ISAS is only available to licensed developers. Many people
use RGBDS and it is probably the most powerful assembler available. Quite a few people use
TASM due to it's simplicity. For serious work, though, RGBDS or ISAS are probably the best
choices.
Here are the main differences between the two most popular & easily available
assemblers:
TASM Advantages:
* Allows quick development for short programs because it's a "simple" compiler
with linker built in.
* Supports 0xh (hex) & 0xb (binary) formats preferred by some that don't like using $x
for hex & %x for binary numbers.
* Has a nice listing output for the compiler results.
* Allows using '[]' or '()' to reference memory. (If you are using the latest TASM
table...)
RGBASM Advantages:
* Allows development of GameBoy programs up to 4Mbytes in size. To develop a ROM larger
than 32kbytes in size using TASM you have to paste files together using DOS "copy /b
f1+f2 f3" or something similar. If you plan on calling code in 2 or more different
ROM banks you have to assemble these files separately and manually make sure that CALLs or
JPs to these banks are valid as the assembler is incapable of catching errors in this
case.
* Allows including all or part of a raw binary data file into your program. Often this
means data such as a tileset, tile map, etc. To do this with TASM you have to convert the
binary data to the format .byte $xx,$xx,$xx,$xx,.... using a program such as 'dump' by
Jens Ch. Restemeier.
* Has a macro language which blows tasm away. Period.
* Automatically optimizes 'LD' instructions. A 'LD' from $ff00-$ffff takes two bytes. A
'LD' from the rest of memory takes three bytes. TASM isn't capable enough to
auto-optimize.
* Allows local labels between standard labels:
Test1:
ld a,[x]
.loop:
dec a
jr nz,.loop
Test2:
ld a,[x]
.loop:
dec a
jr nz,.loop
(Local labels start with .) You can not do this with TASM. Local labels are very helpful
in large code projects.
* Has a compiler directive BANK(x) that returns the bank number in which label 'x'
resides. As a result, it is easy to build a macro such as 'lcall x' that does a call from
bank-to-bank and you don't have to specifically state which bank you wish to call. (The
macro will figure this out for you by using BANK(x).) With TASM you'd have to do something
like 'lcall 5,x' in which you specify the bank and the address in the bank you wish to
CALL.
* Uses an Assembler / Linker setup so you can use Borland or GNU MAKE. Therefore don't
have to recompile your whole project when making a minor change.