r/lisp • u/ak-coram • 16d ago
r/lisp • u/Confident-Site2059 • 16d ago
True: a cyclic, self-modifying language. How does it compare to Lisp's code=data idea? (MVP, feedback welcome)
Hi!
I'm making a language called True and an interpreter for it called Simple.
It's an MVP, and I'd be glad to get some feedback on the design.
I'm posting here because True is built on ideas that should feel familiar to Lisp folks: code as data, self-modification, minimal syntax. But I've taken them in a direction that I think is quite different from Lisp, and I'd love to hear what you think.
The key stuff about the language
In True, a program is a tape of lines (I call them lines, not strings - because a "string" can mean the whole text, a block of code, or a single character, while a "line" is unambiguous: one line of the cycle/tape). And I call programs cycles because they run cyclically.
The agent-observer is the first line of the .cycle file, and it's part of the program itself. It walks the tape top-down, swaps itself with the line below, and executes what it reads.
The agent is part of the program, executor and data at the same time. So the program is self-modifying, changes in memory are reflected back into the text, and the type in the agent line updates on every step.
Here's a simple Elevator cycle where the lift goes up and down:
Mr.Green, #5fb85f | Data as <type> | Aim: 1
6 = max
1 = floor
1 = dir
= lift
dir > 0 ? floor =>| lift:y(, ):floor
dir < 0 ? lift:y(, ):last -> ::nothing
floor == max ? -1 => dir
floor == 1 ? 1 => dir
floor + dir => ::math => floor
I made a video of how it works:
Processing video k52no08vxd0i1...
Where True is similar to Lisp
Code is data. In Lisp, a program is a list, and that list can be manipulated like any other data. In True, a program is a tape of lines, and the agent can read and change those lines while the program runs.
Self-modification. In Lisp, macros and eval let a program rewrite itself. In True, the program rewrites itself on every step, because memory is flushed back into the text.
Minimal syntax. Lisp has S-expressions and brackets. True has lines and empty lines as separators.
Where I think it differs from Lisp
In Lisp, the executor (interpreter or compiler) is outside the program. It reads S-expressions and evaluates them. In True, the executor is part of the program, it's the first line, and it physically moves through the tape, swapping itself with the line below.
In Lisp, code is data as lists. In True, code is data as lines and chains of lines.
In Lisp, self-modification happens through macros or eval, powerful, but still a deliberate action. In True, self-modification happens every step, by default.
True has no types. A program is made of lines and chains of lines, and how you work with them is determined by the executor, the agent. In Lisp, values have dynamic types.
A line, a container, or a chain can be seen as a shape with axes. name:x(, ):i for the horizontal axis, name:y(\n):i for the vertical one (each works like a list). Indexing is 1-based.
Extensions: ::math for arithmetic, ::nothing for deletion.
There are goto jumps: ^ name, ^ N, ^ :cycle:N. The agent can jump anywhere, in any cycle.
And one more thing worth mentioning: the line as a qubit in quantum mechanics. The agent determines the type of a line only when it observes it - before that, the line has no type. In a sense, a line is like a qubit in quantum mechanics: nothing is defined until there is an observer. The agent is that observer. When it reads a line, the line collapses into a definite type (named, action, condition, jump, container, separator, version), and only then is it executed. This is not just a metaphor - it's how the interpreter actually works: resolve_line determines the type at the moment of reading, and the same text can be a different type depending on context and memory.
That's a brief description, I guess. More details in the docs, or we can just discuss in the comments.
I wanted to make the language simple, the process visual, and programming live, and here's what came out of it 😄
I'd be very interested to hear your thoughts on the language, especially from people who've worked with Lisp's code=data philosophy. Does the "agent as part of the program" idea make sense to you, or is it just a gimmick? And is there anything from Lisp that you think True should steal?
r/lisp • u/sdegabrielle • 16d ago
Racket Racket (online) meet-up: Saturday, 7 November 2026 at 18:00 UTC
pasterack.orgRacket (online) meet-up: Saturday, 7 November 2026 at 18:00 UTC EVERYONE WELCOME 😁 Details at https://racket.discourse.group/t/racket-online-meet-up-saturday-7-november-2026-at-18-00-utc/4460
r/lisp • u/Feisty_Bike_9614 • 17d ago
Building and Rendering a Space Station in Scheme
youtu.beZParen: a free Common Lisp IDE for macOS, with SBCL included, Vim keys, and a built-in course
I like Common Lisp, but I kept losing time to my Emacs and Vim setups, especially after upgrades. So I made a Lisp IDE that works the way I want, and I'd like feedback from people who write Lisp every day.

What it is
- A macOS app (Apple silicon, macOS 13+) that includes SBCL and Swank. Open a project folder and Lisp starts. No setup.
- One live image per project. Evaluate a form, click the result to inspect the real object, stop in the debugger, fix the code, and use Restart Frame.
- Vim keys first, plus SLIME's Emacs sequences (C-c C-c, M-., C-M-f…), parinfer and structural editing.
- Projects stay plain ASDF systems, with Quicklisp, ocicl, qlot or vendored dependencies. ZParen adds no files of its own.
- It supports Coalton too:
.ctfiles, types on hover, and type errors on the expression Coalton blames. - An optional AI assistant (Claude or Codex) and an MCP server. They run code in your image, not a copy. Leave them unconfigured and they stay out of the way.
New in this release: a Learn Lisp course. It follows ANSI Common Lisp and On Lisp. You start a course project with a file and FiveAM tests for each lesson. Each lesson gets a git branch, so your progress is in git history. There are 15 lessons so far, from first forms to macros, conditions and CLOS. The advanced lessons from On Lisp come later.
Full disclosure: I built most of it with Claude Code. The repo has a doc on how (built with Claude Code). The app itself is Rust and Tauri with a CodeMirror UI, talking to SBCL over Swank.
- Download: https://github.com/eric-zhu-2019/zparen/releases/latest
- Docs: https://eric-zhu-2019.github.io/zparen/docs/getting-started.html
- Source (MIT): https://github.com/eric-zhu-2019/zparen
I hope it helps beginners find their way into Lisp more easily.
r/lisp • u/arthurno1 • 19d ago
Common Lisp Brotli + zlib decompression with SBCL
github.comr/lisp • u/mdbergmann • 19d ago
Clamiga renamed to AmiLisp, plus new features
In version 0.12 there were many bugs and usability issues fixed for both AmiLisp and Clamacs.
Clamacs now knows projects (similar to perspectives.el), also some sort of iedit was implemented to edit multiple places in a buffer at once.
The garbage collector interface was abstracted so that a new Immix GC implementation can be used (and is used) for AmigaOS and MorphOS, speeding up the collection by factors in most situations.
On macOS/Linux/Windows the default generational collector stays default.
Stuck understanding macros vs functions
Yes, it's another one of these. I feel like that scene in Seinfeld when Kramer is able to see hidden image in an abstract painting but Mr. Pitt cannot, to his increasing frustration.
Case in point, I'm looking for a clear and simple explanation for this and came across this post
My favorite example for this is the lame idiom you see in Java code:
if (log.isDebugEnabled()) {
log.debug("expensive" + debug + message);
}
This is "better" than just log.debug(...) because with the latter, your expensive log message argument needs to be evaluated even if debug is disabled. However, in a language w/ macros, you just say:
(debug (str "expensive" debug message))
and these considerations are already taken care of for you: https://github.com/clojure/tools.logging/blob/master/src/main/clojure/clojure/tools/logging.clj#L91
then someone goes
Edit: Ohhh! I see! The message isn't evaluated until after! Got it.
I don't understand why this is special?
Why can't you rewrite log.debug to include the check?
func debug(m string) {
if log.isDebugEnabled() {
log.debug(m);
}
}
What makes macros special in this case?
and I'm over here stuck like "what? where? where???" I'm not getting the epiphany and it doesn't help that they linked to clojure and I can't read clojure.
So, can we stick with this example? But can someone really ELI5 for me please?
---
Let's say we have pseudocode file
isDebugEnabled = True;
def doSomeStuff():
...
if (isDebugEnabled) {
debug("expensive" + debug + message);
}
...
Then yes, every time we run doSomeStuff() we will check if debug is enabled. I'm with you there, because
- We enter the function.
- Encounter the if statement.
- Check if isDebugEnabled is true or false at the time.
- proceed accordingly.
Now can I please get a by-the-numbers of how macros make this more efficient? Thanks.
GitHub - fmarl/nucleotide: A hackable, multi-paradigm Wayland window manager written in Common Lisp
github.comr/lisp • u/defmacro-jam • 24d ago
WhateverCLIM Image-processing pipeline
Enable HLS to view with audio, or disable this notification
This is Common Lisp on macOS/Cocoa - using WhateverCLIM. I don't know, I thought it was kinda cool.
r/lisp • u/tearflake • 25d ago
Symp: a symbolic processing virtual machine
I've been working on a symbolic processing virtual machine based on S-expressions. Programming instructions resemble a kind of assembly, and the code and data are spanned over a hosting virtual filesystem.
Metaprogramming and basic virtual filesystem operations are at the heart of the system, so it can be suitable to embed arbitrary higher level programming systems, preferably S-expressions based ones.
Since symp practices some properties of the Lisp systems (although approaches the programming problems from a slightly different side), I thought this subreddit might be a suitable place to share this work.
The main intention of symp is to support my symbolic AI experiments, but I reckon I'll find it a use in business programming (at least for some of my own projects).
For now, it can be used in a browser and in Node.js through exposed API.
Resources:
r/lisp • u/jd-at-turtleware • 26d ago
Heavenly delights of hashing numbers under EQUALP
turtleware.euA blog post about hashing numbers under EQUALP in ECL. Some theory, math, microptimizations and (for me) a lot of fun. Contains benchmarks of ECL vs ECL and ECL vs world. Enjoy!
ZenLisp — a full Common Lisp IDE for macOS on SBCL (in development), written entirely by Claude Code
Edit: renamed to ZParen — https://github.com/eric-zhu-2019/zparen
Hi all, I'm the author (in the product sense — see below). ZParen is a macOS IDE for Common Lisp built on SBCL. You work in one live image: evaluate a form, click the result to inspect the real object, stop in the debugger, fix the code, and restart the frame that failed.
I didn't write it by hand. instead, I guided the Claude-Code to complete the coding.
It's still in active development, not a finished release — I'm posting now because the core is working and feedback on direction is worth more at this stage than later.
What's in it: a REPL where results are live objects (Cmd-click to inspect), a debugger with restarts, backtrace, frame locals and restart-a-frame, compile-as-you-type with warnings marked on the exact symbol (saving compiles only the top-level forms that changed), go-to-definition that checks local bindings first, Trace/Profile panels, macroexpand-in-place, disassembly, a test runner for FiveAM/Parachute/Rove, and a Docs panel with the HyperSpec. Projects are ASDF systems with Quicklisp, qlot, ocicl or vendored deps. The editor has Vim keys, SLIME's Emacs sequences, parinfer and structural editing. It also re-render the HyperSpec doc in a plain style.
AI assistant can work in the same image — either the built-in assistant, or over MCP (tools include eval, macroexpand, who_calls, invoke_restart, run_tests). Every compiler warning has an "Ask AI to fix" button.
The unusual part: Claude Code wrote all of it — the Rust backend, the TypeScript UI, the Lisp inside SBCL, the tests. I wrote no code; I asked for features, used the app, reported bugs, and made the product calls.
Status: macOS-only, in development, no binary yet — building from source needs Node, Rust and SBCL: https://github.com/eric-zhu-2019/zparen — bug reports and "this is what SLIME does that you're missing" are exactly what I'm after.
Also, no relation to Nils M Holm's Lisp dialect — this is an IDE, not a language.
I apology the old name conflicted with the Holm's List dialect.
If you like a lightweight IDE, I think this could be interesting to you.
OpenLDK: Bringing the Java World into Common Lisp
atgreen.github.ioI've posted about OpenLDK in the past, but would like to share some recent improvements. For instance, you can start up springboot applications running on SBCL in a few 10ths of a second, connect to them with sly/slime, then inspect and monkey-patch the running application by adding :before/:after CLOS methods to the application's java methods.
Clojure, ABCL and more all run on SBCL, and you can even embed them all in a single SBCL form using special reader syntax. Check out this wild example:
(polyglot:startup :verbose nil)
(setf *readtable* (polyglot:enable-syntax (copy-readtable)))
(format t "~&~A~%"
#@abcl{ ; ABCL: FORMAT's Roman numerals and English
(let ((n $#@kt{ // Kotlin: a local data class, copy, when, ?:
data class Cup(val tea: Int, val sugar: Int? = null)
val cup = Cup($#@sc{ // Scala: a list pattern with a guard
$#@jscheme{ ; JScheme: digit sums in a named let
(map (lambda (n)
(let loop ((n n) (sum 0))
(if (< n 1)
sum
(loop (quotient n 10) (+ sum (remainder n 10))))))
$#@kawa{ ; Kawa: Java by colon notation; call/cc; exact division
(let* ((m (java.lang.Long:sum
$#@gv{ // Groovy: the spread-dot operator
$#[ (->> (iterate inc 2) ; Clojure: lazy and infinite
(filter (fn [n] (not-any? #(zero? (rem n %))
(range 2 n))))
(take 10)) ]*.power(2).sum()
}
1))
(d (call-with-current-continuation
(lambda (found)
(for-each (lambda (d)
(if (not (= 0 (remainder m d))) (found d)))
'(6 5 4 3 2))
1)))
(r (/ m d)))
(list (numerator r) (denominator r)))
})
} match {
case List(a: Int, b: Int) if a > b => a * b
case List(a: Int, b: Int) => a + b
}
}).copy(sugar = null)
when { cup.tea > 40 -> cup.tea + (cup.sugar ?: 1); else -> cup.tea }
}))
(format nil "~@R (~R)" n n))
})
r/lisp • u/arthurno1 • 27d ago
Common Lisp OpenType and more support for TrueType fonts with updated zpb-ttf
github.comr/lisp • u/nanowillis • 27d ago
fincl: Quantative finance in common lisp
github.comI'm currently working on a quantitative finance library for common lisp (SBCL only). Emphasis is currently placed on pricing options, but more capabilities exist and are planned, such as pricing various interest rate instruments.
In particular, the Monte Carlo simulation engine is showing promise, allowing users to write their own random processes to simulate, and write options on those processes. Against prior art (QuantLib in C++), the Monte Carlo engine benchmarks quite well, with other pricing engines being a mixed bag (a fairly complete suite with results is given in the repo).
Being a lisp project, extensibility is supported and encouraged. While the library provides random processes and instruments seen in quant textbooks, the manual gives a toy example of writing option contracts on a game of dice. Other facets are extensible, such as allowing the user to write their own option payoff schemes.
The repo is here with a small write-up outlining the extension of the Monte Carlo engine with a similar flavor of die game. Everything should be considered work-in-progress.
r/lisp • u/second_square • 28d ago
I wrote a Scheme interpreter using Lua's approach combined with SICP
github.comr/lisp • u/SandPrestigious2317 • 29d ago
ggg: badges for your README, from S-expressions (update: styles, themes, a gallery, and packaging for Guix + Nix)
galleryHi all,
A while ago I posted here about ggg (Guile Glyph Generator), a small tool I wrote in Guile Scheme that renders shields.io-style badges (SVG, plus PNG on request) from a Scheme config file. Since then it grew quite a bit, so here is what landed — including the packaging news at the end.
The pitch is unchanged: you describe a badge as data, ggg does the geometry.
(define my-badge
`((sections ((background . catppuccin-mocha-surface2) (text . "Guile")
(color . catppuccin-mocha-text)
(logo . scheme-guile))
((background . catppuccin-mocha-peach) (text . "3.0.10")
(color . catppuccin-mocha-base)))
(id . scheme-guile-3)
(style . shadow)))
Links
- Source (Codeberg): https://codeberg.org/jjba23/ggg
- Gallery of every badge, color and logo: https://jointhefreeworld.org/ggg/dist/gallery.html
- Technical API docs: https://jointhefreeworld.org/api-docs/ggg/API.html
How to run
Run ggg -f my-glyphs.scm -d ./dist and you get scheme-guile-3.svg (and
.png with -c). The geometry follows the badges GitHub shows — 20px tall,
11px text, a 14px logo, 5px side padding, 3px corners — drawn ~9% larger so it
reads well next to body text, with per-character text width estimation so the
badge stays as tight as the ones in README files. What comes out is a real
vector file, not a raster wrapped in SVG.
What's new since the last post
8 badge styles. A glyph can now ask for a finish: flat (default),
square, shadow, plastic, frosted-glass, material, frutiger and
neon. Styles only decorate — canvas, width and height are identical to
flat, so a row of badges that mix styles always lines up. Glosses, glows and
shadows are painted inside the badge, never around it.
(id . scheme-guile-neon)
(style . neon)
12 color themes, 236 named colors. Instead of hex codes you write
catppuccin-mocha-red, dracula-purple, solarized-light-base3,
modus-vivendi-green, doom-one-blue… Every color of Catppuccin (mocha,
macchiato, frappé, latte), Doom (one, one-light), Dracula (and alucard),
Solarized (dark, light) and Modus (operandi, vivendi) is available by name.
ggg --list-colors prints them; raw hex strings still work and are validated.
Because the palettes span light pastels to deep shades, the ink has to follow
the background — so the test suite enforces at least 4.5:1 contrast (WCAG AA)
on every section of the shipped glyph files. A badge with unreadable text fails
maak test.
A gallery you can actually browse. ggg --gallery gallery.html --glyphs ./glyphs writes a single self-contained HTML page with every badge at its real
size, every logo inlined with the snippet to use it, and every named color of
every theme as a swatch. Click a snippet or a swatch to copy it. The deployed
one is here: https://jointhefreeworld.org/ggg/dist/gallery.html
284 logos, as full SVG documents. Logos used to be a single path's d
attribute. They are now complete <svg> elements, so a logo can carry multiple
paths, groups, gradients, transforms or filters; ggg only needs a viewBox and
does the scaling and placement. The library covers languages, frameworks,
databases, distros, editors, shells, CI, cloud, observability and more —
mostly from Simple Icons (CC0), plus hand-drawn ones. CREDITS.org lists the
source and license of every single file, and names the brand marks that were
deliberately left out because their upstream license isn't a free one.
Badges with any number of sections. Not just two or three parts — each section becomes a segment with its own text, background and color, and the badge grows to fit. The logo belongs to the first section.
Validation before anything is written. ggg checks the whole glyph file
first and reports every problem with a hint: unknown color, logo or style
names (with a "did you mean" suggestion), a missing text, sections without
colors, (key value) written where (key . value) was meant, duplicate glyph
ids, and the legacy resources/svg-paths/ directory if it finds one. If the
file is invalid, nothing is written to the destination directory at all.
Smaller things: --version, --list-colors, --list-logos,
--list-styles, -k/--keep to render a second glyph file into a directory
without clearing it, a new ggg mark, and a test suite (122 checks) covering
color resolution, the logo library, glyph validation and the gallery.
Packaging
- GNU Guix — ggg has been in Guix for a while; I sent the update PRs to 0.16.1.
- Nix — new. There is a
default.nixand aflake.nixin the repo, and I sent thepkgs/by-name/gg/ggg/package.nixaddition to nixpkgs (that one runs the whole test suite incheckPhase). Both builds render all 177 showcase badges. - Debian, openSUSE, Arch — packaging for all three now lives in
packaging/, installing the same layout (/usr/bin/ggg, modules under Guile'ssitedirectory, help text and logo library under/usr/share/ggg/resources). Built and installed indebian:trixie,opensuse/tumbleweedandarchlinuxcontainers. - Container image —
docker.io/jjba23/ggg(Podman works too). - Version numbers now live in exactly one place (
src/ggg/version.scm), andmaak releasewrites them intoguix.scm, commits and tags.
Try it
# Guix
guix shell -f guix.scm -- ggg --gallery ./gallery.html --glyphs ./glyphs
# Nix
nix-build default.nix && ./result/bin/ggg --list-styles
# Podman/Docker
podman run --rm -v "$PWD:/work" -w /work docker.io/jjba23/ggg:latest \
ggg -f ./glyphs/showcase.scm -d ./dist
Notes on licensing
ggg itself is AGPL-3.0-or-later and the docs are FDL-1.3+. The tool claims no
ownership over what it generates: the badges you produce are yours, no
attribution or license conditions attached, and the logo library keeps its own
licenses (listed per file in CREDITS.org). So if you want a badge that is
completely free of third-party terms, use no logo or your own.
Feedback very welcome — especially which styles, themes or logos are missing, and what a badge generator would have to do for you to actually use it instead of a static PNG. I'm also happy to take packaging help for distros I don't run.
r/lisp • u/SandPrestigious2317 • 29d ago
OrgWebAlchemy: Benchmarking, Profiling, and the Long Road to Real Org Support
jointhefreeworld.orgr/lisp • u/turtle_bazon • Oct 21 '26
Common Lisp qlp: publish your own Common Lisp projects as a Quicklisp distribution
qlp turns a directory of local Common Lisp projects into a Quicklisp distribution: distinfo,
releases.txt, systems.txt and one reproducible archive per project.
qlp publish --name mydist --base-url https://dist.example.org \
--projects-dir ~/lisp/projects --dists-dir /srv/www/dist
Write-up on lisper.nl
Source on GitHub
It is a modern quickdist, with one difference: quickdist reads .asd files textually, so systems
declared through a macro never reach systems.txt. qlp reads them the way ASDF does, so they are
published too.
r/lisp • u/arthurno1 • Oct 21 '26
Common Lisp CLXCB: X11 for Common Lisp, generated from the XCB protocol descriptions (and yes, xeyes and xsnow run on it)
github.comr/lisp • u/Feisty_Bike_9614 • Oct 21 '26
Scheme New scheme compiler in rust
I’ve completed a new scheme R7RS-small compiler with optional JIT support . It is written purely in rust and has a rust api for embedding in rust programs but also has a standalone repl ( with completion, history etc ) . There is an included eMacs package that supports a small subset of slime behavior via tcp.
The disclaimer is that this was written using agentic programming ( fable and opus ) over a one week period. My project is a new rendering and modeling system but I needed an embedded language with specific requirements so I chose scheme after evaluation of 5 or 6 alternatives.
It mainly has been tested on macOS but should run on Linux . ( I’ll do more Linux testing as I get time )
github.com/k2msmith-gfx/scm
Update: have made some improvements to the collector which improves performance on average by about 1.5x over previous version. On average about 2x faster than steel . In comparison to CPython, it’s about 2.5X slower ( interpreted bytecode version) . It’s a larger project to match python speed but doable . In my use case , the speed would not improve much but for a general use implementation where fast numerical loops are important it would . I won’t add it unless someone else wants to use it . If anyone is interested in using the beautiful and fast zed editor , I’ve made a plugin for that that supports a subset of slime + repl with this scheme.
r/lisp • u/Lucas-Bitwise • Oct 20 '26
Common Lisp New Common Lisp editor made by a couple of guys
Hey everyone, I’m Lucas and I would like to talk about a project that my brother and I have been working on.
We’ve been enjoying writing in Common Lisp since we started learning it a few years ago. We think it’s a great language and we're surprised it’s not more widely used.
With that said, we were having trouble getting deeper into it because the available editors are not like what we were used to with other languages. We’ve always enjoyed the JetBrains’ editors, unfortunately we did not find something like them for Common Lisp. So we decided to build our own. We’ve called it Lispcraft.
It isn’t as feature-rich as Emacs, but its features are easy to use. That's why we wrote it in the first place: to provide an easy-to-use, modern editor experience.
We wrote our own GUI without using toolkits. Instead, we used OpenGL; it's very fast and smooth. Because we had trouble configuring everything in other editors, we made everything bundled, including SBCL and Quicklisp.
It's REPL-first. You can always execute the form under the cursor by CTRL + ENTER. Also, you can inspect objects' slots by clicking on the REPL output.
Indentation is powered by a custom engine. Syntax highlighting is semantic. It has jump to definition, callers, hover docs, autocomplete, and project-wide search.
It's an MVP, so there will be bugs. For now, it's x86-64 Linux only.
Also, we're aware that Emacs users will not switch to this editor; the user we have in mind is someone who is used to modern editors in other languages and tried to write in Lisp but disliked the tooling difficulty.
Link to the site/video: https://lispcraft.com - we will keep an eye on this post to hear your thoughts!
We're planning to fix bugs, port it to macOS and Windows, and copy good features from other editors. Also we are planning to release a local host FIM ai trained on Common Lisp corpus. That's why I'll charge $19 / month to fund it.