Huh, I wonder why they made their own IDE instead of integrating with Sly/SLIME. Not trying to knock the project, just genuinely curious. Writing a whole editor sounds like a lot of work.
I like the choice of Iosevka as a font, though.
Edit:
One value I do see myself getting from Mine is as an example Coalton project. Last time I tried Coalton I couldn't figure out how to get ASDF to load standalone Coalton files. Now I have a working example to copy.
> However, the above is a tall order for someone just wanting to dip their toes in, to see if they have any interest in Coalton or Common Lisp. A couple hours on the weekend is easily sunk into getting configurations right, and the right subsystems installed, and the right paths setup, just so the first line of code can be executed.
> mine is not Emacs. It aims to eliminate all of that, and be a Coalton/Lisp-first development environment, whose only job is to be a Coalton/Lisp-first development environment. But more than that, it needs to be accessible. A non-programmer should find it easy to download, install, and run mine with nothing more than a download link.
I think the number of non-programmers who think 'I want to learn to program; I'll start with common lisp but emacs is too difficult!' is so small it is not a group worth considering. It's probably MIT & Stanford undergrads?
It's their IDE and they can design it how they want, but that's a weird goal for a CL IDE.
"It should be easy enough for" sets a UX bar, not a target audience. Kind of like the English phrase "X is so easy that even a toddler could do it," regardless of whether such a statement is figurative or literal.
I personally suspect that the overwhelming majority of those complaining would find a different reason to not learn lisp if the Emacs barrier were removed, but I very much might be wrong.
Coalton is also a full-featured embedded language of Lisp that is sufficiently paradigmatically different than run-of-the-mill Lisp code you'd see in a Common Lisp textbook, since it has a complete, Haskell-like static type system and Lisp-1 naming. Coalton also sees active development because aspects of the language continue to evolve.
The consequence is that an integration with SLIME would have to be a very extensive contrib [1] that is shipped with the Coalton version the user is using, and updated whenever Coalton is updated. No doubt the contrib would have to be very elaborate—it would have to hook in to basically every aspect of SLIME and SWANK if it should be "Coalton-native", from the display of type errors to how auto-complete is handled. Unless the contrib author is very meticulous about backward compatibility, then version mismatches would make everyone involved unhappy. The contrib author would get annoyed at constant bug reports about things not working (even if there's a nice "your Coalton or contrib are out-of-date" error), and users would get annoyed they have to keep a Lisp library in sync with an Emacs add-on.
None of this gets to the matter that Emacs simply isn't a popular text editor, and it's not really the one people are rushing to learn, even if it has substantial merit. I don't know how trustworthy this source is [2], but it claims that Emacs represents a fraction of a percent of the developer community. Even if it's off by 10x, it's still 1-in-50 developers at best.
Iosevka is the king of scalable terminal/programming fonts. I'm not sure why, maybe it's because the glyphs have lines and angles that look "terminal-y" in the same pleasing way Terminus and the 3270 font do whilst avoiding the problems that accompany trying to scale a pixel font.
Everybody has its own preferences. I have tried it out (linux, command line version) and I can report: Mine is really fast and responsive compared to other Lisp IDEs like emacs which appears to be slow like a snail in comparison.
Interesting! Looks like the IDE itself is written in Coalton (https://github.com/coalton-lang/coalton/tree/main/mine) and you can either bring your own terminal or use the standalone version which uses Tauri and Xterm.js.
I'm going to download and check out Mine and Coalton. Right now, I use Neovide and Lem interchangeably. However, I am in deep with Shen. I bought a hardcopy of The Book of Shen, 5th Edition, and I still have Peter Kogge's 1991 text, "The Architecture of Symbolic Computers". I suspect the Hindley-Milner type system in Coalton will be more familiar to the Haskellers out there, but it is not as strong as Shen's Sequent calculus type system. In Shen, computation is allowed in side-conditions (if, let, and, etc.), so you can compute over terms inside types. Shen wins for raw expressive power and programmable types. Shen is very portable, but being a DSL, Coalton must integrate nicely with Common Lisp. And you get native exe's. Glad to see a simple way for people to program in CL or Coalton without having to go through the decades I have done with Vim and Emacs. VS Code bores me, but it is practical, even if it seems like junkyard truck with everything bolted on or hanging off of it.
I live in Emacs, but I will give Mine a try when get a free hour. I read about Coalton in X and follow the author but I haven't invested time yet to try out.
If you're a power user, the sooner you learn Emacs the better as the synergies with any Lisp language (particularly Common Lisp) are simply too strong to be ignored and there is no contemporary alternative that rivals it.
For new users, this looks like a welcome alternative to messy things like Lem that never really worked very well for me.
For historical interest, Lem did used to advertise itself as a Common Lisp development tool specifically, but that has changed relatively recently (past year?). From my distant vantage point, it looks like general interest in it grew, and Lem itself evolved in general-purpose directions, so they pivoted the messaging to be about it serving as a general-purpose editor instead of one just for Common Lisp.
Emacs on native Windows has to go through the Win32 API for everything - file I/O, process spawning, subprocesses. Packages that shell out constantly (lsp-mode, magit, etc) will feel sluggish because spawning processes on Windows is genuinely slow compared to Unix. The more shell-heavy your config, the worse it gets. This isn't really Emacs' fault.
I really don't understand devs still insisting on running Emacs on Windows natively. Come on, guys, WSL2 been around like forever. You get real fork/exec speeds, proper shell integration, the full Unix toolchain, etc. Why choose inflicting pain instead of a trodden, well-known, existing path?
Two decades professionally here too (and nearly three in terms of programming as a whole), and I still use ‘em. Reviewing and adjusting, they make for quite a good experience even in agent-first development with the various nice extensions.
Also I still have to write code by hand, because there’s a whole bunch of edits and adjustments that I’m far faster at shrug
>Also I still have to write code by hand, because there’s a whole bunch of edits and adjustments that I’m far faster at shrug
I'm faster too, in general. The thing is now with AI I'm working on at least 3 to 4 projects in parallel. I tell the AI to do an edit and I context switch to something else.
I do the same, but 3-4 is simply too many. I would guess you’re smarter than me, because more than 2 and I’m already at a fixed bottleneck of reviewing it (and reviewing my teams output on top)
nah reviews take a while right? You can have 2 or 3 agents running in the background while you review. It has nothing to do with intelligence. You can review one project while having 20 agents run in the background too... your intelligence is conceptually orthogonal to the amount of agents you have running.
Then you are probably not interested in this work at all. It is meant to develop Lisp—a language whose primary advantage in 2026 is ergonomics to humans, particularly a certain kind of human. If you're doing 100% agentic development, that advantage disappears and you might as well use something popular and statically typed, like Rust or TypeScript.
> If you're doing 100% agentic development, that advantage disappears
I beg to differ. Turns out, Lisp REPL - an actual, "true" REPL, not something like Python's (which is not the same), is an enormous multiplier for agentic workflows.
a) Lisp code can be very terse yet retain its readability - it never becomes cryptic like APL. Therefore, it's more token efficient. It was actually proven that Clojure is one of the most token-efficient "mainstreamish" PLs. https://martinalderson.com/posts/which-programming-languages...
b) When you give an LLM a closed loop system where it can evaluate code in a live REPL and observe the results, it stops guessing and starts reasoning empirically. Instead of predicting what code will do, it can run it, read the output, adjust, and iterate - the same way a skilled human developer works. Incremental evaluation of forms maps naturally to how an LLM generates tokens.
This isn't some theoretical hand-waving - I experience it every day - my WM on Mac is yabai that gets controlled via Hammerspoon, which uses Lua, which means I can use Fennel, which means I can use Lisp REPL. I would give the LLM a task, something to do with my app windows - it connects to the live REPL and starts analyzing, prototyping and poking into things interactively.
All my custom MCPs are written in babashka (Clojure) https://github.com/agzam/death-contraptions - whenever there's a problem or I need to improve my AI harness, LLM just does it from "inside out" and it takes less time and fewer tokens.
My main editor is Emacs - LLM can fully control it. I can make it change virtually any aspect of it. To load-test the MCP that does that, I made it play Tetris in Emacs. And not just to run it, but to play it for real - without losing. It was insane.
And of course, day-to-day I have to deal with non-Lispy, non-homoiconic languages more. And to be honest (even though of course I'm biased in this) static type systems is the exact thing in practice where their advantages feel like stop making any big difference. While Lisp REPL feels far more useful.
Technically, I think this is meant to develop Coalton, which is also statically typed and incredibly effective as a language for agents. All those ergonomic benefits that humans enjoy also allow AIs to develop lisp systems quite rapidly and robustly.
Not true. Are people not interested in archeology or history or museums? Denying such things as invalid is offensive. There are projects to reproduce things from ancient history like the Lycurgus cup.
IMHO, It's a better time than ever to develop a new IDE. Just make one that cares deeply about performance (i.e loads instantly, and always has a snappy response). Make features easy to control. Allow me to turn on only the things I care about and to shut the rest off.
I can't even remember the last time I was impressed by the speed of an IDE, though we have more computing power now than ever. I'd love to see someone new come in and wipe the floor with all of the current contenders.
It’s not awkward at all. It’s a fun project and neat. I support these types of projects. I guess I’m being voted down because people hate IDEs and text editors now.
I think it’s wrong to trash this project just because it’s an older concept.
Why don't you read my comment again and respond to the comment at hand rather then make some asinine response on how people respond to the "content" of a comment. No shit sherlock.
To spell it out for you, my comment was mayhap a bit more sophisticated for you to comprehend. I was not talking about "content" but the nature of the "content" within my comment and how one irrelevant adjective "legacy" was taken out of hand because it offended you. Why did it offend you? Probably because it's true.
I keep hoping the Common Lisp community will step up and deliver better Visual Studio Code support. Asking new devs to learn Emacs, alongside all of Lisp's idiosyncrasies, is too tall an order. I bro'd through it in the 90s but today's new devs have been spoiled by modern UIs (and that's a good thing) and shouldn't have to cope with Emacs and its stubborn retroness.
Seeing something like this is a step in the right direction.
> will step up and deliver better Visual Studio Code support.
In order to understand what it means to have true Lisp support in an editor/IDE, you have to understand what Lisp is about. Lisp is not just a syntax - it is a live, interactive, self-modifying computational environment. VSCode, like most editors, treats code as text files and execution as a subprocess you invoke. That model is fundamentally at odds with how Lisp development works.
Yes, there are some extensions like Calva and Joyride that attempt some serious work - but the host editor's mental model is always pushing back. So really it ain't about syntax highlighting, bracket matching, and a REPL pane you can type into.
That is something that "new devs" don't understand about Emacs. It's not about the features, nor about its looks - it's about what fundamentally it is - the Lisp REPL - a live, interactive, self-modifying computational environment. Something that VSCode could never truly become. I could never write some code in some scratch buffer, eval it and change some aspect of my editor - in Emacs, I can. And I wouldn't even have to save that code anywhere. In order for VSCode to become like that, you'd have to break its fundamental model, which causes it to become something else - not VSCode.
Therefore, if someone has no interest in Lisp just because VSCode doesn't support it nicely, well, honestly - it's their loss. You know, just because a megacorporation threw billions at developing it, it doesn't mean it's objectively better - there are still other, more pragmatic alternatives. F-35s that cost $1.7 trillion may look shiny and intimidating, but when it comes to the "real deal" - much cheaper, ugly, purpose-built, A-10 Warthog proves its worth, and does it so well that the Pentagon just can't seem to be able to retire it.
> today's new devs have been spoiled by modern UIs (and that's a good thing) and shouldn't have to cope with Emacs and its stubborn retroness.
Two words: Programmable editor.
One of the best advantages of Lisp is the ability to metaprogram. After solving a problem, you find that your code can fit other cases and then you you write a program that will produce the relevant code for those cases. In most other PL you would have to write the slightly different code again or use a template language.
Once you get accustomed to that, you will start to decompose other parts of your workflow in smaller building blocks and realize that only a few parts differ, but they all fits the same workflow. And one of the main realization 99% of them are text, act on text, and produce text. So what you really need is a framework around text, not a bespoke assemblage of tools.
With Unix, you have the text processing tools and vi (some would say ed). All centered around the terminal, the shell and files. Emacs is another version with a lisp vm, a collection of functions and the buffer as the interface. A third version is acme with buffers and mouse clicks as commands. The idea here is to be able to build small tools that can take care of the misc. things we need to do while writing programs. From navigation to analyzing, from formatting to building, and the myriads things in between.
Modern UIs are good for beginner and light usage. Or if you're lucky, they have your specific workflow neatly packaged in some plugins. But when you get tired of having another helpful "update" messing your muscle memory, or want to establish an efficient workflow with some external program (A CL lisp runtime in your case), that's when the weakness appears.
I don't think Emacs is that hard to get used to, as long as you don't expect to replicate your IDE experience right away. Like if you use Jetbrains products, expect to switch to Emacs and get the same approach right away you will just have a very very bad time.
I started using Emacs recently for Orgmode as an alternative to Obsidian, first I just thought I'd try using for about a month, and if I don't like it I'd quit. But I kept using it month after month, eventually switching it completely. It's been over a year since then.
Then I also figured I'd try some lisp since that's what it's used for, and installing SBCL and Sly was super easy. And then the actual experience of writing Lisp was easy too.
This is on Windows 10 too. You can install and update Emacs and SBCL for Common Lisp very easily with Scoop. It might not be the optimal way to do it, but it works perfectly fine.
For comparison I tried installing Lem on Windows and I couldn't get it to work.
I'm talking about beginners, not seasoned Lisp hands, most of whom—until the great boomer dieoff occurs at least—are already comfortable in Emacs. If you're still just finding your feet in Lisp, you're not aware enough of its tremendous power to miss it from your IDE. You're just wondering why you have to Escape Meta Alt Control Shift to get anything done instead of, you know, just using the menu and mouse commands and keyboard shortcuts that literally everyone else uses.
You can always start the REPL on its own and start playing that way.
Or use something like:
sbcl --load <filename>
Sly/Slime is not essential to play around with Lisp. Emacs just has the right architecture for an REPL workflow. You can do REPL development with Sql and various other programs in Emacs.
Something like SLIME isn't essential to execute Lisp code, you're right, but it is essential in order to understand the efficiencies afforded by interactive development, which may as well be one of the pillars of the language, since "garbage collection" and "an object system" aren't in and of themselves differentiators anymore*. Using something like SLIME also takes a lot of the pains that people have with Lisp away, namely balancing parens and indenting code correctly. People who do the "I'll use my own editor" approach to beginning Lisp usually write things that look like:
(defun myfun(x)
(let (x)
(setq x 5)
(when (eq x 6)
(print "6")
)
)
)
Which is absolutely not what Lisp code should look like. Emacs-and-kin don't outright stop that, but the defaults are such that it's less likely.
____
* Of course, technically, CLOS is something to behold. But you won't sell someone on Lisp because it can do "OOP".
Interactive development is because Common Lisp runntime has the concept of images and systems. Just like you start you OS and do things with it, you start the Lisp runtime and do things with it. It’s a point A to point B type of interaction like running a script. Smalltalk, SMl, a modern web browser,… has the same kind of interaction. It’s not dependent on any editor.
Also automatic idiomatic formatting of lisp code is possible in any editor as long as they have the settings for it. Not sure how Emacs is the gatekeeper on that one.
What you say is entirely true in theory. An editor can have whatever it wants. Anything is possible—but somebody needs to do the work. If your favorite code editor is Zed, chances are nobody wrote proper Lisp indentation in it or any sort of Lisp interaction mode.
Why has it stuck with Emacs and its derivatives? I don't know. It seems interest in investing time to make a good Lisp environment for a non-Emacs editor fizzles out once it gets to the difficult part of productionizing it, which is why Emacs continues to be the #1 no-cost choice.
Someone threw out a Zed LSP for Common Lisp with LLMs help: https://github.com/etyurkin/zed-cl It requires heavy compilation of the wasm toolchain so I finally didn't try it. It seems it doesn't have a lisp debugger.
Emacs has support for all kind of programming languages and other tools. It's very easy to hack somethings and the effort required to polish it enough for a 0.1 release is small. Compared that to creating a plugin for VS Code or IDEA? Not worth it especially with the disjointed interfaces (Emacs has buffers and nothing else).
If the beginners are curious about Lisp and insist on using VSCode, they can install Calva and try Clojure. It takes less than a minute and it has a really good "quick start" guide. There's no rule that says you have to get into Lisp specifically via SBCL. Once you grok structural editing and REPL-driven workflow, jumping between different Lisp dialects is not that hard.
And if a programmer refuses to learn a new language, technique or paradigm just because their favorite editor doesn't support it... well, that is sad, but also - not everyone has to be passionate about their work, huge sectors of the economy are driven by mediocre players and that is just fine. Passionate programmers sooner or later find their way to Lisp.
Yeah, I mean there is some support for various editors (https://lispcookbook.github.io/cl-cookbook/editor-support.ht...) including VS Code (https://lispcookbook.github.io/cl-cookbook/vscode-alive.html), but it's kind of rough (https://blog.djhaskin.com/blog/experience-report-using-vs-co...) and not exactly feature-complete with the emacs experience, plus you're still left having to figure out how to install and setup a Lisp implementation and quicklisp. I like that mine solves those for a newcomer, especially on Windows. (I myself use vim + slimv, but even that isn't quite at parity in some respects with emacs. The biggest weaknesses are around debugging, especially in the presence of multiple threads. But the essentials do work (stepping, eval-in-frame, continuing-from-a-stack-frame, selecting the various types of restarts, compiling changes before selecting restarts) so I'm still fairly productive and don't feel like I'm lacking anything sorely needed for professional work. I've hacked together some automatic refactoring bits as well, which emacs doesn't have either, and I'm eventually going to make a separated GUI test runner.)
I've been kicking the tires with mine a little bit yesterday and today, I think it's quite good for the beginner experience. But I'm constantly of two minds about reporting some feature requests. The project's primary goal seems to be existing as a stepping stone to even see what Lisp (and especially Coalton) is really all about before "graduating" to something like emacs, it feels like a secondary goal (though it is mentioned as a goal) to be usable by professionals as well, but there's inherent tension there. That's also been a weakness with the other editors: anyone already comfortable with Lisp development, professional or not, in emacs or not, isn't very likely to give the time of day to some new thing that's almost certainly not going to be as good as what they're used to. And so the new thing doesn't get the attention and feedback from experienced developers and the gap never closes.
Huh, I wonder why they made their own IDE instead of integrating with Sly/SLIME. Not trying to knock the project, just genuinely curious. Writing a whole editor sounds like a lot of work.
I like the choice of Iosevka as a font, though.
Edit: One value I do see myself getting from Mine is as an example Coalton project. Last time I tried Coalton I couldn't figure out how to get ASDF to load standalone Coalton files. Now I have a working example to copy.
There is an explanation in the blog: https://coalton-lang.github.io/20260424-mine/
> However, the above is a tall order for someone just wanting to dip their toes in, to see if they have any interest in Coalton or Common Lisp. A couple hours on the weekend is easily sunk into getting configurations right, and the right subsystems installed, and the right paths setup, just so the first line of code can be executed.
> mine is not Emacs. It aims to eliminate all of that, and be a Coalton/Lisp-first development environment, whose only job is to be a Coalton/Lisp-first development environment. But more than that, it needs to be accessible. A non-programmer should find it easy to download, install, and run mine with nothing more than a download link.
> mine is not Emacs.
Ah… yes, okay, I see what they did there… chuckle, sigh. Well, it's arguably in the same grand cultural tradition as EINE and ZWEI at least!
I vaguely remember that there was also TRES. EINE = Eine Is Not Emacs
ZWEI = Zwei Was Eine Initially
TRES = Tres Replaces Eine’s Successor
DREI = DREI Replaces EINE's Inheritor
https://mcclim.common-lisp.dev/static/documents/drei.pdf
Why would a non-programmer want to download, install and run a CL IDE?
1. It is a potential first step on the way from non-programmer to programmer.
2. "Easy enough for a non-programmer" may also say something about how easy it is for a programmer.
I think the number of non-programmers who think 'I want to learn to program; I'll start with common lisp but emacs is too difficult!' is so small it is not a group worth considering. It's probably MIT & Stanford undergrads?
It's their IDE and they can design it how they want, but that's a weird goal for a CL IDE.
"It should be easy enough for" sets a UX bar, not a target audience. Kind of like the English phrase "X is so easy that even a toddler could do it," regardless of whether such a statement is figurative or literal.
You haven't seen the Lisp subreddit then, there is a post complaining about having to learn Emacs at least once every week or so.
I personally suspect that the overwhelming majority of those complaining would find a different reason to not learn lisp if the Emacs barrier were removed, but I very much might be wrong.
I wanted to avoid Emacs so I discovered Lem (so now I live in a different Emacs when writing CL), so it's not always this way
Coalton is also a full-featured embedded language of Lisp that is sufficiently paradigmatically different than run-of-the-mill Lisp code you'd see in a Common Lisp textbook, since it has a complete, Haskell-like static type system and Lisp-1 naming. Coalton also sees active development because aspects of the language continue to evolve.
The consequence is that an integration with SLIME would have to be a very extensive contrib [1] that is shipped with the Coalton version the user is using, and updated whenever Coalton is updated. No doubt the contrib would have to be very elaborate—it would have to hook in to basically every aspect of SLIME and SWANK if it should be "Coalton-native", from the display of type errors to how auto-complete is handled. Unless the contrib author is very meticulous about backward compatibility, then version mismatches would make everyone involved unhappy. The contrib author would get annoyed at constant bug reports about things not working (even if there's a nice "your Coalton or contrib are out-of-date" error), and users would get annoyed they have to keep a Lisp library in sync with an Emacs add-on.
None of this gets to the matter that Emacs simply isn't a popular text editor, and it's not really the one people are rushing to learn, even if it has substantial merit. I don't know how trustworthy this source is [2], but it claims that Emacs represents a fraction of a percent of the developer community. Even if it's off by 10x, it's still 1-in-50 developers at best.
[1] There's a basic one that shows Coalton type hints, but not much more: https://github.com/slime/slime/blob/master/contrib/slime-coa...
[2] https://pypl.github.io/IDE.html
Iosevka is the king of scalable terminal/programming fonts. I'm not sure why, maybe it's because the glyphs have lines and angles that look "terminal-y" in the same pleasing way Terminus and the 3270 font do whilst avoiding the problems that accompany trying to scale a pixel font.
I love Iosevka. I use it as my monospace, serif and sans-serif fonts and it's gorgeous, in its own unique way.
Everybody has its own preferences. I have tried it out (linux, command line version) and I can report: Mine is really fast and responsive compared to other Lisp IDEs like emacs which appears to be slow like a snail in comparison.
Interesting! Looks like the IDE itself is written in Coalton (https://github.com/coalton-lang/coalton/tree/main/mine) and you can either bring your own terminal or use the standalone version which uses Tauri and Xterm.js.
I'm going to download and check out Mine and Coalton. Right now, I use Neovide and Lem interchangeably. However, I am in deep with Shen. I bought a hardcopy of The Book of Shen, 5th Edition, and I still have Peter Kogge's 1991 text, "The Architecture of Symbolic Computers". I suspect the Hindley-Milner type system in Coalton will be more familiar to the Haskellers out there, but it is not as strong as Shen's Sequent calculus type system. In Shen, computation is allowed in side-conditions (if, let, and, etc.), so you can compute over terms inside types. Shen wins for raw expressive power and programmable types. Shen is very portable, but being a DSL, Coalton must integrate nicely with Common Lisp. And you get native exe's. Glad to see a simple way for people to program in CL or Coalton without having to go through the decades I have done with Vim and Emacs. VS Code bores me, but it is practical, even if it seems like junkyard truck with everything bolted on or hanging off of it.
I live in Emacs, but I will give Mine a try when get a free hour. I read about Coalton in X and follow the author but I haven't invested time yet to try out.
If you're a power user, the sooner you learn Emacs the better as the synergies with any Lisp language (particularly Common Lisp) are simply too strong to be ignored and there is no contemporary alternative that rivals it.
For new users, this looks like a welcome alternative to messy things like Lem that never really worked very well for me.
Lem doesn't claim to be a Lisp development environment or IDE. It describes itself as
General-purpose editor/IDE with high expansibility in Common Lisp
For historical interest, Lem did used to advertise itself as a Common Lisp development tool specifically, but that has changed relatively recently (past year?). From my distant vantage point, it looks like general interest in it grew, and Lem itself evolved in general-purpose directions, so they pivoted the messaging to be about it serving as a general-purpose editor instead of one just for Common Lisp.
Problem is, Emacs is really slow on Windows. If I can get a reasonably fast Lisp IDE on Windows, I'm all for it.
> Emacs is really slow on Windows
Emacs on native Windows has to go through the Win32 API for everything - file I/O, process spawning, subprocesses. Packages that shell out constantly (lsp-mode, magit, etc) will feel sluggish because spawning processes on Windows is genuinely slow compared to Unix. The more shell-heavy your config, the worse it gets. This isn't really Emacs' fault.
I really don't understand devs still insisting on running Emacs on Windows natively. Come on, guys, WSL2 been around like forever. You get real fork/exec speeds, proper shell integration, the full Unix toolchain, etc. Why choose inflicting pain instead of a trodden, well-known, existing path?
Mostly to run it in environments where WSL2 is not an option, typically because I cannot or do not want to enable the necessary hypervisor support.
Very cool project and welcome edition to the CL community!
[flagged]
Two decades professionally here too (and nearly three in terms of programming as a whole), and I still use ‘em. Reviewing and adjusting, they make for quite a good experience even in agent-first development with the various nice extensions.
Also I still have to write code by hand, because there’s a whole bunch of edits and adjustments that I’m far faster at shrug
>Also I still have to write code by hand, because there’s a whole bunch of edits and adjustments that I’m far faster at shrug
I'm faster too, in general. The thing is now with AI I'm working on at least 3 to 4 projects in parallel. I tell the AI to do an edit and I context switch to something else.
shrug
I do the same, but 3-4 is simply too many. I would guess you’re smarter than me, because more than 2 and I’m already at a fixed bottleneck of reviewing it (and reviewing my teams output on top)
nah reviews take a while right? You can have 2 or 3 agents running in the background while you review. It has nothing to do with intelligence. You can review one project while having 20 agents run in the background too... your intelligence is conceptually orthogonal to the amount of agents you have running.
I don’t have the mental capacity to do that at that scale. It produces more than I can review.
Then you are probably not interested in this work at all. It is meant to develop Lisp—a language whose primary advantage in 2026 is ergonomics to humans, particularly a certain kind of human. If you're doing 100% agentic development, that advantage disappears and you might as well use something popular and statically typed, like Rust or TypeScript.
> If you're doing 100% agentic development, that advantage disappears
I beg to differ. Turns out, Lisp REPL - an actual, "true" REPL, not something like Python's (which is not the same), is an enormous multiplier for agentic workflows.
a) Lisp code can be very terse yet retain its readability - it never becomes cryptic like APL. Therefore, it's more token efficient. It was actually proven that Clojure is one of the most token-efficient "mainstreamish" PLs. https://martinalderson.com/posts/which-programming-languages...
b) When you give an LLM a closed loop system where it can evaluate code in a live REPL and observe the results, it stops guessing and starts reasoning empirically. Instead of predicting what code will do, it can run it, read the output, adjust, and iterate - the same way a skilled human developer works. Incremental evaluation of forms maps naturally to how an LLM generates tokens.
This isn't some theoretical hand-waving - I experience it every day - my WM on Mac is yabai that gets controlled via Hammerspoon, which uses Lua, which means I can use Fennel, which means I can use Lisp REPL. I would give the LLM a task, something to do with my app windows - it connects to the live REPL and starts analyzing, prototyping and poking into things interactively.
All my custom MCPs are written in babashka (Clojure) https://github.com/agzam/death-contraptions - whenever there's a problem or I need to improve my AI harness, LLM just does it from "inside out" and it takes less time and fewer tokens.
My main editor is Emacs - LLM can fully control it. I can make it change virtually any aspect of it. To load-test the MCP that does that, I made it play Tetris in Emacs. And not just to run it, but to play it for real - without losing. It was insane.
And of course, day-to-day I have to deal with non-Lispy, non-homoiconic languages more. And to be honest (even though of course I'm biased in this) static type systems is the exact thing in practice where their advantages feel like stop making any big difference. While Lisp REPL feels far more useful.
Technically, I think this is meant to develop Coalton, which is also statically typed and incredibly effective as a language for agents. All those ergonomic benefits that humans enjoy also allow AIs to develop lisp systems quite rapidly and robustly.
Not true. Are people not interested in archeology or history or museums? Denying such things as invalid is offensive. There are projects to reproduce things from ancient history like the Lycurgus cup.
Same. It's an awkward time to develop a new IDE.
nothing awkward about it.
IMHO, It's a better time than ever to develop a new IDE. Just make one that cares deeply about performance (i.e loads instantly, and always has a snappy response). Make features easy to control. Allow me to turn on only the things I care about and to shut the rest off.
I can't even remember the last time I was impressed by the speed of an IDE, though we have more computing power now than ever. I'd love to see someone new come in and wipe the floor with all of the current contenders.
It’s not awkward at all. It’s a fun project and neat. I support these types of projects. I guess I’m being voted down because people hate IDEs and text editors now.
I think it’s wrong to trash this project just because it’s an older concept.
You are being downvoted for calling IDEs and text editors legacy, which is seen as signalling and not contributing to the conversation.
Oh one Adjective "legacy"? And that threw people off? Ok replace that with "cool" and I wouldn't get downvotes? Geeze
Yes, you can expect people here to read your comments and judge them by their content. Were you expecting otherwise?
Why don't you read my comment again and respond to the comment at hand rather then make some asinine response on how people respond to the "content" of a comment. No shit sherlock.
To spell it out for you, my comment was mayhap a bit more sophisticated for you to comprehend. I was not talking about "content" but the nature of the "content" within my comment and how one irrelevant adjective "legacy" was taken out of hand because it offended you. Why did it offend you? Probably because it's true.
I keep hoping the Common Lisp community will step up and deliver better Visual Studio Code support. Asking new devs to learn Emacs, alongside all of Lisp's idiosyncrasies, is too tall an order. I bro'd through it in the 90s but today's new devs have been spoiled by modern UIs (and that's a good thing) and shouldn't have to cope with Emacs and its stubborn retroness.
Seeing something like this is a step in the right direction.
> will step up and deliver better Visual Studio Code support.
In order to understand what it means to have true Lisp support in an editor/IDE, you have to understand what Lisp is about. Lisp is not just a syntax - it is a live, interactive, self-modifying computational environment. VSCode, like most editors, treats code as text files and execution as a subprocess you invoke. That model is fundamentally at odds with how Lisp development works.
Yes, there are some extensions like Calva and Joyride that attempt some serious work - but the host editor's mental model is always pushing back. So really it ain't about syntax highlighting, bracket matching, and a REPL pane you can type into.
That is something that "new devs" don't understand about Emacs. It's not about the features, nor about its looks - it's about what fundamentally it is - the Lisp REPL - a live, interactive, self-modifying computational environment. Something that VSCode could never truly become. I could never write some code in some scratch buffer, eval it and change some aspect of my editor - in Emacs, I can. And I wouldn't even have to save that code anywhere. In order for VSCode to become like that, you'd have to break its fundamental model, which causes it to become something else - not VSCode.
Therefore, if someone has no interest in Lisp just because VSCode doesn't support it nicely, well, honestly - it's their loss. You know, just because a megacorporation threw billions at developing it, it doesn't mean it's objectively better - there are still other, more pragmatic alternatives. F-35s that cost $1.7 trillion may look shiny and intimidating, but when it comes to the "real deal" - much cheaper, ugly, purpose-built, A-10 Warthog proves its worth, and does it so well that the Pentagon just can't seem to be able to retire it.
> today's new devs have been spoiled by modern UIs (and that's a good thing) and shouldn't have to cope with Emacs and its stubborn retroness.
Two words: Programmable editor.
One of the best advantages of Lisp is the ability to metaprogram. After solving a problem, you find that your code can fit other cases and then you you write a program that will produce the relevant code for those cases. In most other PL you would have to write the slightly different code again or use a template language.
Once you get accustomed to that, you will start to decompose other parts of your workflow in smaller building blocks and realize that only a few parts differ, but they all fits the same workflow. And one of the main realization 99% of them are text, act on text, and produce text. So what you really need is a framework around text, not a bespoke assemblage of tools.
With Unix, you have the text processing tools and vi (some would say ed). All centered around the terminal, the shell and files. Emacs is another version with a lisp vm, a collection of functions and the buffer as the interface. A third version is acme with buffers and mouse clicks as commands. The idea here is to be able to build small tools that can take care of the misc. things we need to do while writing programs. From navigation to analyzing, from formatting to building, and the myriads things in between.
Modern UIs are good for beginner and light usage. Or if you're lucky, they have your specific workflow neatly packaged in some plugins. But when you get tired of having another helpful "update" messing your muscle memory, or want to establish an efficient workflow with some external program (A CL lisp runtime in your case), that's when the weakness appears.
I don't think Emacs is that hard to get used to, as long as you don't expect to replicate your IDE experience right away. Like if you use Jetbrains products, expect to switch to Emacs and get the same approach right away you will just have a very very bad time.
I started using Emacs recently for Orgmode as an alternative to Obsidian, first I just thought I'd try using for about a month, and if I don't like it I'd quit. But I kept using it month after month, eventually switching it completely. It's been over a year since then.
Then I also figured I'd try some lisp since that's what it's used for, and installing SBCL and Sly was super easy. And then the actual experience of writing Lisp was easy too.
This is on Windows 10 too. You can install and update Emacs and SBCL for Common Lisp very easily with Scoop. It might not be the optimal way to do it, but it works perfectly fine. For comparison I tried installing Lem on Windows and I couldn't get it to work.
If Lisp developers want a better editor and IDE they can support Lem.
VS Code doesn't provide the liveness and extensibility Emacs and Lisp developers enjoy in their environments.
Lem is still too Emacs-like.
I'm talking about beginners, not seasoned Lisp hands, most of whom—until the great boomer dieoff occurs at least—are already comfortable in Emacs. If you're still just finding your feet in Lisp, you're not aware enough of its tremendous power to miss it from your IDE. You're just wondering why you have to Escape Meta Alt Control Shift to get anything done instead of, you know, just using the menu and mouse commands and keyboard shortcuts that literally everyone else uses.
You can always start the REPL on its own and start playing that way.
Or use something like:
Sly/Slime is not essential to play around with Lisp. Emacs just has the right architecture for an REPL workflow. You can do REPL development with Sql and various other programs in Emacs.Something like SLIME isn't essential to execute Lisp code, you're right, but it is essential in order to understand the efficiencies afforded by interactive development, which may as well be one of the pillars of the language, since "garbage collection" and "an object system" aren't in and of themselves differentiators anymore*. Using something like SLIME also takes a lot of the pains that people have with Lisp away, namely balancing parens and indenting code correctly. People who do the "I'll use my own editor" approach to beginning Lisp usually write things that look like:
Which is absolutely not what Lisp code should look like. Emacs-and-kin don't outright stop that, but the defaults are such that it's less likely.____
* Of course, technically, CLOS is something to behold. But you won't sell someone on Lisp because it can do "OOP".
Interactive development is because Common Lisp runntime has the concept of images and systems. Just like you start you OS and do things with it, you start the Lisp runtime and do things with it. It’s a point A to point B type of interaction like running a script. Smalltalk, SMl, a modern web browser,… has the same kind of interaction. It’s not dependent on any editor.
Also automatic idiomatic formatting of lisp code is possible in any editor as long as they have the settings for it. Not sure how Emacs is the gatekeeper on that one.
What you say is entirely true in theory. An editor can have whatever it wants. Anything is possible—but somebody needs to do the work. If your favorite code editor is Zed, chances are nobody wrote proper Lisp indentation in it or any sort of Lisp interaction mode.
Why has it stuck with Emacs and its derivatives? I don't know. It seems interest in investing time to make a good Lisp environment for a non-Emacs editor fizzles out once it gets to the difficult part of productionizing it, which is why Emacs continues to be the #1 no-cost choice.
Someone threw out a Zed LSP for Common Lisp with LLMs help: https://github.com/etyurkin/zed-cl It requires heavy compilation of the wasm toolchain so I finally didn't try it. It seems it doesn't have a lisp debugger.
Emacs has support for all kind of programming languages and other tools. It's very easy to hack somethings and the effort required to polish it enough for a 0.1 release is small. Compared that to creating a plugin for VS Code or IDEA? Not worth it especially with the disjointed interfaces (Emacs has buffers and nothing else).
> I'm talking about beginners
If the beginners are curious about Lisp and insist on using VSCode, they can install Calva and try Clojure. It takes less than a minute and it has a really good "quick start" guide. There's no rule that says you have to get into Lisp specifically via SBCL. Once you grok structural editing and REPL-driven workflow, jumping between different Lisp dialects is not that hard.
And if a programmer refuses to learn a new language, technique or paradigm just because their favorite editor doesn't support it... well, that is sad, but also - not everyone has to be passionate about their work, huge sectors of the economy are driven by mediocre players and that is just fine. Passionate programmers sooner or later find their way to Lisp.
Yeah, I mean there is some support for various editors (https://lispcookbook.github.io/cl-cookbook/editor-support.ht...) including VS Code (https://lispcookbook.github.io/cl-cookbook/vscode-alive.html), but it's kind of rough (https://blog.djhaskin.com/blog/experience-report-using-vs-co...) and not exactly feature-complete with the emacs experience, plus you're still left having to figure out how to install and setup a Lisp implementation and quicklisp. I like that mine solves those for a newcomer, especially on Windows. (I myself use vim + slimv, but even that isn't quite at parity in some respects with emacs. The biggest weaknesses are around debugging, especially in the presence of multiple threads. But the essentials do work (stepping, eval-in-frame, continuing-from-a-stack-frame, selecting the various types of restarts, compiling changes before selecting restarts) so I'm still fairly productive and don't feel like I'm lacking anything sorely needed for professional work. I've hacked together some automatic refactoring bits as well, which emacs doesn't have either, and I'm eventually going to make a separated GUI test runner.)
I've been kicking the tires with mine a little bit yesterday and today, I think it's quite good for the beginner experience. But I'm constantly of two minds about reporting some feature requests. The project's primary goal seems to be existing as a stepping stone to even see what Lisp (and especially Coalton) is really all about before "graduating" to something like emacs, it feels like a secondary goal (though it is mentioned as a goal) to be usable by professionals as well, but there's inherent tension there. That's also been a weakness with the other editors: anyone already comfortable with Lisp development, professional or not, in emacs or not, isn't very likely to give the time of day to some new thing that's almost certainly not going to be as good as what they're used to. And so the new thing doesn't get the attention and feedback from experienced developers and the gap never closes.