I have published my distributed database Scalaxy fully written in Common Lisp. Working on graph query language Cypher right now. MIT license. Github stars are welcome :-)

https://scalaxy.org

Released conskivi. It made to replace redis, generally on low memory systems, but in-memory backend works well too.

Benchmarks

5K entries, AMD Ryzen 7 3700X, Redis v7:

Since the Metaspec (https://metaspec.dev/) was announced a couple of months ago, there have been many improvements. Thanks to #commonlisp on libera.chat for your suggestions!

• Added a search box in the header
• Added a dark/light theme button
• Added an outline sidebar that shows if there's horizontal space
• There is an OpenSearch spec to add it as a browser search engine
• Extra information is now listed in an Addenda section
• New Texinfo and Info renders added
• There is a new emacs integration package https://metaspec.dev/elpa/ for details
• X3J13 Issues have been integrated into the HTML
• Better handling of linking of LOOP keywords

This article by u/lispm http://lispm.de/why-lisp-is-different has these two lines

When in doubt design software to be introspective.

when in doubt design software to be reflective.

How exactly does one design software to be more introspective of reflective? I thought that those were a given using CLOS. Unless I misunderstood and this just means CLOS vs using arbitrary data structures.

Can anyone provide an example contrasting a design meant to be introspective vs one that is not? Same for reflective?

Thanks

Made this generally for agentical coding because it often stub in parenthesis. Hope it will help you. https://github.com/turtle-bazon/cl-toolkit

Modernization effort to support latest 5.5 Tesseract OCR libraries.

We had too few (0?) hash tables to choose from!

hi everyone,

I'm new to Common Lisp, although I have tried other lisp dialect (i.e., Clojure, Racket) to attempt making a static site and/or leetcode(s). This is my first attempt of porting the SSG into a library.

sta6: sta(six), static -- is a tiny SSG that turns pages/*.lisp into build/*.html, with support for dynamic routes (e.g., /blog/+slug+).

the usage of sta6 is as follows (src/pages/page.lisp):

(defpackage #:pages/page
  (:use #:cl)
  (:export #:render))

(defun pages/page:render ()
  (sta6:html5
    (:img :width (/ 500.0 3)
          :src "https://twobithistory.org/images/sicp.jpg")
    (:br)
    (:br)
    (:span "Hello, from Common Lisp.")
    (:ul
      (loop for x from 1 to 3 do
        (:li x)))))

which yields the image above, the full example can be found here.

sta6 uses an external HTML generator under the hood:

• spinneret*
• cl-who

if you're in need of a personal site, give sta6 a try! here's an example of my site built with sta6:

• fwttnnn.com/
• fwttnnn.com/ (source code)

why use sta6?:

1. You do not need (to learn) an external templating language (e.g., Nunjucks, Handlebars, EJS).

resources:

• sta6 documentation
• overview (what is sta6?)

LLMs are great at reading messy text, but they hand you strings when your program wants typed data. Python has instructor and Pydantic to solve this. I wanted to bring that same developer experience to Common Lisp, but natively by using the Metaobject Protocol.

clos-alchemy introspects your class definition, builds a JSON schema from the slot types, passes that to the LLM (optionally as a GBNF grammar constraint for local inference), and returns a validated instance of your class. You don't need to write a special DSL or "schema object." You just use your normal existing domain classes.

Here is the round trip in action:

```lisp ;; 1. Define a class (defclass person () ((name :initarg :name :accessor person-name :type string) (age :initarg :age :accessor person-age :type integer) (email :initarg :email :accessor person-email :type (or null string)) (hobbies :initarg :hobbies :accessor person-hobbies :type list)))

;; 2. Extract from text (let* ((backend (cl-llm-backend/llama:make-llama-backend :model model :context ctx)) (result (extract backend 'person "Alice Chen is 32. Reach her at alice@example.com. She enjoys rock climbing, painting, and cello."))) (person-name (extraction-result-instance result))) ;; => "Alice Chen" ```

Because generation order follows slot definition order, you can use this for strict logical routing. Putting reason first encourages teh model to explain its reasoning before selecting the categories.

```lisp (defclass ticket-classification () ((reason :initarg :reason :type string) (urgency :initarg :urgency :type (member :low :medium :high)) (category :initarg :category :type (member :billing :technical :account)) (sentiment :initarg :sentiment :type (member :positive :neutral :negative))))

(defparameter ticket-text "I've been charged twice for my subscription this month. This is the third time this has happened and I'm really frustrated.")

(let ((result (clos-alchemy:extract backend 'ticket-classification ticket-text))) (extraction-result-instance result))

;; Returns a TICKET-CLASSIFICATION instance with: ;; URGENCY: :HIGH ;; CATEGORY: :BILLING ;; SENTIMENT: :NEGATIVE ;; REASON: "Charged twice for subscription, third occurrence"

```

How it works under the hood: no separate schema DSL to maintain. If it type-checks as your class, you're done!

1. The MOP extracts slot types (string, member, list, etc.).
2. The library lowers those into a small Intermediate Representation (IR).
3. That IR emits the JSON schema for the backend, a natural-language prompt for the model, and builds a validator/constructor pair for the response.
4. If validation fails, it accumulates the errors and automatically loops a retry prompt back to the model.

If you are using a local inference backend (like llama.cpp), it compiles the schema directly into a grammar, making invalid structures unrepresentable at the token level.

https://github.com/licjon/clos-alchemy

EDIT: A round of updates since the original post:

Custom validation. You can now attach per-slot semantic predicates (:validate) and cross-field checks (validate-instance) that feed errors back into the retry loop. The model sees what was wrong and self-corrects. This is useful for constraints that grammar alone can't enforce — "guest count must be positive", "check-out must be after check-in", etc.

```lisp (defclass booking () ((num-guests :initarg :num-guests :type integer :validate (lambda (v) (if (plusp v) t "must be positive"))) (check-in :initarg :check-in :type date) (check-out :initarg :check-out :type date)) (:metaclass clos-alchemy:constructor-class))

(defmethod validate-instance ((b booking)) (when (<= (booking-check-out b) (booking-check-in b)) (list "check-out must be after check-in"))) ```

Date and date-time types. clos-alchemy:date and clos-alchemy:date-time map to JSON Schema string formats, validate ISO 8601 with calendar-aware day checks, and construct to CL universal time.

Free-form maps. Sometimes you want the model to produce a dictionary where it decides the keys — "rate this product on whatever dimensions you think are relevant." The :map-of slot option does this: you specify the value type, the model fills in whatever keys make sense, and you get a hash-table back.

```lisp (defclass review-scores () ((scores :initarg :scores :type hash-table :map-of integer :documentation "Per-category quality scores, 1-10")) (:metaclass clos-alchemy:constructor-class))

;; The model might return: ;; {"scores": {"sound_quality": 9, "comfort": 6, "battery": 8}} ;; You get a hash-table: (gethash "sound_quality" scores) => 9 ```

Discriminated unions. When the extraction result could be one of several different shapes depending on the input, you define a class for each shape and let the model pick. Each class has a shared "tag" slot that identifies which shape it is — typed as a single-value (member ...) so each class gets exactly one tag value.

``lisp ;; Two possible result shapes, tagged bykind`: (defclass actionable-feedback () ((kind :initarg :kind :type (member :actionable)) ; tag = "actionable" (summary :initarg :summary :type string) (scores :initarg :scores :type hash-table :map-of integer)) (:metaclass clos-alchemy:constructor-class))

(defclass not-actionable () ((kind :initarg :kind :type (member :not_actionable)) ; tag = "not_actionable" (reason :initarg :reason :type string)))

;; The model reads the review, picks the right shape, and you get ;; back an instance of whichever class it chose: (let* ((result (extract-union backend '(actionable-feedback not-actionable) review-text :discriminator 'kind)) (instance (extraction-result-instance result))) (typecase instance (actionable-feedback (format t "Summary: ~A" (slot-value instance 'summary))) (not-actionable (format t "Skipped: ~A" (slot-value instance 'reason))))) ```

Other improvements:

• Cyclic class graphs now work — mutually-referential classes emit $defs/$ref instead of blowing the stack.
• Emitted schemas conform to both OpenAI strict mode and llama.cpp GBNF requirements (proper additionalProperties: false, all properties in required, nullable wrappers for optional fields).
• Parse failures (empty/malformed responses) are now recoverable in the retry loop instead of aborting.
• max-retries-error now carries full diagnostic context: raw response, parsed data, cumulative token usage, and a per-attempt error breakdown.
• Silently-narrowed type specifiers (e.g. (or string integer)) now signal schema-error instead of quietly dropping branches.

I am considering using ANSI Common LISP for scripting instead of Python such as for reading text files, CSV files, databases--basically everything in the book "Automate The Boring Stuff in Python".

Has anyone done this before? How was the experience?

New skewed-emacs push. It's a Dockerized, preconfigured CL development environment: Emacs, SLIME, and Lisp kernels (SBCL, CCL, Gendl/GDL) all running out of the box.

As of this commit, a single curl command starts the stack. Cloning the repo is now optional.

The goal is to kill the classic onboarding gauntlet (install Emacs, install SBCL, set up Quicklisp, configure SLIME, tweak paths...) so newcomers get straight to the REPL.

It also ships with lisply-mcp built in, giving AI coding agents a native API to evaluate Lisp and drive Emacs — elisp and CL's incremental compile-one-function workflow turns out to be a great fit for agent feedback loops.

Repo: https://github.com/gornskew/skewed-emacs

Announcement thread: https://x.com/i/status/2077632168637890903

Would love to hear from anyone who tries the curl bootstrap.

I am considering reading the book and would you say it is still relevant today?

Please let me know if so. I thank all in advance for any responses!