vindarel

+1 to explore Coalton. It's also talked about on this website and often by its authors.

Links to Coalton and related libraries and apps (included Lem editor's mode and a web playground): https://github.com/CodyReichert/awesome-cl/#typing

lparallel's website is back here: https://sharplispers.github.io/lparallel/ :) (https://github.com/sharplispers/lparallel)

Lem's Coalton mode looks good: https://lem-project.github.io/modes/coalton-lang/

I'd prefer that a LispWorks user answer, but there are quite a few interesting features, such as:

- tree shaking and small binaries (±5MB a GUI app)

- the CAPI cross-platform and native GUI toolkit

- mobile platforme runtime (iOs, Android)

- its Java interface

- its KnowledgeWorks system for "rule-based, object-oriented, logical, functional and database programming"

- more?

ps: today we maintain a list of pretty decent libraries: https://github.com/CodyReichert/awesome-cl/

I think LispWorks is fine (also look at these plugins https://github.com/apr3vau/lw-plugins - terminal integration, code folding, side tree, markdown highlighting, Nerd Fonts, fuzzy-matching, enhanced directory mode, expand region, pair editing, SVG rendering…) but I had this feeling with the newer web-based Allegro IDE (the poor syntax highlighting surprised me, did I do sthg wrong?).

I can't load my side projects in LispWorks' community edition, so… (because of the heap limit)

excellent, thanks!

TBH no people don't google (what they don't expect to see), repetition and showing links is necessary. I hadn't followed along. Hope it will get contributors.

ACK, allright. I just want to point people to stuff. Create emulation. Show that the ecosystem is evolving -in the right direction even, maybe. That we are not doomed to stay with Emacs&SLIME. A few years ago, we didn't have SLIMA, the VSCode plugin, Jupyter and JupyterLite kernels, the very useful ICL, nor CLOG, nor these incomplete IDE attempts (Intellij, Sublime…). How good is the new Zed plugin BTW? https://github.com/etyurkin/zed-cl

(I'm not even evangelizing in these comments so thanks for the feedback I guess!)

That's awesome, thank you. How do you know it, is there a reference on the net somewhere?

Thank you, TLS should be fine now. (fixed ±12 hours ago)

JetBrains IDE plugin for Common Lisp: https://github.com/Enerccio/SLT (I'm sure you saw it before and I don't know how polish it is, and I'm pretty sure it has less features than Emacs&SLIME, yet, but I must link it for reference. Because yes, before 2023 we could complain there were no JetBrains IDE plugin for Common Lisp, since 2023, we have one.)

New projects are making the newcomer experience easier:

- ICL https://github.com/atgreen/icl/ a full featured REPL in the terminal and the browser.

- JSCL's playground 100% in the browser https://wiki3-ai.github.io/jscl-kernel/ (very new)

- constantly new editor plugins. A new one: Zed https://github.com/etyurkin/zed-cl (all editors, for readers, including VSCode, Pulsar etc: https://lispcookbook.github.io/cl-cookbook/editor-support.ht... Those editors appeared in recent years. So, I see a good trend in the ecosystem).

There's a new one, pretty good, resembling Python/Julia syntax, check it out! https://moonli-lang.github.io/

    defun multiply-thrice(x):
      print(x * x * x)
    end

    multiply-thrice(23)

> so many shortcomings and missing features

I suggest to have a look at CIEL: https://github.com/ciel-lang/CIEL/

-> CL, with batteries out of the box: http, json, csv, DB, functional data structures, regexp, pattern matching, missing docstrings, missing functions, easy script runner…

and to Epsilon: https://github.com/jbouwman/epsilon/

> Epsilon is a Lisp programming environment built using SBCL that provides functional data structures and some encoding, cryptographic hashing and network programming capabilities.

Hello, yes there's project scoping: https://lem-project.github.io/usage/usage/#project-commands (added by yours truly, which was easy thanks to Lem's quality code base). I find the vim layer excellent, you can open an issue if you find obvious things missing.

Recently added in Lem: tree-sitter for JSON, YAML, Nix, Markdown, WAT; new language modes: Clojure, Perl, Kotlin, Zig (with LSP); git-gutter mode.

Lem has a (quite simple still) Git/hg/fossil interactive mode (interactive rebase is there but no reword for instance) and org-mode support is coming (https://github.com/mahmoodsh36/organ-mode).

Lem now is ncurses + webview (+ the non-longer maintained SDL2 backend) and it has daily multi-platform binaries. Try it out!

https://lem-project.github.io/

The same day, after this post, SBCL's main developer made reduce faster (https://www.reddit.com/r/lisp/comments/1pmip8o/fast_sequence...). Let's see on the next SBCL release what the final results are.

Differences I see with cl-repl (https://github.com/lisp-maintainers/cl-repl):

- icl doesn't have an interactive debugger, you ask for the backtrace with ,bt. cl-repl has one (less feature complete than Slime). I actually like the lack of a debugger for newcomers.

- icl: does auto-indentation right

- cl-repl: has an %edit command to launch an editor and load the file content on close.

- icl: better, prettier autocompletion with a drop-down. cl-repl is based on readline.

- icl: based on Slime's backend, so you can connect to another running image.

- cl-repl: has a ! shortcut to execute a shell command.

- cl-repl might be faster to launch.

big thanks to atgreen for all the nice projects!

The other way round, a Haskell on top of a Lisp, in production today: https://github.com/coalton-lang/coalton/

> Coalton is an efficient, statically typed functional programming language that supercharges Common Lisp.

Presentation this year on the ELS: https://www.youtube.com/watch?v=of92m4XNgrM

It's interesting to know your use case, thanks. I don't like dealing with package-inferred-systems when exploring, reading or using other people's libraries.

Pretty good, except and I don't share the advice to use package-inferred-systems, like, at all. It hides the third-party libraries you rely on, it prevents you from using one package in multiple files (a flexibility not common out there), you can't see the project's structure at first glance… just use a simple .asd file declaration, you'll be fine.

more: https://lispcookbook.github.io/cl-cookbook/

libraries: https://github.com/CodyReichert/awesome-cl/

You can pin dependencies with Qlot or Ocicl (or vendor them with vend), but it might be a long time before you actually need this (the ecosystem is pretty darn stable).

https://github.com/fukamachi/qlot/

https://github.com/ocicl/ocicl/

https://github.com/fosskers/vend/ (new)

between CL, some say it's the debugging and interactive experience: https://gist.github.com/vindarel/c1ef5e043773921e3b11d8f4fe1...

Arc was re-written to Common Lisp (SBCL) around last year, for performance reasons.

> [Clarc] is much faster and also will easily let HN run on multiple cores. It’s been in the works for years, mainly because I rarely find time to work on it, but it’s all pretty close to done.

> there’s now an Arc-to-JS called Lilt, and an Arc-to-Common Lisp called Clarc. […]

> open-sourcing the Arc implementation (i.e. Clarc) would be much easier [than the HN site]. [Because…]

more and sources of Dang quotes: https://lisp-journey.gitlab.io/blog/hacker-news-now-runs-on-...

And the Lem editor (an Emacs-like in Common Lisp).

it's confusing but there's actually written "kragen sitaker" on the article title as if it was an invite post.

Is it the right link? "Lisp" is mentioned once, in a good way. It's an old post too, it mentions Emacs' ilisp mode, which is the now unused ancestor of Slime.

Just to counter-balance the inferred conclusion that Common Lisp would not have any commercial usage (sorry, words are important, FUD is too close from hasty wording or hasty conclusions): https://github.com/azzamsa/awesome-lisp-companies/ (example companies using CL today, and yes some pick it for new projects, and yes some hire) (and I don't want to argue if the list is impressive or not: it's some commercial usage :D best,)

Old Lisp posts are cool, then if you want a refresher of what's happening in the CL ecosystem (tools, libraries, compilers…) here's an overview of the last two years (shameless plug): https://lisp-journey.gitlab.io/blog/these-years-in-common-li... and very cool new projects appeared in 2025.