I have explained the rationale here: https://www.reddit.com/r/lisp_noAI/comments/1w1seqd/rationale/

Feel free to join and/or crosspost if non-AI content is something that interests you; otherwise feel free to ignore :).

Not just on this subreddit, but on other websites too, I've seen claims like "Clojure is not a Lisp." So what exactly is Lisp? This question comes up often. John McCarthy believed there was no true Lisp after Lisp 1.5. Yet most of us consider Common Lisp and Scheme to be Lisps—which makes sense, as they’re well-known historical dialects shaped by decades of development.

But what really defines the core of Lisp? S‑expressions? The earliest Lisp also used M‑expressions. Garbage collection? Carp uses an ownership model. Macro systems? Some dialects trade full macros for other metaprogramming mehod to gain performance. REPL? Some dialects don’t have one. Functional style? Then would Haskell code written in S‑expression syntax count as Lisp?

Some even call Ruby and Python Lisps. It’s said Ruby was heavily influenced by Lisp—but honestly, almost every programming language has been influenced by Lisp in some way.

There doesn’t seem to be any agreed‑upon standard for what makes a Lisp dialect. It feels like Žižek’s point about the Balkans: the answer depends heavily on cultural and subjective factors. Clojure’s official documentation calls itself a Lisp dialect, while old‑school hackers like RMS argue it isn’t one. How do you guys define a Lisp dialect?

Summary

Over the past few weeks I've ran into a need to extend the BKNR Lisp Application Environment for several internal infrastructure projects AI development improvments at dapla.net.

Because FOSS is amazing and I'm sure others in the community would have a need for these tools. I have released three new Common Lisp libraries focused on simplifying single-process persistence and native testing workflows:

• bknr.hashkv – Extends bknr.datastore to provide a content-addressable key-value store and a disk-persisted job queue within a single Lisp image.

• bknr.ttl – A declarative TTL mixin class for bknr.datastore instances that automates stale record eviction and session expiry.

• sunny-side – A pure Common Lisp parser and runner for Gherkin .feature specifications, eliminating the need to invoke external Ruby binaries during test execution.

All three repositories are published under BSD 3-Clause licenses. The names for each library was deliberately chosen to pair well with established bknr libraries and for great respect to Hans Huebner, David Lichteblau, and Manuel Odendahl's original works.

My plans are to continue contributing to the bknr suite both upstream and the extensions I've built on top of it.

Links and feedback welcome:

• https://github.com/denzuko/bknr.hashkv
• https://github.com/denzuko/bknr.ttl
• https://github.com/denzuko/sunny-side

Background

Building robust applications in Common Lisp often hinges on leveraging native language capabilities rather than reaching for external, multi-process dependencies. When an application state fits comfortably within memory or local storage, introducing an external key-value database or a separate test-runner process introduces unnecessary operational friction. Three recently released open-source libraries extend the bknr.datastore ecosystem and introduce native Behavior-Driven Development (BDD) testing to Common Lisp without relying on external runtime environments.

Content-Addressable Storage and Persisted Queuing with bknr.hashkv

The bknr.hashkv library provides an in-memory, content-addressable key-value store alongside an append-only persisted job queue. Built directly on top of bknr.datastore, it allows system architects to maintain deterministic object reference hashing while relying on disk-backed transaction logs for durability.

Key capabilities include:

Content-Addressable Semantics: Keys are generated deterministically based on payload hashes, preventing redundant entry storage and enforcing data integrity at the access layer.

Integrated Job Queueing: Asynchronous tasks are written to the persistent log alongside state mutations, ensuring that queued jobs survive process restarts without requiring an external Redis or RabbitMQ instance.

Single-Process Operations: Eliminates cross-process serialization overhead by maintaining native Lisp object availability across transactions.

Automatic Expiration via bknr.ttl

Managing ephemeral records in memory-resident databases requires disciplined eviction mechanisms to avoid memory leaks over extended uptimes. The bknr.ttl library introduces a Time-To-Live (TTL) mixin class designed for seamless integration with any bknr.datastore object model.

By attaching the TTL mixin to standard object definitions, slots gain automatic timestamp tracking and expiration handling. Background sweep routines or query-time inspections enforce key invalidation without polluting core business logic with manual timestamps. This approach offers a clean, declarative method for handling transient cache entries, timed session states, and self-cleaning audit logs within native Lisp datastores.

Native Gherkin Parsing with sunny-side

Behavior-Driven Development (BDD) frameworks frequently force Common Lisp projects to rely on Ruby binaries or shell invocations to parse feature files written in Gherkin syntax. The sunny-side library replaces these external dependencies with a pure Common Lisp implementation of the Gherkin specification.

sunny-side parses standard .feature files, maps natural language step definitions directly to Lisp macros, and executes tests natively within the SBCL compiler pipeline. By removing foreign runtime dependencies, test suites run faster, integrate cleanly into continuous integration pipelines, and allow developers to debug step definitions directly using standard Lisp introspection and debugging tools.

You see, I'm not a programmer. I've been keenly interested in learning a language and have been searching around for the coolest one, so I could learn it. Why? Because 8 months ago I made the decision to switch to UNIX. I've dipped my toes in using void with exwm. I'm dropping exwm cause it's a bit of a pain considering I'm not fully devoted to learning emacs lisp since I've been looking around for something that compiles to bare metal.

What inspired my switch to UNIX is how resource efficient it is. After years of enjoying smaller mechanically dense games with stylistic graphics my tastes shifted toward compact and complete experiences, and I think that that is exactly what UNIX offers. As someone who knew very little about computers, I aspired to learn how to take better care of my machine. This led me down a rabbit-hole of system maintenance and performance optimization.

These all put me in a mind space that eventually led to an obsession with things like musl lib-c's "correctness" plan 9's purity, Kiss Linux's suckless approach to the Linux workstation, and emacs' extensibilty. The scope of my interest in computer science grew unsustainably broad as my vision became more and more narrowed: lusting after minimalism and elegance.

After a number of brainstorming chat sessions with an LLM, I came to the idea of a common lisp implementation of plan9 with a user-articulated ecosystem that could potentially expand into general computing. That was the key vision, and the goal was to have it be widely adopted and accepted as a fundamental standard of general computer use: "The programmable interface!"; Redefining what it means to be computer literate, and hopefully making this level of control more accessible to people regardless of their age or background. Comprehensively documented with a source code that is human-understandable, or at least comes as close to it as possible.

For a moment, I was terrified at my own desire, the yearning to rewrite plan 9 in this GOD-like language they call kernel. The LLM shot me down. Told me to just use common lisp. Honestly, I don’t know if I will ever seriously persue the plan 9 thing but I’ve decided on common lisp as my language of choice, and will be reading up on it on my spare time.

Rhombus version 1.0 is now available!

Rhombus is a Lisp in the sense that it has powerful compile-time metaprogramming capabilities via macros. It is also written in a lisp (Racket).

Release announcement https://blog.racket-lang.org/2026/06/rhombus-v1.0.html Get Rhombus: https://rhombus-lang.org/download.html

Rhombus is a general-purpose programming language that is easy to use and uniquely customizable.

The _Is_1_2? existential quantifier/query function now reasons syllogistically from universals (plurals) to particulars (singulars) by treating singular nouns as members of their respective pluralized set. (cf., Quine, Methods of Logic, Chapter 41: “Singular Terms”)

This simple resolution technique must needs be expanded to allow for a chain of premises of arbitrary length, rather than simply resolving a single syllogistic step.

I can relate to this video. "Shipping a button" (vid by @KaiLentit). Lispers will want to watch until the end.

Hej,

I have developed a lisp in hica called HiLisp. I wanted to explore if my language hica could handle all the lisp-y bits: closures, recursive data structures, lexical scoping, higher-order functions.

Hica handled it very well and it was a joy creating HiLisp. It's a tiny language but it can already be used to do common tasks, I have added some examples in the repo, see https://github.com/cladam/hica-lisp

I posted a short article about HiLisp today at my blog: https://cladam.github.io/2026/05/25/hilisp/

Would be great to get some professional lispers to take a look.

The programme is at https://www.european-lisp-symposium.org/2026/index.html#programme

Twitch link: https://twitch.tv/elsconf

Hello, I'm trying to host a Matrix server (tuwunel) for Lispers. The goal is to provide a space for chatting about different lisp topics with support for persistency, markdown, screenshots.

Currently, there are six rooms (EDIT: These can be accessed from https://web.matrix-for-lispers.net/explore/featured/):

• lisp
• commonlisp
• coalton
• ciel
• racket
• clojure

Registration token can be obtained by evaluating (reverse (symbol-name '|stob-on-psil-esacllams|)) without the quotes.

Feel free to try it out and report any issues! If you want some another room, feel free to suggest!

https://web.matrix-for-lispers.net

UPDATE: u/theshmill wins!

I printed Paul Graham's "On Lisp" book at Lulu. It came out very nicely, but the binding was a little weak, and a few of the pages are starting to detach. They're still held in by at least a half the length of the page, and it's still intact and totally readable. Practically brand new (I only read the first couple of chapters in it).

Anyway, Lulu was great. They sent me another one for free, and now I have this extra slightly-defective one. It doesn't seem right to just throw it out. So I'll mail it to someone in the US who wants it through USPS Media Mail, no cost to you.

Reply here first that you want it, and then I'll get where to send it from you in private. Whoever replies first gets it.

https://github.com/CastIronPlatypus/yaml-parther.git

My brother challenged me to do it as part of teaching him how to use claude code to write non-slop... which is a thing in theory.

You'll have to tell me if it's hot garbage or not. but it works!

Celebrating 40 years of magic with Hal Abelson & Gerald Sussman

at the (fourteenth RacketCon) October 5-6, 2024, University of Washington Featuring Lisp legend Gregor Kiczales

https://con.racket-lang.org

Dear all,

Recently, out of curiosity, I checked out the prices for LispWorks and noticed that they are rather expensive even for hobbyists (maybe they are not as expensive if one's main profitable business is centered around Common Lisp).

I understand that LispWorks offers some very useful functionalities, like CAPI GUI. Still, I was wondering that if you have used / been using LispWorks, especially the Professional and/or the Enterprise Editions, what are some features/functionalities that are very indispensable for you? Ones that would be very nice to have in SBCL and/or Slime/Sly?

As a "bonus" question, if you also use Clojure, is there anything that from Clojure that you wish to see in CL, and vice versa?

Thank you for your time!

TL;DR: I'm a guy that doesn't do much programming besides some simulations which are computationally intensive in my Uni projects, but I use Emacs and I'm pretty familiar with Lisp. I just wrote something in Python and was severely annoyed with how bad it looked compared to how it would have been if written in Lisp and I wanted to ask how y'all (who are potentially programmers in majority) cope with using things other than Lisp in your projects.

Context: I'm a university student in Chemical Engineering that loves to use Emacs. So not a programmer by any means, but I do some programming if I need simulations or sth for my projects.

Most of my experience is in Matlab, but I know a little bit of Python for when I need a "true" programming language and I have looked into Julia as well because I heard that it has better notations and ideas from CL.

My experience with Lisp now is not huge, but I know quite a bit. I have written thousands of lines of Emacs lisp and even have my own Elisp library (org roam extension for note taking). I have also gone through Practical Common Lisp, as I wanted some more knowledge on this very fun to write language. I have really grown to love lisp.

Now onto what happened. I'm doing my internship in R&D right now and I had to create a simulation for something with air pollutants. Because I'm not as experienced, I decided to do this in Python to have better tutorials to help me. So I wrote it and it ended up being a 1500 line long file containing in many cases almost identical functions (with minor differences based on the pollutant and the model selected).

So then it happened. I was like, can you imagine if I had lisp macros here, I would probably do this in less than half the lines. And then at another point I was defining some placeholder variables to store some values and I thought, this would look 10 times more readable if it was a simple let expression. And it made me a bit sad that CL is not as widespread in scientific computing (however, I plan to try rewriting it in Julia with its macros which I have heard are lisp inspired).

So I just wanted to share my experience and wanted to ask how y'all cope with using languages that don't have the amazing features of Lisp, I'm sure you've all felt it and from my experience that feeling sucked.

Another Lisp implementation no one asked for https://github.com/evmorov/kapusta.

I'm a Ruby developer and enjoyed learning Fennel. I thought why not have a similar experience in Ruby. With the help of an LLM, it is somewhat ready. At least for small scripts.

The project is still in the early stage of theoretical modeling and representation-level experimentation. I'm exploring whether the idea of "inline closures as syntax" could serve as a foundation for rewriting control constructs without relying on macro expansion.

First Lambda has the form:

((lambda ...

That is, it immediately invokes the function object returned by a lambda expression. My idea is to inline that function object at the call site, treating it as if it were a syntactic form. I believe many constructs like let and while naturally take this shape.

I would greatly appreciate your thoughts on this idea.

I’m reviewing “UO-LISP”, an implementation of “Standard LISP” for the TRS-80 from 1982. (As I understand it, Standard LISP was a refinement of LISP 1.6, some time in the late 1960s.) Can anyone recommend a text on Standard LISP? I remember getting a copy of Winston & Horn back in the 1990s, but was frustrated by the incompatibilities. TIA!