The Magic of Lisp, The Speed of C: How ChrysaLisp Delivers Malleability Without Compromise

jay_bird · 5 December 2025 12:30

The title is copy-pasted from Chris Hines here:

docs/ai_digest/malleability.md

master

# Malleability

This is a fantastic topic that gets to the very soul of Lisp and why ChrysaLisp
was created. Explaining this "magic"—the blend of extreme dynamism with
hard-systems performance—is crucial. This document breaks down this concept,
using the philosophies and code provided as evidence.

Lisp is not Macros, it's not even Lists ! It is none of these things that you
have herd about when folks try to explain the power of LIsp ! It is
**malleability** !

## The Magic of Lisp, The Speed of C: How ChrysaLisp Delivers Malleability Without Compromise

For decades, a fundamental trade-off has haunted programming language design. On
one side stand languages like C++, C, and Forth, offering raw, predictable,
"close-to-the-metal" performance. They are static, rigid, and fast. On the other
side stands Lisp, the epitome of dynamic expression and malleability. Its core
principle of **homoiconicity**—where the code itself is represented as the
language's primary data structure (the list)—grants it a unique power: the
ability to treat the program as a piece of clay, to be analyzed, transformed,

This file has been truncated. show original

It starts going over my head a few paragraphs in, but I’m understanding at least that it’s an attempt to marry “extreme dynamism with hard-systems performance”. That link above is describing Chrysalisp, the lisp language that works inside the OS. For the OS, actually, I’ll just copy-paste Chris’ description:

ChrysaLisp is a unique, 64-bit, MIMD operating system designed from the ground up for parallel and distributed computing. It’s a complete, self-hosting environment featuring its own toolchain, a Virtual Processor (VP) for cross-platform portability, a responsive graphical user interface (GUI), a powerful command-line terminal with Unix-like pipes, an object-oriented assembler, extensive class libraries, a C-Script compiler for efficient low-level coding, a unique Lisp interpreter, an integrated debugger and profiler, powerful programers editor, and vector font engine.

And that there seems to be some very interesting ideas on Lisp - the fundamental data structure of Chrysalisp is the vector, rather than the cons cell.

I’ve ran Chrysalisp and it’s great fun. Can’t say I’ve delved too deep, but I have asked myself why it doesn’t get more traction from people into strange little wonderful systems, it’s really a bit of a marvel! It’s all there aha.

Interested in anyone’s thoughts on the system, to see if anyone has messed around with it. Cheers

neauoire · 5 December 2025 15:38

I did! A few years back, I made a couple of little apps, like clocks, color pickers and that sort of things. It’s quite nice.

Edit: Wow, my apps are still in the repo too!

jay_bird · 6 December 2025 19:14

Ok, I have seen that clock I believe

In my notes now is written:

uxn + chrysalisp

But I’ve no idea if that even makes sense (in either direction). Have yet to play with uxn. I love the things people are doing with it though, and imagine I’d only love it!

neauoire · 6 December 2025 19:38

I implemented a Lisp in Uxn yesterday, and I was shocked how nicely Lisp maps to a stack machine, I’ve written a couple of Lisp runtimes over the years(typically in algols), but nothing ever looked as nice as laying it all out on a stack.

jay_bird · 6 December 2025 22:25

I’d seen that you’d started it, but didn’t know you were done - I’m @jbc on mastodon. Also, hi @akkartik, who I was chatting to recently over there too!

Gawd, sounds fun, and the code certainly looks clean. Just browsed awesome-uxn after your message to see what new stuff is there, been a while since I looked… Holy moly, people have been busy making stuff!

khinsen · 7 December 2025 11:06

There’s another Lisp-without-cons: Clojure. Which shows that conses are not really that fundamental to the Lisp spirit.

Chrysalisp’s vectors look very much like Python lists. And reference counting also the basis of Python. Wondering if that’s a coincidence.

natecull · 14 December 2025 08:29

Interesting! I’ll have to take a look. Reminds me a bit of REBOL and Red, and and also that Taos essay from 1990 seems familiar.

Reference counting fails in the presence of mutable objects that can create circular references, doesn’t it? How does this project solve that problem?

Edit: Ah, it solves it by allowing cycles, but pushing the problem of “don’t create cycles or bad memory things happen” to the programmer. Also, it doesn’t have closures. Hmm. (That last one is I guess a bit like PicoLisp.)

Also, an empty list (vector) is not nil, but is “an error”. Another hmm.

Then it’s got a class-based object system as well, with multiple types of maps and sets.

Also it’s got Ruby-style (or is it Common Lisp style?) “keyword symbols” beginning with a colon, that always evaluate to themselves, in case plain Lisp/Scheme-style symbols weren’t enough. Macros, of course, and of course not any Scheme hygenic kind (probably just as well).

Also “character classes”, a sort of string-but-as-a-set kind of thing.

Numeric values seem to be 64-bit (three types: integer, fixed-point, non-IEEE floating point) and designed for 32-bit machines with no numeric coprocessor.

And then of course a whole OS built on top.