1. 49

I think this is an interesting thing to ask of the community, and I couldn’t find any similar posts. Feel free to share as much as you’d like, with the minimum being (of course) the name of the editor.

    1. 19

      Neovim with a LOT of addons.


      I use Packer for plugin management and Mason for LSP server/whathaveyou management. I’ve thrown in a smattering of LSP-related plugins to make life easier for myself, as well as a bunch of autocomplete plugins. I make heavy use of Telescope to navigate my files and buffers. My setup starts almost instantly (thanks to lazy loading) so I can have a bunch of ephemeral sessions. The time where I always have an instance of nvim running is when I’m working on a large project with an LSP that needs to reinitialize every time I start nvim.

      At this point I should’ve just used Spacemacs in evil mode…

      1. 2

        I like how you use the arrowkeys for resizing!

    2. 15

      I think I’m in the minority by using joe, a plain text editor without customization for about twenty-five years now. I will try out an IDE from time to time, but I’ve never been able to get them to work (the last few times I’ve crashed them—don’t ask me which ones, I don’t recall, nor really care).

      1. 6

        Wow. Most of my colleagues consider me on the bare bones of the spectrum. Your setup makes me feel like I’ve been on some bougie luxury cruise. I’ve used vim for nearly as long, originally just because it was the only thing on the few dozen linux and BSD machines I admin’d. The reason it has stuck with me for so long though is the customization. The ability to quickly capture a new need in a custom command, add a custom key mapping, or write a small plugin has been a huge productivity boost for me. When you have a need to automate some part of your editing do you ignore and forge ahead manually or do you automate it outside the editor with awk, sed, etc?

        1. 2

          I automate it outside the editor. I can highlight some text within joe and have that text run through a program, with the output replacing the selected text. Also, joe can edit multiple files, and can have several views into the same file.

          Unix is pretty much my IDE, and it’s not uncommon for me to have half a dozen xterms going.

    3. 14

      Orbiton, a little editor I made. I use it for editing configuration files, programming, writing TODO lists and README.md files. It has several unique features, is configuration-free and has fewer hotkeys to learn than GNU Nano. It is probably not a perfect match for every Linux or BSD user or developer out there, but I like it and use it on a daily basis. https://github.com/xyproto/orbiton

    4. 12

      Helix, with almost default config, just some custom keybindings:

      true-color = true
      color-modes = true
      idle-timeout = 75
      render = true
      insert = "bar"
      normal = "block"
      select = "underline"
      g = { a = "code_action" }
      0 = "goto_line_start"
      "$" = "goto_line_end"
      S = "surround_add"
      0 = "goto_line_start"
      "$" = "goto_line_end"
      j = { k = "normal_mode" }
      1. 6

        But a confession: I use IntelliJ for work projects :P

      2. 2

        which terminal emulators do you use? On various computers/platforms?

        1. 4

          On macOS, I use Kitty, mainly because the split and tab functions.

          I also use the same helix config on github codespace. It works really well.

        2. 1

          I find it works really well in Windows Terminal.

      3. 2

        Yep pretty much like me and for the opposite reason of @eBPF using Neovim above: because it really does not need any plugins for my use cases.

        bufferline = "multiple"
        color-modes = true
        cursorline = true
        insert = "bar"
        "S-left" = ":bp"
        "S-right" = ":bn"
      4. 2

        Same config, give or take a line 🤘

    5. 11

      My fingers learned vim many years ago and after four books, 150+ articles, a couple of dozen papers and a couple of hundred lines of code, they refuse to learn anything else. VS Code’s vi mode is very close, but not quite there. I now use ALE for LSP integration. My vimrc is pretty short, just moving a few default locations (tmp files and undo things in ~/.cache instead of littered in the working directory, for example), setting unlimited undo persistent undo, loading ALE and telling it where to find clangd and clang-format on different operating systems.

      I tend to rely on multiple terminal windows / tabs a lot more than most folks. I like separation of concerns. My terminal manages windowing, I don’t use tmux inside it and I don’t use multiple buffers in vim. I do use ^z and fog within a terminal for switching between things so that I have a consistent switching mechanism, whether I’m switching to another vim, a debugger, a program I’m testing, or whatever. The same applies at the outer layer: navigating between terminal windows is consistent with navigating between other kinds of window and so doesn’t incur additional cognitive load.

      VS Code’s remote extension is great if the remote is one of a handful of programs, but if the remote is an unsupported OS or architecture then there’s no graceful fallback to limited support, there’s a complete cliff. This is part of the reason that I still prefer vim: in the absolute worst case, I have some other vi clone (e.g. nvi) and basic things work. More commonly, I can find vim on basically any system I might use, though possibly without ALE and the LSP integration depending on what access rights I have.

    6. 11

      I use a window manager called Emacs which also happens to ship with a built-in text editor. By default it’s not great, but it can be fluidly customized more thoroughly than anything else I’ve seen. If you’re using a program that doesn’t have view-source functionality for every command you could possibly invoke, insist on better!

      1. 2

        How does “view source” work in emacs? In (neo)vim I can trace execution to see/log exactly what happens when I run a command, but it’s hard to “view source” because there are a lot of events, hooks, etc that are all separate but can all be triggered as a result of running a single command or even a simple motion.

        1. 2

          C-h f <function> or C-h k <keybinding> to get to the help for the functionality, which will have a link to the source for the underlying function. E.g., C-h f font-utils-is-qualified-variant <RET> results in

          font-utils-is-qualified-variant is an autoloaded compiled Lisp function in

          where font-utils.el is a link to the source code for font-utils-is-qualified-variant.

        2. 1

          So specifically I said view source for every command; in Emacs terminology commands are a subset of functions which can be bound to a key press or invoked by name using M-x.

          In Emacs every named function (not lambdas) can have its source viewed (functionality implemented in C sometimes doesn’t work with this depending on how Emacs is installed, but if you compiled it yourself from source then this should always work). It’s true that this doesn’t work for lambdas, and you can have lambdas attached to hooks, but it’s a best practice not to do this and to use named functions for hooks instead of lambdas. This convention was not actually motivated by a good reason, but rather it’s because lambdas cannot be compared for equality when they’re byte-compiled, so it’s possible for an add-hook command to duplicate a hook when re-run if it uses a lambda. So we kind of got a situation where visibility is better than it otherwise would be, but due to a stupid reason, not on purpose.

          But viewing the source of a command should be enough to make it clear what set of hooks are run when that command is run.

    7. 10

      I have a heavily-customised emacs setup, packaged up as a single giant Nix expression: https://git.sr.ht/~jack/nix-overlay/tree/master/item/jack-emacs

      The Nix packaging is heavily inspired by Matthew Bauer’s configuration: https://matthewbauer.us/bauer/

    8. 10

      I use a simple and boring Emacs config, with some personal keyboard shortcuts and some customize settings.

      That’s usually the starting place, and then I make local changes on each machine (work, home, laptop, etc.) based on what I’m doing there.

    9. 9

      Emacs and evil-mode with a ton of slightly crufty customization. https://github.com/emoses/dotfiles/tree/master/emacs

      Lots of stuff for $JOB and $JOB-1, $JOB-2 was a Java shop and I go for IntelliJ for Java work.

      Also includes a mode for everything I’ve ever played with and I rarely take those back out.

    10. 8

      For most quick stuff, I use good ol’ vim. I’ve got a vimrc and supporting config I’ve honed and carried with me for about 10 years, resetting it only once. I added an LSP plugin not too long ago and find myself using it more now that the LSP enables mindless autocomplete.

      I use Helix some on my Windows machine because the lag in vim is bad and I’ve never bothered to troubleshoot it. I’ve also started using VSCode some to see what the fuss is about. I like it for doing something in WSL2 for a project I can’t bother to make build correctly on Windows.

      Most of the time, I’m using a Jetbrains editor, though. It’s a solid tool regardless of the community edition or ultimate edition. Work pays for UE so I use it for Python, Scala, Rust, shell, YAML, and more… the conveniences it offers are probably available with some plugins in vim, etc. but Jetbrains makes plugin discovery mindless.

    11. 8

      I’m using Emacs and my configuration is public and fairly well documented.

      I’ve used it before since about Emacs 19, but had a long absence from it during which I used Vim and periodically tried to switch to and like e.g. Eclipse, Intellij, Vscode, and others.

      After the big improvements to performance and usability in the last few versions, it would now take a lot for me to try to switch again, especially since I’m now also quite invested in Org mode.

      That said, there are promising projects that I keep an eye on, right now in particular Lapce.

    12. 8

      Doom Emacs

      I used VS Code for a few months recently and I was quite happy, but the vim support automatically disintegrated after some time with more and more functionality breaking (not sure why) and I switched back to Doom when u would only do one step of undo.

    13. 8

      It’s me! The one who uses Panic’s Nova! https://nova.app

      It’s an absolute underdog — a Mac-only GUI IDE - but I love it and have loved it since it launched at the end of 2020, and it’s been receiving regular and substantial updates since then.

      • It uses a small amount of memory and energy, zippy, opens big files happily
      • Has many high-quality extensions, many of which make use of an excellent built-in LSP client.
      • Thoughtful UI design that feels totally idiomatic to macOS.
      • A built-in debugger
      • A git GUI which handles the most common git tasks really well
      • Built-in preview browser
      • A licensing model I’m happy with (pay the softawer + a year of updates, use as long as you like)
      • vim mode

      And there’s so many tiny great things, like how you can hover over sections of the minimap and see symbols of what you’re hovering over. Details!

      I work mostly with JS/TS and use the Nova with (my own) Deno extension. Deno’s rust-based toolchain with Nova’s native performance just feels so light and great.

      1. 2

        I was going to chime in that I did use Nova for a couple years for embedded (ARM32/64) development, Python scripting, and shell scripting. I have a fairly complex setup where I need to compile inside Docker and then have a variety of scripts for running or debugging in QEMU or hardware. I am a longtime Mac & iOS developer (20+ years) and really appreciate Panic and their apps, but I was just getting random crashes once or twice a week (always reported) but they were killing my productivity when they happened. Combine that with the need to do some STM32 development and debugging and VS Code’s built-in debugger support, I fully switched over to VS Code and in months now haven’t had a single crash. In addition, I find I am able to script the tasks, launchers, and hotkeys that I want faster and more flexibly, and there is a huge variety of debugger support. VS Code also feels faster. It pains me to leave behind a true native app but I have not looked back since VS Code. I feel like the sweet spot for Nova is web and scripting development but when it comes to a lot of native development, it can’t really compete the same was VS Code can.

        VS Code extensions I particularly like: CodeLLDB, Cortex-Debug, indent-rainbow, PDF Preview, PlatformIO, and Vim (25+ year Vim user as well, depending on task).

      2. 2

        Same. I love Nova. It feels like the most “Mac-assed Mac app.” Two other things ill add that I’ve enjoyed-

        • The diff view. It’s absolutely perfect for comparing current branch/commit vs. older commits / tags
        • The gitlens-type feature. No extension needed, just flip the setting on

        I’ve been starting to dabble with Deno and i’m using your extension. Thanks for making it!

        1. 1

          Ohhh yeah the diff view is great! And thanks for trying my extension!

      3. 2

        $100 for a text editor? Is it worth it?

        1. 9

          For me who makes a web developer’s salary and wants to see investment in tools that are not made with electron, yes!

        2. 1

          For me definitely. Programming is what I do for a living, and $100 is a small amount to pay for something which makes my work more pleasant every day.

          And ahem, it’s an IDE.

          1. 1

            And ahem, it’s an IDE

            I mean even Panic don’t call it an IDE - I think there’s a certain level of functionality that people expect when the term IDE is used.

            I haven’t looked at Panic since it was in pre-release days, but I would be very surprised if it had the functionality an IDE like Jetbrains offers.

            That doesn’t mean it’s bad necessarily, it just means it’s a different type of tool.

            An electric drill can drive screws, but it isn’t the same thing as an impact driver, which is designed to drive screws.

            1. 2

              If having a debugger, symbol browser, and LSP support doesn’t get you into the IDE club I don’t know what does!

              1. 1

                Usage detection and refactoring support is the thing that is pretty universally missing from “editors” that people end up calling “IDEs”.

                I just downloaded the latest version, opened up a project and it could neither tell me where a symbol was being used, nor gave me any way to intelligently rename or otherwise alter that symbol with automatic changes being applied to the calling locations.

                It also doesn’t help IMO that the extension system is apparently based on javascript, but from a quick check, at least some of the extensions then require nodeJS and NPM be installed, for extensions that have no specific ties to JS as a language.

                1. 1

                  I’m not familiar with Jetbrains IDEs. What do they offer beyond what LSP offers? I’ve just recently, over the last couple of years, started using LSP more. I’d be interested to know what I’m still missing compared to a “proper” IDE.

                  For reference, these are the LSP functions that I most often use:

                  • Go to definition of symbol
                  • Find references to symbol
                  • Go to type definition
                  • Find implementations
                  • Rename symbol
                  • Apply suggested bugfix (usually that’s adding an import)

                  It’s been a long time since I’ve really used a proper IDE and I don’t think I’ve ever used a Jetbrains one. What else is there?

                  1. 2

                    Well if those things you list actually worked in Nova maybe I’d be ok with that, but I couldn’t get it to work any more than a glorified “find substring in project” (more details here: https://lobste.rs/s/nbr9bl/what_s_your_editor_setup#c_s0ewvx)

                    Jetbrains does support a lot more though:

                    • change method signature (i.e. add/remove/re-order method arguments) - this also works on interfaces, so implementing classes reflect the same change, as well as calls to the changed method;
                    • extract variable/constant/class property/method from an expression (including duplicates);
                    • extract interface from class (i.e. create an interface and replace applicable references to the concrete class, with the interface name);
                    • inline a variable/method/constant/property;
                    • move a symbol to a different namespace (including moving an entire namespace);
                    1. 1

                      Sorry, I was hijacking this thread to ask about Jetbrains - I don’t know anything about Nova! Maybe Nova is buggy. For the things I listed, LSP works really well.

                      Thank you for the examples of other things that Jetbrains does. You’ve got me interested now: I wonder which IDE functionality is most used? Does Jetbrains collect telemetry? Come to think of it, I wonder which LSP functionality I actually use often. Naïvely, this seems like something that could actually be amenable to empirical study.

                      1. 2

                        I wonder which IDE functionality is most used

                        Yeah I’m not sure really - and it probably depends a lot on the language involved. I would imagine that things like this are much more heavily used, as you go up the scale in terms of how powerful the language’s type system is.

                        1. 1

                          Yeah, you would think that a powerful static type system would allow more things like this to be automated. I have seen some impressive demonstrations with Idris but most IDE functionality seems to focus on Java-style OO languages rather than anything fancier. Is there anything Jetbrains-like for Haskell?

                          1. 1

                            I don’t believe there’s any first-party support, but there seems to be at least one third party plugin for it - whether it supports full/any refactoring support or not I don’t really know, Haskell isn’t really in my wheelhouse.

                2. 1

                  I have all of these features, you just haven’t set anything up.

                  You need to install an extension which supports the type of project you’re opening (e.g. the Rust extension, the TypeScript / Deno extension, Gleam extension, etc.). The extension is responsible for hooking up a LSP with Nova’s built-in LSP client which enables these features.

                  Because the extension API uses JS, some people build their extensions using the NPM ecosystem. The final extension is run in a non-Node runtime. There’s certainly no requirement to have NodeJS or NPM to be installed for an extension to work, that’s on the extension author.

                  1. 1

                    Ok, so I went back to it, because hey maybe I just missed something. Believe me, I’d love a lighter IDE than Jetbrains. I’d even accept some reduced functionality of esoteric things like vagrant support, or run-on-remote-interpreter support, if necessary.

                    The project in question happens to be PHP - a language Nova supports “out of the box”. The only extra extension I found which suggests it adds more functionality “language support” for PHP, is the one I mentioned above, which says, very clearly in its description:

                    Intelephense requires some additional tools to be installed on your Mac: Node.js

                    Anyway. So I tried with the built in language extension, because hey, it should work right?

                    “Go to definition” works.. it’s janky and kind of slow but it works (or so I thought).

                    As far as I can tell, thats it.

                    I found “Jump to (Previous|Next) Instance” which just highlights the same class name (in a comment as it happens) in the currently open file. Not sure if that’s what it’s supposed to do, but it’s completely unintuitive what this is meant to do, or why I would want that.

                    I tried Cmd-Click just by reflex from JetBrains muscle memory - and it shows me results when invoked on methods.. but besides being ridiculously slow, it’s woefully inaccurate. It just seems to show any method call that’s the same method name, regardless of the class it’s invoked on. Further investigation shows that’s actually the same behaviour for “go to Symbol” on methods too.

                    I get it - some language extensions will have more functionality than others - but this is a language they list with built in support, and it has a lot of capability to specify types, right in the language. If it can’t infer the correct symbol reference from php8.x typed code, I can’t even begin to imagine what it’s like with a language like Javascript or Python or Ruby.

                    Maybe it all works wonderfully if you specify an interpreter path for the project? I don’t know. It doesn’t let me specify a remote interpreter (e.g. in a VM or Container, or an actual remote machine), and I’m not about to go down the rabbit hole of trying to get the same language runtime and extension versions installed on macOS just to test that theory.

    14. 7

      Mostly VS Code with the VSCodeVim extension, plus the usual soup of language-specific extensions for the languages I use at work. I have a difficult relationship with that extension because I couldn’t use VS Code without it, but the UX for a lot of stuff (ex commands is the one that comes to mind) is terrible. It aims to emulate vim so hard it reimplements a lot of things in a half-broken way, for example undo/redo which I always remap to VS Code’s native stack, and search and replace. It also used to be very slow, though I think it’s improved on that front. I have also tried amVim which maps more closely to VS Code, but it feels like it implements the wrong subset of Vim for me to use it.

      (Whenever I complain about VS Code’s vim extension(s) I get the itch to try and write my own, so I’m currently attempting to stop myself from starting another project I’ll be abandoning soon lol)

      I’m trying to use Helix more often and I almost exclusively use that outside of work; the LSP integration and the tree-sitter highlighting are very nice, but some languages are not very well supported (I’m mostly looking at F# here, the tree-sitter parser for that is half unfinished and the language server crashes very often, though the latter could be said for VS Code too) and the UX for diagnostics is not ideal; it just superimposes them on the top right of the screen with the text aligned to the right and often on top of the code and as of now there’s no way to change that save for doing away with the language server completely.

      I like the editing experience in Helix much more than any other editor I’ve tried though, and there are plans for a GUI in the future, so I hope I’ll be able to move everything to Helix in the future.

      1. 10

        Have you looked at vscode neovim? It supposedly embeds an actual neovim instance into the editor so you’re using proper vim instead of an emulation.

        1. 1

          Nope, I knew of VSCodeVim’s neovim integration but I’d never seen this extension. The ex commands UX looks better at least. Maybe I’ll try it, thanks!

      2. 1

        Thanks for the tip about remapping the undo / redo stack! It’s way too confusing to have two undo stacks floating around, and I occasionally trigger the wrong one and chaos typically ensues. 😅

    15. 7

      If I’m allowed to and it’s supported by the language I generally use a JetBrains IDE. I’ve had to cross languages quite a bit and I’ve used CLion, WebStorm, IntelliJ, Android Studio, RubyMine, PyCharm, GoLand, and Rider. I initially felt bad about getting and keeping the whole subscription but I’ve made my money back in productivity many times over the years.

      For C++, it’s Visual Studio or CLion. VS might be older, but it’s an industrial tool for big projects that gets the job done. Visual Studio C# support is great, and the F# support (along with Rider’s) was surprisingly good.

      Visual Studio Code is my fallback. I’ve spent thousands of hours in vim and I have a heavily configured .vimrc with a lot of plugins. I only use it in more limited cases since it’s easier to share workflows with other developers in VS Code and markdown preview in VS Code is helpful. I also recently made a VS Code plugin to integrate with a tool that I wrote, and it was almost painless, even though I’d never worked in TypeScript before.

      1. 1

        Can I ask, once you had IntellIJ/IDEA Ultimate, why did you bother with the “clone” IDEs like RubyMine/PyCharm - the plugins for both languages work in IDEA (I realise that some of the tools like CLion and GoLand aren’t supported in IDEA)

        1. 1

          I like keeping things separate and it seems weird to me to use a plugin for an existing IDE when you have the real IDE available. I had a hobby code base of heavy Python and C++ and I do remember PyCharm doing a lot better job dealing with the Python side.

    16. 6

      I switched from Vim to Kakoune (with kak-lsp) over a year ago. I have a (very) small amount of custom KakouneScript that helps me better integrate my Kakoune sessions with external programs, similar to what connect.kak does. I have one other not-written-by-me plugin installed that lets me use Kakoune as a pager/STDIN reader more pleasantly. I’m having a great time, though can understand why this doesn’t work for most people.

      1. 4

        Same here, though I’ve been using kakoune for significantly longer. I’ve written a lot of the plugins in my config, I really like knowing the exact scope of what a plugin can do, how it might interact with others and of course being able to modify it to fit my needs.

        I only recently started using kak-lsp with clangd, and am really impressed with how painless the entire setup was.

    17. 6

      Neovim with a (relatively) modest amount of plugins.


      I use LSP and Treesitter, but don’t use auto complete plugins or Mason or Telescope or any of the other popular feature rich plugins. I rely on :make and :grep and a custom interface over fzy.

    18. 6

      Emacs, specifically Emacs 29 with a few extra patches (most notably native comp and xwidgets).

      I do a lot of things in Emacs, not least because it gives me a consistent way to work between macOS, Linux, and WSL if I have to work on Windows:


      I’m also partial to Acme but am too deeply invested in Emacs at this point.

    19. 5

      Emacs in a terminal window.

      I have elpy installed for autocompletion and the nicer flycheck integrations, but I don’t really use most of its “IDE” features. I have doom-modeline but not the rest of the doom-emacs stuff. Tried some of the project management stuff like projectile/helm-projectile and never got into it. Ditto org-mode. Ditto evil/spacemacs/etc. – I don’t mind most of the default keybindings, and I don’t want the vim ones.

      Even if I stopped using literally every other feature of Emacs I probably would continue to use it for magit alone.

    20. 5

      I use Sublime Text for HTML and VSCode for Go. I prefer ST overall, especially the keybindings and speed, but the LSP integration of VSCode is just better, so I use that when the LSP matters.

      1. 1

        Could you elaborate on how VSCode is better at LSP? I’ve only recently started using LSP but so far I’ve found that it’s pretty much identical in every editor that I’ve tried. If you find that it’s better in one than another, that suggests that I’m missing out on something!

        1. 1

          I’m sure you could configure Sublime Text to work identically, but out of the box in VSCode, you can press F2 to rename something and tests have a little run button next to them. It pops up a little yellow lightbulb to suggest things the LSP can do, like extract stuff to a function or insert field names. When you run tests, it automatically colors the code based on coverage (which is sometimes annoying because you don’t care). The built in console is convenient. Nothing life changing, but it’s enough for me to switch over when I’m doing Go.

          1. 1

            Ah, OK. I guess I haven’t noticed LSP functionality for tests as I don’t usually run tests from my text editor. But thank you for answering: it’s good to know there’s more that LSP can do!

    21. 5

      On Amiga: TurboText without any customisations. It just works, is Style Guide compliant and extensible via ARexx.

      On Mac: Sublime. I have a subl link to start it from the shell and have it set as $EDITOR. No customisations worth mentioning, but I have installed various syntax extensions for languages I use (including editing tmLanguage syntax definitions) and a JSON extension to reformat JSON files in various ways.

      At work, I mostly use Xcode, with a lot of customised keyboard shortcuts (rename symbol, find symbol…), various extensions for rewrapping comments, shortening literals expressions, a linter etc.

    22. 5

      I switch between Neovim and VSCode. VSCode because it’s better for LaTeX, Autohotkey, and Copilot, plus it’s easier to pair with other people on it. Neovim for everything else. I’ve extended it with a lot of plugins and custom lua functions, like this one to tie tasks to specific buffers:

      function LoadLocal(local_cmd)
        vim.b.local_cmd = local_cmd
      function RunLocal()
      vim.cmd [[command! -nargs=1 LoadLocal call v:lua.LoadLocal(<f-args>)]]
      vim.keymap.set('n', 'gxl', RunLocal, {silent = true})

      The custom functions are what keep me away from alternatives like Kakoune and Helix. The cold start time is really bad and I should probably lazy load the plugins. Time to dig into @eBPF’s config

      1. 2

        VSCod[ium] […] because easier to pair with other people on it

        What would make this text editor easier to pair?

        1. 1

          The sheer number of mappings I use makes my neovim unusable by anyone else.

        2. 1

          Mostly this: https://code.visualstudio.com/learn/collaboration/live-share

          I don’t usually use VSCode but have occasionally used it for remote mentoring sessions because of Live Share.

          1. 1

            I’ve always found upterm / tmate to be ideal in these situations as the only requirement is a terminal emulator which makes it great on bandwidth, the flexibility multiplexers add is nice, and its not limited to a single software. It doesn’t support users keeping their settings as mentioned, but I’d be damned if someone made me use proprietary software just to pair.

      2. 2

        I’ve not used it, but there is a copilot plugin for neovim.

        1. 1

          There are a host of FOSS options out there too if you don’t want to accidentally feed your or your employers code to the Microsoft GitHub servers or have it packaged into their proprietary offerings.

          1. 2

            I haven’t come across a FOSS Copilot equivalent, care to share some links?

      3. 2

        The cold start time is really bad and I should probably lazy load the plugins.

        Not to shill too much, but that’s one of the things I like in kakoune: even though my config is pretty beefy (20 custom plugins, including the substantial lsp one, plus all the bunded ones), the startup time is still 60ms (vs 2ms for no plugins whatsoever).

    23. 5

      Emacs primarily, but vscode at times. I got hooked on emacs a year and a half ago for org mode. I used doomemacs up until December when I finally took the time to build a config of my own. Since then I’ve used vscode less and less, but I still think it’s a nice editor.

      I used vim for many years prior to embracing emacs, but now I rarely reach for it and have stripped the config way down.

    24. 5

      emacs evil mode with evil-numbers, evil-leader, evil-commentary, smex, ido-grid-mode

    25. 5

      Emacs with my own modal editing keybindings based on ryo-modal

    26. 5

      Kakoune with not many plugins. Just an lsp-client, clipboard integration, and some small stuff. I prefer to use the shell directly for stuff like git over having a plugin in my editor.

      It has a client-server model, so you run multiple instances with a shared project state and this works very smoothly with my tiling window manager i3.

      Normal setup is that I have my monitor divided in two columns in stacked mode where the column on the left holds at least an editor window and a terminal and the other an editor window and a browser. Depending on the thing I am doing there may be more terminals/windows. Things that are not directly related to the task I am doing are on a separate workspace.

      I really like having two things side by side and nothing more. Thanks to the i3 shortcuts I can switch quickly between what is shown.

      What I like about Kakoune, next to the lack of window management, is the ease of working with multiple selections and cursors. I am far from a pro with them, but the little skill I have it already pays dividends.

    27. 4

      So 25 years of emacs and vi/vim/neovim but I’ve been writing most code recently in … Visual Studio Code.

      It just works. I have configuration fatigue. I changed the theme and font to my liking and installed the Rust and Python extensions and .. done!

      Emacs and Neovim have a special place in my heart^W toolbox .. I’m sure one day I’ll return to them. Or maybe Helix.

    28. 4

      Plain vim with very little customisation - just my personal-preference tabstop/shiftwidth, syntax on and autoindent set in ~.exrc, and language/team-specific stops/widths in per-project .vimrcs. No plugins, occasionally a syntax file if needed. I’d much prefer to customise myself to the defaults than miss my custom settings when I’m in the middle of some situation on a new box/terminal/console or whatever.

    29. 4

      I live in Emacs, but I’ve been using PyCharm a lot lately and it’s pretty good OOTB for python programming.

    30. 4

      spacemacs with copilot.el and I love it. On servers/for admin work I use vim/vi/cat though…

    31. 4

      Sublime Text mostly, as is very fast and responsive. VSCode sometimes when I can’t find a language package for Sublime.

    32. 4

      My main driver is PyCharm. I pay for the Professional edition and I think it’s fully worth it.

      I used to use Vim, I spent tens of hours customizing it, but then I realized I don’t want to deal with random breakages and trying to get plugins to play nice together. PyCharm just works ™️

    33. 3

      I have my own editor sce (similar to nano or mcedit), that I use for everything from the console, since 2008. :)

      It’s a minimalist editor (no syntax highlighting, no auto-completion, no plugins, no buffers, no shells, no themes, no nonsense), written in Python (2 or 3), self-contained in an 84 KiB executable file that just needs the Python runtime. It works everywhere, from Linux, OSX, OpenBSD, and even Android (under Termux).

    34. 3

      In my terminal environments I use three editors, depending on my connection. When working on my server over an slow or unreliable connection, I use a simple line editor I wrote in Forth. It’s a brutally simple system, but one I’ve been using for a few years now in various forms. When I have a faster connection available, or for longer edits, either vi or nano. Most of my editing is done using one of these. My nano configuration is the only one with anything customized. I have a vertical line setup to indicate a 64 column boundary, and syntax highlighting for assembly files.

      When I’m working on my iPad, I use Textastic. It feels reasonably lightweight, and if I’ll be offline for a while, I often pull a copy of my projects into it, then use the upload functionality to update the copies on my remote systems when I go back online. (Since getting an Android phone recently, I’m not using this as much; I do most of my edits in a local termux-based environment now)

    35. 3

      I wasn’t going to comment on this one, because I don’t consider my setup to be well thought out or “special.” But after reading the comments, it’s clear to me that perhaps my “boring” setup is different enough to warrant inclusion.

      I use Emacs for everything I possibly can. I envy those who do everything on their computers in Emacs, from reading email, to consuming content. But I’m not there anymore. I just look on in wonder and amazement, with an eye toward the future where I can focus on living in a live computering environment.

      But when I’m paid to deliver software, I use IntelliJ CE with the appropriate language plugins. Because I absolutely refuse to live in a world where I can’t do a rename refactor, or a method extraction, automatically. And I simply require those things as table stakes for developing software. If I can’t do basic refactorings (rename is the bare minimum), I can’t bill for software development work in good conscience.

    36. 3

      GVim. Some of my settings can be found here

      Most of my programs used to be within the 50 line range. Only markdown files (for ebooks) could be considered as heavy use. Recently, I started working on TUI apps and these are in the 200-250 lines range. Still not yet feeling that I should customize GVim any more or look into IDEs. But I do hope to start experimenting with Vim9 scripting sometime this year.

      1. 3

        You are the first person I see that uses the peachpuff color scheme, nice!

        1. 2

          Haha. I don’t like dark mode (that have black background). I have redshift installed, but light mode with white background was still causing eye strain. Peachpuff worked out better and now I’m used to it. For epub reading, I use a custom reddish background.

    37. 3

      IntelliJ. Sometimes, Sublime Text.

    38. 3

      nvi + tmux; default configuration.

    39. 3

      I’ve been on neovim for a while now. My init.lua is mostly mini.nvim plugins + a few others (like telescope) and the built-in LSP. It’s gotten to the point now where I rarely change anything because I feel super comfortable with this setup.


    40. 3

      Neovim, with modifications + plugins but not too far off of plugin defaults because I’d rather not surprise folks on remote pairing over tmate or upterm. I always run my text editor in a terminal because it’s lightweight and I need to use (Neo)Vim on other servers enough to where I’m comfortable in the terminal. My current favorite terminal emulator is Kitty. I wish I was better with tmux but lazily default to using the tiling window manager for ‘splits’. I use a fully-customized Iosevka version for my font of choice (and definitely with ligatures turned off as Unicode is always preferred with clear intent and no false positives)–though I’ve consider trialing and purchasing Berkley Mono. And for now happy enough with home-manager for NixOS for managing it all. My configs have largely been converted from Vimscript to Lua–with a longer-term goals of converting from Lua to something with types and ADTs like LunarML.

    41. 3

      Kate for most things. It works often out of the box for many languages (LSP and debugging etc.) I also contribute to it every now and then, so I’m a bit biased, heh. :)

      Jetbrains Rider for C#, since the tooling is a bit weird to setup for Linux.

      VSCodium for those rare cases I need a VSCode extension for some language. Usually for web stuff.

    42. 3

      Emacs and various jetbrains tools. I happily pay for the all products pack

    43. 3

      In general, I use the “happy path” - I’m usually working on other peoples’ systems, and I never got much value out of tweaking, so I basically stay bone stock with only minor tweaks. I also tend to use whatever’s popular for an environment. So:

      • If I’m developing for Apple stuff (Swift/Objective-C, etc.), I just use Xcode. The UI is a bit of a cipher, but it does seem to be actually improving.
      • If I’m developing for Windows (native or .NET), Visual Studio. Despite working with weird awful Unix-shaped things for years, I started with it and it’s mothers’ milk to me. Developing for Windows actually feels right - it’s the bar I judge other IDEs by.
      • For anything else/on Unix-shaped things, regardless of stack: I hate Vim, but I can’t use anything else - both out of being used to it, and because it’s often the only option I have for requirements including “developing on a remote system, no Emacs on the platform, autotools as build system”. I don’t even use the fancy stuff like CtrlP or LSPs. I’d love to try stuff like CLion, but I’m rarely in the situation, and when I am, I forget to.
      1. 1

        What do you hate about Vim?

    44. 3

      NeoVim: vimrc and stuff factored out of the vimrc

      Of particular note:

      • denite for fuzzy finding of files, text in files, open buffers, marks, etc. Shougo’s moved on to another brand new implementation, ddu, and I’ll upgrade Eventually. I tried telescope a while back but its find abilities felt weaker.
      • firenvim + browser plugin to get neovim into textareas
      • pounce is an entry in the sneak/hop/etc hinted motion genre, I’m not quite used to it yet but it’s the best I’ve tried
      • oscyank is the absolute best if you use vim in ssh and want to copy yanked text to your actual real clipboard
      • quick-scope highlights optimum targets for f/F/t/T motions
    45. 2

      I mainly use VSCode since a few years. Was using Sublime Text before.

      I’m impressed by how many people are still using Sublime here. The lack of native LSP integration became a bit of an issue for me over time. That’s clearly one of the main points that motivated me into trying VSCode.

      That’s also interesting how Kakoune and Helix are emerging and being used by more and more developers. Helix seems really promising.

      Surprised no one mentioned Lapce yet. Curious about the experience from anyone using it.

    46. 2

      Pretty basic spacemacs, on top of Xubuntu.

    47. 2

      I use (arguably) too many text editors. I don’t entirely know why.

      In regular use right now are Epsilon, CodeWright, Lemmy, JOE, and Sublime Text. I used to be and probably still am an Emacs fan (see: Epsilon, and maybe also CodeWright), though I still also use vi (but not really VIM; see: Lemmy). For lots of quick and dirty editing and copy and pasting that isn’t actually taking notes or writing code, etc., I use a simple Notepad-like editor (win32pad). Sometimes I use simple(-ish) console editors like Edit from Yori (i.e., yedit.exe). In certain cases I use IDEs or more IDE-like things. Or sometimes “weirder” editors (e.g., KEDIT, Winf). On Windows, “fallback” editors I still reach for include EditPlus and PFE; used to use both of those a lot more (especially EditPlus) than I do these days, but I still always have them around, and they still get used from time to time (more often PFE than EditPlus right now, for whatever reasons).

      Send help(?)

    48. 2

      Emacs for life because nothing else comes close. My .emacs has been evolving over 25 years now. Besides the usual coding and text stuff I also use it for email, chat, Mastodon, terminal emulation, X11 window management (EXWM). I regularly access my session from remote machines and from my phone. It’s a Lisp desktop environment that comes with an excellent text editor.

    49. 2

      Vanilla emacs with a very small .emacs to set a theme, set a handful of defaults, and set up a few language modes that don’t come by default.

    50. 2

      Doom Emacs

      My config: https://github.com/wraithm/doom.d

      I used vim for most of my life, but then switched to Emacs. I used evil-mode with a bunch of other custom configurations. After several years of just my own Emacs config, I switched to Doom and couldn’t be happier. It’s basically everything I want. It’s got just the right vim emulation with all the appropriate IDE bells and whistles to get LSP and whatever custom modes I need for everything else. I found spacemacs to be way too heavy and confusing. Doom loads pretty quickly, but I also run it in a server-client mode such that I can boot into it on a terminal or open a new graphical mode frame very quickly with all my buffers up.

    51. 2

      Xcode for C++ (and Obj-C / Swift when I use those.) With the wonderful Iosevka Slab fonts.

      VS Code for Go and TypeScript.

    52. 2

      I use sublime with a little ~project/workflow extension I wrote and a theme I occasionally pick at.

      The former is for being able to make named N-project groups that I can open/close all at once. Since these project constellations are explicitly registered, it also minimizes the out-of-sight out-of-mind anxiety that makes me tend to leave a lot of crap open in the hope that it’ll keep me from forgetting…

    53. 2

      IDEA for Kotlin and markdown, CLion for C++ and Rust.

    54. 2

      helix out of the box. Sadly not available prebuilt on raspian, neovim there. The lsp support is wonderful.

      Missing true-color in remote terminal via mosh in iTerm2 (& lxterminal), though.

    55. 2

      I’m baffled by how many people continue to use emacs/vim for editing code. I’ve tried them both (and neovim) but I have no interest in spending my days configuring or figuring out why it’s not working as expected anymore when there are so many “out of the box” things that just work. Feel free to flame me below for not being trve kvlt on programming.


      • Geany on my low-spec notebook because it’s lightweight and runs well.
      • VS Code on non-JVM projects
      • Intellij IDEA for JVM projects
      1. 1

        For my part, the ‘out of the box’ editors don’t just work. I can’t run a shell in one, or manage my passwords in another, or work with git repos in that one over there, or connect a running REPL to my window manager in yet another.

        Emacs is a Lisp operating system. It is how I use my computer. It is my computer.

    56. 2

      Just Emacs here, bunch of packages and some editing cruft collected over the last 20 years. I use org-mode, mu4e and friends when I can. I mainly write yaml these days, and some powershell for $DAYJOB.

    57. 2

      Almost default VSCode (only the font I used to change), couple keybindings change (F2 for save! Yeah I grew up on Pascal), plugins depending on the project. For quick editing I press F4 in FAR Manager since I’m always there.

    58. 2
    59. 2

      Helix with this config. Coming through Kakoune rather than vim directly, I have added all the things to Helix’s normal mode to avoid ever needing select mode.

      "{" = "goto_prev_paragraph" ; "}" = "goto_next_paragraph" is a habit all the way from the vim days though :)

    60. 1

      Neovim with some basic plugins.

      My favorite thing about my editor setup is that I usually run it inside tmux, where I typically have another pane running a program I call consume, which executes commands sent over a shared pipe using arbitrary keybindings I set up on the fly. So if I’m running unit tests, for example, I’ll hit ,t and it’ll run my unit test command in the other pane.

      I think I stole the original idea from Gary Bernhardt.

    61. 1

      It depends on the language, I’m a heavy user of JetBrains IDEs at the moment, so IntelliJ for Clojure/Java/Kotlin, GoLand for Go, CLion for Rust etc. For other languages without decent JetBrains plugins (Zig is the main one at the moment for me), I have a fairly comprehensive neovim config.

    62. 1

      I use LunarVim, almost no need to add or change anything.

    63. 1

      VSCode with these settings and extensions.

    64. 1

      I mostly used a heavily customized (Neo)vim for about a decade. I eventually came to the realization that I just don’t like modal editing. In my opinion the benefits of modal go away when you have all the modifier keys under your thumbs (I use the Kinesis Advantage 360). I still occasionally use Vim when I’m in a terminal, but my daily driver is VS Code. They’re knocking it out of the park with the monthly releases; it just keeps getting better.

    65. 1

      I paired full-time for years and thus have the default keymaps for vim, IntelliJ and VSCode all burnt into my hands. I switch between them, depending on the task at hand.

      It’s nice to be able to help my colleagues using their editor of choice. It’s even nicer to be able swap tips.

    66. 1

      Neovim with LSP and TS and

      • Telescope as a fuzzy-finder (particularly, Ctrl-F = Telescope lsp_dynamic_workspace_symbols, but it does several nifty things that I use less often)
      • navigator as a swiss-army-chainsaw navigator (go to definition, go to implementation, list references, show and jump to warnings/errors, show and apply code actions)
      • CHADTree as a file navigator
      • symbols-outline as a symbol navigator
      • Airline for the pretty status bar
      • gitsigns and neogit for Git interaction
      • nvim-dap, nvim-dap-go, nvim-dap-ui, nvim-dap-virtual-text for debugging. I don’t do a lot of in-editor debugging and I’m easing into this one, but it’s pretty cool sometimes.
      • Toggleterm to assist with doing quick CLI stuff without going to a different console tab or ^Zing the editor.
      • indent-blankline to make editing YAML suck less.

      they all play surprisingly nice together and don’t cause any noticeable slowdown.

    67. 1

      If JetBrains make an IDE for something, I’ll probably use that, or vim for simpler things. There’s a lot to be said for building expertise in your tooling, rather than switching too often - watching other people work in IDEs they’re familiar with is very satisfying.

    68. 1

      in the process of transitioning from vim to neovim. I work in gamedev so I do a lot of work on Windows and I’ve found nvim-qt to work really well, plus there’s a lot of neat plugins I want to check out, but I’ve basically just got my legacy vim setup working in neovim and haven’t really checked out any of the stuff that’s native to neovim. I mostly do Rust services and desktop stuff at the moment, with some Python tools stuff that has to run on Windows because it’s used by some gamedev colleagues that aren’t using Linux. https://github.com/jordanorelli/.dotfiles/blob/master/vimrc

    69. 1

      Late to the party, but I use vis with very few plugins; vis-go is essential for me when writing Go though. The vis defaults suit my needs. I like structural regular expressions, multiple cursors, and vi-like editing.

      (Before anyone asks: no, I don’t like kakoune).

    70. 1

      Helix, since January. I miss only one thing, remote editing like in netrw@[neo]vim or tramp@emacs

    71. 1

      Panwriter, with Pandoc installed for conversions. It’s very good for what I need – ENOTCODER – but as an Electron app it’s big and RAM-hungry.


      For shell mode config file stuff, Tilde. Finally there is a CUA standards-compliant editor for text-mode Linux. It’s been too many decades.


      I have written about both:



      When I need a GUI text editor – rarely – mostly Pluma, occasionally Leafpad, Mousepad, Geany, etc. depending what desktop I’m running. Anything which doesn’t have a menu bar and standard keystrokes is out, so no Gedit or anything here.

    72. [Comment removed by author]

    73. 1

      I normally use either PhpStorm, PyCharm, or IDEA depending on the project I am working on. Otherwise, I will opt for VSCodium for a quick writing projects and D2 diagrams, and vim for most system configuration file editing.

    74. 1

      Currently using neovim, but mostly because I haven’t been able to production-ize my wayland support for plan9port so I can get acme back.

    75. 1

      I’ve used Vim since I started programming in around 2005, but I switched to Neovim (for good) about three years ago. I don’t use LSP (I find it a bit hyper-active) or autocompletion plugins, but I much prefer Lua to Vimscript. The biggest adjustment was moving from Ultisnips to nvim-snippy. You can absolutely use Ultisnips with Neovim, but it depends on Python, and I didn’t want that dependency anymore. nvim-snippy is on the lighter side for a snippet plugin, but I’ve come to like that. It does 90% of what I want, and I can understand it. (By comparison, LuaSnip, which does a ton more than nvim-snippy, but I found it difficult to work with. In fairness, LuaSnip was changing very rapidly when I tried it, so I should probably try it again sometime.)

      Obligatory dotfiles:

    76. 1

      Kakoune with kak-lsp and minimal plugins for clipboard and such.

    77. 1

      i use nano, vscode (mostly via code-server and github.dev), sometimes notepad(++), and sometimes various codemirror-powered online editor things. i don’t have any config changes really except for nano where i edited the js syntax highlighting definition to work on mjs and ts files.

    78. 1

      Most of the time I use Sublime Text, with near-default settings. I use the ayu light color scheme/UI theme, and I’ve got a couple language plugins installed, but nothing major. Well worth the price, especially as a bundle with Sublime Merge, which is probably the best Git GUI I’ve ever used.

      When I’m working directly on a remote machine over SSH, I’m not picky, I just use whatever is available. Most of the time that’s either vi or nano, though sometimes if it’s a machine I’m often remotely accessing I’ll install mg and use that.

    79. 1

      Neovim with a bunch of plugins.


      I make heavy use of Telescope, NvimTree (with vim-rooter), and WhichKey. Most of the time I rely on tmux for a quasi tab system for moves that are more context switching heavy (although I use vim buffers and marks primarily for in-context switching). I also preref a “real” terminal over some of the built-in emulation options which tmux makes effortless.

    80. 1

      VsCode. I work mainly with Elixir. The LSP is still rough around the edges, but it mostly works alright. I used to love VIM, but I am too lazy to configure it again.

    81. 1

      I use dte. Before that I was using Vim for 10+ years. Can’t see myself going back. Yes, it’s minimal, but it’s also very powerful. I almost exclusively run dte in tmux and integrate tools such ctags, tig, fzf and many others with it.