GFA Basic

GFA Basic (written GFA-BASIC by its publisher) is a BASIC dialect created by Frank Ostrowski at GFA Systemtechnik in Düsseldorf. It shipped for the Atari ST in the summer of 1986, and by comparison the ST BASIC that Atari bundled with the machine was slow and buggy. GFA Basic dropped line numbers and added Pascal-style procedures with local variables. Its editor checked syntax as you typed, and its interpreter was among the fastest on the machine. It quickly became one of the most widely used BASICs on the ST. By May 1988 Antic said most of its ST programs were written in it, and it was the language of many magazine listings, shareware utilities and game-development tools. Ports followed for the Commodore Amiga, MS-DOS and Windows. A 32-bit Windows version is still maintained by a small user community four decades later.

History & Origins

From Turbo-Basic XL to the ST

Ostrowski’s story begins on the Atari 8-bit computers. A 1988 Happy Computer profile says that after school and military service Ostrowski was unemployed for three years. Turbo-Basic XL, a fast replacement for Atari BASIC, was written in that period. The German magazine Happy Computer published it as its “Listing des Monats” (listing of the month) in December 1985, with a 2,000-mark prize.

The listing caught the attention of Integral Hydraulik, a Düsseldorf company. According to Clemens Weller’s Computer History Online, Ostrowski started there as a salaried programmer on 3 February 1986, with the specific aim of writing a BASIC interpreter for the new Atari ST. Weller names the employer as Integral Hydraulik, “later GFA Systemtechnik”. GFA Systemtechnik GmbH is described by the English Wikipedia as a company in Kiel and Düsseldorf whose name stands for Gesellschaft für Automatisierung (“Company for Automation”). A near-final GFA-BASIC was already on show at CeBIT in spring 1986.

1986: three releases in six months

Weller’s chronology gives a remarkably fast schedule:

ST-Computer visited GFA on 14 December 1986 and described the period as “a year of the most intensive programming work (GFA-BASIC and compiler)”. The visit confirms that version 2.0 was in wide use and the compiler was new. GFA’s Rolf Hilchner told the magazine that about 15,000 copies had been sold in Germany alone, all without copy protection. He argued that copy protection made professional work, such as running from a hard disk, impossible.

Later community material is inconsistent here. The “About” page of the current GFA-BASIC 32 site says the first version was released in 1985. The contemporary 1986 sources above put the first shipment in June 1986, and this page follows them.

MichTron and the English-speaking market

In North America the product was published by MichTron of Pontiac, Michigan. Antic’s June 1987 review, by David Plotkin, described GFA BASIC as “recently brought to the U.S. from Germany”, priced it at $79.95 and called it “powerful and extremely fast”. It also said “the current manual is poor, although MichTron is rectifying this.” Reviewers on both sides of the Atlantic complained about the translated manuals. In START (January 1989) Plotkin wrote that the 3.0 manual “must be rewritten”. In the UK, the edition of the GFA compiler manual reviewed by Page 6 was printed on bright red paper to deter photocopying, and the reviewer reported that a photocopy turned out easier to read than the original.

Design Philosophy

GFA Basic was designed for programmers who had outgrown line-numbered BASIC but did not want the edit–compile–crash–reboot cycle of C on the early ST. Several principles stand out:

• No line numbers. Targets for GOTO or RESTORE are named labels.
• Structured control flow. IF/ELSE/ENDIF, REPEAT/UNTIL, WHILE/WEND and DO/LOOP were there from version 2.0. Version 3.0 added an else-if clause and SELECT/CASE.
• Procedures, not GOSUB spaghetti. Procedures accept parameters, can declare LOCAL variables, and can modify a caller’s variable through Pascal-style VAR parameters. A procedure runs only when it is explicitly called.
• The editor as a syntax checker. Each line is tokenized and checked when you leave it. If it has an error, the bell sounds and you cannot move on until it is fixed.
• Direct access to the machine. GEMDOS, BIOS and XBIOS calls, Line-A graphics, raw memory access and calls to machine-code routines were all available from BASIC.

Éric Chahi, who built the tools for Another World in GFA Basic, summed up the appeal: “No compilation, a well structured code with functions and local variables, and the ability to call assembly code.”

Key Features

Language

A small example in the GFA-BASIC 3.x style (illustrative and untested; there is no runnable GFA Basic environment on this site):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

' GFA-BASIC 3.x: no line numbers, procedures and functions
FOR i%=1 TO 5
  PRINT i%,@square(i%)
NEXT i%
greet("Atari ST")
'
PROCEDURE greet(who$)
  LOCAL n%
  n%=LEN(who$)
  PRINT "Hello, ";who$;" (";n%;" characters)"
RETURN
'
FUNCTION square(x%)
  RETURN x%*x%
ENDFUNC

The START review of version 3.0 lists the ST variable types as byte, boolean, word, integer, floating point and string, all usable in arrays. Variable names carry their type as a suffix: i% is an integer and who$ a string, while a bare name is floating point. Version 3.0 also added:

• Multi-line functions (FUNCTION … ENDFUNC) alongside the older single-line DEFFN.
• SELECT/CASE with single values, ranges, lists and a DEFAULT branch.
• INLINE, which reserves space inside the program file itself for data such as a picture or a block of machine code, so the data is saved and loaded with the listing.
• Timer-driven procedures. EVERY runs a procedure at fixed intervals and AFTER runs it once after a delay.
• Tracing. A user procedure can be run after every statement, and the system variable TRACE$ holds the text of the command being executed.

GEM integration

GFA Basic made the ST’s GEM desktop accessible from BASIC. Programs could install drop-down menus, open windows, show alert boxes and file selectors, and process events through the ON MENU mechanism and the MENU() array. In version 3.0 almost every AES and VDI call could be used by name, so programmers no longer had to remember function numbers.

Interpreter, compiler and run-only runtime

The system came as an integrated editor and interpreter, a separately sold compiler that produced stand-alone programs, and a freely redistributable run-only interpreter for tokenized programs.

Speed, with context

GFA Basic’s reputation rested largely on speed. START (October 1988) published benchmark timings for the ST BASICs then on sale. The benchmarks were written with similar code in each dialect and used the same set of tests, and the magazine warned that they indicate relative speed rather than optimized performance. Selected interpreted timings, in seconds:

The 3.0 figures came from a run-only test package supplied by MichTron before release. Part of the interpreter’s early speed came from a trade-off. ST-Computer noted in 1987 that version 2.0 had no double-precision variables and worked to about 11 significant digits.

Evolution

Version 3.x on the ST

GFA-BASIC 3.0 (1988) was described in START (October 1988) as a “completely new implementation” that would still run any 2.0 program, adding “more than 300 new commands” and packaged with a resource construction set. ST-Log (February 1989) explained that the file format had changed, so old programs had to be saved as ASCII and merged in to re-tokenize them, and that the default extension changed from .BAS to .GFA. START’s January 1989 review put the manual at over 600 pages. 3.5 (by early 1990) added matrix operations. The last version GFA published for the Atari line was 3.6 TT, adapted to the Atari TT.

Atari users kept the 3.6 line alive after official development stopped, even without the source code. The German Wikipedia describes them replacing library modules piece by piece and binary-patching the interpreter and IDE. Lonny Pursell’s GFA-Basic Editor (GBE) and RUN! Software’s RUN!Lib and RUN!Only interpreter came out of this work.

Amiga

An Amiga version followed the ST original. EDM2 dates the port to 1988, but no 1988 Amiga release was confirmed for this page. A Usenet review of the Amiga GFA BASIC 3.5 interpreter and compiler gives UK prices of £49.95 and £29.95 through GFA Data Media (UK) Ltd. The reviewer praised its access to the Exec, Intuition, DOS and Graphics libraries but criticized the translated manual. The review called the first Amiga version its author saw, 3.041, fast but too buggy to be useful.

MS-DOS and Windows

A December 1990 message on the GFA NET bulletin board says the MS-DOS interpreter “has been released in Germany and Holland”, with no compiler yet. The writer also said versions for OS/2, Windows and Unix existed. EDM2 lists a GFA-BASIC for OS/2 1.0 (1990) and a SCO Open Desktop version, but only the DOS and Windows versions are confirmed by product reviews found for this page.

GFA Basic for Windows 3 was reviewed in Dr. Dobb’s Journal in April 1992 at $295 from GFA Software Technologies Inc. in Salem, Massachusetts. The reviewer found that apart from about 25 Windows-specific commands the language was compatible with its DOS counterpart. The review also compared it with Visual Basic: GFA Basic kept a procedural, event-loop style built on ON MENU and the MENU() array, while Visual Basic required a fully event-driven model. The 16-bit Windows line ended at version 4.38, according to the German Wikipedia and EDM2.

GFA-BASIC 32

GFA-BASIC 32 for Windows 95 and later broke with the interpreter-plus-compiler model. Code is compiled to machine code even when run from the IDE. The window and dialog handling was redesigned to be much closer to Visual Basic, and integers widened from 16 to 32 bits. Projects are single .g32 files holding code, forms and resources. The last commercial version, 2.30, is dated 25 July 2001 by the German Wikipedia.

Decline of the Company

GFA Basic lost ground on the ST by the mid-1990s to C and Modula-2 compilers such as Pure C. Critics cited system libraries that misbehaved under newer operating systems and an editor that was not a proper GEM application. Thalion’s Richard Karsmakers noted that versions up to 3.6 did not run at all under MultiTOS.

On Windows it competed directly with Visual Basic. Sources differ on exactly when GFA Software Technologies went under. EDM2 says the company went out of business in 2001. The German Wikipedia says it stopped responding to orders and support requests from late 2002 and switched off the official mailing list without warning in summer 2005. According to the German Wikipedia (citing AtariWiki), Frank Ostrowski died in 2011, aged 50, after a serious illness. The source code of the Windows versions is reported to be lost.

Current Relevance

GFA Basic survives in two communities:

• Windows. Since about 2006 a small group has maintained GFA-BASIC 32 without the original source. Releases come through the site of Sjouke Hamstra, author of Programming in GFA-BASIC for Windows (1996). Releases are a free, fully functional download. Build 2.62.2628 is dated 9 April 2026, and the GFA-BASIC 32 blog was still publishing programming articles in March 2026.
• Atari. GBE (still maintained as of 2022, according to the German Wikipedia) and other patched 3.6-based tools remain in use by Atari ST/TT and emulator users, and GFA listings are a large part of the platform’s preserved software.

GFA Basic also has descendants in syntax. X11-Basic, a free cross-platform interpreter and compiler, states that its syntax is “most similar to GFA-Basic on the ATARI-ST”. There are also converters from GFA 3 listings to Java and from 16-bit GFA-Windows source to VB.NET.

Why It Matters

GFA Basic showed that BASIC on a home computer did not have to mean line numbers, GOTO and slow execution. It delivered a structured, procedure-based BASIC with a syntax-checking editor and real access to the GUI, and it was fast enough for commercial work.

On the Atari ST it became the default language for hobbyists and magazine type-ins. It also served professionals who needed tools quickly: the polygon editor behind Another World and the data editors behind Thalion’s Amberstar were both written in it. It is also one of the few home-computer BASICs whose 32-bit Windows descendant is still being updated in 2026.