I’ve been building the Common Lisp programming environment I want to work in, and I’d love some help testing it.

It’s called Turbo Lisp (based on SBCL). It brings together a Listener, debugger, object inspector, conditional breakpoints + stepper, and Zeta—an extensible editor in the Emacs tradition, written in Common Lisp.

On macOS, it uses native AppKit UI through Chattanooga, a Lisp/Objective-C bridge I built. It also runs in the terminal through Oak Ridge, my Lisp port of Ratatui. Both use WhateverCLIM, which is the CLIM2 code from Franz plus my own modernization, including presentations: displayed Lisp objects you can click and inspect.

Rather than write a wall of text, here are two short, captioned demos (you may need to switch to 1080p on YouTube):

• Native macOS: encounter a bug, find its source, and repair the running program
• Terminal: debugger recovery, inspecting objects, and editing pixel graphics—did you even know terminals could do that?

v0.2.1 patch release is available for Apple Silicon Macs, Intel Macs, and Linux x86-64. The Mac builds currently require macOS 26.

I’m especially interested in hearing:

• Does it install and start properly on your machine?
• Can you find your way around the Listener, editor, and debugger?
• Does the terminal interface work with your terminal emulator?
• Where does it feel confusing, awkward, or broken?

You don’t need to be a CLIM expert. A report that says “I tried this and got stuck here” is useful. Please include your OS, CPU architecture, and terminal emulator where relevant.

It’s still early, and I’m looking for honest feedback from people using it outside my own setup.

Source, README, and downloads

# UK Racket meet-up (London) Tuesday 20 October 2026

7:30pm at The City Pride 🍕 28 Farringdon Ln, London EC1R 3AU

Join us for discussion and pizza. All welcome.😁
From November we will be doing short talks and demos!

https://racket.discourse.group/t/uk-racket-meet-up-london-tuesday-20-october-2026-7-30pm/4430

https://luma.com/em6sejij

As far as I know this book was hard copy only. Does anyone know if this is legitemate?

The system had a large-scale parallel hardware system called a parallel inference machine (PIM), and five PIM models were produced, including the PIM/p comprised of 512 constituent processors, and the PIM/m comprised of 256 constituent processors. Approximately ¥54 billion was invested in the project over 11 years, and it came to an end in 1992.

https://museum.ipsj.or.jp/en/computer/other/0002.html

Or European "ESPRIT"

https://cordis.europa.eu/programme/id/FP2-ESPRIT-2

That's interesting which way that Lisp AI-wave scare particular National Tech Pops at 70'-80'-90'.

All for nothing.

Except this artifact of ancient hitek civ's Casio Lisp Pocket machine which, even broken, ads for 700+ $ at present time.

yep. whole post about this small cute japan pocket Lisp/Prolog machine. Not refrigerator sized CAR/CDR but 1989 year born. 8-) Love it.

I've just released Easy-ISLisp version 5.69.

This is a small maintenance release that fixes a compilation error in main.c encountered when building Easy-ISLisp with GCC on WSL2.

The issue was caused by a variable declaration immediately following a case label in the command-line option handler.

The fix was simple: enclosing the relevant code in a block using {}.

There are no other changes in this release.

Sometimes maintaining a language implementation is just about fixing little things like this!

GitHub: https://github.com/sasagawa888/eisl

Happy Lisp hacking!

Have any of you done Topology x Lisp research ?

Topological Analysis of Lisp syntax is something I’m actually very interested in for FuturLang research

# Missed RacketCon this year?

The videos are now available at https://con.racket-lang.org or https://youtube.com/playlist?list=PLac8FQVpsRAU&si=fPf0NNLIMv14WtfR

Discuss on the Racket [Discourse](https://racket.discourse.group/invites/VxkBcXY7yL) and [Discord](https://discord.gg/6Zq8sH5)

Please consider sponsoring us https://racket-lang.org/rplf.html

I'm currently working on a project looking at how/why devs and CTOs choose programming languages, and I'm particularly interested in understanding people's experiences with Clojure.

The survey takes about 7 mins, and I'd love to hear from as many people as possible!

Appreciate it 🙌

Here's the survey

Finally posting after lurking here for a long time. Friends don't care too much about this sort of thing.

This is written in Odin, with my own small Lisp interpreter from over 5 years ago. Lisp was the easy choice, primarily because paren's are easier to parse into pretty circles, but also it is much lighter than including Lua.

Using Raylib for the rendering.

There are tons of things I want to implement, but I finally got it into a state that I'm happy sharing something about it. Like one thing I want to change is that spells shouldn't define the cost, but functions like `move-toward` should consume MP as they are called.

There are other spell effects not demoed: shield, heal, buff, debuff, damage, status, teleport, etc.

As for the window decor, a Windows 7 skin for KDE Plasma.

Hi all,

Younger dev here I’ve been reading the SICP book and also blog posts about Common Lisp and Emacs Lisp and I’m fascinated by the culture during its heyday (e.g. Symbolics era). But I didn't find more anecdotes besides the one here about how in the 1990s a piece of Germany’s air traffic control software ran on Emacs.

I’d love to hear about the programs you used to deal with and overall what tasks you think Lisp excelled in.

Thank you!

Hi community. It's been now a bit more than 2 years since I started to work on this "project management project", with many ideas and with a good vision of how to improve and be better than certain bespoke commercial tooling out there. I am happy to announce version v1.6.7 with a lot of polished aspects and new features that make it a joy to use (even if I say so myself)

LucidPlan is a simple, hackable, free and open source project management software that you can easily self-host, you only need something that runs Guile Scheme and a SQLite database. (Guix is recommended, not mandatory)

I spent years using things like Jira, Trello, Asana, GitHub projects and eventually became frustrated with how much complexity gets piled onto what should essentially be:

projects → tickets → priorities → workflow → done

I decided to build my own as a challenge, but also to create something blazingly fast and simple, that people can quickly learn (even applicable to non-tech projects). Also I aimed for ease of self-hosting, no SPA frameworks and no dependency on proprietary clouds or software.

LucidPlan is licensed under the GNU AGPLv3 or later. Source code:

https://codeberg.org/jjba23/lucidplan

You can also look at my running instance:

https://lucidplan.jointhefreeworld.org/

The project leverages the power of Lisp (Guile Scheme) by using SXML for front-end aspects, clean controllers with Artanis and a powerful repository pattern abstraction.

What does it do?

• Manages your project backlogs with ticket priorities
• Native drag-and-drop ticket reordering (priority)
• Kanban boards with drag-and-drop status changes
• Global/project search (still more work to be done)
• Users, assignees and fine-grained permissions
• Light/dark mode
• Keyboard-accessible ticket and project lists
• Org-mode syntax in ticket titles and descriptions
• Org links and rich Org content rendered to HTML
• Hackable/customizable with Scheme
• Lightweight, and mobile-friendly
• SQLite backend
• Lightweight vanilla JavaScript on the frontend for some interactive enhancements

The Org-mode integration is particularly fun: you can write ticket descriptions using Org syntax and LucidPlan renders the result as HTML.

For example, your ticket can contain things like:

* Investigate weird bug

The problem seems to happen when [[https://example.org][this thing]] is enabled.

- Check configuration
- Reproduce the problem
- Fix it

…and LucidPlan renders that into the ticket as pretty styled HTML. (see orgwebalchemy post: https://www.reddit.com/r/lisp/comments/1wox8h4/parsing_org_mode_with_parsing_expression_grammars/ ).

There is still plenty to improve, and I'd genuinely love feedback from people who actually use project-management software daily. I think you'll find LucidPlan as a refreshing take.

Especially interested in hearing from the community:

• What do you hate about existing project-management tools?
• What features do you consider essential?
• Would you use a Lisp/Guile-based project-management system?
• What would make LucidPlan useful for your own projects? What killer feature can I work next?

Happy hacking :-)