> Emacs are only for text, obviously.

I don't know if I missed something in your post, but this couldn't be further from the truth. It's cliche to refer to emacs as it's own OS, and it is not uncommon for users to do all of their computing inside of emacs - web browsing, email, note taking, documentation, writing, version control, terminal, ide, window manager, remote admin, etc. Based on your criteria emacs seems like a perfect fit, I encourage you take take a deeper look at emacs if you're interested.

https://github.com/emacs-tw/awesome-emacs

There are Emacs packages that themselves have the qualities listed here. GNU Hyperbole, org-mode, calc, org-roam/denote, evil are some examples.

Yeah its been described as a virtual lisp machine as well. I use emacs for everything personally, aside from Firefox (which I launch within emacs/exwm). Its hard to go back once you get used to consistent keybindings and commands across your OS. I sure wish RSS was more popular, too. I wouldnt even really need Firefox if that were the case.

Rob Pike's acme text editor for the Plan 9 operating system: http://acme.cat-v.org/

https://www.youtube.com/watch?v=dP1xVpMPn8M (excellent overview of the editor by Russ Cox)

And acme's predecessor sam: http://sam.cat-v.org

You'll need plan9port to run acme on Linux, though. But the core ideas are very simple and powerful (sam: everything is a huge string; acme: everything is a clickable file) and thus hopefully long-lasting.

I would also mention edbrowse, a line-oriented web browser initially for blind people. Maybe this is too far on the fringe, though. It does have a lot of depth (excellent scripting capabilities); it's an amazing project actually: http://edbrowse.org/

I've heard this about AutoHotKey: https://www.hillelwayne.com/post/ahk/

Not just macros, but deeper automation of anything in a Windows UI, with a great depth of community scripts and knowledge.

Sioyek: https://sioyek.info

It's a PDF viewer with many powerfull features ( for example you can preview references even when the document doesn't have links) and vim-like keybinds. Although it is a little too soon to determine if it will be future proof.

FFMpeg and its libraries https://ffmpeg.org/about.html

Smalltalk, my experience has mostly been with the Squeak and Pharo variants. It hits everything on your list, in my opinion.

I second this recommendation. Squeak and Pharo are awesome, not limited to text, and have fast virtual machines.

> fast virtual machines

Compared to what? To do what?

Well, compared to popular dynamic languages with similar levels of abstraction, like Python or Ruby. Squeak was just released with SistaV1, so I think the speculative inclining JIT is just around the corner. While using Pharo, I'm used to get code running 2-3 faster than the equivalent in Python.

> popular dynamic languages with similar levels of abstraction

JavaScript?

Man i wish I could really understand pharoh.

The freely available book "Pharo by example" I found good to learn from, a few years ago. Smalltalk is an enormously powerful language but initially it can feel "the wrong way round" like driving on the other side in a foreign country . You can get used to that though, and its worth it. I think in the years since I learned Smalltalk via Pharo, its got a bit bloated with features, so Squeak might also be worth a look for trying out simple things to learn.

Thank you for the advice, I'll look into it.

one of the most annoying things about smalltalk/pharo is that the "marketing" tell you it's simple and the syntax fit in a sheet of paper, yet all the times i tried to try it i had to go through a lot of pharo introductory tutorial before i could even start to type an "hello world".

needless to say I got bored ad moved on.

With any programming language there's a lot of introductory tutorial before we even start to type "hello world".

    ~$ ./visual ./visualnc64.im -nogui -doit "Stdout nextPutAll: 'hello world'; cr. ObjectMemory quit"

hello world

    ~$

— or something like —

    $ cat hello.st
    Stdio stdout 
        nextPutAll: 'hello world'; 
        nextPut: Character lf.!
    SmalltalkImage current snapshot: false andQuit: true!

    $ bin/pharo --headless Pharo10-SNAPSHOT-64bit-502addc.image hello.st

`Transcript show: 'Hello, World'`

Not especially complex syntax. It just doesn't have a lot in common with languages with Algol-like syntax

Some people have mentioned window managers, but nothing comes quite close in terms of extensibility and feature as dwm[0] and xmonad[1], which is a near dwm reimplementation in haskell with many more interesting features.

Both programs are configured by writing code, which compiles to a binary that you then use. Xmonad and xmonad-contrib are maybe more accurately described as haskell libraries that make writing your own window manager trivial. Highly recommend if you enjoy configuration, you can do some really cool stuff with it.

[0] https://dwm.suckless.org/ [1] https://xmonad.org/

I eventually found my dream WM, and it's Awesome:

https://awesomewm.org

It's pretty far from suckless philosophy, which for me is a good thing. I think this makes it way more flexible and usable. Great documentation, loads of features, and infinitely extensible with lua configuration. If you aren't bothered by your WM using a few megs of memory then I think it's the best choice.

Currently using DWM-flexipatch for the last 6 months. Would be interested in learning what features I gain from switching to Awesome.

Adding stumpwm to this list---interactively programming your window manager is an amazing feeling

There was a time when GWM (generic window manager) was quiet popular. It had a Lisp config language (Wool).

A feature which is useful in my opinion is that the end user can enter commands to use external programs with pipes. There are other good ideas such as standard I/O, command lines, etc. Better also is: you have enough ropes to hang yourself, and also a few more just in case (this is UNIX philosophy). Most web browsers are the opposite of what is any good, though; they do not believe the end user, offer too few controls, do things automatically that they should not do, break things, etc. I do not know of any good ones, and most of them just become worse over time.

I try to write better programs, although of course, if it is any good or not, is a matter of your opinion.

I wrote a ZZT editor which is has some similarities with vim (it has a modal interface similar to vim, using various key commands for many operations (even can use hjkl for cursor movement, and numeric prefixes, like vim does), and also you can enter SQL codes to perform queries and batch operations, and can use SQL codes to customize keybindings too). You can also use external text editors to edit ZZT-OOP text (later might also be adding option to allow a built-in text editor too, with syntax highlighting and auto-completion).

I had written other programs too, and there are probably many that I had not written, too. However, many newer programs are not designed well like that and instead include only a few options that are nearly worthless. I try to oppose that and write a better one.

Blender is kind of vim/emacs of the 3d world. Especially with its extensibility through python.

I've always thought a python-based emacs would be really fun. I just seem to write code in python so much more naturally than lisp.

And I guess kicad (pcb cad) is getting there.

The reason editors seem to be a well populated niche, I think, is not only because it is a common need but because it is an application domain ripe for having an application+framework+extensions hybrid. The generic nature of the content being manipulated means that a generic buffer management framework can go a long way to allow humans to adapt it to many purposes. This generic approach also limits the complexity of writing an extension, which makes it more accessible to new or narrowly motivated hackers. Other content-generating applications with similar scripting potential exist in imaging and graphics, e.g. photoshop, gimp, cinepaint, blender. I am sure there are audio equivalents but I know less about those.

An even more robust and powerful application plus framework is arguably an RDBMS system. Even if you limit yourself to the intended usage model, the commercial products like MSSQL and Oracle meet many of your criteria. Of course, the open source ones like PostgreSQL, MariaDB, and SQLite take this even further. They have pretty extensive internal interfaces you can also extend, if you are not content with the planned extensibility of SQL, stored procedures, etc.

But, are you limiting yourself to standalone applications? Many frameworks are very modular and meet many of your criteria for software, but are intended to be consumed by developers and so may not have as much standalone function. Consider web app frameworks, conventional thick GUI frameworks, and more focused tooling like parser generators.

And of course developers may be blind to them, but the operating systems and compilers we use are also rather elaborate and extensible frameworks. I think things like GCC and the Linux kernel demonstrably meet these criteria today, as they did when I was starting my career ~25 years ago.

VisiData: https://www.visidata.org/

WeeChat: https://weechat.org/

fzf: https://github.com/junegunn/fzf

Ed. Ed is the standard text editor.

not in a similar category but foobar2000 for windows is infinitely customisable and really powerful. including its UI, plugins, embedded language for tag properties.

for example check the reddit and look at peoples setups. all wildly different

Obsidian and Logseq. Both work with Markdown files and have a large number of community plugins.

I think Excel checks off all your boxes:

- powerful

- understandable

- hackable

- extensible

- reliable

- future-proof (few breaking updates) <-- can't promise anything but you can open an XLS from 1995 in Excel 2021.

- feature-rich

A dialect of Lisp. Choose your flavor, though I recommend Clojure.

I would say this counts because the language itself is programmable. The lisp I use can be tailored to exactly how I want to write code, just like my vim setup.

Anyone who's been using CL for the past couple of decades basically has their own dialect on their hands, given all the tools they've built around the standard ones.

I'm not saying this is the best way to collaborate with code that others need to muck with, just as I wouldn't expect anyone to be able to do anything of use in my vim setup. It's for you.

Clojure is more lisp for java programmers, than java for lisp programmers. Unless you have your feet well grounded in the Java ecosystem, using Clojure to develop anything meaningful will be somewhat of a struggle.

For a different application area consider the Minecraft sandbox environment.

Or Minetest if you want to go the FOSS route

There's also classicube which is a FOSS implementation of minecraft classic.

Surfingkeys https://github.com/brookhong/Surfingkeys is a browser extension for surfing web with vim like interface. It has lots of built-in functionality, for example: focus on the first input, edit URL and visit the changed URL, go one path up in URL, go to audio playing tab, copy column(s) of a table, copy code blocks... It's extensible, you can bind JS functions to keymaps.

Autocad[0], the emacs for CAD. Since 1982 and still the industry standard. You can even script it with lisp[1].

[0] https://en.wikipedia.org/wiki/AutoCAD

[1] https://en.wikipedia.org/wiki/AutoLISP

Window managers: awesome, i3.

Pico was used in the examples in undergrad to avoid derailing the class teaching how to exit Vi (the GNU version is "nano")

https://en.wikipedia.org/wiki/Pico_(text_editor)

blender, if it ever manages to make a consistent experience.

ableton, is sort-of-there but it could be less verbose

PHP as a scripting tool , has everything fast

Secondlife/opensimulator as gaming platform. Unfortunately too much legacy stuff and not enough innovation, but more open and hackable than others

My friends and I call these "golden software." Things that are reliable, meaningfully F/OSS, versatile and extremely useful. Our top tier is:

- Syncthing - OBS - VLC Personally I also think: - Licecap - TouchDesigner - Stylish

Check out micro which is supposed to be a modern nano. https://github.com/zyedidia/micro

Or check out nano, which is actually a modern nano!

- qutebrowser

- vifm

- ranger

- i3

- sway

- tmux

- zathura

- tig

Vifm looks really interesting, and admittedly I haven't tried ranger. Will give them a go, thanks!

The others are all very fine pieces of software I all use but imo not nearly on the same level. They're essentially programs with fancy keyshortcuts.

You should also check out nnn (https://github.com/jarun/nnn) if you're looking for terminal-based file manager.

IIRC the golden standard is midnight commander ( https://midnight-commander.org/ ), which is another old timer. I wonder how nnn and vifm compare to mc.

Nyxt, the lisp enhanced web browser

jEdit - Java based editor with lots of plugins and extremely customizable.

Sooo.... Am I the only one who thinks this looks like a post promoting "tiddlywiki"?

VSCode demolishes Vim and Emacs. Want something easier to extend? Write your own editor.

Visual Code, I guess obviously. Has mostly overtaken both Emacs and Vim.

That's like saying the phone has overtaken the horse.

I doubt many people sshing into a box using vim will choose visual code. There might have been some people using vim for daily development who switched but probably not many

vscode actually is very convenient when working on remote machines. You'll run the vscode editor on your own box, but have it access the remote's filesystem over ssh. https://code.visualstudio.com/docs/remote/ssh

Probably overkill for occasional remote file editing (it'll run some server component on the remote machine), but pretty good for more involving remote development work.

Switched from vim to vscode with vimmode for the key bindings. Od definitely include it on the list for the extensibility and features.

> I doubt many people sshing into a box using vim will choose visual code.

Actually I do just that.

With the remote development tools I can open a remote folder in vscode and edit from there. And when I start terminals, they're going to start a shell on the remote linux box.

Everything via ssh.

It's like saying that the electric car engine has overtaken the oil-based car engine.

Really? Did you miss the part where both of them are editors?

Are you opening visual code in your putty session to edit a config variable? They are as similiar as word and pico.

No, but that's for basic text editing only. Anything more serious and you spending 2 hours per 6 hour development time configuring vim.

You configure Vim Daily? For every Task? Wow!

I have once .vimrc configured for all the languages that I use/know. Whenever I work with a new client. I pull that .vimrc on the allocated machine. Run PluginInstall and in minutes I am ready to go!

I would claim the opposite — VSCode is nearly unusable without very heavy customization unless you're fine with being very inefficient. Hotkeys for many common operations are not assigned out of the box. Without that, using it involves driving the interface with both the mouse and the keyboard. Those that are assigned are awkward and look like they've been designed for a spider since they require you to reach keys on the opposite sides of the keyboard. I always get the feeling that its own authors don't use it for anything more complicated than editing /etc/hosts, although it's quite obviously not true.

Overtaken how? Download size? Startup time? Ubiquitous availability? Number of kernel hackers who use it as their daily driver? What's your metric?

Memory usage and CPU time ! Heyooo!

I remember when Emacs was viewed as requiring a lot of resources (in the early 1990s) and I remember the sysadmin of our shared UNIX system scolding us if we had more than one emacs process running (as opposed to opening multiple files in different buffers).

The old joke was that EMACS stood for Eight Megs And Constantly Swapping. Of course, eight megs is nothing these days.

Not a fan of vscode (or emacs, which it “has overtaken”, not vim), but I think it fits OP’s first paragraph.

Popularity, features, quality. I still use Emacs myself but I'm not fucking blind.

Relax and open your eyes.

I've been using VSCode kinda on and off, but I haven't learned it properly yet. Do you think it's truly worth it? It seems to me like you'd use it mainly when you don't have access to a full IDE, so I haven't really found a niche yet.

VSCode is magical in my experience. I say this as a 20 year emacs user, and 10 year Vim user.

VSCode is good. But it is a memory hog compared to Vim. I need that memory for my compile/simulate tasks.

I wish someone could show me actual repl work in vscode for a lisp or erlang. It sometimes gets the way there, but doesn't to make it.

I think the plugin writers are either shoe-horned by VCCodes lack of plugin capability or they are basing their work off some other toolings expected behavior and it doesn't "sit right" with how I work.