One of my favorite talks is "Stop Writing Dead Programs" (https://www.youtube.com/watch?v=8Ab3ArE8W3s) and touches on a lot of what could be in terms of live development.
Lisp is very well-suited to live development due to code being data, but live development doesn't need to be lispy.
I built a live development extension for Love2D which lets you do graphics livecoding (both lua and glsl) in real-time - every keystroke updating the output, (if a valid program).
https://github.com/jasonjmcghee/livelove
Here are some (early) demos of things you can do with it:
https://gist.github.com/jasonjmcghee/9701aacce85799e0f1c7304...
So many cool things once you break down the barrier between editor and running program.
I've also asked myself the question of, what would a language look like that was natively built for live development, and built out a prototype - though it's definitely a sandbox so haven't posted it anywhere yet, other than demos on mastadon.
> On the need to sustain your creative drive in the face of technological change
> https://thecreativeindependent.com/people/multi-disciplinary...
nb. I recently submitted it here: https://news.ycombinator.com/item?id=43759204
More people need to read Jack's interview, especially in the context of the contemporary tension between generative AI v/s wetware creativity.
I've been plastering that interview in every discord / slack / zulip I lurk in, and been sliding it into everyone's Whatsapp DMs :D
I remember giving Love2D a go a couple of years ago with Fennel and the lack of such a thing sent me grumbling back to Common Lisp. I'd never even have thought of building that functionality in Love/Lua myself - assuming it's something that the runtime just didn't support - and it absolutely would never have occurred to me to use LSP to set it up. I've not even used it yet and it's already doing things to my brain, so thanks!
It’s good that it’s fast. Still no good enough!
But "live" is a whole different thing. And most languages aren't built with the expectation that you'll be patching it while it's running - at least as standard operating procedure and without nuking state.
And that's a key part.
I think you should be able to build an app and develop a game without ever having to restart them.
And that would come with new challenges and the need for new tooling / constructs. E.g. When you change a type / structure, and there's existing state, what happens? (migration, deletion etc)
https://github.com/toplap/awesome-livecoding
also this live coding book is free to read!
The short of it is, you need a communication medium between LSP and your program. When you edit a text file, it needs to tell the program it updated, along with the latest text.
To communicate the values of variables is more work- you need a way to keep track of all changes to all variables. I wrote auto instrumentation code that wraps every modification to every variable in the files it instruments (which for livelove is everything but the library files themselves). Obviously this isn't perfect, but it does pretty well- and to see the value of anything you just need to make sure it's assigned to something somewhere or modified (very likely already the case).
---
There are absolutely hot reload Lua libraries- there's even an IDE where this is a key feature!
When I am exploring ideas that are not fully concrete yet, I can begin by writing a small set of functions with very basic functionality. Then as the ideas evolve, I can refine existing functions or add new ones, then quickly "reload" them (with say, C-M-x in Emacs), and see the effects immediately. There is no separate compile or rebuild step. I don't have to restart any service or application. The effects are truly immediate -- what previously did X, now does Y.
In the Python or JavaScript ecosystems, similar live reloading capability is often provided by frameworks (e.g., FastAPI, React, etc.), which monitor file changes during development. In CL, it's just part of the language implementation itself.
Of course, at the end of the day, everything is committed and pushed to a version control system. Sometimes I restart the application too just to be sure it reflects the actual source, especially, after hours of live reloading. The stereotype of Lisp programmers making all of their modifications in an ephemeral image and then dumping it all to disk is not something I have actually seen in practice, at least not among the people I know.
So the rest of the software development practices happen to be typical. But during exploration, debugging, or troubleshooting, the live coding experience in Common Lisp is so seamless, it feels like programming at the speed of thought.
Yes, it's incredible and still an alien technology in some respects. Native AOT compilation at the level of functions with hot swapping - and without any ceremony, always available in the IDE - is one of them. As the OP writes at the end, only Smalltalk and Erlang come close.
But, when viewed objectively, in 2025 CL is quite behind in some aspects:
- Only one commercial IDE offers a true graphical debugger. Both SLIME and SLY (I'm not sure about stickers) fall behind JS or Python environments.
- Asynchronicity is based on explicit callbacks or callbacks wrapped in promises (and some macros). No async/await, no coroutines. Since writing async code is harder, people default to sequential code and a thread pool. For IO-bound apps, this unnecessarily adds synchronization problems that would be mostly avoided in single-threaded concurrency.
- Tiny ecosystem of libraries. Due to the stability (or stagnation) of the language, a lot of old code still works, but even with this, finding what you need on Quicklisp can be challenging.
- The stdlib is old, crufty, and quirky. It's also very small by today's "batteries included" standards. Initiatives like CL21 or CIEL try to alleviate this somewhat.
- Even in SBCL, the type system is limited compared to MyPy, TypeScript, or TypedRacket.
- Bolting packages (module system) on top of symbols leads to some problems in practice.
- The progress in CL development is severely hampered by the set-in-stone standard, small pool of users, and the need to reconcile 10 different implementations.
It's still a nice tool for many uses, and the interactive development is indeed comfortable and productive. Still, if nothing significant happens, I don't think CL will have a chance to gain popularity again. Up until now, a successor language was hard to justify - despite some shortcomings, CL was still a language from the future. Now that future is largely here already, so the shortcomings become more and more glaring. There's SICL, but it'll take another decade (if at all) before we can expect results from that.
I'm now looking at Jank and Gerbil with some expectations, though I think I'll stick with CL in my current project.
Packages are namespaces, unrelated to modules. They are not used to organize dependencies but to remove ambiguity of naming and to provide encapsulation.
> The progress in CL development is severely hampered by the set-in-stone standard, small pool of users
The language is extensible, compilers do get new features added, sometimes in a coordinated manner. Standard being stable is not that significant an obstacle to moving forward; pool of users being small is much more noticeable. Yet more noticeable is that community is less healthy than the Emacs one. This comparison is valid because development in Emacs Lisp is attractive for the same reasons, unique to it and CL; they also happen to have extremely similar syntax. Elisp is moving forward steadily, and in recent years quite rapidly. CL would progress forward similarly, or better, had it had something like Emacs that provided that synergetic effect.
(I don't know for popularity but my personal opinion is that CL is still unmatched: this level of interactive development + good debugging tools + excellent implementation that compiles to fast machine code + fast startup for binaries + self-contained binaries + stable yet improving language, implementations and ecosystem + connect from a running program + commercial vendors if you need + … such a unique and productive set)
(re. the type system: https://github.com/coalton-lang/coalton/ for a Haskell on top of CL now)
I dunno what you are using but we are a small team working on large codebases; one in js/ts mix, one in python and one in cl. Everyone cannot wait for it to be CL time; everything js and especially ts feels so incredibly clunky and half baked. The debuggers are awful and actually don't even stop on breakpoints a lot of the time for no apparent reason.
For most things in cl you have libraries (async etc) and for the rest you roll your own (much) faster than you can try out the tearinducing garbage on npm to figure out what half baked buggy thing might fit your purpose (before it gets hijacked by some north Korean hacker group of ofcourse). With LLMs this has become way easier.
Using the strong typesystem cl has and then adding on coalton when you need it, I prefer over typescript, if only for the speed of dev / no noticeable recompile.
I’ve been using quil as I work through _The_Nature_of_Code_ by Daniel Shiffman:
I just learned that there is now a tweak mode in Processing that lets you tweak certain parameters in the code (via draggable values, etc.) while the sketch is running, which is pretty awesome for experimenting with values. However, you still have to reload the whole sketch when you want to change other parts of the code, you can’t just eval a function in the editor and get immediate feedback like in Quil.
https://www.youtube.com/watch?v=I0kWZP9L9Kc
Wonderful CL channel in general.
So much fun, I can't find any of the videos in a quick search, so maybe lost to time. Great performative lisping in them hills though.
EDIT: I did find the old page on the wayback machine. https://web.archive.org/web/20120810224932/http://www.pawfal...
Edit - can also apparently do it with TS directly with Deno (also V8), here's an example: https://dev.to/craigmorten/how-to-code-live-browser-refresh-...
Now that I think about it, Logo seems to be pretty much a livecoding environment (not surprising given that it is a Lisp, but with less parentheses). You can define and edit functions from the REPL while the program continues with the same state, the same canvas. You can even pause e.g. a running procedure that draws a polygon, rotate and move the turtle and then continue the polygon procedure with that new state (at least this is possible with UCBLogo).
this is livecoding 3d voxel to solve puzzles. the demo was fun. looks like it'll be released soon.