Neovim with a LOT of addons.

https://github.com/9p4/dotfiles/tree/main/dot_config/nvim

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…

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

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

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

[editor]
true-color = true
color-modes = true
idle-timeout = 75

[editor.indent-guides]
render = true

[editor.cursor-shape]
insert = "bar"
normal = "block"
select = "underline"

[keys.normal]
g = { a = "code_action" }
0 = "goto_line_start"
"$" = "goto_line_end"
S = "surround_add"

[keys.select]
0 = "goto_line_start"
"$" = "goto_line_end"

[keys.insert]
j = { k = "normal_mode" }

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!

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/

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

Neovim with a (relatively) modest amount of plugins.

https://github.com/bronzehedwick/dotfiles

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.

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:

https://chaos.social/@citizen428/109703887983215601

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

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.

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.

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.

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
end

function RunLocal()
  vim.cmd(vim.b.local_cmd)
end

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

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.

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

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

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.

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.

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.

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

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

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

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 ™️

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

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)

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.

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.

IntelliJ. Sometimes, Sublime Text.

nvi + tmux; default configuration.

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.

https://github.com/Jackevansevo/Dotfiles/blob/master/nvim/init.lua

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.

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.

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

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.

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

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.

Pretty basic spacemacs, on top of Xubuntu.

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(?)

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.

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.

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.

neovim https://git.sr.ht/~npmaile/configs/tree/master/item/neovim/.config/nvim

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

VS Code for Go and TypeScript.

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…

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

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.

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.

Anywho:

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

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.

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.

I use vim https://github.com/fs111/dotvim

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 :)

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.

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.

VSCode with these settings and extensions.

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.

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.

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.

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.

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

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

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.

https://panwriter.com/

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.

https://github.com/gphalkes/tilde

I have written about both:

https://www.theregister.com/2022/08/24/panwriter/

https://www.theregister.com/2021/12/17/tilde_text_editor/

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.

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.

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.

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:

• https://github.com/telemachus/dotfiles/tree/main/config/nvim (configuration for neovim itself)
• https://github.com/telemachus/nvim-dotfiles (personal utilities plugin still in Vimscript)

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

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.

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.

Neovim with a bunch of plugins.

https://github.com/kbknapp/dotfiles/tree/master/nvim

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.

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.

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.

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

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