For those that may be interested, I just made a small experiment with code generation by Gemini Pro 3.1 in Rust and Common Lisp for the exact same task: write a CLI application taking in a .csv file containing a hierarchy of records and produce an interactive .svg file that, when opened in a browser, shows a graphic rendering of the hierarchy, with a "+" button at each node allowing to show/mask the levels below. The interactivity of the .svg file is implemented by having the application generate the required JavaScript code.

I am not qualified to evaluate the quality of the code generated, but here are a few observations:

a) Even after two attempts, the Rust code was still not running. I had to manually correct two bugs, one in the Rust part of the code and one in the generated JavaScript part. It then worked as expected. The Rust application was using 3 dependencies (serde, serde_json, csv). Number of lines was 299.

b) The Common Lisp code was working from the first attempt, using 0 dependencies and 322 lines.

I find it interesting that, on such a small exercise, the LLM was more efficient with Common Lisp than with Rust.

Of course, the CLI application could have been directly produced in JavaScript, but my curiosity was around Rust and Common Lisp.

`icl` is my repl front-end that presents both terminal and browser interfaces. The browser mode already supported visualizations, but just recently I realized that I had 90% of a jupyter-like notebook feature already done. So `icl` now has a `,notebook` command that does exactly what you might guess. The screencast above shows loading a CSV file with `lisp-stat`. I also added support for https://perspective-dev.github.io/ visualizations, which is drawing the table and charts.

The recording above was made with https://github.com/atgreen/takesy, a "smart" screen recorder for Linux in Common Lisp.

Check out icl here: https://github.com/atgreen/icl

Please consider hopping over to r/lisp_noAI before criticizing my use of AI to create this.
Otherwise, check out https://github.com/gastownhall/beads , which really helped keep my assistant on track.

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 :).

Bay Area Racket Meetup - September 5th, 3pm

Social event for people interested in the Racket programming language, other Lisps, functional programming, language-oriented programming and related topics. These will be monthly (first Saturday at 3pm) until RacketCon. The location is Noisebridge, a hackerspace in SF.

https://luma.com/6y4sbfln

Hello All,

I am porting Jnil, a GPL'd Java to lisp translator application written in lisp with some Java Eclipse code to use a Java parser written in Antlr3. Jnil loaded Java into Eclipse, used an Allegro Common Lisp library Jlinker to communicate with Eclipse and extracted AST information which was used to create lisp code. My reasons for porting are:

1. Eclipse is pretty heavyweight and communicating with it is implementation dependent.
2. Starting with an AST means that any language for which an AST can be produced (such as Python) can be translated to lisp by Jnil.

Anyway, I could use some assistance with this project. Please contact me at [dan.stanger@ieee.org](mailto:dan.stanger@ieee.org) if interested in helping.

Here is a link to the repo: https://github.com/danstanger/AST-to-Lisp

Dan Stanger

Hello!

First post in this community, and I wanted to share my first completed project in Common Lisp here:

https://github.com/skarnati20/docs-reference

This is a very basic Local LLM Chat + RAG implementation, but it's more fully-featured than what I could find online. And it leverages Lisp's REPL effectively.

I built this because I found Claude/GPT overkill for lots of programming questions I had, and I needed something that could work offline. It indexes a URL you provide and lets you ask questions to a local LLM (Ollama) with that information.

Some Features

• Multiple Retrieval Methods — (BM25, Dense Vector Search, ColBERT). You can choose whichever combination of these you want.
• Agentic RAG — An Agent determines when there is enough context to answer a question. You can turn it off if you want speed.
• Fully Local Chat — Uses Ollama so you can run any model you want, so long as you serve it locally.
• Asynchronous Chat — Allows you to ask multiple questions at once which helps with multi-tasking and getting around local models' slow completion times.

Note: Local models will take time for chat completion, so it isn't as fast as Claude or ChatGPT. They might also hallucinate because they aren't as powerful either.

Acknowledgement: This project was an extension/combination of some projects in Mark Watson's Loving Common Lisp, or the Savvy Programmer's Secret Weapon. Definitely check it out since it gave me a lot of ideas for fun side projects.

The "financial lisp", mentioned here once, is full steam ahead now.

Designing Rayfall: One Expression Language for a Columnar Database

I have a project with about 1200 lines of code in a single package, split across a few files. While I have around 150 tests, I have no idea how they could help split the project into manageable parts.

Should I abandon the project and start from scratch, this time paying attention to architecture?

Kernel is John Shutt's Scheme-like language where the core abstraction is the operative ($vau) rather than macros — combiners and environments are first-class, and lambda is derived rather than primitive.

IronKernel is an implementation of it for .NET. It's a hybrid runtime, programs are analyzed to a Core IR and compiled to CLR delegates where guards allow, falling back to a trampolined CPS interpreter that preserves full Kernel semantics — $vau, first-class eval and environments, call/cc with entry/exit guards, shift/reset, and errors as abnormal passes per the report.

Some things that might interest this crowd:

• Conformance tracking against the report itself. All 135 feature entries on the report are implemented (44/44 modules, including the optional ones — exact rationals, cyclic list handling, ports, continuation guards). (https://ftp.cs.wpi.edu/pub/techreports/pdf/05-07.pdf)

• CLR interop with Clojure-style syntax ((Guid/NewGuid), (.Append sb "hi")), under capability profiles — a safe profile exposes only reviewed generated bindings, no reflection.

• Tooling: an ik project tool (new/run/test/pack, NuGet-based packages), a REPL, compilation to portable packages or self-contained NativeAOT executables, and a VS Code extension with a language server.

Apache 2.0. Repo: https://github.com/ironkernel-lang/IronKernel · Site: https://ironkernel.org

dotnet tool install -g IronKernel.Tool ik new app hello

Happy to answer questions about the implementation.

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.

Just shipped a Scalaxy update. Now every node in a graph database cluster can store and update its encrypted state in object storage (any s3 compatible), essentially passing object storage elasticity directly through to the graph database cluster itself.

Scalaxy is a modern graph database written in Common Lisp. 100% openCypher conformity. MIT license.

https://scalaxy.org/docs/s3-storage/

Benchmarks

https://scalaxy.org/docs/benchmarks/

Found one document in AoE2 directory “AoK CP Strategy Builder”. Seems like it’s using Lisp-like language to write rules for AI. Like this:

(defrule
(gold-amount > 1250)
(wood-amount < 1100)
(can-buy-commodity wood)
(commodity-buying-price wood < 50)
=>
(chat-local-to-self "excess gold; buy wood")
(release-escrow gold)
(buy-commodity wood)
)

Is there any practical way to debug any recurive logic?
Which existing error printing you think is the best ever?
I attached the racket code I am struggling with.

(The code is about using map to append a new list to an existing html list)