Ask HN: What code editors or IDEs are easily scriptable?

38 points by ericb ↗ HN
I want to build a deeper relationship with an editor or IDE that's designed to be extended or scripted.

I'd prefer to use an everyday-language I work in for scripting, which rules out Vimscript, Lua or Lisp. I'd be most happy with any of Ruby, Python, Go or Rust. Ideas?

67 comments

[ 2.3 ms ] story [ 146 ms ] thread
Do VScode and Jetbrains's plug-ins /extensions satisfy your scripting needs? They're in JS and Java, I think.
In my experience, VS Code’s extension system really shines here. There are also boilerplate repos out there to get started.
> There are also boilerplate repos out there to get started.

Should be unnecessary (and might be outdated unless meticulously maintained) IF one chooses to just follow the VSC API docs' `yo code` approach. Which generates the project structure with a simple hello `extension.ts` IIRC.

They are meticulously maintained, and far more comprehensive than yo code.
For Jetbrains IDEs, I recommend using LivePlugin rather than building a full-blown plugin for every script: https://github.com/dkandalov/live-plugin
That's really awesome! As they support Groovy and Kotlin, they basically support most JVM languages too, so you can probably use this with Scala, Clojure etc.

I may give it a spin myself as I am pretty heavy user of IntelliJ.

By the way, I think Fleet, the new "Beta" editor by Jetbrains, is currently designing a custom plugin system to make it "nicer" to write plugins than for IntelliJ, but apparently it's not yet open for trials: https://www.jetbrains.com/help/fleet/managing-plugins.html

Sublime uses python if i remember correctly
nvim has excellent lua scripting support.
OP said;

"I'd prefer to use an everyday-language I work in for scripting, which rules out Vimscript, Lua or Lisp."

I'm a poor citizen of the internet today. Thanks for the callout, you're right.
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.
Another vote for Kakoune. I think most people will find its approach a bit obtuse at first, but once it starts to click it’s pretty interesting.

Maybe if you’re a seasoned terminal veteran it will make more sense to you right outta the gate. I started using Kakoune not long after I started using the terminal much more heavily, so it was a bit difficult at first, but it has been and continues to be rewarding.

For example, select some text and press the pipe character, and then you can enter a script or shell command (sort, uniq, fmt, etc.). The selected text will be fed to stdin of the command, and then will be replaced with the output.

Combine this power with multiselections, which can be operated on in separate contexts, and you’ve got a stew going.

The consequence of this is that kakoune forks for _everything_. In practice maybe this is fine but it seems wasteful
(comment deleted)
I mean as far as i know the only answer that fits your "no lua/lisp" requirement is intellij IDEs, they use java/kotlin.
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.
Emacs Lisp is my first Lisp, so I don't even really notice how supposedly weird it is. It's a fine language, don't let it get in your way, and it's just as important to be able to read other's code than it is to write your own. Unless you have all the time in the world, you want to use as much of other people's work as possible. Would I have preferred an editor written in Ruby? Sure. But I think I was right to not worry about that.
Indeed—most of the weirdness comes from things like dynamic scoping (deprecated, going away, good riddance—most of the packages I use have all switched to using lexical scoping anyway) and function names like `mapcar` instead of just `map`. But that's a trivial matter. Would I write a shell script in Emacs Lisp just for kicks? No. Is it more than good enough to script the crap out of my text editor? Oh yeah.

> read other's code

I'll second this: there are so many really good packages out there that it makes it easy to find something to get some pointers on how to proceed.

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...
also the way you can use shell - hmmm I'd like all the build timestamps of my 6.4 bootroms...

alright I'll put all the filenames in the buffer

    ls /tftp/bootroms/foobar/foobar_6.4_*.bin | gvim -
I'll run an awk one-liner to print the filename and date seperated by a tab

    :%!awk '{ printf("\%s\t", $0); system("strings " $0 " | grep '\''20[0-2][0-9],'\''") }'
I don't want that long path

    :1,$s:.*/::
I know, I'll sort them by build date

    :%!sort -r -k4 -k2M -k3n -k5
Oh yuck 4 space tabs don't do it

    :set ts=16
    :set expandtab
    :retab
This is probably the most promising answer to me.

> Plain old vim

By this, do you mean this is only available in vim, not NeoVim?

NeoVim has additional scripting functionality over Vim actually, which is why some of their plugins aren’t compatible with Vim. So OP is referring to Vim over the likes of vscode, jetbrains etc
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 tried out Zed after reading this, super impressive and could overtake vscode in a year or two. Missing a few things like supporting editorconfig, but that's being worked on this week. Would switch immediately if it supported a few more things
nobody is going to take VSCode so soon. But I'm starting to feel the VSCode fatigue in the air. Kinda like with React. I was looking for another editor to use or maybe get back to emacs. Funny enough, as I have a lot of free time right now, I decided to code my own editor. It is very fun!
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.

Here's an example of extending an IDE (IntelliJ/PyCharm/RubyMine/WebStorm) by driving it externally:

I used just a little bit of code to make it so when I command-click a filepath anywhere, it opens in IntelliJ. This works in the browser, on chrome links, (github, gitlab, jenkins, error pages, etc) and also in iTerm on stack traces, spec/test paths. I made a chrome plugin, a shell script, and used the remote control plugin (not mine). The result was super-satisfying. I'll probably open source the bits soon. Now, I didn't script the IDE myself--the Remote Control Plugin did that work, but for an open source solution, I wouldn't mind building a remote control plugin myself.

Making this work got me wondering about doing the same with an open-source editor. I also would like to drive things internally, but I want it to be easy so I get a good return on the effort.

For that you can just make the scripts 'gvim file'

If on MacOS and you are using the apple native build, 'open -a gVim file' opens each file in the same editor.

If you want to do that on X11 (even macos X11.app) or MS Windows:

https://vimhelp.org/remote.txt.html#remote.txt

Basically (or gvim, yu might want --remote-silent too):

    vim --servername foo --remote-silent filename [ filename ... ]
The end of that doc explain you can use either Windows messages or OLE.

But the same doc explains how you can completely script vim from the command line:

Tell the remote server "foo" to write all files and exit: vim --servername foo --remote-send '<C-\><C-N>:wqa<CR>'

^\^N is what you press on a keyboard to enter normal mode from every mode except ex mode without a beep.

:wqa means do the command Write All and Quit.

so with --remote-send you can send any sequence of key-strokes to act on buffers.

You probably want to read from https://vimhelp.org/intro.txt.html#notation to learn the fundamentals.

I'd avoid neovim initially until you learn enough to decided if you want it - pros and cons both ways.

Great response, thank-you! I've bounced into vim before. The modal nature threw me a bit--finding :wq written to my code wasn't awesome. :-) I might give it another shot.
VSCode has a comprehensive API that you can create scripts for in Typescript
It's pretty rad really: https://code.visualstudio.com/api/

What I like about it is how it exposes pretty much all capabilities with no chance of breaking the editor host itself. Just the right balance of constrained-enough-but-seemingly-unconstrained.

You can develop these extensions in JS/TS super-smoothly inside VSC and run-with-F5 to open a new window with your extension running.

But frankly for small-script purposes, it's a bit overkill, unless/until you have enough of those that bundling them all up into one "my extension with all the Foos I demand" begins to make sense.

Unfortunately local-only, private one-off extensions aren't installed as trivially as dumping just-a-script-file in some dot folder and calling it done. I mean it almost is with `~/.vscode/extensions/my-ext/` but not 100% reliable. I have 2 custom exts in there that are always available but 1 that inexplicably never is (but builds & runs error/warning-free with F5). The official installation story is a "vsx package" (probably just a ZIP but haven't looked into it yet).

Perhaps try diffing the auto-generated output from installing the vsix via the official means vs your nonfunctional dev-repo?
(comment deleted)
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.
Also ChatGPT is pretty good at writing elisp.
Sublime Text? (It's extendable in Python, but isn't FOSS, which might be a deal-breaker.)
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"

> 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"

You can use Javascript, you don’t need to compile your scripts if you do you javascript, and you don’t need to restart the editor when you change your scripts. You do have to restart the extension host, but that’s not the same thing.

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/

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.
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!

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.