kakoune.el VS steel

Thanks for the tip, meow looks interesting. I never got comfortable in evil-mode, but perhaps meow could be a gateway to trying emacs in anger.

Still waiting for kakoune/helix mode for gnu readline...

https://github.com/meow-edit/meow

https://github.com/jmorag/kakoune.el

To build on what others are saying about Emacs, if you start exploring the package ecosystem, you're going to see quite a lot of really interesting packages that are related to improving/experimenting with the UX of editing text. While I'm not endorsing anyone in particular, I think what this list does show is just how easy it is to do pretty much whatever you want in Emacs;

https://karthinks.com/software/avy-can-do-anything/

https://github.com/jyp/boon

https://github.com/clemera/objed

https://github.com/jmorag/kakoune.el

https://github.com/meow-edit/meow/

https://github.com/xahlee/xah-fly-keys

https://github.com/Kungsgeten/ryo-modal

https://github.com/emacsorphanage/god-mode

Emacs 29 also now has treesitter and LSP mode integration built-in, a compilation mode, a comint mode for REPLs, excellent file browsing packages (I use dired/dirvish), and a few other killer features.

Now, if what you truly dislike are "quirky editors", prepare yourself for a world of hurt because vanilla Emacs departs quite a bit from "modern" text editors. I struggled with this for a while, but eventually by buying into the paradigm, I now feel that when emacs try emulating "modern" IDE features like autocompletion, LSP, and DAP UI, I feel like it's a regression, not a progression. The point here is that you might have an "idea" of what good initial UX and lack of quirks would look like, but Emacs might change the way you think.

If emacs had a layer for kakoune as comprehensive as evil, I think it would be a no-brainer, but such as it is, kakoune.el is the closest we have which isn't quite was I was hoping for.

Problem is, unlike the evil package linked above, which was last updated 6 days ago, the only package I've found for Kakoune is this one, which was last updated like a year ago.

I set up https://github.com/jmorag/kakoune.el and made some aesthetic changes, i think that EXWM came soon thereafter

kakoune.el: https://github.com/jmorag/kakoune.el

Shameless plug kakoune.el

Out of curiosity, what is it that makes you want to change from Kakoune? Perhaps something like terminal emacs with kakoune.el could be of interest to you.

I don't fully understand what you want - but about creating cards while you read https://kakoune.org could be interesting (there's a simple elisp clone: https://github.com/jmorag/kakoune.el). That way you can move along words while reading and if you want to turn a phrase into a card you can simply hold shift to continue marking the desired words and then yank them to somewhere.

I absolutely don't mind the plugin system being a Scheme. It's a plugin for a text editor, and Steel(https://github.com/mattwparas/steel) seems to be a lot less of a maintenance burden than WASM plugins(besides that I find the WASM tooling to be extremely complex).

But besides all that, Helix learned be that I don't need fancy plugins or endless finicking with config files and toolchains. Using a combination of other tools, like yazi and lazygit, helps me not only inside my editor but outside of it as well. And Kakoune does this even better. In that regard it has been a real eye-opener and refreshing. The downside is, it's hard to go back to other editors!

Basically the differences are in the concepts you'll use to write code. Lisps themselves are very different from each other, but just like the languages you're used to, lisps have standard libraries that can be called, and those building blocks can be used to build applications or whatever else. In this case specifically, Steel provides the facility to call Rust functions within a Steel program: https://github.com/mattwparas/steel.

So, although I haven't used Steel, it looks like the advantage you'd get from using it is the opportunity to take advantage of features it provides like transducers and contracts, which are feature common to other Lisps as well.

So, just like choosing any other language, it boils down to a series of tradeoffs.

I've been adding my language steel as the plugin language for helix. There is a lot of discussion around what the plugin system will look like for helix and I figured I'd give it a shot since steel was designed originally for embedding. So far its working pretty well, it turns helix into emacs (without the nearly 50 years of development, so not quite as good). I'm reasonably confident the changes won't be accepted upstream (my language is a scheme but I am the only developer at the moment), but even if not it is a really fun experiment. Hoping that it can be used as a basis for whatever plugin system they eventually land on. An example of what configuration would look like:

Working on automatic doc generation for steel. I've been procrastinating building this out for a while - some of the easy cases are really easy, while the hard cases are definitely not easy.

I'm working on steel, an embedded scheme like programming language. I have lofty goals of eventually adding a JIT and making it viable as a standalone language, but for now its just about as fast as python, and makes for fairly pleasant embedded scripting. Recently added modules and dylibs, and am working on getting documentation into a better place so that adding more libraries becomes easier. I've written a functioning slack bot in it, which is pretty fun, eventually want to make a discord bot as well out of it just to stress test it a bit