The ClaraOS logo: a sun

A small operating system for x86_64 and AArch64, written to be read from the first instruction up.

Those two lines at the top are what the kernel prints when it takes over from the firmware. ClaraOS is a Lisp machine in the making: a C kernel small enough for one person to hold in their head, under a world written in Common Lisp. It has a window manager, and a world that was saved in it boots straight into it; its applications are Lisp programs, a text editor and a file browser the first of them, each loaded from its file when it is first picked. It is not a Unix, and it does not try to run Linux software.

The substrate is the C kernel. It brings up the processor, hands out memory, runs threads, takes interrupts, and holds the Lisp runtime itself: the reader, the evaluator and the garbage collector.

The world is Lisp: the console and the REPL, the logic of the drivers, the filesystem, the window manager and every application.

One address space, one heap, no user mode. Lisp code cannot forge a pointer, so protection comes from the language and not from page tables. An application that fails is a condition for the window manager to handle.

The Lisp is a subset of Common Lisp, chosen so that every file also loads under SBCL on an ordinary computer, where it is written and tested.

The image is the system. The whole Lisp world can be saved to the disk, and a machine that finds it there starts from it, with everything that was defined. A world that was saved with the window manager running starts in it.

Version 0.0.18. 16 of 16 milestones are finished, the latest being M13, applications. A milestone counts as finished when the machine boots and passes its own checks on both architectures.

Substrate

  1. M0boot0.0.1
  2. M1console0.0.2
  3. M2physical memory0.0.3
  4. M3virtual memory0.0.4
  5. M4exceptions and interrupts0.0.6
  6. M5threads0.0.7

The Lisp runtime, in the substrate

  1. M6aobjects and reader0.0.8
  2. M6bevaluator0.0.9
  3. M6ccollector and conditions0.0.10
  4. M7Lisp in the driver's seat0.0.11

Devices and storage

  1. M8PCIe and virtio0.0.12
  2. M9disk and files0.0.13
  3. M10images0.0.14

The world

  1. M11drawing0.0.16
  2. M12the window manager0.0.17
  3. M13applications0.0.18

The roadmap says what each milestone holds and what was left open along the way.

The ClaraOS window manager at the end of a boot that started from a saved world. Along the top of the screen is a bar with the word Applications at its left end and ClaraOS and its version at the right. A window named Listener shows three forms that were typed on the keyboard, the second of them a loop without end that Ctrl-C stopped, answered with the words interrupted from the keyboard. Over its right half lies the window of the text editor, which has the focus: its title is the name of a file, /clara/hello.lisp, and it shows the thirteen lines of that file, a small application written in Lisp, with a row below them that says 13 lines, and line 1, column 1. Over the lower left corner lies the window of the file browser, Files in /clara/, with a list of names in it, the first of them picked: the way up, a file with a long name, boot.lisp, clara.image, console.lisp and more. At the lower right is a smaller window named A picture, with a picture in it: the title ClaraOS, five squares of colour and the words drawn in Lisp. The pointer, an arrow, is in the middle of the screen.
The screen of version 0.0.18 on AArch64 under QEMU, in a world that an earlier boot saved with the window manager running, after the boot test has typed its session: on the keyboard, into the listener's window, and on the serial port, whose last forms opened the window with the picture and launched the file browser and the editor, on a file that the boot before wrote.

On macOS with Homebrew. clang builds both architectures and QEMU boots them, with the same firmware UTM uses.

brew install llvm lld qemu sbcl
git clone https://github.com/the-clara-os/clara-os
cd clara-os
make test          # boot both architectures without a window
make run-aarch64   # a QEMU window, the serial port on your terminal: type a form

At the prompt, (clara.windows:start) starts the window manager in the QEMU window.

The user manual has the rest: running it in UTM, working at the prompt, files, saving the world, windows, and what to do when something goes wrong.