blog post: https://glenneth.org/content/posts/2026-04-25-fluxion-reactive-web-ui-common-lisp.html

code: https://github.com/parenworks/Fluxion

There are quite a few improvements:

• pushed some library implementations for atomics, trivial-garbage, trivial-gray-steams, closer-mop, float-features and many more. Be aware that upstream PRs may be slow to be dealt with.

• support for Windows binary

• saving/loading heap image support

• REPL debugger/inspector conformance issue fixes

• AmigaOS and MorphOS API bindings, including MUI, see screenshots: https://github.com/mdbergmann/cl-amiga#screenshots

• install/uninstall support for POSIX targets (includes windows via mingw)

https://github.com/mdbergmann/cl-amiga/releases/tag/v0.8

Hi. I'm learning CL (experienced programmer but CL noob), and was looking into real-world FOSS written in it for reference and to learn. When looking at pgloader(data loading tool for PostgreSQL), I found it has been rewritten in Clojure. The readme mentions:

pgloader v4 is a full rewrite in Clojure, distributed as a single self-contained JAR requiring Java 21 or later.

Key improvements over v3:

• Single JAR — no native dependencies, no SBCL, no shared libraries
• JDBC connection strings — use jdbc:mysql://, jdbc:postgresql://, jdbc:sqlserver:// etc. everywhere; driver-specific parameters pass through unchanged
• Java heap — no more Common Lisp heap exhaustion on large migrations; tune with standard -Xmx JVM flag
• SSL via URI — use ?sslmode=require / ?sslmode=disable in the connection string instead of --no-ssl-cert-verification

There were probably other problems/motivations for the rewrite not mentioned there, but I'm interested in the opinion from people with real-world experience, how complicated it is deploying (multi-platform) standalone CL executables.

First, it mentions dependencies on SBCL and native/shared libraries. (Let's ignore the fact that the self-contained JAR requires the JRE to be installed). First of all, I presume SBCL is only a build-time dependency, correct? The same way Clojure is required. Or are there cases where some SBCL runtime is required? For instance, Debian still ships pgloader v3.x, i.e. the CL implementation, and it's a standalone executable, it doesn't depend on SBCL (but depends on other system libraries). But if they mention it I presume these must be problematic for multi-platform deployments ??

Second, the issue about CL heap exhaustion. How common is this issue? Cannot it be tuned at comptime/runtime?

In general, from people with the experience, what are the challenges to deploy multi-platform standalone CL executables? Are there some basic guide lines you need to adhere to (besides writing portable CL, of course) for easy deployment?

EDIT: Also, wouldn't ABCL create a standalone JAR too?

Thanks in advance.

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

This AI harness allows you to modify the running code of the harness, via hot reload and leverage cl's built in power to build itself and whatever app you want alongside it.

edit: now with the repo actually public, my bad

We've open-sourced time-algebra, a Common Lisp library built around Allen's interval algebra: thirteen relations between two intervals, half-open by construction.

What it deliberately is not: no timezones, no clock, no get-universal-time, no I/O, no global state, zero dependencies beyond ANSI CL.

390 tests, plus a concurrency suite (8 checks, 1.28M iterations under contention) and an allocation profile (interval-relation at 0 bytes consed). Apache-2.0.

https://gitlab.com/lagoatech/time-algebra

Apache-2.0. Contributions and criticism both welcome.

Added a DSL for creating pages based on Lisp (of course) with primitives for charts (based on uPlot), selections, actions and more tings you are able to build (I use rollershutters here).

https://github.com/mdbergmann/chipi/blob/main/README-web.md#chipi-ui

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