Lisaac

Lisaac is a statically typed, compiled, prototype-based object-oriented language created by Benoît Sonntag at LORIA (the Lorraine computer science laboratory, then attached to INRIA) in Nancy, France. It was designed for exactly one purpose at first - to write Isaac, an experimental operating system in which every hardware device, driver, and kernel service is a prototype object - and it grew from there into a general-purpose language with a self-hosting compiler. Its makers described it as “the first compiled prototype-based language really usable”: it takes the object model of Self, where objects are cloned rather than instantiated from classes and parent slots can be reassigned at run time, and combines it with Eiffel’s static typing and design by contract, then compiles the whole thing, through aggressive whole-program analysis, to plain ANSI C. Lisaac never found an audience beyond a small French research and hobbyist community, but its compiler was a serious piece of work whose results were published in Software: Practice and Experience, and the language has recently been reborn as Lisaac Ω (Omega), a visually edited successor still developed by the same two people.

History & Origins

An operating system made of prototypes

The Isaac project started at LORIA around 2000 as Sonntag’s doctoral research, supervised by Dominique Colnet - the author of SmallEiffel/SmartEiffel, the GNU Eiffel compiler, and a leading figure in whole-program compilation of object-oriented languages. The premise, stated in the Lisaac manual, was that operating systems were rigid because they were written in low-level languages like C, and that the flexibility of a prototype-based object model - especially dynamic inheritance, where an object’s parent can be swapped while the program runs - fit the construction of an operating system unusually well. A driver could inherit from a generic device object and switch its parent to a different implementation on the fly; the kernel could be composed of objects rather than tables of function pointers.

No existing language was suitable. Self had the object model but was a dynamically typed, JIT-compiled research system with no path to bare metal. Eiffel had static typing and contracts but was class-based. C had the hardware access but none of the abstraction. So Sonntag designed Lisaac (“the language for Isaac”) as, in the manual’s words, “a subtle mix of Self and Eiffel, with the addition of some low-level capabilities of the C language” - interrupt handlers, memory-mapped structures, and inline external code as first-class language sections.

The first Lisaac compiler was written in Eiffel and built with SmartEiffel, which is where the compilation strategy came from: SmartEiffel already compiled under the closed-world assumption (all source code known at compile time) and eliminated most dynamic dispatch statically. Lisaac took that base and added type-flow analysis. In January 2004 the compiler was translated into Lisaac and bootstrapped, after which the project was independent of Eiffel.

Publication and release

The language was first described in print in 2002, at TOOLS Pacific in Sydney (“Lisaac: the power of simplicity at work for operating system” - the subtitle a nod to Ungar and Smith’s Self paper, “The Power of Simplicity”) and at an ECOOP workshop on object-oriented operating systems. Sonntag’s thesis, defended in 2003 at Université Henri Poincaré Nancy 1, presented Isaac as “the first truly operational operating system entirely based on prototype-based object technology”, and version 0.1 of the bilingual French/English reference manual is dated September 2003.

Public releases came slowly. Version 0.084 was announced on the French Linux news site LinuxFr in November 2005, at which point the standard library was LGPL but the compiler remained INRIA-owned and free only for non-commercial use; the announcement mentioned that Sonntag had consulted Richard Stallman about how to protect the compilation techniques. Debian packaged 0.84 in mid-2006. The decisive change came on 24 September 2007, when Lisaac 0.12 - a complete rewrite after a year of work - was released under the GPLv3 alongside language specification 0.2. Version 0.13.1 followed in February 2008 and 0.39 beta in November 2009, the latter extending the compiler from 32-bit-only to 16-, 32-, and 64-bit targets and switching its output from GCC-flavoured C to portable C89.

Slowing down

After 0.39 the project entered a long, quiet period. Debian’s 0.39~rc1 package, uploaded in March 2011, was the last upstream version the distribution ever received. A community member began Lysaac, a from-scratch reimplementation of the compiler, in January 2011, but it stalled; its last commits date from 2015. The IsaacOS sources - already abandoned since about 2008 - were dumped on GitHub in June 2013. The main scientific output of the period was the Software: Practice and Experience paper with Colnet (published online in November 2012 and in print in 2014), which is effectively the definitive description of the compiler, followed by a companion paper on garbage collection and array type analysis (online 2014, in print 2015).

Sonntag did keep working. Manual version 0.4 is dated December 2018, a 0.4 and then 0.42 compiler appeared around 2018-2019 (French Wikipedia dates 0.42 to October 2019), and in July 2019 a community archive of every release from 0.072 through 0.42 was placed on GitHub. But by then the language had no users to speak of, and Debian eventually removed the package from testing in August 2024.

Ω

The revival came from a new direction. In August 2024 Sonntag and Colnet posted “Omega: The Power of Visual Simplicity” to arXiv, presented the next year at the FICC 2025 conference. Ω keeps Lisaac’s semantics - prototypes, static typing, contracts, slot access rules, user-defined operators - but abandons the idea that a program is a text file with a context-free grammar. Ω code is stored as UTF-8 text so that Git still works, but it is meant to be edited only through a structure editor, Elit, that has global knowledge of the whole program and can therefore resolve notation that no LL or LR parser could. The pitch is that ordinary domain notation - mathematics, physics - should be usable directly, and that “the first symbolic 2D graphic language” can end “religious wars concerning syntactic choices”. The official repository, opened in September 2025 as lisaac-omega/lisaac under the GPLv3, ships the compiler, Elit, and a library with graphics, audio, crypto, and even an Arduino directory; the web site calls the system Lisaac Ω, positions it as the continuation of Lisaac, and lists version 0.6 in 2026.

Design Philosophy

Lisaac is built on a handful of commitments that the manual and papers repeat consistently:

• Everything is an object, and objects are prototypes. There are no classes. A prototype is a named object with slots; new objects are made with clone. Even integers, characters, and booleans are prototypes (INTEGER, CHARACTER, TRUE, FALSE), implemented as expanded objects in the Eiffel sense so that they occupy no heap storage.
• Compiled objects stay objects. The manual insists that “compiled objects remain objects with all their capabilities and expressivity preserved” - dynamic inheritance, late binding, and blocks are all available at run time; the compiler’s job is to make them cost nothing when the program does not actually use them dynamically.
• Static typing and contracts from Eiffel. Every slot has a declared type, redefinitions must keep the same profile, and Require, Ensure, and Invariant assertions are part of the language, with a debug-level scheme that lets the programmer decide which assertions survive into a build.
• Almost no built-in control flow. As in Smalltalk and Self, if/else, loops, and do while are library methods on booleans and blocks, not syntax. The grammar of the language reportedly fits in about thirty lines. This works only because the compiler inlines blocks and removes tail recursion so thoroughly that library-defined loops compile to the same C goto loops a C programmer would write.
• System programming is not an add-on. Sections for memory mapping (Section Mapping), interrupt handlers (Section Interrupt), and external C (Section External, plus backtick-quoted inline C) exist because the language had to write a kernel.
• Closed-world compilation. The compiler sees the whole program. That assumption - inherited from SmartEiffel and shared with MLton for Standard ML - is what lets Lisaac resolve almost all message sends statically.

Key Features

Prototypes, sections, and slots

A Lisaac source file defines one prototype and is divided into named sections. The canonical “Hello, World!” from the compiler’s own examples shows the shape:

Section Header

  + name        := HELLO_WORLD;

  - bibliography:= "http://IsaacOS.com";
  - author      := "Sonntag Benoit ([email protected])";
  - comment     := "The first program.";

Section Inherit

  - parent_object:OBJECT := OBJECT;

Section Public

  - main <-
  (
    "Hello world!\n".print;
  );

The Section Header declares the prototype’s name and metadata; Section Inherit lists parent slots; Section Public (and Section Private, or a section naming specific prototypes that may access it) holds the slots that make up the object. Prototype names are written in capitals.

Every slot is prefixed with + or -. A + slot is local to each clone - it is an instance variable, and its prototype must be cloned before use. A - slot is shared by every object made from the prototype, like a class variable or a singleton. The same distinction applies to code slots: + methods are duplicated for clones, - methods are shared. A slot whose definition uses := is evaluated once, when the object is initialized; a slot defined with <- is evaluated on every call, which is how methods are written:

Section Header
  + name := COUNTER;

Section Inherit
  - parent_object:OBJECT := OBJECT;

Section Public
  + count:INTEGER;                     // per-object data, default 0
  - step:INTEGER := 1;                 // shared by every COUNTER

  - increment <-
  (
    count := count + step;
  );

  - value:INTEGER <- ( count );        // last expression is the result

Messages, blocks, and control flow

Message sends use Smalltalk-style keyword syntax with dots: io.put_string "Hi", list.add_last item, (a > b).if { ... } else { ... }. Curly braces denote a block - a delayed list of instructions with optional arguments, essentially a closure - and control structures are ordinary messages that take blocks. From the manual’s quick-start:

Section Header
  + name := DO_WHILE;

Section Public
  - main :=
  ( + gender:CHARACTER;
    io.put_string "Enter your gender (M/F) : ";
    {
      io.read_character;
      gender := io.last_character;
    }.do_while {(gender != 'M') && {gender != 'F'}};   // library-defined loop

    (gender == 'M').if {
      io.put_string "Hello Mister !";
    } else {
      io.put_string "Hello Miss !";
    };
  );

if/else is a method on the boolean prototypes, do_while is a method on blocks, and even && takes a block for its right operand so that it can short-circuit. Because the compiler inlines all of this, the generated C contains no closures or function-pointer calls for such code.

Inheritance: multiple, ordered, and dynamic

Parent slots live in Section Inherit. There can be several, and the lookup algorithm searches them depth-first in source order, so multiple inheritance conflicts are resolved by declaration order rather than by explicit renaming. What makes Lisaac unusual is that a parent slot is an ordinary slot: it can be given a value by an expression, and it can be reassigned at run time to change the object’s ancestry - the manual only forbids adding new parent slots dynamically or leaving one null. The Isaac papers use this to let a device object switch drivers or protocol layers by swapping a parent. Sending a message to a parent slot explicitly (parent_object.foo) is the equivalent of Smalltalk’s super or Self’s resend.

Design by contract

Preconditions and postconditions are written in square brackets before and after a slot body, using -? for requirements, +? for guarantees, and ? for plain assertions, each optionally followed by a message string. Old captures a pre-call value and Result names the return value, as in Eiffel, and contracts are inherited along with the slot. A debug level chosen at compile time (-d/-D on the command line) decides which assertions are checked:

  - item i:INTEGER :INTEGER <-
  [ -? {(i >= lower) && {i <= upper}} "Index out of range."; ]
  (
    storage.item (i - lower)
  )
  [ +? {Result = storage.item (i - lower)}; ];

Types, genericity, and low-level access

Types are static and declared after a colon. Generic prototypes are written ARRAY(CHARACTER) or HASHED_DICTIONARY(STRING, INTEGER), Expanded marks a slot or prototype as stored inline rather than by reference, and the standard library provides signed and unsigned 8- through 64-bit integers, fixed- and floating-point reals, an arbitrary-precision integer, strings, arrays, linked lists, dictionaries, sets, and file, image, and time facilities. For systems work, Section Mapping lays a prototype’s slots over a memory region so that a hardware register block can be treated as an object, Section Interrupt declares handlers, and Section External together with backtick-quoted inline C escapes to the host language. Specification 0.2 (2007) added methods returning several values at once and “alimentary” (non-typing) inheritance for mixing in behaviour without creating a subtype.

The compiler

The compiler is where most of the research went. Its strategy, as described in the 2012/2014 Software: Practice and Experience paper, is a three-step fixed-point computation over the entire program: first gather all live code and initial type sets, then repeatedly apply type-flow analysis (per variable, per instance slot, and - unusually - per array element) together with method customization, inlining, dead-code elimination, and dispatch-branch merging until nothing changes, then generate C. Dynamic dispatch is compiled to switch-style branching code rather than virtual tables, and objects are laid out with a compaction algorithm that reorders fields to shrink them. Null-pointer safety falls out of the type analysis: the compiler knows which expressions can never be null and only emits checks where they can. On the compiler’s own 53,000 lines of source, 98.3% of method call sites were resolved statically. The output is C89, so any C compiler can be the back end.

Evolution

The language itself changed most between 0.084 and 0.12, when the type system, contracts, blocks, numeric types, and memory manager were all redone, and again with 0.39, which was about portability rather than semantics. The manual also documents a “COP” (Concurrent Object Prototypes) model, introduced in version 0.3 of the specification (2007), though it is unclear how far it was ever implemented in the released compilers. Ω is a larger break: same semantics, entirely different surface, and a new editor as the primary interface.

Current Relevance

Taken as the classic text language, Lisaac is dormant. There have been no releases of the 0.x compiler since about 2019, the mailing lists and wiki are gone, the Debian package has been dropped, and the last community project around it (Lysaac) went quiet around 2015. The old compiler still builds from the GitHub archive with a plain make and a C compiler, and it is a rewarding artefact to study: a complete, self-hosting, whole-program optimizing compiler for a prototype language, with a 142-page manual and a detailed journal paper explaining how it works.

Taken as a lineage, the picture is different. Lisaac Ω is under active development by Sonntag and Colnet, with the official GitHub mirror syncing with the project’s ZIP releases dozens of times between September 2025 and mid-2026. The web site lists Linux, macOS, Windows, Android, WebAssembly, and Arduino as targets, and the repository carries a wasm directory and an arduino library, though how mature those ports are is not something an outside observer can easily verify. Ω’s audience so far is small - a handful of GitHub stars, French-language course material, and two academic papers - and its decision to abandon plain-text editing makes it a research bet more than a practical tool for now. But it means Lisaac is one of the rare “dead” research languages whose authors are still working on the same ideas twenty-five years later.

Why It Matters

Lisaac is the strongest existing answer to a question the Self group left open in the late 1980s: can a prototype-based language, with all its dynamism, be compiled ahead of time to code as tight as C? Self answered it with a JIT and an enormous runtime. Lisaac answered it with static typing and whole-program analysis, and the answer was mostly yes - competitive with C on real code (faster on some MPEG-2 output paths, slower on the raw decode), with method calls that were 98.3% statically bound and control structures defined in the library that compiled to the same loops C would produce. The techniques are the same family used by MLton (which the paper itself cites as its closest relative) and by the closed-world modes of modern toolchains, and Colnet and Sonntag’s two Software: Practice and Experience papers remain a readable, measurement-heavy account of them.

It also demonstrated something about operating systems. Isaac never became usable, but it was a working kernel written in a high-level, contract-checked, garbage-collected object language that treated interrupt handlers and memory-mapped hardware as objects - years before Rust-in-the-kernel made “systems programming in a safe high-level language” a mainstream conversation. And Lisaac’s habit of making every control structure a message send, then relying on the compiler to make that free, is a clear precursor to the zero-cost-abstraction slogan that Rust and modern C++ would later adopt.

Finally, Lisaac is a case study in how research languages live and die. It had one author, a small institution, a French-speaking community, a proprietary licence for its first five years, and a syntax that was easy to admire and hard to love. It was in Debian for eighteen years and still never escaped its niche. That its creators responded not by giving up but by throwing away the syntax entirely - deciding, in Ω, that the text file itself was the problem - is either the logical conclusion of Lisaac’s “power of simplicity” or the final proof that syntax was never the obstacle. Either way, it is a story worth knowing.