My neovim and tmux workflow : writing code fun again

August 15th 25

TL;DR: If you're feeling too lazy to read this post, get yourself Digestmark and summarize it 😉.

It's been a year or so since I started using neovim as my primary code editor and IDE and it's been an incredible adventure. I naturally got attracted to doing more and more things on the terminal and that lead me to using tmux too. Today, I'm using those two main components plus some other tools that makes writing code fun again. I want to share that with you, starting with what is neovim and tmux and why in the world would you want to use the terminal when you have incredible GUI apps like VScode and the Jetbrains toolset.

A brief history of editors and the terminal

Computing started in a fundamentally different world than the one we know today. In the early days of computing, from the 1960s through the 1980s, there were no graphical interfaces, no mouse cursors dancing across colorful screens, and certainly no drag-and-drop functionality. Everything happened through text-based terminals, green or amber characters glowing on black screens, where every interaction required typing commands. This wasn't a limitation; it was simply how computers worked.

Apple II ProDOS Command-line interface. The catalog command shown lists the files on the current disk.

The transition to graphical user interfaces began in earnest during the 1980s, with systems like the Xerox Star (1981) and later the Apple Lisa (1983) and Macintosh (1984) introducing the mouse and windows paradigm to mainstream computing. Suddenly, computing became visual and intuitive. You could point, click, and manipulate objects on screen. This GUI revolution transformed how we interacted with computers and opened up computing to millions of non-technical users.

Apple Lisa 2 screenshot. One of the first computers using a mouse, with a graphical user interface . Photo Courtesy of David T. Craig.

But here's the thing : the terminal never really went away. While desktop users embraced GUIs, servers, supercomputers, and embedded systems remained firmly rooted in terminal-based interfaces. Why? Because when you're managing a server remotely, when you need to automate tasks across hundreds of machines, or when you're working in resource-constrained environments, the terminal is simply more efficient, scriptable, and reliable than graphical interfaces. Every cloud server, every Docker container, every Linux system running the modern web, they're all fundamentally terminal-based at their core. It was in this terminal-centric world that vi (pronounced "vee-eye") was born in 1976, created by Bill Joy at UC Berkeley. Vi was designed to work over slow network connections and on hardware with severe limitations. It had to be fast, efficient, and work reliably even when you couldn't predict how responsive your connection would be. Vi introduced the concept of modal editing, switching between different modes for inserting text versus navigating and editing, which seemed strange to newcomers but proved incredibly powerful for experienced users. As Unix systems evolved, so did vi. In 1991, Bram Moolenaar created Vim (Vi IMproved), which extended vi with features like syntax highlighting, multiple windows, extensibility through plugins, and compatibility across different operating systems. Vim became the de facto standard for terminal-based editing, beloved by system administrators, programmers, and anyone who spent serious time in the command line. However, by the 2010s, Vim was showing its age. Its codebase had grown organically over decades, making it difficult to add modern features like asynchronous plugins, better Unicode support, or built-in terminal emulation. The architecture that made Vim stable also made it resistant to the kind of fundamental improvements that modern development demanded. Enter Neovim in 2014, a complete refactoring and modernization of Vim that maintained backward compatibility while enabling a new generation of possibilities. Neovim introduced asynchronous plugin architecture (meaning plugins could run in the background without freezing the editor), a built-in terminal emulator, better scripting support through the Lua programming language, and a focus on extensibility that has spawned an entire ecosystem of modern development tools. It kept everything developers loved about Vim while removing the technical debt that held back innovation, creating a foundation for what many consider the future of terminal-based editing.

Why would you use this kind of workflow

There are many reason to use neovim. Personally, I discovered it out of curiosity and started using it to see something else, different from the typical VSCode editor I had for years. If I started with curiosity, it's not what kept me going. I have to say that getting comfortable at using neovim motions, and configuring, customizing the editor has a little bit of learning curve but specifically, this is why I continued using it :

• It's fun : I had a lot of fun learning vim motions, learning the Lua programming language and testing the different neovim distros. The community is also very warm and funny
• It's fast and productive : compared to other big IDEs like the Jetbrains suite, neovim is quite lightweight and runs quickly. I just need to open the project I'm working on and I get instantly productive, without waiting for the IDE to load. Plus, once you get comfortable using neovim motions, you can write and edit code much faster, therefore, making you potentially more productive.
• My entire config, version controlled : I can rollback if needed at any time and share my entire configuration with others. It's also easier for me everytime I need to setup a new computer.
• I got attracted to low-level stuffs : I didn't expect it but spending a lot of time on neovim and the terminal made me more interested about LSPs (language server protocol, aka what makes jumping through files, going to definition, adding imports etc, work in the editor, neovim and VSCode too), synthax highlighting with tree-sitter, terminal graphics, and eventually digging into the ghostty terminal's codebase and learning a little big about Zig
• It's not too much boring : I really like having a boring setup, so I can focus on writing code, rather than tweaking the toolset itself but after years of using the same tools over and over again, it's just too much boring. That boredom sometimes happens even at the language level, and that's why I'm so hyped about go recently. Neovim is like in the sweet spot of the spectrum. You can spend a lot of time tweaking it in the beginning but once you have something stable, you just use it comfortably and update the configuration every once in a while when needed. You can also restart your setup from scratch at any time. 🗿
• It's very customizable : if you think VSCode is very customizable, wait until you test neovim. Possibilities are limitless. Tweak everything you want : theme, shortcuts (commonly called keymaps. e.g, in my config, typing space followed by e, opens the file explorer), layout, display, etc. Neovim has also an incredibly big plugin ecosystem. Let me give an example, if you need a file explorer, you can choose from a large variety of plugins : neo-tree, oil.nvim, nvim-tree etc... with every of those plugins, it's own configuration options. It's just like every neovim user has its own version of the editor, tweaked based on its personnality.

And many more.

There is a lot we can say about neovim and why it's so trendy recently but I think it all boils down to the concept of PDE (Personalized Development Environment). There's a nice video from TJ Devries talking about it.

My workflow and how I get there

My entire neovim, tmux and other tools configuration is openly available at this repository. It's called a dotfiles repository and commonly includes a person's portable configuration. It's not necessarily related to neovim.

I started learning neovim and neovim motions (the different editing shortcuts and modes) with the Tutor, it's just a simple course file that you get from neovim by typing the :Tutor command. It has some exercices to practice and I even get back to read it every once in a while. After that, I started using neovim as a simple text editor, navigating a file, and updating it's content, without any language support. I then installed some neovim distributions (think of distributions as base and opionated configurations to help get started easily without configuring everything from scratch) like Lunarvim , NvChad and Lazyvim. I spend some months using those distros at work as a VSCode replacement, updating and extending the base configuration, adding my own plugins, and updating keymaps etc. After getting comfortable using and configuring neovim, I decided to go from Lunarvim to my own custom configuration, based on kickstart.nvim and it's what I'm still using today, to write this post. kickstart.nvim is a minimal, Neovim configuration designed to serve as a starting point for users to build their own custom Neovim setup. It was created by TJ DeVries, a core Neovim maintainer.

Here is my day to day workflow and the different set of tools I use :

• Neovim : my editor and IDE, with synthax highlight and language supports configured

  • LSPs : I'm using neovim/nvim-lspconfig and mason to install and configure language server protocols. Most of the time, configuring a new language server is as easy as adding an entry to a lua table

  vim.list_extend(ensure_installed, {
  	'stylua', -- Used to format Lua code
  	'delve',
  	'emmet-language-server',
  	'goimports',
  	-- 'golangci-lint',
  	-- 'golangci-lint-langserver',
  	-- 'golines',
  	'gopls',
  	'lua-language-server',
  	'prettier',
  	'prettierd',
  	'stylua',
  	'tailwindcss-language-server',
  	'typescript-language-server',
  	'dockerfile-language-server',
  	'docker-compose-language-service',
  })

  • Common plugins : I try to keep neovim very lightweight, and avoid installing anything not necessary, to keep things simple and fast but here is a list of my favorite plugins :
    • bufferline : editor tabs for opened files, I also like using snipe
    • neo-tree : file explorer, I like opening it in floating mode with <leader> e
    • 'sindrets/diffview.nvim' : very useful when working with pull requests and code reviews
    • 'kevinhwang91/nvim-ufo' : uses lsp to enable code folding
    • 'kdheepak/lazygit.nvim' and 'rbong/vim-flog' : powerful tool to work with git, stage files, merge branches and navigate the git history
  • Running tests : 'nvim-neotest/neotest'
  

  Running tests in neovim with neotest feels so good that it's even going to make you write tests 😅.

  • Debugging with nvim-dap and 'rcarriga/nvim-dap-ui' : it's the most common configuration for debugging but when working with complex applications, I find the nvim-dap-ui hard to navigate and often resort to VSCode. After digging a little bit in Reddit, I found different other options that I want to test in the future.

• Tmux and staying organized while navigating through different projects : Tmux is where the magic of terminal-based development really shines for project management. Instead of juggling multiple terminal windows or tabs scattered across your desktop, tmux creates organized "sessions" that act like virtual workspaces. Each project gets its own session with multiple panes and windows. Imagine having your code editor in one pane, a development server running in another, and maybe a database console or log viewer in a third, all perfectly arranged within a single session. The beauty is in the seamless navigation: switching between projects becomes as simple as pressing a key combination to jump from your frontend session to your backend session to your personal scripts session. You can detach from a session (leaving everything running in the background) and reattach later from anywhere, even from a different computer via SSH. This creates a persistent, organized development environment where context switching becomes effortless and your mental model of "where things are" remains consistent across days, weeks, and even system restarts.

An example of a tmux session with three windows : the frontend and backend opened in neovim and a third window with three panes : two of them for the frontend and backend servers and a third one, to explore the database.

At the time of writing this post, I have about seven sessions opened that I can navigate through with a lot of ease, instantly, enabling me to jump where I need quickly while staying focused on the project I'm currently working on, as each of these sessions and its windows are isolated.

A list of separate tmux sessions for working on different projects, taking notes, learning and experimenting new things.

• Session resurrect with 'rmagatti/auto-session' and tmux-resurrect : These tools automatically restore your entire workspace when you restart. When you open tmux, it brings back all your previous sessions and pane layouts exactly as you left them. Similarly, Neovim restores all your open buffers, so you can pick up right where you stopped working.

  set -g @plugin 'tmux-plugins/tmux-resurrect'
  set -g @plugin 'tmux-plugins/tmux-continuum'

• Ghostty terminal : when you spend a lot of time on the terminal, you really want to pick one that you like. I used to be a big Kitty fan and used Warp alot but since ghostty became publicly available, it's my favorite one. It's a Mitchell Hashimoto's personal project. Ghostty is a fast, feature-rich and personalizable terminal. You can find my ghostty config in my dotfiles repo.

How to get started

There is a lot of places where you can get started with neovim. I think the most straightforward way is to install neovim and a terminal, learn the basic motions and how it works in general, using the Tutor. You can then install a neovim distro to get started easily and start tweaking your editor. If you're using kickstart.nvim, which can be a good starting point as distros base configs can be overwhelming when starting out, you can check my dotfiles for inspiration.

I also recently saw a getting started with neovim course by Lee Robinson, from Vercel, available at vimforreactdevs.com, which can be interesting to check.

If you want to learn more about this workflow, you can also let me know by sending an email or message through one of my social links, and I'll be happy to make a full YouTube video.

What about AI ?

Yes I know, it's a hot topic. But even if I have vibe-coded some projects, I'm among the people that still prefer to write code by hand. I may talk about why in a future post but basically, I had Github Copilot plugin installed in the past, which I ended up disabling. I also tried avante.nvim which provides similar features that tools like Cursor has. If I need some AI assistance, I often prefer to completely switch to Cursor / Claude Code or jut use Claude to explore questions.

Feel free to use whatever you want

The community can be a little bit toxic. We like to joke saying that neovim is a superior code editor and only used by true engineers but that's just a flex. Using VSCode or any GUI can be as productive and enjoyable as using neovim. It's all about personal preferences. The right tool for you is the one that helps you get the work done in a productive and enjoyable way.

But if you give neovim a chance, it can lead you to nice places. So take the leap. Build your PDE.

Thanks for reading.

— Moustapha