Clamiga: A Common Lisp Implementation That Runs on Your Amiga

Common Lisp has a reputation for being old but alive. The ANSI standard dates to 1994, yet the language still feels ahead of its time with CLOS, conditions, and macros. But if you're an Amiga enthusiast, you've been out of luck: none of the major implementations run on 68k. Manfred Bergmann decided to fix that with Clamiga, a Common Lisp implementation built for the Amiga family.

Clamiga is a self-contained bytecode VM written in portable C. It runs on classic AmigaOS 3 (m68k), MorphOS (native PPC), and also on macOS and Linux for development. The name is a portmanteau of CL (Common Lisp) and Amiga, and in Spanish/Portuguese 'amiga' means female friend—so it's the Lisp that's your friend.

Why Another Implementation?

Existing Common Lisp implementations are either tied to modern architectures (SBCL, CCL) or unmaintained (CLISP). None target the Amiga. Clamiga fills that gap with a design that respects the constraints of 68k hardware: 32-bit tagged values, a compacting GC, and architecture-agnostic bytecode.

The bytecode approach means the same compiled Lisp runs on both 68k and PPC, and FASL files are byte-compatible between AmigaOS 3 and MorphOS. The portable C core also means the same system builds and runs on macOS and Linux, making development practical.

Living with 4 MB

Memory is a constant concern on classic Amigas. Clamiga's full core—CLOS, conditions, numeric tower, format, loop—boots in about 0.5 MB of heap. Simple programs run with a 1 MB heap; ASDF needs 11 MB; Quicklisp plus libraries needs 24 MB. Packed byte vectors store 1 byte per element instead of a 4-byte tagged value, making I/O buffers and graphics data 4x smaller. Bulk sequence I/O moves whole chunks per OS call, and precompiled boot FASLs cut cold boot from ~92 seconds to ~9 seconds on a 68020.

The m68k JIT

On AmigaOS 68020+, Clamiga translates bytecode functions to native m68k code at definition time. The JIT covers integer arithmetic, branches, list operations, struct access, function calls, closures, and more. Unsupported instructions fall back to the interpreter transparently.

Benchmarks on an emulated A4000/68040 show significant speedups for compute-bound code: a fixnum loop runs 20x faster, struct-slot reads 13x, chained arithmetic 7.5x. Function-call-heavy code sees only 1.4x. A real-world graphics demo reaches 615 FPS with JIT versus 500 FPS bytecode—still below ACE BASIC's 1900 FPS, but that gap is the cost of a dynamic, garbage-collected, tagged-value language.

MorphOS and Quicklisp

The MorphOS build is a native PPC binary, not emulated. It omits the JIT (m68k-only) but runs the portable VM fast enough on a G4/G5 to make Quicklisp practical. Clamiga ships a compat layer and maintained library forks with #+cl-amiga feature branches, aiming to upstream them once API gaps close.

Clamiga is a serious effort to bring a modern Lisp to a retro platform. It's not for writing fast games, but for interactive development and learning, it's a compelling option.