Gepard – Part Six: The Software

Let’s talk about the software in the order in which it was developed. We therefore start at the beginning (in Gepard terms): the Modula-2 compiler.


One cannot talk about the Gepard story without mentioning its Modula-2. Following the Zeitgeist (and Apple) not only should the operating system of the Gepard be written in Modula-2, but this computer language was also foreseen as the system language, the main application language, and the shell/batch language. This meant e.g. that all hardware was accessible to Modula-2 languages, by providing corresponding libraries.

The Modula-2 compiler was initially written by Jürgen Müller (who did not have much experience in this matter) directly in Assembler. The development started as a cross-assembler project on an Apple II. As soon as enough developer systems were produced, the development was moved to a Gepard itself, and as soon as no Apple II (or C64) was needed anymore, everything was done on the Gepard itself. As a result of being developed in Assembler, the compiler was very fast at compiling code (one Gepard manager believe it to be the fastest M2 compiler at that time in the world). As a result of the main programmer being not that experienced in that area the compiled code was not that fast (although the comparison of the Gepard Modula-2 to any Apple II compiler went of course very well for the Gepard as proven by the original comparison from 1985(?) below).


source: 68000=news Nr. 6

Users of the Gepard Modula-2 also often mentioned the completeness of the compiler positively. Being the main system language, it even featured an inline assembler.

Jürgen Müller received a royalty of 22.50 DM per Gepard for the compiler.

Later on, the Gepard M2 was ported to the Atari ST under the name “Megamax Modula-2” by Thomas Tempelmann. It was then distributed by “Application Systems Heidelberg”, which was funded later on by another former employee of Gepard. The initial version was mainly a pure port of the original Gepard version, later issues had improved features. The lower execution speed of the compiled code was also mentioned in comparative reviews of different Atari ST Modula-2 compilers.

However, the Modula-2 compiler was certainly the main reason to buy a Gepard before OS/9, because there was simply no other language you could use (except Assembler) nor any standard binary format of a program that could be executed.

The (original) Operating System: GDOS

The focus on a programming supporting software system continues on the User Interface side: it is a clone of the UCSD Pascal UI. It is all text, no mouse pointer nor windows in sight. All you have are a fixed set of commands that you reach by typing a single key. Some of the commands are displayed in the first line of the screen. If you branch into one command (which is an application on the top level), you have another set of sub command, some of which are displayed on the top.

Some of thes applications on the UI level are: Editor, Compiler, Monitor, Filer (a program that can do things with files).


This is a strange version “1.4cv”

One could argue that it would have been better to use a standard Operating System, but apart from Unix (which basically required a harddisk) there was not really one. The was CP/M-68k, but this was hardly standard and would have offered only a few advantages while being costly.

However, the lack of Unix was probably *the* problem that prevented the success of Gepards in the professional area after the Atari St and the Amiga had killed the private market for the Gepard. If it would have offered Unix, a Gepard would have been probably a cheaper alternative to “professional” 68000 computers, especially after having finished the development of the 68020 cards.

During the time of the Gepard company, GDOS was developed up to version 1.3*. Version 1.4 was finished after the Gepard company went bust. It was developed by Thomas Tempelmann, who tried to convince Gepard users to pay him some money for the version because the development was no longer financed by Gepard. It is not completely clear to me whether 1.4 was the last “official” version of GDOS because I have a version 1.5 from the floppy disk remainders owned by Jürgen Müller, who was obviously part of the special interest group GDOS maintenance who is mentioned on the splash screen of version 1.5.

A much more capable version of GDOS was always in the planning, even at the time of the Gepard company. A corresponding, much improved version of GDOS was later on published as “GDOS 2.0″ (and later on called OS/Science”) offering e.g. multitasking, different fonts, etc. However, as far as I can tell, this was never delivered with later Gepards, but needed to be bought as a separate software for DM 400.

Application Software

There wasn’t much application software as far as I can tell.

There was Gepard’s own editor (GepStar, a WordStar-like program) and Gepard’s own spread sheet program, GepCalc. Initially sold separately, it was later on bundled with GDOS 2.0.

There was Gepard’s own PCB layout program, PlaTool, which Gepard used itself to design new cards.

Then, there was a small catalogue of little tools like GepTerm, a terminal program, a disk with utilities, one with test tools, disks with Modula-2 libraries for mice and graphic tablets, the GDC graphics, and the graphics of the 80-characters-card. There was a small sampler program, and two disks with samples.

For GDOS, GepStar, GepCalc, and the Boot ROM images, you could also get the source code.

The other Operating System: OS-9

OS-9 is a Unix-like multi-user, multi-tasking operating system originally developed for the Motorola 6809 processor by a company called Microware Systems Corporation. It was originally developed from 1979 as the operating system for the BASIC09 project fundedy by Motorola. At that time it was used mainly for TRS-80 Color Computers, and Dragon computers (requiring a floppy disk drive). In 1983, OS-9 was ported to the Motorola 68000 CPU.

In contrast to most operating systems, OS-9 was sold mainly as a 3rd-party-product that needed to be purchased by the users. Therefore, also the Gepard version of OS-9 was sold for about DM 750 from about the end of 1986 onwards. At Gepard times it had a small but active community including an own newsletter. On the Gepard, OS-9 uses its own file system and cannot be copied by GDOS tools.

You can still get OS-9 for many computers today.

Even if you cannot copy OS-9 using GDOS, you can copy it using OS-9. First, boot OS-9. As the user name, use an empty string, i.e. just hit ENTER. Now, you can format a new floppy disk with format /d0 (if you want to use the first drive) or format /d1 (for the second drive). Using the backup command, you can copy disks. For a cheat sheet of OS-9 commands, look onto the last page of this file.

Software, that did not really make it

CP/M 68k

This actually appears in the 1986 price list including a C compiler for DM 1225. I know someone who claims that he actually tried it. However, I do not know anybody who claims to have actually used it. Technically, it would not have been impossible to actually port it. Most probably, the price was basically determined by the license fee and it offered not that much of a benefit compared to GDOS.

PC DOS 2.1/GemDos

In 1986, in the aftermath of Gepard Computer GmbH going bust, someone asked for subscriptions to a project that wanted to port GemDos to the Gepard. It would include PC DOS 2.1 and the GEM Desktop and would cost DM 499.- If 100 users would subscribe, they would buy the license from Digital Research and start porting the software. I never read anything about this project again, so probably the 100 subscriptions never happened. Also, it seems a little bit like a stretch to port PC DOS to the 68000.


Elan (Education Language) is a programming language that was developed in 1976 in Germany. The Operating System to run it was called Eumel. Like the GemDos porting project, this was an attempt by an individual to open the Gepard to other software worlds. Like GDOS was written in Modula-2, Eumel was mostly written in Elan. The price for a multi-user version would have been DM 750.-, but like the GemDos port, this project seems to have never materialised.


3 Responses to “Gepard – Part Six: The Software”

  1. Gepard – An early German 68000 hobbyist workstation | Rare & Old Computers Says:

    […] the software […]

  2. Jürgen Says:

    Jürgen here, the compiler author. Yes, I indeed was (and still am) not an experienced compiler architect: No formal training, but I had read a book about it! 🙂

    But the main reasons for the not-so-efficient code the compiler generated were more due to design constraints than to greenness — or so I like to believe… (a) single-pass compiler, (b) focus on fast compile time, via a compiler written in assembler, and (c) “time-to-market” pressure. (Did that term even exist back then?)

    Using registers for temporary storage was completely out of scope, let alone optimizing their allocation. I did implement simple “peephole” optimization, to eliminate redundant store-and-recall operations, but that was about it. The floating point routines made up for a lot, if math was what you were after: double precision (64 bit) and quite fast indeed.

    Thomas Tempelmann later made some significant improvements, after he fully took over the maintenance of the “Megamax” version of the compiler. Later versions (1990 or so?) did catch up with the competition in terms of code speed, and credit for that goes to Thomas.

  3. Jürgen Says:

    At the risk of talking to myself here, two further supplements to the article above.

    Development of the Modula-2 compiler did indeed start on the Apple II, using the “Phase Zero” cross assembler. But early testing was done on a real 68000, using the “DTACK Grounded” board I had imported from the US. It was connected to the Apple in much the same way as the Gepard would be, in its initial “umbilical cord” version. A whopping 96k of stating RAM and an 8 MHz 68000, at a price I’d rather not think about today… And probably an even more exotic piece of computing equipment than the Gepard.

    A really nice aspect of the compiler, and the GDOS operating system, was that they made full use of the modular concept which gave Modula-2 its name. At compile time, the compiler only needed to know the “Definition Modules”, which specified the interfaces of any modules the programmer wanted to use. The corresponding “Implementation Modules” could be compiled separately, and were dynamically linked to the main program only when that program was loaded and executed.

    The Implementation Module could be changed and recompiled later. As long as the new implementation was still compatible with the same Definition Module, no recompilation of the main programs was necessary. The compiler kept track by assigning a “fingerprint” to each Definition Module, which the implementation module and any main programs referred to.

    Since all of GDOS was written in Modula-2 (with critical routines in inline assembly), this “dynamic loading and linking” also extended to operating system calls. There were no separate vector tables or other calling mechanisms; user programs would refer to OS functions by incorporating the respective modules, with interfaces specified in Modula-2 Definition Modules. Niklas Wirth would have been proud of us… 😉

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s

%d bloggers like this: