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).
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.
Oh wow, just had to log in and give you a high-five for livelove because this is the first I've heard of it and it sounds like the sort of thing I absolutely need to try out.
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!
I guess the prevailing worldview is that "recompile everything and re-run" is good enough if it takes 2 seconds. But agreed that it just "feels" different when you're doing live in lisp... I miss Emacs!
Can't you just do live code reloading with a DLL? Have a small core which is the exe, and then all of the logic is a DLL which can be reloaded when the core detects changes to the dependent files...
Have you done some kind of a write-up on how to do this? Lua is popular enough that I suspect there might actually be a demand of a readymade library to use hot reloading.
I use Common Lisp (CL) for some of my small personal projects. A few publicly available examples I can share include my website [1] and a now-defunct mathematics pastebin [2]. My CL projects are usually text-oriented, not graphics-oriented. What keeps me coming back to CL is how convenient the live coding environment is.
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.
I tried using CL this year for a new version of my personal static site (blog) generator.
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.
Processing is what ignited my passion for programming and Quil has become my favorite way of writing it. It is amazing that you can re-evaluate the draw/update function in a running sketch and immediately see the changes, without having to reload the whole thing. And on top of it you have the beauty of the whole Clojure Stdlib with its immutable datastructures.
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.
This reminds me of the excellent CEPL library (https://github.com/cbaggers/cepl). You can write live shader like programs with cepl with an OpenGL backend.
Among the plethora of strong suits that Common Lisp brings along, the live coding is hands down the best part of it. There is just no better way to experience programming than that.
Sure, the condition system is awesome, CLOS is next to nothing, but the live coding just wins al the way. All the other aspects are just icing on the cake for me.
Reminds me of something from like 2007ish(?)~ called (fluxus). It was a lisp text editor with a render target in the background and some nice standard library for making 3d objects appear or sfx play. Everything was constantly evaluating/hotloading in the background.
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.
Working on a largeish typescript node project right now and no support for recompiling a single function in a live system means I have a good minute of downtime on every change. The lisp paradigm would be so refreshing here.
Love this. Sketch, in particular, looks really exciting to me. I'll have to take a look into trying it out. I still have dreams of doing some of the ideas in Turtle Geometry on a modern computer.
I am not sure if this is what you mean, but the original UCBLogo (which I think is used in the Turtle Geometry book) is still alive and maintained[1] (not by the original authors, but Brian Harvey seems to chime in every now and then) and it does run well on modern computers.
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 sounds like a great developer experience, but the path from live-coded LISP graphics to a game that can be made public on ie. Steam is a long and troublesome path, compared to using for example OpenGL and C++.
I wish more programming languages focused on quick compilation times, easy cross compilation and straightforward deployment in general.
[+] [-] jasonjmcghee|11 months ago|reply
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.
[+] [-] adityaathalye|11 months ago|reply
> 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
[+] [-] J_McQuade|11 months ago|reply
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!
[+] [-] swah|11 months ago|reply
[+] [-] chaosprint|11 months ago|reply
https://github.com/toplap/awesome-livecoding
also this live coding book is free to read!
https://livecodingbook.toplap.org/
[+] [-] hyperbolablabla|11 months ago|reply
[+] [-] HexDecOctBin|11 months ago|reply
[+] [-] susam|11 months ago|reply
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.
[1] https://github.com/susam/susam.net
[2] https://github.com/susam/mathb
[+] [-] klibertp|11 months ago|reply
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.
[+] [-] kailden|11 months ago|reply
https://github.com/quil/quil
I’ve been using quil as I work through _The_Nature_of_Code_ by Daniel Shiffman:
https://natureofcode.com
[+] [-] phforms|11 months ago|reply
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.
[+] [-] joeevans1000|11 months ago|reply
[+] [-] z3phyr|11 months ago|reply
[+] [-] fredrikholm|11 months ago|reply
https://www.youtube.com/watch?v=I0kWZP9L9Kc
Wonderful CL channel in general.
[+] [-] rootnod3|11 months ago|reply
Sure, the condition system is awesome, CLOS is next to nothing, but the live coding just wins al the way. All the other aspects are just icing on the cake for me.
[+] [-] gen_greyface|11 months ago|reply
this is livecoding 3d voxel to solve puzzles. the demo was fun. looks like it'll be released soon.
[+] [-] bschwindHN|11 months ago|reply
[+] [-] MrLeap|11 months ago|reply
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...
[+] [-] baq|11 months ago|reply
[+] [-] dismalaf|11 months ago|reply
[+] [-] taeric|11 months ago|reply
[+] [-] phforms|11 months ago|reply
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).
[1]: https://github.com/jrincayc/ucblogo-code
[+] [-] xyproto|11 months ago|reply
I wish more programming languages focused on quick compilation times, easy cross compilation and straightforward deployment in general.
[+] [-] whaaswijk|11 months ago|reply
[+] [-] gitroom|11 months ago|reply