I am a owner of Atari ST, and I would like to know software and tools used for the programmers for this computer to program mainly video games.

For example:

  1. IDE used
  2. Language (I think it was Basic, but I am not sure)
  3. Websites of interest and running currently, because I have seen multiples dead links.
  4. Method to run these programs once has been developed (I am thinking in the own atari or in other plaftorm).
  • You've mashed several questions together here. If you want good answers you should separate them out individually.
    – mnem
    Commented Aug 20, 2016 at 18:58
  • 2
    To be honest, a programmer with experience developing for Atari should know these questions, for this reason I did a review of my questions in only one post, but I will think to separate the questions if I don´t have response in a few days. Thank you.
    – inane
    Commented Aug 20, 2016 at 19:05
  • 1
    @tofro If you have an answer, please post it below. Thanks. Commented Aug 21, 2016 at 14:29

8 Answers 8


If you're familiar with BASIC, "STOS" is probably your best choice, but it has its limitations, unless you know a little regarding assembly, in which case you can combine the two. 100 % assembly gives best results, but it's a hassle to debug. 8 Mhz processor remains 2 Mhz efficent, because it takes 4 CPU cycles per instruction : fetch, decode, execute and write. Nevertheless, go with STOS. It does most of the work for you, and you can use the compiler afterwards to make your game quicker.


I can only really answer from my own perspective, and I only wrote real code (other than simple BASIC programs) on an Atari over the last couple of years.

IDE Used

In terms of classic tools IDEs were relatively light compared to tools you get today. I worked using Devpac 3, which is a good assembler that includes some useful features and a debugger. STOS could be regarded as a BASIC IDE specifically for games, and GFA BASIC offers pretty much everything you need form a coding/debugging point of view in one place.


BASIC and/or 68k Assembly. I'm sure there were/are some games written in C, but most people seem to prefer the lower barrier of entry offered by BASIC, and from there tend to head full-on into assembly language.

Useful Resources Today

Atari Forum's WIKI has some useful documents and tutorials, and the #atariscne IRC channel on Freenode has some very smart people in it!

Checkout the Dead Hackers Society's Coding files section for tools and libaries to get you started.

DML (aka Douglas Little) recently published AGT (Atari Game Tools); a suite of graphics tools and a C based engine for quickly prototyping games on the Atari STE. The wiki includes some tutorials and you'll have sprites on screen in no time.

Running The Programs

If you develop on the Atari then you'll be building an Atari executable file so you'll be able to simply launch it with a double click. I personally wrote some C and assembly on my Atari, but I ran into issues with screen mode switching and using the debugger for my game (I was working on a Falcon in 256 colour mode). Later on in my project I wrote the code in Devpac but running under the Hatari emulator, that meant I could use Hatari's debugger to work through issues.

  • I'll send you a kidney for that Atari Falcon. :-)
    – cbmeeks
    Commented May 1, 2017 at 13:57
  • Never letting her go :)
    – Matt Lacey
    Commented May 2, 2017 at 0:36
  • 1
    Turbo-C/Pure-C had a good IDE and was a very capable and competent C compiler for the time. It's limited to C89 which is why for modern developments it's better to use a gcc variant, but if you want to host on real hardware, Pure-C is still a good contender imho. Commented Dec 12, 2022 at 8:57

I used to program on the Atari about 20+ years ago, so I might be a bit rusty on the subject. Also I used to mainly write demo effects and music, so I wasn't working on core game development directly (other than writing music for some).

  1. IDE is a more modern concept, so you probably won't find one on the platform itself, but there are some out there for cross development. For Basic there were a couple of editor/interpreter combos (aside from the original Atari Basic), most notably GFA Basic and Omikron Basic, the latter of which was made the official Atari Basic at some point later. For Assembler the two main tools in use were Devpac and TurboAss(embler), both of which integrated editors and debuggers. In the case of TurboAss the debugger was even reset safe, so in case your program did something weird (short of overwriting the debugger code) you could hit reset and find yourself back in the debugger. Pretty nifty!

  2. Language for games development was mainly Motorola 68k assembly (out of necessity, since most higher level languages had too much overhead to perform well), and some C. I only learned C much later, so can't tell you more about those tools. I did Basic for a while and then straight to assembly! :)

  3. A good place to start looking is http://www.atari-forum.com, which is where a lot of the active crowd is hanging out (both demoscene and hobby games devs).

  4. Like @LaceySnr wrote, just double-click the executable, or start it directly from Devpac/Turboass. Turboass has the Alt-A shortcut to run. There seem to be some home-made link cables in use where people cross compile/assemble on PC and then transfer the binary into the real machine to run there. See post by "Leonard" here: http://www.atari-forum.com/viewtopic.php?f=68&t=7152

Hope that helps!


  • Welcome to retrocomputing! This is a great answer, I hope you stick around to ask and answer more questions.
    – JAL
    Commented Aug 31, 2016 at 3:07
  • IDEs have been around since Turbo Pascal 1.0 in 1983.
    – RonJohn
    Commented Dec 11, 2022 at 15:45

I used, and still have, the Laser C compiler for Atari ST. It is the later version of what was first branded as the Megamax C compiler. It was/is actually a pretty good C dev environment. It has quite a few libraries for useful functions and relevant stuff for the hardware and OS.


I very much enjoyed this blog post which discusses how to get started with 68k assembly and DevPac3. The learning curve with assembly is very steep, but it does offer you the best performance.

If you want a gentler introduction to ST games programming, I can recommend STOS. It's a flavour of BASIC specifically designed for creating games.


I used DevPac all along for assembler and GFABasic for the tools. I remember that the Omikron basic was very popular in Germany. A lot of people starting had hopes with STOS, but I never got into it.


During my Atari times (from Mega-S2 to TT030) I used mainly these 3 programming languages/environments:

  • GFA-Basic. Nice structured Basic with complete features for sound and graphics. Integrated IDE and cheap compiler. Was updated also to run on TT and Falco (Omikron BASIC the other widespread Basic variant on ST was much more problematic in that regard).
  • ST-Pascal from CCD. Good solid Pascal not Turbo compatible but good enough to do all my work for University at that time. No integrated IDE, I used the text editor Tempus which was the best text editor on ST.
  • Turbo-C/Pure-C. Yes, Borland had ported Turbo-C to the Atari-ST. Borland sold later the product to the German company ASH who renamed it Pure-C. It had the best code generator of all C compilers. It was also one of the few C Compilers on the platform that were ANSI-C89 conforming. The IDE with its project management was excellent and was updated also for TT and Falcon. I used it professionally for embedded things long after Atari faltered.

Oh common, you people just can't seem to take any kind of joke.

All the tools I referenced in my previous post were real.

Even thought Signum debugger was not used by many people and largely forgotten it seems. Probably for that name was also used by a virus and a well known unrelated tool.

As I wrote, Signum debugger was a text based assembly debugger working very much like the command line debug on DOS based systems See: https://en.wikipedia.org/wiki/Debug_(command)

Remember that there was no internet at that time, even BBS were a relatively "high-end" new thing and not many people used modems back then. Softwares were sometimes bought in shops but most often copied from a friend to another friend and then another...

A simple file edit could have given several names to this tool, hard to tell for the lack of other source of information... I myself barely used it in the late 80's before I got my hands on DevPac's MonST debugger which had a lot more friendly user interface.

My joke regarding the C language revolved around the fact that most developers used DevPac which was centered around 68k assembly programming.

And the acronyms group names were a reference to things like TCB, TNT, TLB that were kind of big names on this platform at that time.

GFA basic was also used indeed but mainly for tools I believe. For that matter I also remember that there also was a GFA assembly / debugging tool around released in 1988 IIRC.

Which I remember seeing people use at Ocean for the development of the Atari-ST version of Pang! (A game with balloons bouncing around that you had to pop)

A-Debug was a tool released by Brainstorm and was an improvement on Devpack's MonST in various ways. Its most useful feature was to be able to run entirely without the Atari's system and with every interruptions disabled (IPL:7)

As long as the memory containing the program itself was not overwritten. There was no programmable memory protection of any kind at that time, only hardcoded stuff in the MMU. And every program had to share the same flat, fixed addresses memory space.

I'd say that 90% or more of applications were written in Assembly mainly using DevPac. Regarding C (Turbo C was the tool IIRC?) it was probably making the bulk of the relatively small remaining part.

There also was the STOS which I got with my first Atari-ST. But I barely ever used it see: https://en.wikipedia.org/wiki/STOS_BASIC

You need to take into account that compilers at that time were not particularly good at any kind of optimization and running on extremely limited computers compared to today's standards.

I.E. 8mhz processors with a two byte cache (prefetch), requiring a minimum of 4 cycles per instruction and sharing the only bus with the chip in charge of the display (not even a "blitter" (as per STF versions at least, STE had a small one) to do any kind of graphic operation, no just a chip to actually send the pixels to the monitor's screen, a "shifter")

Add to this the fact that everything, The dynamic data used by the bios, xbios, higher TOS functions (Trap#1) and eventually the GEM on top of any program including all of its data, had to fit in an astounding 0.5 Mega bytes of memory... Guess why people were using assembly programming to squeeze every ounce of performance they could...

I reckon that this is kind of an old thread and could be seen as necro, however this is related to computers that are soon to be a 40 years old topic...

Anyway, enjoy yourselves.

  • 1
    You have managed to edit this post 52 times in 2 hours. This must be some kind of record.
    – Chenmunka
    Commented Dec 11, 2022 at 11:44
  • 2
    And no, jokes tend to go down badly on all SE sites. Except perhaps astronomy.meta.stackexchange.com/q/323/44406
    – Chenmunka
    Commented Dec 11, 2022 at 11:46
  • Atari St: I used Megamax C. There was also Mark Williams C and Lattice C. My impression though is that most games were written in assembler. I had one but I can't remember its name.
    – JeremyP
    Commented Dec 11, 2022 at 16:14
  • Please do not vandalise posts in this manner.
    – Chenmunka
    Commented Dec 12, 2022 at 8:54

You must log in to answer this question.

Not the answer you're looking for? Browse other questions tagged .