AmigaE

Amiga E (usually just “E”, and often written AmigaE) is a compiled, general-purpose programming language created by Dutch programmer Wouter van Oortmerssen for the Commodore Amiga. Work began in 1991, the first public release came in January 1993, and the last official version, v3.3a, shipped in October 1997. In the author’s words it was “an object oriented / procedural / unpure functional higher programming language, mainly influenced by languages such as C++, Ada, Lisp etc.” - and it was built to program the Amiga’s operating system directly.

E combined things that rarely lived together in a 1990s home-computer language: C-like low-level control with inline 68000 assembly, near-instant compilation, Ada-style exception handlers, single-inheritance objects with virtual methods, garbage-collected Lisp cells, and Prolog-style pattern matching. Van Oortmerssen later wrote that “Amiga E was a tremendous success, it became one of the most popular programming languages on the amiga.”

History & Origins

A one-person compiler in assembly

Van Oortmerssen, then living in the Netherlands, wrote E as a personal project, and the version table in the v3.3a manual traces its growth (minor bug-fix releases v3.0b and v3.0e are omitted here):

Some sources give September 1993 as E’s release date. That is when the AmigaE mailing-list archives were uploaded to Aminet. The author’s own table puts the first public release in January 1993, and an add-on GUI for using AmigaE, egui, was already on Aminet in March 1993.

The whole compiler, EC, was written in 68000 assembly language using the AsmOne assembler. Looking back, van Oortmerssen called it “the craziest software engineering exercise I have ever gone through (400kb of mostly uncommented assembly in a single source file, for a complex compiler).”

Going commercial

With v3.0a in July 1994 E “gets a price tag.” The public distribution stayed freely copyable, but it contained a demo compiler: by the v3.3a documentation, the demo refused to produce executables larger than 8 KB (the manual notes wryly that “this used to be 12k, yes. Guess why it has changed”). Registered users got the full EC executable, for a price the manual gives as 65 Dutch guilders (about US$40), through registration sites run by volunteers in several countries. The most important of them was Jason R. Hulance in England, who also wrote A Beginner’s Guide to Amiga E and whom the manual credits as “practically being the coauthor of the Amiga E package.”

Cover disks and popularity

E reached a much wider audience in December 1995, when CU Amiga issue 70 put the full registered v3.1i compiler on its cover disks together with a free 132-page printed guide. The magazine’s pitch centred on compile speed (“the compiler works extremely quickly! This means you don’t have to hang around for ages before you can actually run your programs”) and pointed to Paul Nolan’s Photogenics and Chad Randall’s icon editor as proof that E was “a real, professional programming language.”

The end of official development

v3.3a, dated 27 October 1997, was the last release. By then van Oortmerssen had moved to the University of Southampton, where he later completed a PhD in programming languages, and the Amiga market was shrinking fast. In March 1999 he made EC freeware and released its assembly source (the readmes are signed “march 1999”; his later homepage loosely dates the open-source release to ‘97). The source readme is candid about what it contained: “EC’s source code is terribly complicated, very badly programmed, and contains more long distance dependancies than any bit of code I’ve ever seen,” and “unless the modification you intend to make is absolutely trivial, writing the compiler from scratch would be a lot quicker.”

The 1999 release came with its own copyleft-style terms rather than a standard licence. Anyone redistributing a modified EC had to ship the modified source, give the project a different name with a version number above 3.3a, and credit the original. Van Oortmerssen’s current page nonetheless describes the compiler as open source under the GPL, although the 1999 readme only says the terms are “similar” to the GNU licence.

Design Philosophy

E was aimed at a very specific target: writing real Amiga applications quickly. The readme says “the Amiga implementation is specifically targeted at programming system applications,” and several design decisions follow from that:

• Compile speed over everything. The v3.3a readme advertises a speed of more than 20,000 lines per minute “on a 7 Mhz amiga”, and the manual says the same of “a vanilla A500” (a stock 68000 machine). This is the author’s own figure for compiling E source with EC on that hardware; no independent benchmark or test program is documented. Whatever the exact number, fast compilation was the feature reviewers mentioned first.
• The operating system as the standard library. Amiga system includes shipped as precompiled E modules (v39, then v40 in v3.2a), and library calls such as OpenLibrary() or AllocMem() could be made directly.
• Loose typing by default. Every value is basically a 32-bit LONG, and types are added only where they matter: for pointers into structures, strings, lists and objects. This keeps simple programs short while still allowing structured access to OS data.
• Borrow good ideas freely. Exceptions came from Ada, objects from C++, cells and quoted expressions from Lisp, and pattern matching from logic and functional programming. The manual’s appendix includes a section mapping E to C, C++, Pascal, Ada and Lisp.

Key Features

Syntax basics

E uses keyword-delimited blocks (PROC/ENDPROC, IF/ENDIF, WHILE/ENDWHILE) and := for assignment. Strings use single quotes, built-in functions are capitalised, and both /* */ and -> comments are allowed. The manual’s Hello World:

/* nominated for Most Boring Example */
PROC main()
  WriteF('Hello, World!\n')
ENDPROC

A procedure whose body is a single expression can be written with IS, and procedures can take default arguments and return up to three values:

PROC bla(a, b=1, c=NIL)      -> bla(x) is the same as bla(x,1,NIL)
  /* ... */
ENDPROC

PROC sincos(rad)
  DEF sin, cos
  /* whatever computation is needed */
ENDPROC sin, cos

-> caller takes as many results as it wants:
-> s,c:=sincos(3.14)

Exception handling

E’s exception mechanism, which the manual calls “basically the same as in ADA”, is attached to procedures with HANDLE and EXCEPT. Its most distinctive part is RAISE ... IF, which makes built-in or library functions raise an exception automatically when they fail:

CONST SIZE=100000
ENUM NOMEM
RAISE NOMEM IF AllocMem()=NIL

PROC main()
  alloc()
ENDPROC

PROC alloc() HANDLE
  DEF mem
  mem:=AllocMem(SIZE,0)       -> raises NOMEM on failure
  alloc()                     -> recurse until memory runs out
EXCEPT DO
  IF mem THEN FreeMem(mem,SIZE)
  ReThrow()                   -> unwind through every handler
ENDPROC

EXCEPT DO makes normal execution also fall into the handler, so it doubles as cleanup code. On Amiga, where the OS did not free a crashed program’s resources, this mattered a great deal.

Objects

OBJECT declares a structure; OF gives single inheritance; PROC name() OF type defines a method. All method calls are virtual, dispatched through a hidden class pointer that NEW installs. PRIVATE/PUBLIC control data hiding, END calls an end() destructor, and SUPER calls a parent’s method. The manual’s polymorphism example:

OBJECT loc
  PRIVATE xpos:INT, ypos:INT
ENDOBJECT

OBJECT point OF loc
  PRIVATE colour:INT
ENDOBJECT

OBJECT circle OF point
  PRIVATE radius:INT
ENDOBJECT

PROC show() OF loc IS WriteF('I''m a Location!\n')
PROC show() OF point IS WriteF('I''m a Point!\n')
PROC show() OF circle IS WriteF('I''m a Circle!\n')

PROC main()
  DEF x:PTR TO loc,l:PTR TO loc,p:PTR TO point,c:PTR TO circle
  ForAll({x},[NEW l,NEW p,NEW c],`x.show())
ENDPROC

Because Amiga system structures are ordinary OBJECTs in E’s modules, a program can even inherit from an OS structure such as Intuition’s gadget and add methods to it.

Lists, quoted expressions and unification

• Immediate lists such as [1,2,3] can be written anywhere an expression is allowed, so an Amiga tag list can be written in place, as in the manual’s [WA_FLAGS,1,WA_IDCMP,$200,WA_WIDTH,120,WA_HEIGHT,150,TAG_DONE].
• Quoted expressions (a backquote, as in `x*x*x) produce a pointer to code that can be run later with Eval() or passed to iterators like ForAll() and MapList(). The manual describes them as “parameterless (or global parameter only) lambdas.”
• Unification with <=> matches a value against a pattern and binds variables:

a:=[1,2,3]
IF a <=> [1,x,y] THEN WriteF('\d \d\n', x, y)   -> prints 2 3

Lisp cells

Starting with v3, E has “Conservative Mark and Sweep Garbage-Collected Lisp-Cells”. <a|b> conses a pair, <a,b,c> builds a list, and Car/Cdr take it apart, with cells reclaimed automatically:

PROC append(x,y) IS IF x THEN <Car(x)|append(Cdr(x),y)> ELSE y
PROC sum(x) IS IF x THEN Car(x)+sum(Cdr(x)) ELSE 0

Close to the metal

Assembly mnemonics can be written directly among E statements and share E’s identifiers, and binary data can be pulled in with INCBIN. From v3.2a, EC could compile a program straight into an Amiga shared .library. The distribution also included the EDBG source-level debugger, the EasyGUI toolkit, a preprocessor and utilities such as ShowModule and EBuild.

Evolution

After official development stopped, the released source and the language’s following produced a family of successors:

Current Relevance

The original Amiga E is historical: v3.3a has not changed since 1997, and the original compiler generates code only for 68000-family AmigaOS machines. It is still freely downloadable from Aminet (dev/e/amigae33a.lha, ec33a.lha, ec33a_src.lha), and van Oortmerssen’s site hosts the same archives. The full v3.3a manual and Jason Hulance’s Beginner’s Guide are online as HTML.

The language itself has not died. E-VO had several releases in 2025-2026 on GitHub, and PortablE lets E code run on newer Amiga-compatible systems. E-VO in particular still targets classic 68000 and 68020+ Amigas, compiling on the machine it runs on. No official Docker image exists, since the compiler needs AmigaOS (real hardware or an emulator) to run.

Why It Matters

Amiga E showed how much language a single determined programmer could fit into a small, fast, native compiler on a 7 MHz home computer. Objects, exceptions, garbage-collected cells, pattern matching and inline assembly all shipped in about 86 KB of hand-written 68000 code. Magazines such as CU Amiga promoted it to readers as a way to start writing their own programs, and it gathered a lasting community of mailing lists, modules and tutorials.

It was also the start of a notable career in language design. Van Oortmerssen went on to create the False esoteric language, the Aardappel and Bla research languages, the Cube and Cube 2 / Sauerbraten game engines (with Lee Salzman), Google’s FlatBuffers serialization library, and the Lobster game programming language. E’s mix of pragmatic low-level access with borrowed high-level ideas runs through much of that later work.