What code editors or IDEs are easily scriptable?

You shouldn't dismiss Lua outright, it's a language designed specifically for embedding, there's practically nothing to learn to begin using it productively.

See this presentation by a core Neovim maintainer that explains why Lua was chosen https://www.youtube.com/watch?v=IP3J56sKtn0.

See also http://lua-users.org/wiki/MechanismNotPolicy to understand Lua's core design.

Of the “preferred not” languages you listed, Lisp and Lisp-derivatives are easily the most pragmatic languages you will see doing “real” work outside of the scripting environment. So, given the dearth of good scriptable editors using other languages, why not give Emacs a try? I will grant that Elisp is a bit of an odd dialect, but a lot of what you learn from learning Elisp will transfer to understanding other languages better, modulo function names and whatnot. It’s also helpful that Elisp has comprehensive documentation available right from the editor itself. There are also hundreds of high-quality examples you can look at too, and Elisp lets to poke at basically every aspect of the editor.

Plain old vim doesn't only do vimscript, you can also script it in Perl, Python, TCL, Lua and maybe one more I cannot remember. See e.g. this python howto: http://codeseekah.com/2012/03/04/vim-scripting-with-python-l...

Neovim. You can use Lua, but you can also use your language of choice via msgpack.

https://github.com/orgs/neovim/repositories?type=all&q=Clien...

Emacs, as has been mentioned multiple times in this thread, but I wanted to share a bit more about why.

Emacs is a text manipulation environment, and it's incredibly powerful to be able to run any elisp code. In org-mode, I use plain lists and checkboxes often, and after inserting the checkbox, I always need to move my cursor 2 spaces to the right. Well, with Emacs and elisp, I can do that:

  (defun my-org-toggle-checkbox-and-move-right ()
    "Toggle checkbox and move cursor 2 spaces to the right."
    (interactive)
    (org-toggle-checkbox)
    (forward-char 2))

  ;; Bind the function to a key if desired
  ;; (global-set-key (kbd "C-c t") 'my-org-toggle-checkbox-and-move-right)

Other examples: https://www.reddit.com/r/emacs/comments/1bgyq3y/wrote_my_fir... or https://blog.thomasheartman.com/posts/my-first-emacs-lisp or https://emacs.stackexchange.com/questions/54602/how-do-i-def...

And of course, because your config is text/code you can version control it, which allows rollbacks if you make a mistake ;)

VSCode has a comprehensive API that you can create scripts for in Typescript

Some people live in their editor and occasionally drop into a shell. I've personally found a lot less friction in doing the opposite. Live in the shell, and occasionally drop into your editor.

I used to think that it would be better to have a lot of scripting and automation built into my editor, but there are so many well-built, connect-able tools already available in a unix shell that it's usually easier to write scripts in that context, instead. There are often easy ways to pull the outputs of those scripts into your editor or use your editor as a thin, pass-thru layer to run shell scripts on certain selected bits of text in a file.

Well, every IDE is designed to be extended. Unfortunately neither Go nor Rust are really intended for the extension use case. Sublime Text supports Python scripting but isn't an IDE.

I think the best IDE scripting experience I know of right now is IntelliJ (or other Jetbrains IDEs) with the Live Plugin extension. You can write simple scripts in Kotlin or Groovy. They're similar langs but the latter is dynamically typed. And then you can just do things like register menu items, explore the language AST, edit buffers, trigger refactorings, access remote machines. Anything, really.

As your script gets too big, you just convert it to a 'real' plugin project with multiple files, can use libraries, etc.

Then you can upload it to the Marketplace so people can find it.

And if your plugin ends up being really good, Jetbrains run a monetization system so you can sell it easily. They handle all the billing, tax, licensing etc for you, so you can focus on your plugin.

It's pretty rad. That said, in years of working with IntelliJ I never felt a need to extend it for my own personal use. It's not like emacs where every user ends up with piles of elisp. The defaults are pretty good, and many features where in other IDEs you'd be forced to write a script can be done entirely via the GUI. For example if you want to define templates that auto-expand and where the cursor moves between 'slots', you can do that using a mini templating language without needing to do any coding. There's a thing called Structural Search & Replace which is similar - it lets you create templates that match against ASTs and do transforms on them.

I'll echo others' comments that you should consider not completely ruling out Lua. I'm a Neovim user almost exclusively, and knew no Lua at all coming in to it. In less than a day I was up to speed enough to be able to write complex extensions in it, and honestly didn't struggle much with the language itself in getting to that point. Most of my time was spent learning the APIs, not the language.

That said, while I've not done so, it _is_ possible to write Neovim extensions in Python. Check out this project for details: https://github.com/neovim/pynvim

While there are obviously many editors out there these days, IMO the ubiquity of [n]vim and emacs make them strong leaders. Convincing me to use anything else would be difficult.

I love Neovim, and it fits my needs well - but my choosing it over emacs was largely arbitrary. Now I'm in a position where I understand Neovim very well but lack that knowledge of emacs. As far as I know they're on par with each other.

Kakoune _barely_ has a scripting language. It has essentially a set of commands and some basic string substitution, one of which will let you drop to a shell (something akin to substitute this string with the result of evaluating its contents through bash). With this you can write your scripts in whatever language you like. My plugins are almost all in Rust, some are in bash.

To add a few less popular options, I really liked working with TextAdept. Almost the whole API is accessible via Lua and you can script the heck out of that editor.

The challenge with that is that you don't get a lot of items out of the box. The community is awesome though and the author of the project is very responsive in github.

There's also Lite XL, which is also a very hackable editor. Also hackable in Lua. The documentation for it is a bit lacking but one can jump into the code and start tweaking things in it.

There's also micro. This one also uses Lua for writing plugins and such. It's a terminal editor if that's something you are interested in.

What kind of things do you want to script?

Personally I use macros in an editor for "text manipulation", and drop to Python/sed/awk for "text processing". I don't find I have a need for anything in-between.

Sublime uses python if i remember correctly

There are a variety of API clients written in various languages to configure and script Neovim including Ruby, Python, Go, and Rust. You can find an extensive list here: https://github.com/neovim/neovim/wiki/Related-projects#api-c...

Do VScode and Jetbrains's plug-ins /extensions satisfy your scripting needs? They're in JS and Java, I think.

You said no-Lua, but since for many interested in this thread Lua's a non-problem, I'll pitch a disconcertingly under-hyped / under-noticed native (aka non-Electron) editor with Lua extension story (and many of its parts built on that plus its small C core) called TextAdept.

I'm still a happy camper on VSCode but if it ever begins to crumble/rot/overbloat (by subjective criteria), I'd hop onto that. Lua is (for my purposes here) no better/worse than JS/TS. Save for those darned 1-based array indexings!

LSP-capable too, last I heard, else it'd be a non-option for me in 2024. https://orbitalquark.github.io/textadept/

Sublime Text? (It's extendable in Python, but isn't FOSS, which might be a deal-breaker.)

https://RTCode.io is built on Monaco! It's incredibly easy to script!

0. Go to https://RTCode.io/x/

1. Type a number

2. Select the number

3. Press ↑/↓ keys

3. Open the context menu (right click/long tap)

4. Mess with Selections: or Eval menu items

Claude has helped with the selection actions!

See https://diff.rt.ht which is also built on Monaco!

For more advanced stuff visit: https://go.rt.ht and select the Backend or PDF starters and hover over the attributes!

Feel free to view the sources to see how I script it!

I wouldn't exclude Lua, it's a simple language whose basics you can learn pretty quickly if you know JavaScript or comparable languages. I therefore would recommend Neovim.

Emacs.

The 'custom css and js loader' extension for vscode is pretty good. since most of the editor is rendered with HTML you can pretty much do anything you want, pairs nicely with the built-in dev console and easier/quicker to iterate than doing things the 'proper way' via extensions/api.

The team that built Neovim was actually very focused on python extensibility before they went for Lua IIRC, so the neovim python library works very well I think.

https://pynvim.readthedocs.io/en/latest/

For myself the attraction of the unix operating environment(aka the userland) is that now your operating system is your ide.

Now admittedly this is never as sleek or uniform as an actual Integrated Development Environment, but the extensibility, well the extensibility is unmatched. you can even have an ide in your ide.

"Scripts in languages such as Python, PHP and awk can now be used to edit documents": https://www.textpad.com/relnotes-textpad#v9050

adding a few fun ones that I've used in the past:

TextAdept. The API is fully open to Lua and a bunch of stuff can be scripted in it. The author is super responsive on github and has a nice small welcoming community.

Lite XL is mostly written in Lua, less documentation than TextAdept but is not terribly hard to jump into the code and figure out how the editor works and modify it.

Micro uses Lua for plugins. It's a terminal only editor, which is a plus for some people, but still the mouse support is quite nice.

IMO, the language is only a small part of a deeper relationship with your IDE. The IDE needs a good debugger, a good introspection system, and good hooks to modify things (ideally anything). Emacs meets this criteria, but few others do. This is why there is a living corpus of 40+ year old elisp that can be drawn upon for functionality and inspiration.

Definitely VS Code is my favourite. I’ve created so far 3 extensions. I really like the SDK and the way you can control every aspect of the IDE.

Emacs ≥ VIM ≥ Neovim

Started on Emacs because that was what Prof required, after leaving school with a BS in CS, switched to VIM, years afterwards found a comfy place in Neovim managed in NixOS via Flakes & Home-Manager. A purely scriptable and declarative setup that can be reproduced on nearly any machine one might wish to work on. Scriptable interaction with Language Servers, Linters, Formatters and Debuggers in any language that is needed for work or fun (C, C++, Go, JavaScript, Lua, Python, Ruby, Rust, etc.)

Highly recommend.

Zed is written in Rust: https://github.com/zed-industries/zed. It seems relatively straightforward to write an extension for it, but I've never personally tried (I suck at Rust).

I will say that Lua is extremely easy to pick up, and as far as hacking on an IDE I think that simplicity might make it an ideal language.

I'm curious about the implications of "deeper relationship".

Definitely VS Code. I’ve created 3 extensions and I really like it.

emacs is basicly a lisp machine running a descent text editor on top of it. you can't get much more scriptable than that.

Emacs

Sublime Text could have been perfect, it uses python and it is hot-reloadable, but the API is limited, you can't extend the interface _at all_, want tabs in the build/task panel? nope, want to customize your status bar with clickeable elements? nope

VSCode is a joke, you can't use javascript, worse, you need to compile your scripts, and you need to restart the editor whenever you change your "scripts"

nvim has excellent lua scripting support.

I mean as far as i know the only answer that fits your "no lua/lisp" requirement is intellij IDEs, they use java/kotlin.