Recently I stopped using tmux to try zellij, however I noticed when I removed tmux from my nix config. I was getting the following error, when rebuilding my home-manager config:

The user systemd session is degraded:
  UNIT         LOAD   ACTIVE SUB    DESCRIPTION
● tmux.service loaded failed failed tmux default session (detached)

Legend: LOAD   → Reflects whether the unit definition was properly loaded.
        ACTIVE → The high-level unit activation state, i.e. generalization of SUB.
        SUB    → The low-level unit activation state, values depend on unit type.

I was wondering where this error was coming from, turns it the symlink to tmux.service has not been deleted that nix would create.

ls -al ~/.config/systemd/user/tmux.service
Permissions Size User        Group       Date Modified Name
.rw-rw-r--   453 haseebmajid haseebmajid 22 Aug  2023   /home/haseebmajid/.config/systemd/user/tmux.service

If we look at other systemd services we can see them symlinked to a nix package in the nix store.

ls -al ~/.config/systemd/user
lrwxrwxrwx     - haseebmajid haseebmajid 20 Feb 17:04   spotifyd.service -> /nix/store/7v52bpcyi0zqv012rrmd7s2r742hb2cy-home-manager-files/.config/systemd/user/spotifyd.service
lrwxrwxrwx     - haseebmajid haseebmajid 20 Feb 17:04   swayidle.service -> /nix/store/7v52bpcyi0zqv012rrmd7s2r742hb2cy-home-manager-files/.config/systemd/user/swayidle.service

So we can simply remove the tmux file, rm ~/.config/systemd/user/tmux.service. I should look into why this symlink is not removed.

The following sections will break down what I learnt, why I found it useful. The sections are ordered roughly in the order I learnt the tool/thing throughout the year.

Neovim

The first big change I made was in April. I moved away from using VS Code to Neovim, mostly to flex on other developers (joking of course). I had a colleague who started to have a look at Neovim, and I was intrigued at the things you can now do in Neovim. It looked like it had all the main features I was using in VS Code.

I originally started using Astronvim, but when I started adding my own plugins I found I broke it effortlessly, probably a layer 8 issue. I then moved over to Folke’s LazyVim, which had much better defaults and plugins for what I wanted.

Furthermore, I also took this as an opportunity to learn more vim binding and to become more efficient in vim. As I had got a bit complacent with my current knowledge of vim bindings and shortcuts to move around and edit code.

Eventually, I ended up creating my own configuration, which most people recommend trying to do. I ended up using NixVim to do this (more on NixOS later). But it was very useful to be able to see what Neovim could do, before I started on my own config.

Since VS Code and my Neovim config both use the same LSP behind the scenes gopls, for Golang development I wasn’t really missing out on any features that VS Code offered over Neovim. Except perhaps remote sharing.

So why use Neovim:

• As most things with me and using Linux, I like to be able to customise and personalise things for myself
• Requires fewer resources to run compared with my old editor
• Runs in the terminal so can use it with tmux
• Forced me to learn my tools a lot better

By staying in the terminal, it allowed me to use tmux with Neovim, and manage my different projects much easier. It also made it a lot more efficient to jump between different projects. Which is very useful when working with microservices.

If you want to use Neovim, I recommend doing the following:

• learn vim bindings, use a plugin in your current editor
• use a distribution like LazyVim
• write your own config
• alongside this, look at other peoples’ workflow and see what you like, i.e. using tmux.

Some of my favourite plugins:

• telescope of course
• dap for debugging
• neotest for testing
• oil, for managing folders and files
• codeium for AI completions

Tmux

One of the main reasons I ended up moving to Neovim was that I was able to stay in the terminal more. I found a really good workflow with Tmux. Where each folder/repository, would be a separate session in tmux. I would then use a the t smart session manager, with the tmux resurrect and continuum plugins to help manage my sessions I have.

Tmux is a multiplexer, with a client server architecture, which means I can kill the terminal and the session still is alive on the server. It also means I could open terminal windows effortlessly. Creating splits with ease. It also stopped me from having a hundred VS Code instances open and trying to work out which one is the one I need.

For me, whilst Neovim was really cool to learn, combining it with tmux was a real game changer for my workflow. It just made me feel so much more efficient, jumping between sessions, without needing a mouse being able to be more keyboard driven.

Touch Typing

To become a more efficient developer, I also started to learn how to touch type properly, using all 5 of my fingers vs previously relying mostly on two fingers. Even though I could type at a decent speed of 80 WPM, I would make plenty of mistakes. Eventually, it would be much better for my wrists and fingers to touch type properly. Using several tools such as typing club and monkey type. I was able to get back to my normal typing speed in a few months, which fewer mistakes.

Especially as I was now trying to use my vim bindings, and expanding my knowledge of vim shortcuts, I didn’t want to have to think where certain letters were or go and redo a shortcut because I made a mistake.

If you don’t know how to touch type, I would recommend spending the effort, Especially if you look down when you type it’s better for you ergonomically and will be better for you eventually, I think.

NixOS

One of the other significant changes was in May I moved from Arch (I used arch btw), to shock surprise NixOS. I divided straight into it. Which probably wasn’t the cleverest thing I’ve ever done. As there was a steep learning curve. I’ve written some previous articles which go more into detail about NixOS and how I set it up.

The best thing about Nix was I can use declaratively set up my config, which makes it easier to keep multiple machines in sync. I also think alongside home-manager it makes managing my user, such as installing software and config for the apps. So even when I use another OS, I can still use nix and share config between multiple machines.

At times, it does feel like I am fighting the OS, especially when the package I need is not in nixpkgs, but overall, I am happy to be able to keep all my config in code. Sync multiple devices. Also being able to revert to older generations, making it harder to break my system.

I think where nix is powerful is its development environments you can create using nix flakes. Which solves a lot of issues I had with dev containers. Making sure people have the same versions of the tools they require for a project.

So why use NixOS:

• declarative: put your config in code
• rollbacks: easy to rollback changes
• multiple versions of the same tool, installed

If you want to use NixOS, I recommend doing the following:

• Try nix package manager on your current setup
• Try NixOS in a VM
• Move to NixOS, installing via an ISO
• Look at nix flakes, for even more reproducibility

You can read more about my basic setup here

Hyprland

Alongside moving to NixOS, soon after I moved away from Gnome to Hyprland I wanted to have another go at a tiling window manager. I kept seeing people using Hyprland, I tried a tiling manager QTile but found it a pain to set everything up myself, that of a normal desktop environment.

Hyprland is nice because Wayland support, you might be thinking, why not use sway. I ended up using Hyprland because the desktop sharing support was better with its own desktop portals fork. Allowing me to share a specific window rather than my entire screen. This made it more practical to use at work. It also has a few nice features that people like when ricing, like rounded corners, gaps and also some slick animations.

Other than that, a tiling manager allows you to customise your setup to almost exactly whatever you want, as you have to set up things like a notification daemon, app launcher and a status bar if you want one. It also allows us to be more keyboard focused.

I think Hyprland has helped me use the keyboard more, relying on the mouse less. Allowing to be organised more keeping different apps in different workspaces. Such as one for my main, another for the browser and for my to-dos etc.

You can read more about my Hyprland setup here

Split Keyboard

Another one I copied from a colleague at work, he used a split keyboard so very late into the year, around December I decided to take the plunge and buy a ZSA Voyager. Split keyboards, also sometimes called ergonomic keyboards, have several benefits, here is a link to the video that finally convinced me.

The main advantages are because its split it opens up your chest, the keys are column staggered and so your fingers just need to go up and down rather to the side. They are not cheap, however, and are quite an investment. So this It would be something I upgrade after having most of the rest of your setup, such as a mouse, monitors etc. As a stop gap mechanical keyboards are plenty affordable these days. You can get some fantastic ones cheapish, especially if you can get it during a sale.

Desktop vs Laptop

I bought a framework laptop, with an eGPU and then removed my desktop, and have had two stints trying to just live using my laptop. Which is cool as it’s more portable and when it’s on my desk I can make more of a workstation. Close the lid and connect it to all my peripherals, giving me a desktop like experience. Two monitors, keyboard, mouse, webcam and mic etc.

Especially with the AMD motherboard, I am even able to play some games with minimal lag on 4k monitors without an eGPU, such as gw2 and master duel (I know not very extensive games but still very cool).

I tried it earlier in the year and gave up on it and moved back to my desktop as it made gaming easier. But I am going to give it another crack, especially with an AMD board, making Guild Wars 2 playable.

I have been tmux with the foot terminal and when trying to share my screen I couldn’t work out which terminal to share based on the name. Since they are running tmux, all the terminals were titled terminal - t.

To fix this and name it after what is running (and where) in tmux, i.e. foot blog/nvim. We can do this by adding the following to our tmux config:

set-option -g set-titles on
set-option -g set-titles-string "#S / #W"

Here, the #S is the session name and #W the window name; hence, we get something like the above. Though you could use lots of other different formats ¹.

This is enough for me to figure out which window to share.

When I moved to NixOS I noticed that tmux-resurrect stop restoring some applications such as man and nvim. Like it used to on my Arch machine. I recently found a solution to my problem (thanks to a lovely chap on the nixos discourse).

By adding the following lines to our tmux config:

resurrect_dir="$HOME/.tmux/resurrect"
set -g @resurrect-dir $resurrect_dir
set -g @resurrect-hook-post-save-all 'target=$(readlink -f $resurrect_dir/last); sed "s| --cmd .*-vim-pack-dir||g; s|/etc/profiles/per-user/$USER/bin/||g; s|/home/$USER/.nix-profile/bin/||g" $target | sponge $target'

What this does is it edits the tmux-resurrect file from this:

# bat ~/.tmux/resurrect/last --plain

pane    dotfiles    0   1   :*  0   nvim ~/dotfiles :/home/haseeb/dotfiles  1   nvim    :/home/haseeb/.nix-profile/bin/nvim --cmd lua vim.g.loaded_node_provider=0;vim.g.loaded_perl_provider=0;vim.g.loaded_python_provider=0;vim.g.python3_host_prog='/nix/store/4n4d0f1xd14gl4pfymdcqb9pmagcyyfj-neovim-0.9.1/bin/nvim-python3';vim.g.ruby_host_prog='/nix/store/4n4d0f1xd14gl4pfymdcqb9pmagcyyfj-neovim-0.9.1/bin/nvim-ruby'

to this:

# bat ~/.tmux/resurrect/last --plain

pane    dotfiles    0   1   :*  0   nvim ~/dotfiles :/home/haseeb/dotfiles  1   nvim    :nvim

NOTE: we are just left with :nvim as the binary to run (from tmux-resurrect perspective). Then to restore my neovim session we could use a plugin which creates a Session.vim file in the local directory of that project, that tmux-resurrect can use to restore the actual neovim session rather than just running neovim.

However I don’t want to manage session files like that. So I use auto-session which checks if a session exists in a specific directory and if it does it automatically restores the last saved session when neovim opens.

Appendix

• Discourse Thread
• My tmux config

In this post I will show you how you can setup tmux (plugins) using the nix package manager, specifically using home-manager. I will also show you how you can avoid an issue I encountered where tmux resurrect wasn’t working properly due to plugin ordering.

Typically we use the tmux plugin manager to manage our tmux plugins. However, when I moved to NixOS, I wanted to move away from having lots of different ways of managing what is on my system. For example, on my Arch Linux machine I had:

• Pacman/Yay
• lazyvim
• tpm

However, it wasn’t obvious how to do this. In my case, I decided to use home-manager which is a tool we can use with Nix to manage user config including dotfiles. For tmux specifically, there is a module we can leverage. So assuming you already have home manager and Nix setup. We can create a new module, say called tmux.nix

tmux.nix

{ pkgs, ... }:
let
  tmux-super-fingers = pkgs.tmuxPlugins.mkTmuxPlugin
    {
      pluginName = "tmux-super-fingers";
      version = "unstable-2023-01-06";
      src = pkgs.fetchFromGitHub {
        owner = "artemave";
        repo = "tmux_super_fingers";
        rev = "2c12044984124e74e21a5a87d00f844083e4bdf7";
        sha256 = "sha256-cPZCV8xk9QpU49/7H8iGhQYK6JwWjviL29eWabuqruc=";
      };
    };
in
{
  programs.tmux = {
    enable = true;
    shell = "${pkgs.fish}/bin/fish";
    terminal = "tmux-256color";
    historyLimit = 100000;
    plugins = with pkgs;
      [
        {
          plugin = tmux-super-fingers;
          extraConfig = "set -g @super-fingers-key f";
        }
        tmuxPlugins.better-mouse-mode
      ];
    extraConfig = ''
    '';
  };
}

In the file above there are a few key things I’d like to discuss programs.tmux.enable = true, this automatically installs tmux for us. We also set some other config options such as the shell to use and the history limit. Nix will automatically add these to our tmux config file for us, which helps manage the config a bit easier in my opinion.

Next install tmux plugins available as a nix package we can simply do:

 plugins = with pkgs;
      [
        tmuxPlugins.better-mouse-mode
      ];

If however the plugin is not available, we can still install it like we did for tmux super fingers.

tmux-super-fingers = pkgs.tmuxPlugins.mkTmuxPlugin
{
    pluginName = "tmux-super-fingers";
    version = "unstable-2023-01-06";
    src = pkgs.fetchFromGitHub {
        owner = "artemave";
        repo = "tmux_super_fingers";
        rev = "2c12044984124e74e21a5a87d00f844083e4bdf7";
        sha256 = "sha256-cPZCV8xk9QpU49/7H8iGhQYK6JwWjviL29eWabuqruc=";
    };
};

We tell home-manager where to get the plugin from on Git Hub, which plugin we’d like to install, and a specific revision (can be a tag or a commit sha). There is also a sha256, which can be found when you run the home-manager switch command and leave the sha256 field empty. It will initially fail with the expected sha value which you can then copy over to the file.

This sha is used to check if this derivation is already built by Nix and available to the machine, so we can skip building it again. You can read more about it here.

Then we add it to our list of plugins we want to be installed. We can also specify extra config related to that plugin, using the extraConfig field. which I think helps organise our config a bit more, like so:

{
    plugin = tmux-super-fingers;
    extraConfig = "set -g @super-fingers-key f";
}

continuum & resurrect issues

I had some issues getting tmux resurrect and continuum to work on my new machine. It turned out it was due to the ordering of my plugins. Any plugin that edits the right status bar, like the catppuccin theme plugin needs to go before these two. Now my tmux sessions automatically save and reload themselves. So when I shut down my PC I can carry on from where I left.

Like so:

# must be before continuum edits right status bar
{
    plugin = tmuxPlugins.catppuccin;
    extraConfig = '' 
    set -g @catppuccin_flavour 'frappe'
    set -g @catppuccin_window_tabs_enabled on
    set -g @catppuccin_date_time "%H:%M"
    '';
}
{
    plugin = tmuxPlugins.resurrect;
    extraConfig = ''
    set -g @resurrect-strategy-vim 'session'
    set -g @resurrect-strategy-nvim 'session'
    set -g @resurrect-capture-pane-contents 'on'
    '';
}
{
    plugin = tmuxPlugins.continuum;
    extraConfig = ''
    set -g @continuum-restore 'on'
    set -g @continuum-boot 'on'
    set -g @continuum-save-interval '10'
    '';
}

I haven’t worked out how to restore my nvim session, however. The resurrect plugin needs a session.vim file to do that. For now, this is good enough, as I have a session manager with nvim itself so it is simply a button press to restore it.

If you are using home-manager make sure to import this module into your main home manager nix file such as home.nix. Then you should be able to run home-manager switch to install the tmux, and its plugins and build the config at ~/.config/tmux/tmux.conf.

My tmux file

In this blog post, I will go over my current development workflow using the above tools namely, fish shell tmux and neovim. I’ll be using the dotfiles found here.

I aim to move away from using my mouse as much as possible as it just slows me down when my hands are away from my keyboard.

Alacritty

Link to config

This section should be pretty quick, alacritty is the terminal I use on both Linux and MacOS. I use it because it will run on Linux and MacOS so I can have a similar terminal between all of my devices where I do any development. It is also GPU rendered so it should have better performance as compared with the default terminals available on your OS.

It was born out of frustration with using vim inside tmux being slow. I haven’t noticed any issues with speed or lag when using alacritty that’s the terminal I’ll stick with.

Some people like to use kitty, but I’ve had no reason to swap yet. One thing you cannot do in alacritty is open tabs, you can open multiple terminals or use tmux.

config

My Alacritty config doesn’t have much of interest, except this snippet which allows me to copy to my clipboard my selected text in the terminal and also right-click paste.

selection:
  save_to_clipboard: true
mouse_bindings:
  - { mouse: Right, action: Paste }

However, as I’m trying to use my mouse less this config is a lot less relevant

MacOS

Since I want similar keymaps between Linux and MacOS I’ve swapped the ctrl and super keys on my Mac. So it matches my Linux machine and I don’t have to memorise/get confused between two different key bindings.

key_bindings:
  - { key: C, mods: Command, chars: "\x03" }
  - { key: D, mods: Command, chars: "\x05" }
  - { key: R, mods: Command, chars: "\x13" }
  - { key: W, mods: Command, chars: "\x17" }
  - { key: A, mods: Command, chars: "\x01" }
  - { key: H, mods: Command, chars: "\x08" }
  - { key: J, mods: Command, chars: "\x0A" }
  - { key: K, mods: Command, chars: "\x0B" }
  - { key: L, mods: Command, chars: "\x0C" }
  - { key: Back, mods: Super, chars: "\x15" }
  - { key: Left, mods: Super, chars: "\eb" }
  - { key: Right, mods: Super, chars: "\ef" }
  - { key: Left, mods: Command, chars: "\eOH", mode: AppCursor }
  - { key: Right, mods: Command, chars: "\eOF", mode: AppCursor }
  - { key: J, mods: Alt, chars: "\ej" }
  - { key: K, mods: Alt, chars: "\ek" }
  - { key: H, mods: Alt, chars: "\eh" }
  - { key: L, mods: Alt, chars: "\el" }
  - { key: N, mods: Alt, chars: "\en" }
  - { key: Minus, mods: Alt, chars: "\e-" }
  - { key: Equals, mods: Alt, chars: "\e=" }

So here ctrl + c (remember my super and ctrl keys are swapped) will map to super + c in the terminal to kill a process.

fish

Link to config

I use fish shell as my default shell. You can replicate a lot of the features I am about to discuss in zsh as well, using extensions. However, I found it slowed down zsh a lot and it wasn’t as responsive as fish.

You should know that fish shell is not POSIX compliant, which means you cannot always run bash commands in fish the syntax sometimes will vary.

Some features I like in fish include:

Suggested commands as you type it will try to guess which command to run. The last one in your history that best matches.

Auto Suggestions

I’m also a big fan of using abbreviations ¹ which are similar to aliases except when you the “alias” it gets converted to the actual command you want to run. Say we have:

__git.create_abbr gco git checkout

When we type gco the shell will expand into git checkout. This has a few advantages now in your shell history we have git checkout not gco making it easier to search through. Also, we know which command we will type.

Fish also provides some syntax highlighting for our commands which makes them nicer to look at because colours are great!

Plugins

Some fish plugins I use include:

PatrickF1/fzf integrates fzf (powerful fuzzy finder) nicely with fish. My main use case is improving reverse search seen below.

But it can allow you to do lots of other things such as searching for files ctrl + alt + f.

edc/bass allows us to run bash utilities in fish shell.

Starship

As my shell prompt, I use starship prompt a super customisable font with great defaults.

But overall I could probably easily swap to zsh but I find fish to be more responsive and feel snappier. It has some nice features which make our lives a bit easier.

tmux

Link to config

I mentioned tmux above. What is tmux? Well, it is in the name itself. It’s a terminal multiplexer, what does that mean? Well, it means we can open multiple panes (think of each as its separate terminal).

One nice feature of tmux is that say your terminal crashes and the tmux session will still be alive. We can simply reattach to it later.

Tmux Panes

In the image above we have 3 panes.

Session vs Window vs Pane

tmux has this concept of sessions, windows and panes

²

• a session can have multiples windows (think of a window as tabs in a terminal)
• a window can have multiple panes
• a pane is where we run our commands

Typically I create a new session for each project I am working on. For example, at the moment I have the following sessions:

# tmux ls
blog: 2 windows (created Sun Apr 30 22:37:51 2023) (attached)
bookmarkey: 2 windows (created Sun Apr 30 20:15:51 2023)
dotfiles: 1 windows (created Sun Apr 30 20:15:51 2023)
talks: 1 windows (created Sun Apr 30 20:15:51 2023)

Where bookmarkey, for example, has two windows one for the gui and one for the api, as it is a full-stack application.

Smart Session Manager

To help manage my sessions I use tmux smart session manager. This amazing plugin allows us to create a new session in a specific folder.

Outside of tmux, I can use t to open this menu below:

Where you can see the existing sessions at the bottom see blog, dotfiles etc. If I navigate to a folder where a session already exists it will automatically attach to that session. Else it will create a session in that folder.

Note that plugin uses zoxide which you can think of it as a smarter cd. It keeps track of which folders we visit the most. For example, I have a folder at ~/projects/bookmarkey/gui since I visit it so often I can go to the folder by using this command z gui. The script combines this with the fzf fuzzy finding tool. Provides a nice way to search through our folders and sessions.

Once I am done with a session I simply detach from it and swap to another session either by <prefix> + d or using the t command or even within tmux <prefix> + shift + t, which brings up that search menu.

Essentially this means I can have all my different projects opened and set up just how I want but they are out of “focus” until I need them. Making it easier to just focus on the project I am working on.

This was the plugin that convinced me to start using tmux.

Config

Some parts of my config that may be interesting

set-option -g prefix C-a
unbind-key C-b
bind-key C-a send-prefix

unbind %
unbind '"'
bind | split-window -h -c "#{pane_current_path}"
bind - split-window -v -c "#{pane_current_path}"

I remap the prefix key from ctrl + b to ctrl + a and to create a split using - for horizontal and | for vertical splits (all taken from other people’s configs ofc 😅). These mappings just make more sense in my head and also are similar to mappings to make splits in nvim as well.

The -c "#{pane_current_path}" part means when we open the new pane the working directory will be same as the current pane it is opened from.

I use the following plugins:

# List of plugins
set -g @plugin 'tmux-plugins/tpm'
set -g @plugin 'aserowy/tmux.nvim'
set -g @plugin 'joshmedeski/t-smart-tmux-session-manager'
set -g @plugin 'ofirgall/tmux-window-name'
set -g @plugin 'tmux-plugins/tmux-resurrect'
set -g @plugin 'tmux-plugins/tmux-continuum'
set -g @plugin 'ofirgall/tmux-browser'

run '~/.tmux/plugins/tpm/tpm'

They are set up using the tpm. Then to install any new plugins you add to your config you can do <prefix> + shift + I.

• aserowy/tmux.nvim: Installed in tmux and nvim allows for easier navigation between the two
• joshmedeski/t-smart-tmux-session-manager: We spoke about this above, easier session management
• tmux-plugins/tmux-resurrect: This and tmux-continuum are used to save and restore sessions so they persist even after shutdown
• ofirgall/tmux-browser: It opens a browser when you attach and closes when you detach

For restoring sessions:

## Restore Vim sessions
set -g @resurrect-strategy-vim 'session'
## Restore Neovim sessions
set -g @resurrect-strategy-nvim 'session'
## Restore Panes
set -g @resurrect-capture-pane-contents 'on'

## Restore last saved environment (automatically)
set -g @continuum-restore 'on'
set -g @continuum-boot 'on'

Resurrect allows us to save and restore a session, continuum will automate the saving and restoration of sessions.

neovim

Link to config

I recently swapped from VSCode to [neovim]((https://neovim.io/) mainly just to give it ago after watching some other developers’ workflows on Youtube such as Primeagen, Elijah Manor and Dreams of Code.

Some advantages include it being more lightweight and feels a bit more responsive. If you want to be able to customise everything about your editor then neovim is for you. However, there are neovim distributions like LunarVim, Astronvim and Nvchad, which come with a bunch of plugins keybindings all set up for you.

In my case, I ended up using LazyVim which has some nice defaults but is more barebones than some of the distributions I listed above.

Plugins

Telescope is an amazing plugin we can make it even better with a few small additions.

telescope-zoxide allows us to use zoxide with telescope we can swap folders on the fly. If we add a shortcut like this:

vim.keymap.set("n", "<leader>mm", require("telescope").extensions.zoxide.list, { desc = "Change directory using zoxide" })

telescope-undo allows us to see updates we have done to our file, allowing us to revert to a previous version.

vim.keymap.set("n", "<leader>uu", "<cmd>Telescope undo<cr>", { desc = "Show undoo tree" })

To integrate with tmux we also install the aseorwy/tmux.nvim in nvim. Now we can navigate our nvim and splits to our tmux panes. Which means we can say have a terminal open at the bottom. Then go to it by pressing ctrl + k.

Finally, look at some of the keymaps (mostly nicked from ThePrimeagen):

Paste our contents without replace what’s in the register.

vim.keymap.set("x", "<leader>p", "\"_dP", { desc = "Paste without updating register" })

Allows us to keep indenting or outdenting without needing to reselect.

vim.keymap.set("v", "<", "<gv", { desc = "Stay in visual mode during outdent" })
vim.keymap.set("v", ">", ">gv", { desc = "Stay in visual mode during indent" })

At the moment my neovim setup is pretty basic but I’m it will change as I learn more about neovim and improve my setup, suggestions are always welcome.

Summary

I hope you enjoyed this post a bit different to what I usually write but I enjoyed documenting my development workflow. I will likely add more posts in the future going into my Linux setup and also other tools I’m to become more efficient. Such vim binding on Firefox. Basically I’m trying to be more keyboard driven.