I’m curious: was Arc running Racket BC or CS? I understand it got a big performance boost after switching to Chez Scheme.

    dang: It was running BC. I had high hopes for switching to CS because I'd heard the same thing you had, but when I tried it, HN slowed to a crawl. This stuff is so unpredictable.

we can explore libraries on https://github.com/CodyReichert/awesome-cl/

concise literals: serapeum's dict or other libraries bring you { } for hash tables and the like.

persistent collections: FSet (and more)

lazy sequences: series, gtwiwtg (generators) (and more)

pattern-matching: Trivia

many libraries are shipped in CIEL: https://ciel-lang.org/ (shameless plug)

---

> It’s currently used in …

more example companies: https://github.com/azzamsa/awesome-lisp-companies/

also: https://lisp-screenshots.org/

---

> at the cost of slightly slower startup times

that means ±30ms, not the Java-esque slow startup time ;)

---

editors: don't miss https://lispcookbook.github.io/cl-cookbook/editor-support.ht... and the new Mine, OLIVE for VSCode, ICL repl (terminal and browser).

* [clj-coll](https://github.com/dtenny/clj-coll) - Clojure collection and sequence APIs in Common Lisp, with optional Clojure collection syntax.

  * provides immutable Cons, Queue, PersistentList, capabilities as well as Vector, Set, and Map analogues built on FSet (but accessed entirely via Clojure APIs).

  * optional read syntax so you can type `{:a 1 :b 2}`, `#{1 2 3}`, and `[1 2 3]`.

* [clj-re](https://github.com/dtenny/clj-re/) - Clojure-style regular expression functions.

* [clj-arrows](https://github.com/dtenny/clj-arrows) - Clojure-compatible threading/transformation/arrow macros for Common Lisp.

editor: https://coalton-lang.github.io/20260424-mine/

type system: Coalton

> Common Lisp implementation on .NET. Lisp source is compiled to CIL (Common Intermediate Language) and runs on the .NET JIT — so the same Lisp image runs on Windows, macOS, and Linux across x86-64 and ARM64 without per-platform porting work.

(It's built in Common Lisp (LispWorks))

ps: you don't need to learn Emacs. A terminal even is enough. See the Cookbook/ Editors section.

Mine: a complete, single-download application that comes with everything needed to experience the interactive and incremental development programming workflow, including hot-reloading and on-the-fly debugging. For CL and Coalton.

https://coalton-lang.github.io/20260424-mine/

OLIVE: a new hand-made plugin for VSCode.

ICL: a new REPL for the terminal and the browser with advanced features.

as a bonus: a JupyterLite kernel based on JSCL that runs 100% in the browser.

find them all: https://lispcookbook.github.io/cl-cookbook/editor-support.ht...

games (Kandria),

Maxima,

a faster pgloader (https://tapoueh.org/blog/2014/05/why-is-pgloader-so-much-fas...),

hackernews (was rewritten to SBCL: https://lisp-journey.gitlab.io/blog/hacker-news-now-runs-on-...), first reddit…

https://lisp-screenshots.org/

https://www.lispworks.com/success-stories/

also Emacs (for another dialect).

Common Lisp for Python: https://github.com/marcoheisig/cl4py

call Python from CL: https://github.com/digikar99/py4cl2-cffi

Here you will find some screenshots of some of today's web applications built in CL: http://lisp-screenshots.org/ and here an opinionated tutorial: https://web-apps-in-lisp.github.io/ One example: ScreenShotBot https://screenshotbot.io/ a successful open-source product and company. It now replaced Facebook's automatic screenshot testing tool (source: their blog). So, web apps in Lisp are possible -with a right amount of learning time and elbow grease.

The incremental development and interactive top-level are still precious and unmatched.

    (defparameter *a* (list 1 2 3))

- why nothing on the "compiler" line? Everytime you load a snippet or a file with SBCL, it compiles it (to machine code). There's also compile-file.

- interpreter: likewise, all code is compiled by default with SBCL, not interpreted, even in the REPL. To use the interpreter, we must do this: https://github.com/lisp-tips/lisp-tips/issues/52

- command line program: the racket cell shows the use of -e (eval), the same can be done with any CL implementation.

- since the string split line introduces cl-ppcre, one could mention cl-str :D (plug) (much terser join, trim, concat etc)

- ah ok, for dates and times, flattening a list, hash-table literals… we need more libraries.

- more files operations: https://lispcookbook.github.io/cl-cookbook/files.html

- emacs buffers: now compare with Lem buffers 8-)

- posix-getenv: I'd rather use uiop:getenv (comes in implementations).

- uiop:*command-line-arguments*

- exit: uiop:quit

- uiop:run-program (sync) / launch-program (async)

- java interop: with LispWorks or ABCL (or other libraries)

my 2c