Archive

fzf keybindings and fuzzy finder quick reference

fzf Cheatsheet

Neovim keybindings and essential commands quick reference

![[ cheatsheets/starship ]]

Editors & Development #

Neovim Cheatsheet

GitUI TUI git client keybindings and quick reference

GitUI Cheatsheet

tmux keybindings and quick reference

![[ cheatsheets/lazygit ]]

Terminal Multiplexers #

tmux Cheatsheet

LF file manager keybindings and quick reference

![[ cheatsheets/zellij ]]

File Management #

LF Cheatsheet

Git commands and workflows quick reference

![[ cheatsheets/yazi ]]

Git & Version Control #

Git Cheatsheet

Daily Workflow Cheatsheet

![[ cheatsheets/gh ]]

Utilities #

![[ cheatsheets/atuin ]]

![[ cheatsheets/delta ]]

![[ cheatsheets/workspace ]]

Workflow Cheatsheets #

Daily terminal workflow and productivity patterns

Session Management Cheatsheet

![[ cheatsheets/git-workflow ]]

Terminal session management with tmux and workspace patterns

zsh Configuration

2026-02-07T00:00:00Z

zsh is my primary shell, configured for productivity with autosuggestions, syntax highlighting, and a custom prompt.

Features #

zsh-autosuggestions - Fish-like suggestions as you type
zsh-syntax-highlighting - Command validation as you type
Starship prompt - Fast, customizable prompt with git info
fzf integration - Fuzzy completion and history search
Atuin - Enhanced shell history with sync

Setup #

Installation #

zsh should be installed via your package manager:

# Ubuntu/Debian
sudo apt install zsh

# Arch Linux
sudo pacman -S zsh

# macOS
brew install zsh

Make zsh your default shell:

chsh -s $(which zsh)

Configuration #

The main config file is ~/.zshrc. Key sections include:

Path Management #

export PATH="$HOME/.local/bin:$PATH"
export PATH="$HOME/.cargo/bin:$PATH"
export PATH="$HOME/go/bin:$PATH"

Tool Activation #

# mise (tool manager)
eval "$(~/.local/bin/mise activate zsh)"

# starship prompt
eval "$(starship init zsh)"

# atuin history
eval "$(atuin init zsh)"

# direnv
eval "$(direnv hook zsh)"

Plugins #

# These provide suggestions and highlighting
source ~/.zsh/plugins/zsh-autosuggestions/zsh-autosuggestions.zsh
source ~/.zsh/plugins/zsh-syntax-highlighting/zsh-syntax-highlighting.zsh
source ~/.zsh/plugins/zsh-history-substring-search/zsh-history-substring-search.zsh

Custom Functions #

web2app #

Create desktop web app launchers:

web2app "GitHub" "https://github.com" "https://icon-url.png"

Browser Detection #

Automatically detects your default browser from desktop files:

# Falls back through: brave, chromium, google-chrome, firefox
echo $BROWSER

History Configuration #

Extended history with sharing between sessions:

HISTFILESIZE=1000000000
HISTSIZE=1000000000
SAVEHIST=1000000000
setopt appendhistory
setopt share_history

Key Bindings #

Key	Action
`Ctrl+E`	Edit command in $EDITOR
`Ctrl+K`	Clear screen and run wfetch
`Ctrl+N`	Expand alias
`Ctrl+P`	List all commands with fzf
`Ctrl+G`	Open gitui
`Up/Down`	History search by prefix

Completion #

Advanced completion with:

Case-insensitive matching
Fuzzy matching
Menu selection with arrow keys
Grouped results with descriptions

Zellij

2026-02-07T00:00:00Z

Zellij is a terminal workspace with batteries included. It's a modern alternative to tmux and screen.

Features #

Layout system - Define window layouts in YAML
Plugins - Extend functionality with WebAssembly plugins
Rust-based - Fast and safe implementation
WebAssembly - Plugin system built on WASM
Easy to use - Sensible defaults, minimal configuration

Setup #

Install via package manager:

# Via mise (recommended)
mise install zellij

# Arch Linux
sudo pacman -S zellij

# macOS
brew install zellij

# Cargo
cargo install zellij

Launching #

# Start new session
zellij

# Start with specific layout
zellij --layout mylayout

# Attach to existing
zellij attach

# List sessions
zellij list-sessions

Key Bindings #

Zellij uses Ctrl+g as the prefix key:

Session #

Key	Action
`Ctrl+g` `d`	Detach
`Ctrl+g` `q`	Quit
`Ctrl+g` `s`	Session manager

Panes #

Key	Action
`Ctrl+g` `n`	New pane (horizontal)
`Ctrl+g` `p`	New pane (vertical)
`Ctrl+g` `x`	Close pane
`Ctrl+g` `h/j/k/l`	Move between panes
`Ctrl+g` `f`	Fullscreen pane
`Alt+Arrow`	Move between panes (no prefix)

Tabs #

Key	Action
`Ctrl+g` `c`	New tab
`Ctrl+g` `,`	Rename tab
`Ctrl+g` `Ctrl+h/l`	Previous/next tab
`Ctrl+g` `[1-9]`	Go to tab

Scroll/Search #

Key	Action
`Ctrl+g` `[`	Enter scroll mode
`Ctrl+s`	Search (in scroll mode)
`n/N`	Next/previous match
`Esc`	Exit scroll mode

Layouts #

Create layouts in ~/.config/zellij/layouts/:

# ~/.config/zellij/layouts/dev.yaml
template:
  direction: Horizontal
  parts:
    - direction: Vertical
      split_size:
        Percent: 50
      parts:
        - direction: Vertical
        - direction: Vertical
    - direction: Vertical
      split_size:
        Percent: 50
      parts:
        - direction: Vertical
          run:
            command: {cmd: cargo, args: ["watch", "-x", "run"]}

Use: zellij --layout dev

Configuration #

Config file: ~/.config/zellij/config.kdl

Example:

theme "dracula"

default_shell "zsh"

keybinds {
    normal {
        bind "Ctrl a" { SwitchToMode "Tmux"; }
    }
}

plugins {
    filepicker location="zellij:filepicker"
}

Yep

2026-02-07T00:00:00Z

Things I use, recommend, and endorse without reservation.

Software #

Development #

Neovim - Modern vim. Fast, extensible, powerful. See Neovim Configuration
tmux - Terminal multiplexer that changed how I work. See tmux Configuration
zsh - Best shell experience with the right plugins. See zsh Configuration
mise - One tool to manage all dev tool versions. See mise Tool Management
fzf - Fuzzy finding that integrates everywhere. See fzf
git - Version control done right. See Git Configuration
uv - Python packaging and dependency management done right. See [[uv]]

Terminal #

kitty - GPU-accelerated terminal. See kitty Terminal
wezterm - Cross-platform and scriptable. See WezTerm

Window Management #

Hyprland - Wayland tiling compositor with excellent workspace support. See Hyprland Window Manager
Awesome WM - When I need X11. See Awesome Window Manager
KDE Plasma - Actually like this DE - great workspace management and keyboard shortcuts

I need window managers with robust workspace hotkeys: win+num to switch, win+shift+num to send apps, win+ctrl+num to join workspaces. Both tiling and floating work fine if the workspace management is solid.

Utilities #

atuin - Shell history that syncs. See Atuin
starship - Fast, informative prompt. See Starship Prompt
gitui - Fast git TUI written in Rust. See gitui
lazygit - Alternative git UI. See Lazygit
lf - Fast terminal file manager. See lf
yazi - Alternative file manager with async I/O. See Yazi

Python #

uv - Fast, all-in-one Python packaging and dependency management
ruff - Fast Python linter and formatter
pytest - Testing without complexity

Hardware #

(Add specific hardware recommendations if desired)

Workflows #

Keyboard-driven everything - Minimize mouse usage
Win+num workspace switching - Instant access to any workspace
Dotfiles in git - Version control everything
Containers for isolation - Keep host system clean
Documentation as code - Write it down, automate it
Vanilla JS - Prefer simple over complex build pipelines

Development Approach #

JavaScript/Frontend #

Vanilla JavaScript - No build step, no dependencies when possible
CDN libraries - Alpine.js, htmx, or similar via script tag
Avoid heavy frameworks - No webpack, no deep node_modules trees
Progressive enhancement - Start simple, add complexity only when needed

Python #

uv - For all dependency management and virtual environments
pyproject.toml - Modern Python packaging standard
Simple structure - Flat is better than nested
Type hints - For code clarity without ceremony

Principles #

Open source over proprietary when possible
Simple over complex
Fast over feature-rich
Keyboard over mouse
Text over GUI
Vanilla over framework when feasible
One tool that does it well over many tools

See Nope for things I avoid.

Yazi

2026-02-07T00:00:00Z

Yazi is a blazing-fast terminal file manager written in Rust with async I/O.

Features #

Async I/O - Non-blocking file operations
Fast - Written in Rust, optimized for speed
Previews - Built-in image, video, and code previews
Customizable - Keybindings, themes, and plugins
Integration - Works with neovim, tmux, shells

Setup #

Install via package manager:

# Via mise (recommended)
mise install yazi

# Or install script
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
# Then cargo install yazi-fm

# Arch Linux (AUR)
yay -S yazi

Configuration #

Config directory: ~/.config/yazi/

yazi.toml - General configuration
keymap.toml - Key bindings
theme.toml - Colors and styling

Key Bindings #

Key	Action
`j/k` or `↓/↑`	Move down/up
`h/l` or `←/→`	Parent/child directory
`gg`	Go to top
`G`	Go to bottom
`H`	Back in history
`L`	Forward in history

File Operations #

Key	Action
`Space`	Select item
`y`	Yank (copy)
`x`	Cut
`p`	Paste
`d`	Delete
`D`	Permanent delete
`r`	Rename
`a`	Create file
`A`	Create directory
`Enter`	Open file
`o`	Open with specific app

View #

Key	Action
`Tab`	Switch panel
`~`	Go to home
`.`	Toggle hidden files
`s`	Search files
`S`	Search contents
`/`	Filter items
`z`	Jump to directory
`c`	Copy path

Shell Integration #

Add to ~/.zshrc:

function yy() {
    local tmp="$(mktemp -t "yazi-cwd.XXXXXX")"
    yazi "$@" --cwd-file="$tmp"
    if cwd="$(cat -- "$tmp")" && [ -n "$cwd" ] && [ "$cwd" != "$PWD" ]; then
        cd -- "$cwd"
    fi
    rm -f -- "$tmp"
}

Then use yy to launch yazi and automatically cd to the last visited directory on exit.

Workspace Script

2026-02-07T00:00:00Z

A custom workspace management script that automates tmux session creation and management for organized project development.

Overview #

The workspace script provides automated tmux session management, making it easy to:

Create organized session groups
Quickly switch between projects
Maintain consistent development environments
Sync workspace configuration across machines

Location #

~/git/workspaces/workspaces.py

Features #

Git repository discovery - Automatically find repos in workspace directories
Session groups - Organize related projects
Quick attach - Fast switching between workspaces
Configuration sync - Keep workspace definitions in version control

Usage #

Basic Commands #

# Attach to workspace (creates if needed)
~/git/workspaces/workspaces.py -W git attach

# Create new workspace
~/git/workspaces/workspaces.py -W git create

# Add current repo to workspace
~/git/workspaces/workspaces.py -W git add

From tmux #

The script integrates with tmux keybindings:

Key	Action
`Alt+Space`	Attach to workspace
`Alt+T`	Attach to workspace in current directory
`Alt+Escape`	Create new workspace
`Alt+Backspace`	Add repo to workspace

How It Works #

Discovers repositories - Scans configured directories for git repos
Creates sessions - Generates tmux sessions with standardized layouts
Manages windows - Each repo gets its own window or layout
Syncs config - Stores workspace definitions in git-tracked files

Configuration #

Workspaces are defined in:

~/.config/workspaces/config.toml

Example:

[workspaces.git]
path = "~/git"
auto_discover = true
layout = "main-vertical"

[workspaces.work]
path = "~/work"
auto_discover = false
repos = ["project1", "project2"]

Integration with tmux #

The script is called from tmux keybindings in ~/.tmux.conf:

bind -n M-Space display-popup -T 'attach to workspace' -E -d '~/git' "~/git/workspaces/workspaces.py -W git attach"

This creates popup windows for workspace management without leaving your current context.

WezTerm

2026-02-07T00:00:00Z

WezTerm is a GPU-accelerated cross-platform terminal emulator and multiplexer written in Rust.

Features #

Cross-platform - Works on Linux, macOS, and Windows
GPU-accelerated - Smooth rendering using OpenGL
Lua configuration - Powerful scripting with Lua
Built-in multiplexer - Tabs and panes without external tools
SSH client - Native SSH support with terminal features

Setup #

Install via package manager:

# Ubuntu/Debian
# Download .deb from GitHub releases

# Arch Linux
sudo pacman -S wezterm

# macOS
brew install --cask wezterm

# Windows
# Download from GitHub releases or use winget
winget install wez.wezterm

Configuration #

Config file: ~/.config/wezterm/wezterm.lua

Example configuration:

local wezterm = require 'wezterm'

return {
    font = wezterm.font 'JetBrains Mono',
    font_size = 12.0,
    color_scheme = 'Dracula',
    window_background_opacity = 0.95,
    enable_tab_bar = true,
    hide_tab_bar_if_only_one_tab = true,
}

Key Bindings #

Key	Action
`Ctrl+Shift+T`	New tab
`Ctrl+Shift+W`	Close tab
`Ctrl+Shift+Tab`	Next tab
`Ctrl+Shift+Enter`	Split pane vertically
`Ctrl+Shift+%`	Split pane horizontally
`Ctrl+Shift+Arrow`	Move between panes
`Ctrl+Shift+Space`	Quick select mode
`Ctrl+Shift+F`	Search scrollback

Multiplexer Features #

WezTerm includes a built-in multiplexer that can replace tmux:

-- Enable multiplexing
config.leader = { key = 'a', mods = 'CTRL' }
config.keys = {
    { key = '|', mods = 'LEADER|SHIFT', action = wezterm.action.SplitHorizontal { domain = 'CurrentPaneDomain' } },
    { key = '-', mods = 'LEADER', action = wezterm.action.SplitVertical { domain = 'CurrentPaneDomain' } },
}

Waybar

2026-02-07T00:00:00Z

Waybar is a highly customizable Wayland bar for Sway and other wlroots-based compositors.

Features #

Wayland native - No XWayland needed
CSS styling - Full CSS3 support for theming
Modular - Use only the modules you need
Custom scripts - Display any information via custom modules
System tray - Support for tray icons

Setup #

Install via package manager:

# Ubuntu/Debian
sudo apt install waybar

# Arch Linux
sudo pacman -S waybar

# Fedora
sudo dnf install waybar

Configuration #

Config file: ~/.config/waybar/config

Example configuration:

{
    "layer": "top",
    "position": "top",
    "height": 30,
    "modules-left": ["sway/workspaces", "sway/mode"],
    "modules-center": ["sway/window"],
    "modules-right": ["pulseaudio", "network", "cpu", "memory", "battery", "clock", "tray"],
    
    "sway/workspaces": {
        "format": "{name}"
    },
    
    "clock": {
        "format": "{:%Y-%m-%d %H:%M}"
    },
    
    "battery": {
        "format": "{capacity}% {icon}",
        "format-icons": ["", "", "", "", ""]
    }
}

Styling #

Style file: ~/.config/waybar/style.css

Example styling:

* {
    font-family: "JetBrains Mono", sans-serif;
    font-size: 13px;
}

window#waybar {
    background-color: #1e1e2e;
    color: #cdd6f4;
}

#workspaces button {
    padding: 0 10px;
    color: #cdd6f4;
}

#workspaces button.focused {
    background-color: #313244;
}

#clock {
    padding: 0 10px;
}

Common Modules #

clock - Date and time
battery - Battery status
cpu - CPU usage
memory - RAM usage
network - Network status
pulseaudio - Volume control
tray - System tray
workspaces - Workspace tags
window - Active window title
custom - Custom scripts

Custom Module Example #

"custom/weather": {
    "format": "{}",
    "exec": "curl -s wttr.in/?format=1",
    "interval": 3600
}

Uses

2026-02-07T00:00:00Z

This is my setup - the hardware and software I use every day for development.

Hardware #

Development Machine #

(Update with your actual specs)

CPU: AMD Ryzen or Intel
RAM: 32GB+
Storage: NVMe SSD
GPU: Integrated or dedicated for external displays
Displays: Multiple monitors for productivity

Peripherals #

Keyboard: Mechanical with custom layout
Mouse: Trackball or ergonomic mouse (used minimally)
Webcam: For video calls
Microphone: For recording and calls

Mobile #

(Update with your actual devices)

Phone: Android or iOS
Tablet: For reading and media

Software Stack #

Operating System #

OS: Arch Linux
Window Manager: Hyprland (Wayland)
Terminal: kitty
Shell: zsh with starship prompt

Development Environment #

Editor: Neovim (lazy.nvim based config)
Multiplexer: tmux
Version Control: git with delta and gitui
Tool Manager: mise
Container: podman

Daily Tools #

Browser: Brave
Password Manager: Bitwarden
Notes: Markdown files in git
Chat: Signal
Music: Streaming service

CLI Tools #

Essential command-line tools:

fzf - Fuzzy finder
ripgrep - Fast code search
fd - Fast file finder
bat - Syntax-highlighting cat
eza - Modern ls replacement
zoxide - Smart cd command
atuin - Shell history
lf - File manager (primary)
yazi - Alternative file manager

Neovim Plugins #

Key plugins I rely on:

lazy.nvim - Plugin manager
telescope.nvim - Fuzzy finder
nvim-lspconfig - LSP support
nvim-treesitter - Syntax highlighting
gitsigns.nvim - Git integration
lualine.nvim - Status line

Dotfiles Management #

All configurations are in the devtainer repository:

git clone https://github.com/waylonwalker/devtainer.git ~/devtainer

Installed via symlinks or stow.

Workflow #

Terminal (kitty) always open with tmux
Neovim for all editing
Browser for research and documentation
Git for version control
Containers for isolated environments

Inspiration #

This /uses page is inspired by uses.tech - a collection of developer setups.

See Defaults for my default tool choices when starting new projects.

tmux Configuration

2026-02-07T00:00:00Z

tmux is a terminal multiplexer that lets you switch easily between several programs in one terminal, detach them (they keep running in the background) and reattach them to a different terminal.

Features #

Popup windows - Quick access to sessions and tools without leaving current context
Session management - Easy switching between projects
Vi mode - Familiar keybindings for copy mode
Minimal status bar - Hidden by default, toggle when needed

Setup #

Installation #

Install via mise:

mise install tmux

Or your package manager:

# Ubuntu/Debian
sudo apt install tmux

# Arch Linux
sudo pacman -S tmux

Configuration #

The config file is ~/.tmux.conf. Main settings:

# Vi mode for copy/paste
setw -g mode-keys vi

# Don't detach on destroy
set-option -g detach-on-destroy off

# Focus events for nvim integration
set-option -g focus-events on

# Hidden status bar by default
set-option -g status off

Key Bindings #

Prefix #

The prefix key is Ctrl+Space (custom):

bind Space send-prefix

Session Management #

Key	Action
`Alt+Space`	Popup: attach to workspace session
`Alt+T`	Popup: attach to workspace in current directory
`Alt+Escape`	Popup: create new workspace
`Alt+Backspace`	Popup: add repo to workspace
`Ctrl+J`	Popup: switch to any session with fzf
`Alt+G`	Popup: open scratch session
`Alt+Shift+G`	Popup: open scratch session (large)
`Ctrl+K`	Popup: kill sessions
`J`	tmux session tree browser

Copy Mode #

Key	Action
`Alt+[`	Enter copy mode
`Alt+V`	Enter copy mode
`Alt+Enter`	Enter copy mode
`Enter`	Enter copy mode

Copy uses wl-copy on Wayland or xclip on X11.

Status Bar #

Key	Action
`Prefix+s`	Toggle status bar
`Prefix+Ctrl+S`	Toggle status bar

Git Integration #

Key	Action
`Alt+F`	Popup: git commit --verbose
`Alt+Shift+F`	Popup: gitui

Workspaces #

Key	Action
`Ctrl+W`	Popup: attach to ~/work
`Alt+W`	Popup: attach to ~/work
`Ctrl+G`	Popup: attach to ~/git
`Ctrl+P`	Popup: attach to ~/project
`Ctrl+T`	New session: todo list in nvim

Popups are a key feature - they let you access tools without leaving your current context:

# Example: switch sessions without leaving current window
bind C-j display-popup -E "\
    tmux list-sessions -F '#{?session_attached,,#{session_name}}' |\
    sed '/^$/d' |\
    fzf --reverse --header jump-to-session --preview 'tmux capture-pane -pt {}' \\
        --bind 'enter:execute(tmux switch-client -t {})+accept'"

Workflows #

Project Hopping #

Alt+Space to see all workspace sessions
Ctrl+J to fuzzy-find any session
Alt+G for a quick scratch pad

Git Workflow #

Alt+F to write a commit message in a popup
Alt+Shift+F for full gitui when needed

Todo Management #

Ctrl+T opens a dedicated todo session with three files:
- backlog.md - Things to do eventually
- doing.md - Currently working on
- done.md - Completed tasks

Clipboard Integration #

Copy mode automatically integrates with system clipboard:

bind -T copy-mode-vi Enter send-keys -X copy-pipe-and-cancel \\
    "bash -c 'command -v wl-copy >/dev/null && wl-copy || \\
    xclip -i -f -selection primary | xclip -i -selection clipboard'"

tmux Session Switching Demo

2026-02-07T00:00:00Z

A demonstration of switching between multiple tmux sessions using Alt+Space and session management commands.

What is Shown #

Multiple sessions running (dotfiles, project1, work)
Switching between sessions with Alt+Space
Checking current session context with pwd
Listing all active sessions

Key Takeaway #

Session switching allows you to work on multiple projects simultaneously. Switch contexts instantly without losing your place in each project.

tmux session switching demo

tmux configuration for persistent terminal sessions with popup windows and session management

tmux Scratch Session Demo

2026-02-07T00:00:00Z

A demonstration of using tmux scratch sessions for quick notes, experiments, and temporary work without cluttering your main workspace.

What is Shown #

Working in a main project session
Opening scratch session with Alt+G
Running quick commands in the scratch pad
Exiting back to the original session

Key Takeaway #

Scratch sessions provide a clean slate for quick experiments. Create one with Alt+G, do your work, then exit back to where you were.

tmux scratch session demo

tmux configuration for persistent terminal sessions with popup windows and session management

tmux Git Project Session Demo

2026-02-07T00:00:00Z

A demonstration of creating dedicated tmux sessions for individual git repositories, keeping each project's context isolated.

What is Shown #

Starting in a git repository
Creating a new session named after the project
Listing all active sessions
Opening the editor in the new session context

Key Takeaway #

Dedicated sessions per project keep your workspaces organized. Each git repo gets its own tmux session with the correct working directory.

tmux git project session demo

tmux configuration for persistent terminal sessions with popup windows and session management

Git configuration with aliases, delta for diffs, and work/personal separation

Git Configuration

Neovim configuration with lazy.nvim for plugin management

Neovim Telescope File Finding Demo

2026-02-07T00:00:00Z

A demonstration of using Telescope in Neovim for fuzzy file finding and navigation.

What is Shown #

Opening Neovim
Launching Telescope with Space+ff
Typing to filter files
Selecting and opening a file

Key Takeaway #

Telescope brings the power of fzf into Neovim. Find and open files without leaving your editor.

neovim telescope demo

Neovim Configuration

Neovim configuration with lazy.nvim for plugin management

![[ telescope.nvim ]]

Neovim LSP Go-to-Definition Demo

2026-02-07T00:00:00Z

A demonstration of Neovim's Language Server Protocol integration for code navigation and go-to-definition.

What is Shown #

Opening a Python file in Neovim
Navigating to a function call
Using gd to jump to definition
Using Ctrl+o to jump back

Key Takeaway #

LSP transforms Neovim into a full IDE. Jump to definitions, see documentation, and refactor code with built-in intelligence.

neovim lsp demo

Neovim Configuration

lf - a terminal file manager written in Go

![[ nvim-lspconfig ]]

lf in tmux Popup

2026-02-07T00:00:00Z

A demonstration of using lf inside a tmux popup window, showing the seamless integration between file management and terminal multiplexing.

What is Shown #

Working in a terminal session
Opening lf (simulating Alt+E popup binding)
Navigating to a file
Opening the file
Returning to the original session

Key Takeaway #

The tmux popup integration allows you to browse files without leaving your current context. Open files, check directories, then return exactly where you were.

lf tmux popup demo

tmux configuration for persistent terminal sessions with popup windows and session management

lf - a terminal file manager written in Go

lf File Manager Demo

2026-02-07T00:00:00Z

A quick demonstration of lf file manager showing basic navigation using vim-style keybindings.

What is Shown #

Launching lf in the sandbox directory
Navigating with j/k (down/up)
Entering directories with l
Going back with h
Jumping to bottom with G and top with gg
Quitting with q

Key Takeaway #

lf provides fast, keyboard-driven file navigation without leaving the terminal. The vim-style bindings make it intuitive for anyone familiar with modal editors.

lf file manager demo

Lazygit - a simple terminal UI for git commands

lazygit Staging Workflow Demo

2026-02-07T00:00:00Z

A demonstration of the complete git workflow using lazygit: staging files, writing commits, and pushing changes.

What is Shown #

Opening lazygit with modified and new files
Navigating the status panel
Staging files with Space
Creating a commit with c
Pushing changes with p

Key Takeaway #

lazygit's visual interface makes git operations intuitive. Stage with Space, commit with c, push with p—all without typing git commands.

lazygit staging demo

Lazygit

Git configuration with aliases, delta for diffs, and work/personal separation

Git Configuration

gitui - a blazing-fast terminal UI for git

gitui

All posts with the tag "lazydocker"

lazydocker Container Management Demo

2026-02-07T00:00:00Z

A demonstration of using lazydocker to view and manage Docker containers from the terminal.

What is Shown #

Opening lazydocker
Navigating the container list
Viewing container details
Checking logs

Key Takeaway #

lazydocker provides a complete Docker management interface in the terminal. View containers, images, volumes, and logs without docker commands.

lazydocker demo

Posts tagged: lazydocker

gitui Staging and Commit Demo

2026-02-07T00:00:00Z

A demonstration of the complete git workflow using gitui: staging files, writing commits, and pushing changes.

What is Shown #

Opening gitui in a git repository
Staging files with Space
Opening commit dialog with c
Writing a commit message
Submitting with Ctrl+s
Pushing with p

Key Takeaway #

gitui provides a fast, keyboard-driven interface for common git operations. Stage, commit, and push without typing git commands or using a mouse.

gitui staging demo

gitui

gitui - a blazing-fast terminal UI for git

Git configuration with aliases, delta for diffs, and work/personal separation

Git Configuration

fzf - a command-line fuzzy finder

fzf History Search Demo

2026-02-07T00:00:00Z

A demonstration of using fzf (with atuin) to search command history using Ctrl+R.

What is Shown #

Opening history search with Ctrl+R
Typing to filter previous commands
Navigating results with arrow keys
Selecting and executing a previous command

Key Takeaway #

History search eliminates retyping. Find any previous command instantly with fuzzy matching.

fzf history search demo

fzf

Atuin - a magical shell history with sync

Atuin

zsh shell configuration - my primary shell with autosuggestions, syntax highlighting, and custom functions

zsh Configuration

fzf - a command-line fuzzy finder

fzf File Finding Demo

2026-02-07T00:00:00Z

A demonstration of using fzf to quickly find and select files with fuzzy matching and Ctrl+T integration.

What is Shown #

Opening fzf with Ctrl+T
Typing to fuzzy filter results
Selecting a file from the filtered list
The file path is inserted into the command line

Key Takeaway #

fzf's fuzzy finding makes locating files effortless. Type partial names, see results instantly, select with Enter.

fzf file finding demo

fzf

zsh shell configuration - my primary shell with autosuggestions, syntax highlighting, and custom functions

zsh Configuration

Hardware and software I use daily

Starship Prompt

2026-02-07T00:00:00Z

Starship is a minimal, fast, and customizable prompt for any shell. It provides useful context at a glance without cluttering your terminal.

Features #

Fast - Written in Rust, renders in milliseconds
Cross-shell - Works with zsh, bash, fish, and more
Informative - Git status, tool versions, execution time
Customizable - Extensive configuration options

Setup #

Installation #

Via mise (recommended):

mise install starship

Or direct install:

curl -sS https://starship.rs/install.sh | sh

Shell Integration #

Add to ~/.zshrc:

eval "$(starship init zsh)"

Configuration #

Config file: ~/.config/starship.toml

Minimal Setup #

# Don't print a new line at the start of the prompt
add_newline = false

# Replace the "❯" symbol in the prompt with "➜"
[character]
success_symbol = "[➜](bold green)"
error_symbol = "[✗](bold red)"

Git Status #

Show detailed git information:

[git_status]
conflicted = "🏳"
ahead = "🏎💨"
behind = "😰"
diverged = "😵"
up_to_date = "✓"
untracked = "🤷"
stashed = "📦"
modified = "📝"
staged = "[++\($count\)](green)"
renamed = "👅"
deleted = "🗑"

Tool Versions #

Show active tool versions:

[nodejs]
format = "via [🤖 $version](bold green) "

[python]
format = "via [🐍 $version](bold blue) "

[rust]
format = "via [🦀 $version](bold red) "

[golang]
format = "via [🐹 $version](bold cyan) "

Directory #

Customize how directories are displayed:

[directory]
truncation_length = 3
truncate_to_repo = true

Command Duration #

Show how long the last command took:

[cmd_duration]
min_time = 500
format = "took [$duration](bold yellow)"

Modules #

Starship supports many modules out of the box:

Development #

git_branch - Current git branch
git_commit - Current git commit
git_state - Rebase/merge/cherry-pick state
git_status - Working tree status
package - Package version from package.json, Cargo.toml, etc.

Languages #

nodejs - Node.js version
python - Python version and virtualenv
rust - Rust version
golang - Go version
ruby - Ruby version
lua - Lua version

System #

directory - Current directory
hostname - System hostname
username - Current user
time - Current time
battery - Battery percentage
memory_usage - RAM usage

Tools #

aws - AWS profile
gcloud - Google Cloud region
kubernetes - Current k8s context
terraform - Terraform workspace

Conditional Formatting #

Show modules only in certain contexts:

[nodejs]
detect_extensions = ["js", "mjs", "cjs", "ts"]
detect_files = ["package.json", ".node-version"]
detect_folders = ["node_modules"]

Performance #

Starship is designed to be fast, but you can optimize further:

# Disable unused modules
[fill]
disabled = true

[line_break]
disabled = true

# Reduce git status checks
[git_status]
disabled = false
ahead = "⇡${count}"
diverged = "⇕⇡${ahead_count}⇣${behind_count}"
behind = "⇣${count}"

Transient Prompt #

Keep previous prompts minimal:

[character]
success_symbol = "[❯](bold green)"
error_symbol = "[❯](bold red)"

# This requires shell-specific config

For zsh, add to ~/.zshrc:

# Transient prompt
setopt transient_rprompt

Troubleshooting #

Prompt not showing #

Check starship is in PATH: which starship
Verify init command is in shell config
Restart shell: exec zsh

Slow prompt #

Profile with: STARSHIP_LOG=trace starship prompt

Polybar

2026-02-07T00:00:00Z

Polybar is a fast and easy-to-use status bar for X11 window managers.

Features #

Lightweight - Minimal resource usage
Modular - Enable only what you need
Themable - Extensive customization options
Multi-monitor - Support for multiple displays
Font icons - Support for Nerd Fonts and icons

Setup #

Install via package manager:

# Ubuntu/Debian
sudo apt install polybar

# Arch Linux
sudo pacman -S polybar

# Fedora
sudo dnf install polybar

# Build from source
# See GitHub releases for latest version

Configuration #

Config file: ~/.config/polybar/config.ini

Structure:

[bar/main]
width = 100%
height = 24
background = #1e1e2e
foreground = #cdd6f4

font-0 = "JetBrains Mono:size=10;2"
font-1 = "Font Awesome 6 Free:size=10;2"

modules-left = bspwm xwindow
modules-center = date
modules-right = volume network battery

[module/date]
type = internal/date
interval = 1
date = %Y-%m-%d
time = %H:%M
label = %date% %time%

[module/volume]
type = internal/pulseaudio
label-volume = VOL %percentage%%

Launching #

Add to your window manager startup:

# Kill existing
killall -q polybar

# Launch
polybar main &

Common Modules #

i3 - i3 workspace integration
bspwm - BSPWM workspace integration
xwindow - Active window title
xworkspaces - EWMH workspace support
date - Clock and calendar
alsa / pulseaudio - Volume control
battery - Battery status
cpu - CPU usage
memory - RAM usage
network - Network status
temperature - System temperature

Custom Script Module #

[module/custom-script]
type = custom/script
exec = ~/.config/polybar/scripts/custom.sh
interval = 5
label = %output%

Nope

2026-02-07T00:00:00Z

Things I avoid, do not use, or actively recommend against.

This is not about bashing tools that work for others - these are things that do not work for me and my workflows.

Software I Avoid #

IDEs #

VS Code - Resource-heavy for what I need. I prefer Neovim's speed and efficiency.
JetBrains products - Overkill for my use cases and too resource-intensive.

Why: I spend most of my time in a terminal. Heavy IDEs feel sluggish and get in my way.

Window Managers #

GNOME - Too much mouse interaction, not keyboard-friendly enough for my workflow.
i3 (personally) - Used it for years, but prefer Hyprland's Wayland-native approach now.

Note: I actually like KDE, but my primary requirement for any window manager is robust workspace management with hotkeys. I need win+num to switch, win+shift+num to send apps, and win+ctrl+num to join workspaces. I enjoy tiling but have no strong preference between tiling and floating - both work fine with a good workspace manager that lets me reach any app in one keystroke.

Development Tools #

nvm/rbenv/pyenv separately - Use mise Tool Management instead. One tool instead of many.
Docker Desktop - Bloated. Use podman or docker CLI directly.

Python Dependency Management #

After years using pip-tools, hatch, and conda, I've been uv pilled. I now avoid:

Poetry - Overly complex for my needs
Hatch - Used it for years, but uv is simpler
pip-tools - Used it for years, uv replaces it completely
virtualenv - uv handles environments
conda - Used it for years, uv + pyproject.toml is cleaner
flit - Unnecessary with uv

What I use instead: [[uv]] - Fast, simple, and handles everything I need.

JavaScript Development #

I avoid JavaScript frameworks with heavy build pipelines and deep node_modules trees. I prefer:

Vanilla JavaScript - No build step, no dependencies
CDN libraries - Add what you need via script tag
Simple tools - Avoid webpack, complex bundlers, and deep dependency chains

Practices I Avoid #

Mouse-heavy workflows - Slows me down, causes wrist strain
Clicking through GUIs - Prefer keyboard shortcuts and CLI
Manual, repetitive tasks - Automate or script everything
Keeping everything in my head - Document in version control
Heavy build pipelines - Prefer simplicity over complexity

Business Models #

Subscription fatigue - Prefer perpetual licenses or open source
Vendor lock-in - Prefer tools with open standards and export options
Cloud-only dependencies - Keep local-first options available

Counter-Arguments I Accept #

These tools work great for others:

VS Code has excellent debugging support
IDEs provide discoverability for new developers
GUI tools can be more approachable
Complex build pipelines enable powerful optimizations
Poetry and conda solve real problems for many teams

Use what works for you. These are my preferences, not universal truths.

See Yep for things I do recommend.

2026-02-07T00:00:00Z

Upcoming content, improvements, and ideas for this documentation site.

Guides & How-To #

Installation/bootstrap guide - Complete step-by-step fresh machine setup
Migration guide - Moving from other tools (VS Code → Neovim, etc.)
Sync strategy - How dotfiles stay synchronized across machines
Backup & restore - Disaster recovery for the environment
Per-machine configs - Laptop vs desktop differences
Troubleshooting - Common issues and fixes with solutions

Quick Reference Pages (Potential Additions) #

mise recipes - Common mise tool configurations
neovim recipes - Language-specific neovim setups
tmux layouts - Project-specific session layouts
git workflows - Team-specific git process documentation

Deep Dives #

Workflow documentation - "How I work" series
- TDD workflow
- Debugging workflow
- Code review process
Plugin deep dives - Specific neovim plugins explained
Script explanations - Custom scripts in detail
- workspace.py
- web2app function
- kube-check script

Meta/Context #

Tool comparison - Detailed comparisons (Why X over Y) → [[tool-comparison]]
Evolution - How the setup has changed over 10+ years → [[evolution]]
Philosophy - Deeper dive into the "why" behind choices → [[philosophy]]
Hardware - Detailed workstation specs → [[hardware]]

Interactive/Reference #

Cheatsheets - Quick reference cards for common operations → Cheatsheets

Improvements #

Add wikilink support to zellij page (it's missing the embeds) → Zellij
Create uv.md page (referenced in yep.md but missing) → [[uv]]
Add more external embeds to tool pages
VHS recordings for key workflows - Designed 12 tape posts with markdown frontmatter

VHS Recording Infrastructure #

Each VHS tape now has its own markdown post in pages/tapes/ with:

Frontmatter including template: image and image: /tapes/filename.mp4
Description of what is shown
Key takeaway
Related tool embeds

Tape Posts Created:

lf-intro.md - Basic file manager navigation
lf-tmux-popup.md - Popup integration workflow
gitui-intro.md - Staging and committing
tmux-scratch-session.md - Alt+G scratch pad workflow
tmux-session-switching.md - Session management
tmux-git-project-session.md - Project-specific sessions
fzf-file-finding.md - Ctrl+T fuzzy finding
fzf-history-search.md - Ctrl+R history search
lazygit-staging.md - Alternative git UI workflow
lazydocker-containers.md - Docker management
neovim-telescope.md - File finding in editor
neovim-lsp-go-to-definition.md - Code navigation

Still to Record:

Record actual mp4 files for all designed tapes
tmux "day in the terminal" workflow demo
Workspace management script demo
Kubernetes workflow with k9s

Sandbox Setup: All VHS recordings use the vhs/sandbox/ directory for safety. See AGENTS.md for sandbox best practices.

Workflow Demos (20-30 seconds)

"A day in the terminal" - tmux session → neovim → gitui → back
Workspace management - Using workspace script to switch projects
Git workflow - Branch, edit, stage, commit with gitui
File exploration - fzf + lf + bat pipeline
Kubernetes workflow - k9s to inspect, edit, apply

Setup Guides (30-45 seconds)

Fresh machine bootstrap - mise install → stow configs → verify
Adding a new tool - Update mise config → install → verify → commit
Creating a workspace - ~/git/workspaces/workspaces.py create workflow

Configuration Highlights (15-20 seconds)

Starship prompt customization - Show git status, tool versions
tmux keybinding demo - Prefix key, splits, popups
Neovim plugin showcase - Telescope file finding, LSP features

Comparison Videos

"Before/After" - Mouse-heavy workflow vs keyboard-driven
IDE vs Terminal - Same task in VS Code vs neovim+tmux

Tape Organization

vhs/
├── tools/
│   ├── tmux-intro.tape
│   ├── fzf-demo.tape
│   └── lazygit-workflow.tape
├── workflows/
│   ├── git-workflow.tape
│   ├── dev-session.tape
│   └── workspace-switching.tape
└── guides/
    ├── bootstrap.tape
    └── new-tool-setup.tape

Integration with Docs

Embed videos in tool pages after the "Features" section
Use as hero videos on index pages
Link to full recordings from quickstart guides
Create GIF fallbacks for mobile/low-bandwidth
Dark/light theme toggle

Content Ideas #

Still To Create #

ricing - Aesthetic customization beyond function
one-shot-apps - Documentation for the one-shot-apps directory
ansible - Infrastructure as code for machine setup
distrobox - Container-based development environments
qutebrowser - Keyboard-driven web browser config
k9s - Kubernetes terminal UI

Recently Completed (Not Previously Listed) #

hyprland - Wayland tiling compositor configuration → Hyprland Window Manager
helix - Modern modal text editor → Helix Editor
awesome - X11 tiling window manager → Awesome Window Manager
lazygit - Git TUI alternative to gitui → Lazygit
atuin - Enhanced shell history with sync → Atuin
delta - Syntax-highlighted git diff viewer → Delta
gh - GitHub CLI for git operations → GitHub CLI
starship - Fast, customizable shell prompt → Starship Prompt
kitty - GPU-accelerated terminal emulator → kitty Terminal
wezterm - Cross-platform terminal emulator → WezTerm
polybar - Status bar for X11 window managers → Polybar
waybar - Status bar for Wayland compositors → Waybar
yazi - Async file manager alternative to lf → Yazi
workspace - Project management and workspace switching → Workspace Script
defaults - Default application and system configurations → Defaults

This is a living document. Items will be checked off as they're completed and new ideas will be added.

Neovim Configuration

2026-02-07T00:00:00Z

Neovim is my primary text editor, configured with a modern setup using lazy.nvim for plugin management.

Features #

lazy.nvim - Fast, modern plugin manager
LSP - Language Server Protocol for IDE-like features
Treesitter - Better syntax highlighting and parsing
fzf/telescope - Fuzzy finding for files, buffers, and more
Git integration - Gitsigns, fugitive, and diffview

Setup #

Installation #

Via mise (recommended):

mise install neovim

Or from source/package manager:

# Ubuntu/Debian
sudo apt install neovim

# Arch Linux
sudo pacman -S neovim

# macOS
brew install neovim

Configuration Structure #

nvim/.config/nvim/
├── init.lua                 # Entry point
├── lazy-lock.json          # Plugin lockfile
└── lua/
    ├── config/
    │   ├── keymaps.lua     # Key bindings
    │   ├── options.lua     # Vim options
    │   └── lazy.lua        # Plugin manager setup
    └── plugins/            # Individual plugin configs

Plugin Categories #

Core #

lazy.nvim - Plugin manager
plenary.nvim - Lua utility library
nvim-web-devicons - File type icons

LSP & Completion #

nvim-lspconfig - LSP configuration
mason.nvim - LSP server installer
nvim-cmp - Completion engine
LuaSnip - Snippet engine

Fuzzy Finding #

telescope.nvim - Fuzzy finder framework
telescope-fzf-native - Native fzf integration
telescope-ui-select - UI selection enhancement

Git #

gitsigns.nvim - Git decorations in gutter
vim-fugitive - Git commands
diffview.nvim - Enhanced diff viewing

UI #

lualine.nvim - Status line
bufferline.nvim - Tab-like buffer line
nvim-tree.lua - File explorer
which-key.nvim - Keybinding helper
indent-blankline.nvim - Indentation guides

Editing #

nvim-treesitter - Syntax tree parser
vim-surround - Surround text objects
vim-commentary - Comment toggling
nvim-autopairs - Auto-close brackets
vim-sleuth - Automatic indentation detection

Themes #

tokyonight.nvim - Main color scheme

Key Concepts #

Lazy Loading #

Plugins are loaded on demand to improve startup time:

-- Load only when opening a file
{ "nvim-treesitter", event = "BufReadPost" }

-- Load on specific command
{ "neo-tree.nvim", cmd = "Neotree" }

-- Load on key mapping
{ "telescope.nvim", keys = { "<leader>ff", "<leader>fg" } }

LSP Setup #

Language servers are configured via mason and lspconfig:

require("mason").setup()
require("mason-lspconfig").setup({
    ensure_installed = { "lua_ls", "rust_analyzer", "pyright" }
})

Custom Keymaps #

All keymaps are in lua/config/keymaps.lua:

-- Leader key
vim.g.mapleader = " "

-- Quick save
vim.keymap.set("n", "<leader>w", "<cmd>w<cr>")

-- Better window navigation
vim.keymap.set("n", "<C-h>", "<C-w>h")
vim.keymap.set("n", "<C-j>", "<C-w>j")
vim.keymap.set("n", "<C-k>", "<C-w>k")
vim.keymap.set("n", "<C-l>", "<C-w>l")

Daily Workflow #

<leader>ff - Find files
<leader>fg - Live grep
<leader>fb - Find buffers
<leader>fh - Help tags

gd - Go to definition
gr - Go to references
gi - Go to implementation
K - Hover documentation

Git #

]c / [c - Next/previous hunk
<leader>hs - Stage hunk
<leader>hr - Reset hunk
<leader>hp - Preview hunk

Performance Tips #

Check startup time: nvim --startuptime startup.log
Profile plugins: :Lazy profile
Disable unused providers:

vim.g.loaded_python3_provider = 0
vim.g.loaded_ruby_provider = 0
vim.g.loaded_perl_provider = 0
vim.g.loaded_node_provider = 0

mise Tool Management

2026-02-07T00:00:00Z

mise is a universal version manager for development tools. It replaces separate version managers (nvm, pyenv, rbenv, etc.) with a single tool.

Why mise? #

One tool - Manage all languages and tools in one place
Fast - Written in Rust, activates in milliseconds
Compatible - Works with asdf plugins
Project-specific - Per-directory tool versions via .tool-versions

Installation #

curl https://mise.run | sh

Activate in your shell:

echo 'eval "$(~/.local/bin/mise activate zsh)"' >> ~/.zshrc

Configuration #

The main config is at mise/.config/mise/config.toml:

[settings]
idiomatic_version_file_enable_tools = ["ruby"]

[tools]
age = "latest"
argocd = "latest"
atuin = "latest"
bitwarden = "latest"
# ... more tools

Key Commands #

# Install all tools from config
mise install

# Install a specific tool
mise install node@20

# List installed tools
mise list

# Use a specific version in current directory
mise use node@20

# Run a command with a specific tool version
mise exec node@18 -- npm test

Tools Managed #

My setup includes:

Development #

neovim - Text editor
node - JavaScript runtime
pnpm - Package manager
uv - Python package manager

Kubernetes #

kubectl - Kubernetes CLI
helm - Package manager for K8s
k9s - Terminal UI for K8s
argocd - GitOps tool

Utilities #

fzf - Fuzzy finder
ripgrep - Fast grep alternative
fd - Fast find alternative
bat - Enhanced cat
eza - Modern ls replacement
delta - Syntax-highlighting pager for git
difftastic - Structural diff tool
direnv - Environment variable manager

Terminal #

starship - Shell prompt
zellij - Terminal multiplexer
tmux - Terminal multiplexer
lf - File manager
yazi - Alternative file manager

Git #

gitui - Terminal UI for git (primary)
lazygit - Alternative git TUI
github-cli - GitHub CLI
ripsecrets - Secret scanner

Media #

vhs - Terminal recording tool

Project-Specific Versions #

Create a .tool-versions file in project directories:

echo "nodejs 20.11.0" > .tool-versions
echo "python 3.11" >> .tool-versions

mise will automatically switch to these versions when you enter the directory.

lf

2026-02-07T00:00:00Z

lf is a terminal file manager written in Go, heavily inspired by ranger. It focuses on simplicity and speed with minimal dependencies.

lf demo

Features #

Fast - Written in Go, starts instantly
Minimal - Single binary, no runtime dependencies
Configurable - Shell commands for previews and custom actions
Mouse support - Optional mouse integration
Server mode - Remote file management via client/server

Setup #

Install via package manager:

# Via mise (recommended)
mise install lf

# Arch Linux
sudo pacman -S lf

# macOS
brew install lf

# Go install
go install github.com/gokcehan/lf@latest

Configuration #

Config file: ~/.config/lf/lfrc

Example configuration:

# Basic settings
set preview true
set drawbox true
set hidden true
set ignorecase true

# Key mappings
map gh cd ~
map g/ cd /
map E $$EDITOR $f

# Custom commands
map D delete
map x cut
map y copy
map p paste

# Previewer
set previewer ~/.config/lf/preview

Key Bindings #

Key	Action
`j/k` or `↓/↑`	Move down/up
`h/l` or `←/→`	Parent/child directory
`gg`	Go to top
`G`	Go to bottom
`H`	Back in history
`L`	Forward in history
`~`	Go to home

File Operations #

Key	Action
`Space`	Toggle selection
`y`	Yank (copy)
`d`	Cut
`p`	Paste
`D`	Delete
`r`	Rename
`a`	Create file
`A`	Create directory
`E`	Open with $EDITOR
`Enter`	Open file

View #

Key	Action
`.`	Toggle hidden files
`i`	Toggle preview
`zh`	Toggle hidden files

tmux Integration #

From .tmux.conf:

bind -n M-e display-popup -d '#{pane_current_path}' -h 100% -w 75% -x 0 -E "lf"

This opens lf in a popup window with Alt+E, starting in the current pane's directory.

lf in tmux popup workflow

Previews #

lf uses external programs for previews. Create ~/.config/lf/preview:

#!/bin/sh
case "$1" in
    *.txt|*.md) cat "$1" ;;
    *.jpg|*.png) viu "$1" ;;
    *) file "$1" ;;
esac

Shell Integration #

Add to ~/.zshrc:

lfcd () {
    tmp="$(mktemp)"
    lf -last-dir-path="$tmp" "$@"
    if [ -f "$tmp" ]; then
        dir="$(cat "$tmp")"
        rm -f "$tmp"
        [ -d "$dir" ] && [ "$dir" != "$PWD" ] && cd "$dir"
    fi
}

Then use lfcd to launch lf and automatically cd to the last visited directory on exit.

Lazygit

2026-02-07T00:00:00Z

Lazygit is a simple terminal UI for git commands that makes common git operations fast and visual.

Features #

Visual staging - Stage/unstage files with spacebar
Branch management - Create, checkout, merge branches easily
Conflict resolution - Interactive merge conflict handling
Commit history - Browse and search commits
Stash management - View and apply stashes
Custom commands - Add your own keybindings

Setup #

Install via package manager:

# Ubuntu/Debian
sudo add-apt-repository ppa:lazygit-team/release
sudo apt update
sudo apt install lazygit

# Arch Linux
sudo pacman -S lazygit

# macOS
brew install lazygit

# Via mise
mise install lazygit

Launching #

lazygit

Or from within a git repo:

lg  # If you have an alias

Key Bindings #

Global #

Key	Action
`?`	Help
`q`	Quit
`1-5`	Switch panel (Status, Files, Local Branches, Commits, Stash)
`R`	Refresh

Files Panel #

Key	Action
`Space`	Stage/unstage
`d`	Discard changes
`a`	Stage all
`A`	Unstage all
`c`	Commit
`C`	Commit with editor
`e`	Edit file

Branches Panel #

Key	Action
`c`	Checkout
`n`	New branch
`m`	Merge
`r`	Rebase
`d`	Delete

Commits Panel #

Key	Action
`s`	Squash
`r`	Reword
`d`	Drop
`e`	Edit
`p`	Pick

Custom Commands #

Add custom commands in ~/.config/lazygit/config.yml:

customCommands:
  - key: 'f'
    context: 'files'
    description: 'Fixup commit'
    command: 'git commit --fixup {{.SelectedLocalCommit.Sha}}'
    subprocess: true

kitty Terminal

2026-02-07T00:00:00Z

kitty is a fast, feature-rich, GPU-based terminal emulator that offloads rendering to the GPU for smooth performance.

Features #

GPU acceleration - Renders text using the GPU for better performance
Tabs and windows - Built-in multiplexing without needing tmux
Unicode support - Excellent support for emojis and international characters
Image support - Display images directly in the terminal
** kittens** - Extend functionality with Python scripts

Setup #

Install via package manager:

# Ubuntu/Debian
sudo apt install kitty

# Arch Linux
sudo pacman -S kitty

# macOS
brew install kitty

Or via mise:

mise install kitty

Configuration #

Config file: ~/.config/kitty/kitty.conf

Key settings from my config:

# Font
font_family      JetBrains Mono
font_size        12.0

# Opacity
background_opacity 0.95

# Cursor
cursor_shape     block
cursor_blink_interval 0

# Scrollback
scrollback_lines 10000

Key Bindings #

Key	Action
`Ctrl+Shift+Enter`	New window
`Ctrl+Shift+W`	Close window
`Ctrl+Shift+]`	Next window
`Ctrl+Shift+[`	Previous window
`Ctrl+Shift+T`	New tab
`Ctrl+Shift+Q`	Close tab
`Ctrl+Shift+Right`	Next tab
`Ctrl+Shift+Left`	Previous tab
`Ctrl+Shift+Up`	Scroll up
`Ctrl+Shift+Down`	Scroll down
`Ctrl+Shift+G`	Show last command output
`Ctrl+Shift+H`	Browse scrollback in less

kittens #

kittens are small Python programs that extend kitty:

# SSH with kitty enhancements
kitty +kitten ssh hostname

# Diff files with image support
kitty +kitten diff file1 file2

# Transfer files over SSH
kitty +kitten transfer file.txt remote:

Integration with tmux #

While kitty has its own multiplexing, I often use it with tmux for session persistence:

# Start kitty with tmux
kitty tmux

Window Management - Neovim Keybindings

2026-02-07T00:00:00Z

Split, arrange, and navigate editor windows. Keep multiple files visible and organized.

Keybindings #

Key	Mode	Description

Terminal Operations - Neovim Keybindings

2026-02-07T00:00:00Z

Access your shell without leaving your editor. Run commands and build tools.

Keybindings #

Key	Mode	Description

Workspace Tag Operations - Neovim Keybindings

2026-02-07T00:00:00Z

Jump between workspace tags and views. Organize windows.

Keybindings #

Key	Mode	Description

Search and Find - Neovim Keybindings

2026-02-07T00:00:00Z

Find anything in your project instantly. Search files, symbols, and text.

Keybindings #

Key	Mode	Description

Other - Neovim Keybindings

2026-02-07T00:00:00Z

Utility commands for productivity enhancements.

Keybindings #

Key	Mode	Description
	insert	:help i_CTRL-U-default
(fzf-normal)	terminal
(fzf-insert)	terminal
%	visual_select
@	visual_select	:help v_@-default
Q	visual_select	:help v_Q-default
[%	visual_select
]%	visual_select
a%	visual_select
g%	visual_select
gx	visual_select	Opens filepath or URI under cursor with the system handler (file explorer, web browser, …)
(MatchitVisualTextObject)	visual_select
(MatchitVisualMultiForward)	visual_select
(MatchitVisualMultiBackward)	visual_select
(MatchitVisualBackward)	visual_select
(MatchitVisualForward)	visual_select
%	operator_pending
[%	operator_pending
]%	operator_pending
g%	operator_pending
(MatchitOperationMultiForward)	operator_pending
(MatchitOperationMultiBackward)	operator_pending
(MatchitOperationBackward)	operator_pending
(MatchitOperationForward)	operator_pending
%	normal
&	normal	:help &-default
[%	normal
[	normal	Add empty line above cursor
[	normal	:ptprevious
[	normal	:lpfile
[	normal	:cpfile
]%	normal
]	normal	Add empty line below cursor
]	normal	:ptnext
]	normal	:lnfile
]	normal	:cnfile
g%	normal
gx	normal	Opens filepath or URI under cursor with the system handler (file explorer, web browser, …)
(fzf-normal)	normal
(fzf-insert)	normal
(MatchitNormalMultiForward)	normal
(MatchitNormalMultiBackward)	normal
(MatchitNormalBackward)	normal
(MatchitNormalForward)	normal
	normal	:help CTRL-L-default
%	visual
@	visual	:help v_@-default
Q	visual	:help v_Q-default
[%	visual
]%	visual
a%	visual
g%	visual
gx	visual	Opens filepath or URI under cursor with the system handler (file explorer, web browser, …)
(MatchitVisualTextObject)	visual
(MatchitVisualMultiForward)	visual
(MatchitVisualMultiBackward)	visual
(MatchitVisualBackward)	visual
(MatchitVisualForward)	visual

Navigation and Movement - Neovim Keybindings

2026-02-07T00:00:00Z

Move through your code efficiently. Jump between files, symbols, and references.

Keybindings #

Key	Mode	Description
	insert	vim.snippet.jump if active, otherwise
	insert	vim.snippet.jump if active, otherwise
	visual_select	vim.snippet.jump if active, otherwise
#	visual_select	:help v_#-default
*	visual_select	:help v_star-default
	visual_select	vim.snippet.jump if active, otherwise
[B	normal	:brewind
[b	normal	:bprevious
[T	normal	:trewind
[t	normal	:tprevious
[A	normal	:rewind
[a	normal	:previous
[L	normal	:lrewind
[l	normal	:lprevious
[Q	normal	:crewind
[q	normal	:cprevious
[D	normal	Jump to the first diagnostic in the current buffer
[d	normal	Jump to the previous diagnostic in the current buffer
]B	normal	:blast
]b	normal	:bnext
]T	normal	:tlast
]t	normal	:tnext
]A	normal	:last
]a	normal	:next
]L	normal	:llast
]l	normal	:lnext
]Q	normal	:clast
]q	normal	:cnext
]D	normal	Jump to the last diagnostic in the current buffer
]d	normal	Jump to the next diagnostic in the current buffer
	normal	Show diagnostics under the cursor
d	normal	Show diagnostics under the cursor
#	visual	:help v_#-default
*	visual	:help v_star-default
	select	vim.snippet.jump if active, otherwise
	select	vim.snippet.jump if active, otherwise

Media Controls - Neovim Keybindings

2026-02-07T00:00:00Z

Control playback and volume from your keyboard. Manage media.

Keybindings #

Key	Mode	Description

LSP and IntelliSense - Neovim Keybindings

2026-02-07T00:00:00Z

Navigate code like an IDE. Jump to definitions, view documentation, and fix errors.

Keybindings #

Key	Mode	Description
gra	visual_select	vim.lsp.buf.code_action()
gO	normal	vim.lsp.buf.document_symbol()
grt	normal	vim.lsp.buf.type_definition()
gri	normal	vim.lsp.buf.implementation()
grr	normal	vim.lsp.buf.references()
gra	normal	vim.lsp.buf.code_action()
grn	normal	vim.lsp.buf.rename()
gra	visual	vim.lsp.buf.code_action()

Layout Management - Neovim Keybindings

2026-02-07T00:00:00Z

Switch between window layouts. Optimize your workspace.

Keybindings #

Key	Mode	Description

Neovim Keybindings Reference

2026-02-07T00:00:00Z

Complete reference for Neovim keybindings organized by functional category.

Categories #

Navigation and Movement (36 keybindings)
Text Editing (9 keybindings)
LSP and IntelliSense (8 keybindings)
Other (58 keybindings)
Complete List (Alphabetical)

Git Operations - Neovim Keybindings

2026-02-07T00:00:00Z

Manage version control without leaving your editor. Stage, commit, diff, and browse history.

Keybindings #

Key	Mode	Description

File Operations - Neovim Keybindings

2026-02-07T00:00:00Z

Open, save, and manage files quickly. Browse your project structure.

Keybindings #

Key	Mode	Description

Text Editing - Neovim Keybindings

2026-02-07T00:00:00Z

Edit text faster with powerful selection, manipulation, and transformation commands.

Keybindings #

Key	Mode	Description
	insert	vim.lsp.buf.signature_help()
gc	visual_select	Toggle comment
	visual_select	vim.lsp.buf.signature_help()
gc	operator_pending	Comment textobject
Y	normal	:help Y-default
gcc	normal	Toggle comment line
gc	normal	Toggle comment
gc	visual	Toggle comment
	select	vim.lsp.buf.signature_help()

Client Window Operations - Neovim Keybindings

2026-02-07T00:00:00Z

Focus and manage application windows. Switch between programs.

Keybindings #

Key	Mode	Description

Awesome WM Core - Neovim Keybindings

2026-02-07T00:00:00Z

Control your window manager. Launch applications.

Keybindings #

Key	Mode	Description

Complete Keybindings List

2026-02-07T00:00:00Z

All keybindings across Neovim and Awesome WM environments, organized alphabetically for quick reference.

Neovim Keybindings #

Key	Mode	Description	Command
`#`	Visual	:help v_#-default	nil
`#`	Visual_select	:help v_#-default	nil
`%`	Normal		(MatchitNormalForward)
`%`	Operator_pending		(MatchitOperationForward)
`%`	Visual		(MatchitVisualForward)
`%`	Visual_select		(MatchitVisualForward)
`&`	Normal	:help &-default	:&&
`*`	Visual	:help v_star-default	nil
`*`	Visual_select	:help v_star-default	nil
`@`	Visual	:help v_@-default	mode() ==# 'V' ? ':normal! @'.getcharstr().'' : '@'
`@`	Visual_select	:help v_@-default	mode() ==# 'V' ? ':normal! @'.getcharstr().'' : '@'
`[`	Normal	Add empty line above cursor	nil
`[%`	Normal		(MatchitNormalMultiBackward)
`[%`	Operator_pending		(MatchitOperationMultiBackward)
`[%`	Visual		(MatchitVisualMultiBackward)
`[%`	Visual_select		(MatchitVisualMultiBackward)
`[<C-L>`	Normal	:lpfile	nil
`[<C-Q>`	Normal	:cpfile	nil
`[<C-T>`	Normal	:ptprevious	nil
`[a`	Normal	:previous	nil
`[A`	Normal	:rewind	nil
`[b`	Normal	:bprevious	nil
`[B`	Normal	:brewind	nil
`[D`	Normal	Jump to the first diagnostic in the current buffer	nil
`[d`	Normal	Jump to the previous diagnostic in the current buffer	nil
`[l`	Normal	:lprevious	nil
`[L`	Normal	:lrewind	nil
`[q`	Normal	:cprevious	nil
`[Q`	Normal	:crewind	nil
`[t`	Normal	:tprevious	nil
`[T`	Normal	:trewind	nil
`]`	Normal	Add empty line below cursor	nil
`]%`	Normal		(MatchitNormalMultiForward)
`]%`	Operator_pending		(MatchitOperationMultiForward)
`]%`	Visual		(MatchitVisualMultiForward)
`]%`	Visual_select		(MatchitVisualMultiForward)
`]<C-L>`	Normal	:lnfile	nil
`]<C-Q>`	Normal	:cnfile	nil
`]<C-T>`	Normal	:ptnext	nil
`]A`	Normal	:last	nil
`]a`	Normal	:next	nil
`]B`	Normal	:blast	nil
`]b`	Normal	:bnext	nil
`]D`	Normal	Jump to the last diagnostic in the current buffer	nil
`]d`	Normal	Jump to the next diagnostic in the current buffer	nil
`]L`	Normal	:llast	nil
`]l`	Normal	:lnext	nil
`]Q`	Normal	:clast	nil
`]q`	Normal	:cnext	nil
`]T`	Normal	:tlast	nil
`]t`	Normal	:tnext	nil
`a%`	Visual		(MatchitVisualTextObject)
`a%`	Visual_select		(MatchitVisualTextObject)
`g%`	Normal		(MatchitNormalBackward)
`g%`	Operator_pending		(MatchitOperationBackward)
`g%`	Visual		(MatchitVisualBackward)
`g%`	Visual_select		(MatchitVisualBackward)
`gc`	Normal	Toggle comment	nil
`gc`	Operator_pending	Comment textobject	nil
`gc`	Visual	Toggle comment	nil
`gc`	Visual_select	Toggle comment	nil
`gcc`	Normal	Toggle comment line	nil
`gO`	Normal	vim.lsp.buf.document_symbol()	nil
`gra`	Normal	vim.lsp.buf.code_action()	nil
`gra`	Visual	vim.lsp.buf.code_action()	nil
`gra`	Visual_select	vim.lsp.buf.code_action()	nil
`gri`	Normal	vim.lsp.buf.implementation()	nil
`grn`	Normal	vim.lsp.buf.rename()	nil
`grr`	Normal	vim.lsp.buf.references()	nil
`grt`	Normal	vim.lsp.buf.type_definition()	nil
`gx`	Normal	Opens filepath or URI under cursor with the system handler (file explorer, web browser, …)	nil
`gx`	Visual	Opens filepath or URI under cursor with the system handler (file explorer, web browser, …)	nil
`gx`	Visual_select	Opens filepath or URI under cursor with the system handler (file explorer, web browser, …)	nil
`Q`	Visual	:help v_Q-default	mode() ==# 'V' ? ':normal! @=reg_recorded()' : 'Q'
`Q`	Visual_select	:help v_Q-default	mode() ==# 'V' ? ':normal! @=reg_recorded()' : 'Q'
`Y`	Normal	:help Y-default	y$

Keybindings Reference

2026-02-07T00:00:00Z

Complete reference for all keybindings across Neovim and Awesome WM environments.

Environments #

Neovim Keybindings (112 keybindings)
Complete List (Alphabetical)

Dotfiles Overview

2026-02-07T00:00:00Z

Welcome to my personal dotfiles documentation. This is a collection of configurations that I've built up over years of tweaking my development environment to maximize productivity and minimize friction.

Philosophy #

These dotfiles follow a few core principles:

Minimal friction - Tools should get out of the way and let you work
Keyboard-centric - Mouse usage is minimized
Portable - Works across different machines and environments
Version controlled - Everything is tracked and reproducible

What's Included #

Shell & Terminal #

zsh Configuration - Primary shell with extensive customization
tmux Configuration - Terminal multiplexer for persistent sessions
kitty Terminal - GPU-accelerated terminal emulator
WezTerm - Cross-platform terminal emulator

Editors #

Neovim Configuration - Modal editor with extensive plugin ecosystem
Helix Editor - Post-modern modal editor

Window Management #

Hyprland Window Manager - Dynamic tiling Wayland compositor
Awesome Window Manager - Highly configurable X11 window manager

Development Tools #

mise Tool Management - Universal version manager for dev tools
Git Configuration - Version control configuration
gitui - Terminal UI for git (primary)
Lazygit - Alternative git TUI

Status & System #

Waybar - Highly customizable Wayland bar
Polybar - Fast and easy-to-use status bar

Utilities #

Atuin - Magical shell history
Starship Prompt - Minimal, fast shell prompt
fzf - Command-line fuzzy finder
lf - Terminal file manager
Yazi - Alternative file manager
Zellij - Terminal workspace with batteries included

Getting Started #

If you're interested in using any of these configurations, check out the Getting Started guide for installation and setup instructions.

Structure #

The dotfiles are organized by application, with each directory containing the relevant configuration files:

.
├── zsh/           # Shell configuration
├── tmux/          # Terminal multiplexer
├── nvim/          # Neovim configuration
├── hypr/          # Hyprland window manager
├── mise/          # Dev tool management
└── ...

Each tool has its own documentation page covering setup, key features, and customization options.

Contributing #

These are my personal configurations, but feel free to fork and adapt them for your own use. If you find bugs or have suggestions, issues and pull requests are welcome.

Hyprland Window Manager

2026-02-07T00:00:00Z

Hyprland is a dynamic tiling Wayland compositor that doesn't sacrifice on its looks. It provides smooth animations, great functionality, and an easy-to-use configuration.

Features #

Dynamic tiling - Windows tile automatically with no manual layouts
Wayland native - Modern protocol, better performance
Smooth animations - Beautiful window transitions
Layer shell - Status bars and notifications work properly
XWayland - Run X11 applications seamlessly

Setup #

Installation #

On Arch Linux:

sudo pacman -S hyprland

On other distributions, see the official installation guide.

Configuration #

Config files live in ~/.config/hypr/:

hyprland.conf - Main configuration
monitors.conf - Monitor layouts and resolutions
bindings.conf - Key bindings
autostart.conf - Applications to start on launch

Window Rules #

Applications automatically go to specific workspaces:

# Workspace assignments
windowrule = workspace 1, match:class ^(steam)$
windowrule = workspace 4, match:class ^(kitty)$
windowrule = workspace 5, match:class ^(firefox)$
windowrule = workspace 5, match:class ^(brave-browser)$
windowrule = workspace 6, match:class ^(signal)$
windowrule = workspace 8, match:class ^(brave-chat.openai.com__-Default)$
windowrule = workspace 9, match:class ^(org.prismlauncher.PrismLauncher)$

# Float certain windows
windowrule = float on, match:class ^(org.pulseaudio.pavucontrol)$
windowrule = float on, match:class ^(xdg-desktop-portal-gtk)$

Workspaces #

Workspaces are organized by function:

Workspace	Purpose
1	Steam/Games
2	Graphics (Krita)
3	General
4	Terminals
5	Web Browsers
6	Chat (Signal)
7	Media
8	Web Apps (ChatGPT, YouTube)
9	Minecraft
10	System

Default Key Bindings #

Hyprland uses a SUPER (Windows/Super) key modifier:

Window Management #

Key	Action
`SUPER+Q`	Close window
`SUPER+Shift+Q`	Force kill window
`SUPER+T`	Toggle floating
`SUPER+F`	Toggle fullscreen
`SUPER+J`	Toggle split direction

Key	Action
`SUPER+arrow keys`	Change window focus
`SUPER+Shift+arrow keys`	Move window
`SUPER+1-0`	Switch to workspace
`SUPER+Shift+1-0`	Move window to workspace

Mouse #

SUPER+LMB - Move window
SUPER+RMB - Resize window

Scripts #

Custom scripts in ~/.config/hypr/scripts/:

terminal.sh #

Launch terminal with specific rules:

#!/usr/bin/env bash
kitty --class=kitty

focus_or_launch.sh #

Focus a window if it exists, otherwise launch it:

#!/usr/bin/env bash
# Usage: focus_or_launch <class> <command>

toggle_waybar.sh #

Toggle the status bar visibility:

#!/usr/bin/env bash
killall -SIGUSR1 waybar

Autostart #

Applications started automatically:

# From autostart.conf
exec-once = waybar
exec-once = hyprpaper
exec-once = mako  # Notification daemon

Environment Variables #

Wayland-specific settings:

env = XDG_CURRENT_DESKTOP,Hyprland
env = XDG_SESSION_TYPE,wayland
env = XDG_SESSION_DESKTOP,Hyprland

Troubleshooting #

Applications won't launch #

Check if they're trying to use X11:

# Force XWayland for problematic apps
windowrule = xwayland, match:class ^(app-name)$

Ensure xdg-desktop-portal-hyprland is installed:

sudo pacman -S xdg-desktop-portal-hyprland

Helix Editor

2026-02-07T00:00:00Z

Helix is a post-modern modal text editor inspired by Kakoune. It features multiple cursors, tree-sitter integration, and a clean design.

Features #

Modal editing - Vim-like modal interface with improvements
Multiple cursors - Kakoune-style multiple selections
Tree-sitter - Built-in syntax highlighting and parsing
LSP support - Language Server Protocol integration
No plugins needed - Batteries included philosophy

Setup #

Install via package manager:

# Ubuntu/Debian
sudo add-apt-repository ppa:maveonair/helix-editor
sudo apt update
sudo apt install helix

# Arch Linux
sudo pacman -S helix

# macOS
brew install helix

# Via mise
mise install helix

Configuration #

Config file: ~/.config/helix/config.toml

Example configuration:

theme = "dracula"

[editor]
line-number = "relative"
mouse = false
cursorline = true
auto-save = true

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

[editor.file-picker]
hidden = false

Key Differences from Vim/Neovim #

Helix uses a selection-first approach:

Action	Vim	Helix
Select word	`viw`	`w`
Delete word	`diw`	`wd`
Change word	`ciw`	`wc`
Yank word	`yiw`	`wy`
Go to line	`G`	`gh`

Key Bindings #

Key	Mode	Action
`Space`	Normal	Command palette
`Space+f`	Normal	File picker
`Space+b`	Normal	Buffer picker
`Space+g`	Normal	Git picker
`Space+s`	Normal	Symbol picker
`Space+?`	Normal	Command picker
`Ctrl+s`	Any	Save
`Ctrl+c`	Normal	Comment line
`Ctrl+w`	Normal	Window commands

Multiple Cursors #

Helix excels at multiple selections:

% - Select all occurrences in file
s - Select matches in selection
C - Copy selection to next line
A-C - Copy selection to previous line
; - Collapse selection to cursor
Alt-; - Flip cursor and selection

gitui

2026-02-07T00:00:00Z

gitui is a blazing-fast terminal UI for git written in Rust. It provides a keyboard-driven interface for common git operations with minimal dependencies and excellent performance.

gitui staging workflow

Features #

Fast - Written in Rust, starts instantly
Keyboard-driven - No mouse required
Minimal dependencies - Single binary
Async operations - Non-blocking UI
Popup friendly - Works great in tmux popups

Setup #

Install via package manager:

# Via mise (recommended)
mise install gitui

# Arch Linux
sudo pacman -S gitui

# macOS
brew install gitui

# Cargo
cargo install gitui

Launching #

gitui

Or from within a git repo with Ctrl+G (from zsh config).

Key Bindings #

Global #

Key	Action
`?`	Help
`q`	Quit
`Tab`	Switch panel (Status, Log, Diff)
`1-3`	Jump to panel

Status Panel #

Key	Action
`↑/↓`	Navigate files
`Space`	Stage/unstage file
`Enter`	View diff
`a`	Stage all
`r`	Revert changes
`c`	Commit
`p`	Push
`f`	Pull/Fetch
`b`	Branch
`h`	Stash

Commit #

Key	Action
`c`	Open commit dialog
`Ctrl+s`	Submit commit
`Esc`	Cancel

Log Panel #

Key	Action
`↑/↓`	Navigate commits
`Enter`	View commit details
`r`	Revert commit
`e`	Edit past commit (rebase)

Branch #

Key	Action
`b`	Open branch list
`c`	Create branch
`d`	Delete branch
`m`	Merge branch
`Enter`	Checkout branch

tmux Integration #

From .tmux.conf:

bind -n M-F display-popup -h 95% -w 95% -d '#{pane_current_path}' -E 'gitui'

Opens gitui in a popup with Alt+Shift+F for full-screen git operations.

From .zshrc:

bindkey -s '^g' 'gitui\n'

Opens gitui with Ctrl+G in current shell.

Workflow #

Typical git workflow with gitui:

Edit files in neovim
Stage changes with Space in gitui
Review diff with Enter
Commit with c and write message
Push with p

All without leaving the terminal or using a mouse.

Comparison with lazygit #

gitui is my primary git TUI because:

Simpler - Less configuration needed
Faster - Smaller binary, quicker startup
Popup-friendly - Works great in tmux popups
Rust - Aligns with my other Rust tools

I keep lazygit installed as an alternative when I need more advanced features.

Git Configuration

2026-02-07T00:00:00Z

Git configuration optimized for daily development with useful aliases, improved diff viewing, and separate configs for work and personal projects.

Features #

Delta - Syntax-highlighted diffs and pager
Conditional includes - Different configs for work vs personal
Useful aliases - Shortcuts for common operations
Bat integration - Better file viewing

Setup #

Installation #

Git is typically pre-installed. For latest version:

# Ubuntu/Debian
sudo apt install git

# Arch Linux
sudo pacman -S git

# Via mise
mise install git

Configuration #

Main config at ~/.gitconfig:

[user]
    name = Waylon S. Walker
    email = waylon@waylonwalker.com
    signingkey = 66E2BF2B4190EFE4

[core]
    editor = nvim -c startinsert
    excludesfile = ~/.global-gitignore
    pager = bat --style=plain

Conditional Includes #

Different configurations for different directories:

[includeIf "gitdir:~/work/"]
    path = ~/.gitconfig-work

[includeIf "gitdir:~/git/"]
    path = ~/.gitconfig-git

Example ~/.gitconfig-work:

[user]
    email = waylon@company.com
    name = Waylon Walker

Key Settings #

Editor #

Opens nvim in insert mode for commit messages:

editor = nvim -c startinsert

Uses bat for better output:

pager = bat --style=plain
diff = bat --plain

Autocorrect #

Automatically fix typos after 1 second:

[help]
    autocorrect = 10

Aliases #

squash-all #

Squash entire branch history into single commit:

git squash-all "Initial commit"

Implementation:

squash-all = "!f(){ git reset $(git commit-tree HEAD^{tree} -m \"${1:-A new start}\");};f"

restage #

Restage already-staged files:

restage = !git diff --name-only --cached | xargs git add

Credentials #

Uses GitHub CLI for authentication:

[credential "https://github.com"]
    helper =
    helper = !gh auth git-credential

[credential]
    helper = store

Delta Integration #

Delta provides syntax highlighting for diffs:

[pager]
    diff = delta
    log = delta
    reflog = delta
    show = delta

[delta]
    features = side-by-side line-numbers decorations
    syntax-theme = Dracula

Default Behaviors #

[init]
    defaultBranch = main

[push]
    default = current

[pull]
    rebase = true

[rebase]
    autoStash = true

[commit]
    gpgsign = false

Global Gitignore #

A ~/.global-gitignore file excludes files across all repos:

# IDE
.idea/
.vscode/
*.swp
*~

# OS
.DS_Store
Thumbs.db

# Temporary
*.log
*.tmp
.env.local

Workflows #

Starting a New Project #

# Personal project
cd ~/git/new-project
git init
git add .
git commit -m "Initial commit"

# Work project (uses work email automatically)
cd ~/work/company-project
git init
git add .
git commit -m "Initial commit"

Cleaning Up History #

# Squash everything to one commit
git squash-all "Clean history"

# Push with force
git push --force-with-lease

GitHub CLI

2026-02-07T00:00:00Z

GitHub CLI (gh) is GitHub's official command-line tool that brings pull requests, issues, and other GitHub concepts to your terminal.

Features #

Pull requests - Create, view, checkout, and merge PRs
Issues - List, view, create, and close issues
Repositories - Clone, create, fork repos
Actions - View and monitor workflow runs
Codespaces - Manage cloud development environments
Gists - Create and manage gists

Setup #

Install via package manager:

# Via mise (recommended)
mise install github-cli

# Ubuntu/Debian
# Download from GitHub releases

# Arch Linux
sudo pacman -S github-cli

# macOS
brew install gh

Authentication #

# Login to GitHub
gh auth login

# Verify status
gh auth status

# Logout
gh auth logout

Repository Operations #

# Clone repository
gh repo clone owner/repo

# Create new repository
gh repo create my-project --public

# Fork repository
gh repo fork owner/repo

# View repository
gh repo view owner/repo --web

Pull Requests #

# Create PR
git push origin feature-branch
gh pr create --title "Add feature" --body "Description"

# List PRs
gh pr list
gh pr list --state merged

# View PR
gh pr view 123
gh pr view 123 --web

# Checkout PR locally
gh pr checkout 123

# Check PR status
gh pr status

# Merge PR
gh pr merge 123 --squash

Issues #

# List issues
gh issue list
gh issue list --state closed

# Create issue
gh issue create --title "Bug report" --body "Description"

# View issue
gh issue view 123
gh issue view 123 --web

# Close issue
gh issue close 123

# Comment on issue
gh issue comment 123 --body "Thanks for reporting"

Workflows #

# List workflow runs
gh run list

# View workflow run
gh run view 123456789

# Watch workflow run
gh run watch 123456789

# Re-run failed jobs
gh run rerun 123456789

Aliases #

Create shortcuts for common commands:

# Create alias
gh alias set pv 'pr view'
gh alias set co 'pr checkout'

# Use alias
gh pv 123
gh co 123

# List aliases
gh alias list

Configuration #

Config file: ~/.config/gh/config.yml

Example:

git_protocol: ssh
editor: nvim
prompt: enabled
pager: delta
aliases:
    co: pr checkout
    pv: pr view

Getting Started

2026-02-07T00:00:00Z

This guide will help you set up these dotfiles on your own machine.

Prerequisites #

You'll need the following installed:

Git
A terminal emulator (kitty, wezterm, or alacritty recommended)
zsh shell
curl or wget

Quick Setup #

1. Clone the Repository #

git clone https://github.com/waylonwalker/devtainer.git ~/devtainer
cd ~/devtainer

2. Install Tools #

The recommended way to install development tools is using mise Tool Management:

# Install mise
curl https://mise.run | sh

# Activate mise in your shell
echo 'eval "$(~/.local/bin/mise activate zsh)"' >> ~/.zshrc

# Install all tools from the config
mise install

3. Symlink Configurations #

Use stow or manual symlinks to install configs:

# Using stow (if available)
stow zsh starship tmux

# Or manually
ln -sf ~/devtainer/zsh/.zshrc ~/.zshrc
ln -sf ~/devtainer/tmux/.tmux.conf ~/.tmux.conf

Recommended Order #

Shell - Start with zsh for a better shell experience
Terminal - Install kitty or wezterm
Editor - Set up neovim with your preferred config
Multiplexer - Add tmux for session management
Window Manager - Hyprland (Wayland) or Awesome (X11)

Tool-Specific Setup #

Each tool has its own setup page:

[[zsh#setup|zsh Setup]]
[[tmux#setup|tmux Setup]]
[[neovim#setup|neovim Setup]]
[[hyprland#setup|hyprland Setup]]

Troubleshooting #

Config not loading #

Ensure symlinks are correct:

ls -la ~ | grep zshrc

Tool not found #

Check that mise is activated and tools are installed:

mise list
which zsh

Permission issues #

Some scripts may need executable permissions:

chmod +x ~/devtainer/scripts/*

Next Steps #

Once you have the basics set up, explore the individual tool documentation to learn about features and customization options.

fzf

2026-02-07T00:00:00Z

fzf is a general-purpose command-line fuzzy finder that integrates with shells and tools for fast file and command searching.

Features #

Fuzzy matching - Find items with approximate search
Fast - Written in Go, handles large lists
Flexible - Works with any list of text
Preview - Show previews of files and results
Scriptable - Easy to integrate in scripts

Setup #

Install via package manager:

# Via mise (recommended)
mise install fzf

# Ubuntu/Debian
sudo apt install fzf

# Arch Linux
sudo pacman -S fzf

# macOS
brew install fzf

Shell Integration #

Add to ~/.zshrc:

source <(fzf --zsh)

For bash:

eval "$(fzf --bash)"

Key Bindings #

Shell Integration #

Key	Action
`Ctrl+T`	Find files and insert path
`Ctrl+R`	Search command history
`Alt+C`	Find directories and cd
`Tab`	Complete paths with fzf

fzf Interface #

Key	Action
`Ctrl+J/K` or `Ctrl+N/P`	Navigate up/down
`Ctrl+H/L`	Move cursor left/right in query
`Enter`	Select item
`Esc`	Cancel
`Ctrl+U`	Clear query
`Tab`	Multi-select
`Shift+Tab`	Deselect
`?`	Toggle preview

Usage Examples #

Basic Usage #

# Find files
cat file_list.txt | fzf

# Find processes
ps aux | fzf

# Find git branches
git branch | fzf

With Preview #

# Preview files
fzf --preview 'cat {}'

# Preview with bat
fzf --preview 'bat --style=numbers --color=always {}'

# Preview directories
tree -C {} | head -200

Integration Examples #

# Edit file with neovim
nvim $(fzf)

# Kill process
kill -9 $(ps aux | fzf | awk '{print $2}')

# Checkout git branch
git checkout $(git branch | fzf | sed 's/* //')

# cd into directory
cd $(find . -type d | fzf)

Environment Variables #

# Default options
export FZF_DEFAULT_OPTS="--height 40% --layout=reverse --border"

# Default command
export FZF_DEFAULT_COMMAND='fd --type f --hidden --follow --exclude .git'

# Ctrl+T command
export FZF_CTRL_T_COMMAND="$FZF_DEFAULT_COMMAND"

# Alt+C command
export FZF_ALT_C_COMMAND='fd --type d --hidden --follow --exclude .git'

Delta

2026-02-07T00:00:00Z

Delta is a syntax-highlighting pager for git and diff output that makes code reviews more pleasant.

Features #

Syntax highlighting - Language-aware highlighting of diffs
Side-by-side view - Compare old and new versions
Git integration - Works as git pager
Customizable - Themes, colors, and layout options
Fast - Written in Rust

Setup #

Install via package manager:

# Via mise (recommended)
mise install delta

# Ubuntu/Debian
# Download .deb from GitHub releases

# Arch Linux
sudo pacman -S git-delta

# macOS
brew install git-delta

Git Integration #

Add to ~/.gitconfig:

[core]
    pager = delta

[interactive]
    diffFilter = delta --color-only

[delta]
    features = side-by-side line-numbers decorations
    syntax-theme = Dracula
    plus-style = "syntax #003800"
    minus-style = "syntax #3f0001"

[delta "decorations"]
    commit-decoration-style = bold yellow box ul
    file-style = bold yellow ul
    file-decoration-style = none
    hunk-header-decoration-style = cyan box ul

[delta "line-numbers"]
    line-numbers-left-style = cyan
    line-numbers-right-style = cyan
    line-numbers-minus-style = 124
    line-numbers-plus-style = 28

Usage #

Once configured, Delta works automatically:

# Any git diff command
git diff
git show
git log -p
git stash show -p

Standalone #

Use Delta with any diff:

diff -u file1 file2 | delta

Key Bindings (in less) #

Since Delta uses less as the pager:

Key	Action
`q`	Quit
`Space`	Page down
`b`	Page up
`/`	Search
`n/N`	Next/previous match
`g`	Go to top
`G`	Go to bottom

Themes #

Delta supports bat themes:

# List available themes
delta --list-themes

# Use specific theme
delta --syntax-theme=OneHalfDark

Features Options #

# Side-by-side vs unified
delta --side-by-side
delta --no-side-by-side

# Show/hide line numbers
delta --line-numbers
delta --no-line-numbers

# Navigate with n/N
delta --navigate

Defaults

2026-02-07T00:00:00Z

When I need a tool for a task, these are my default choices.

Editor #

Neovim - For everything text-related. See Neovim Configuration

Fallback: Helix Editor for quick edits when neovim config is broken.

Terminal #

kitty - Primary terminal. See kitty Terminal

Fallback: WezTerm when I need better cross-platform consistency.

Shell #

zsh - With autosuggestions, syntax highlighting, and starship prompt. See zsh Configuration

Multiplexer #

tmux - For persistent sessions and popup workflows. See tmux Configuration

Fallback: Zellij when I want built-in multiplexer without external tool.

Version Control #

git - With delta for diffs and gitui for UI. See Git Configuration

Tool Management #

mise - For all language runtimes and dev tools. See mise Tool Management

Replaced: pyenv, nvm, rbenv, and friends.

Fuzzy Finder #

fzf - Integrated with shell and editor. See fzf

File Manager #

lf - Fast terminal file manager. See lf

yazi - Alternative with async I/O. See Yazi

Fallback: Standard shell commands for simple operations.

Window Manager #

Hyprland - Wayland compositor on main machine. See Hyprland Window Manager

Fallback: Awesome Window Manager when I need X11.

Browser #

Brave - Primary browser with good privacy defaults.

Fallback: Firefox for testing and sites that break on Brave.

Search #

ripgrep (rg) - For code search

fd - For file finding

Both integrated with fzf.

Notes #

Plain markdown files in git repos.

Todo: tmux Configuration todo session with backlog/doing/done files.

Communication #

Email: Fastmail
Chat: Signal, occasionally Discord
Video: Jitsi, Zoom when required

Operating System #

Arch Linux - Main development machine

Ubuntu - For servers and containers

Why Defaults Matter #

Having defaults reduces decision fatigue. When I reach for a tool, I already know what to use. This lets me focus on the actual problem instead of evaluating options.

Uses

My default choices for tools and technologies

Colophon

2026-02-07T00:00:00Z

This site is built with modern, open-source tools. Here is what powers it.

Site Generator #

markata - A Python-based static site generator that processes markdown files with customizable hooks and plugins.

Hosting #

Static files served via Cloudflare Pages or similar CDN-based hosting.

Styling #

Custom CSS with a focus on readability and clean typography. No heavy frameworks - just semantic HTML and minimal styling.

Content Format #

All content is written in Markdown with YAML frontmatter:

---
date: '2026-02-07'
description: 'Page description'
published: true
title: 'Page Title'
---

Fonts #

Body: System font stack (native performance)
Code: JetBrains Mono or system monospace

Syntax Highlighting #

Code blocks are syntax-highlighted at build time using Pygments or similar.

Build Process #

Markdown files are processed by markata
Wikilinks are converted to internal links
Static HTML is generated
Deployed to CDN

Source #

The content and build configuration is available in the devtainer repository: github.com/waylonwalker/devtainer

Changelog

2026-02-07T00:00:00Z

Recent changes to my dotfiles and this documentation site.

2026-02-07 #

Added #

Created initial documentation site with markata
Added pages for all major tools (zsh, tmux, neovim, mise, git, etc.)
Generated keybinding references from actual configs
Created llms.txt for AI context
Added slash pages: /about, /colophon, /ai, /links, /yep, /nope, /uses, /defaults

Changed #

Migrated from scattered README files to structured documentation
Updated all internal links to use wikilink format
Improved keybinding descriptions to be benefit-focused

2025-01 #

Added #

Integrated atuin for shell history sync
Added gitui as primary git TUI
Added lf file manager configuration (primary)
Added yazi as alternative file manager
Switched to mise for tool management
Added zellij as alternative to tmux

Changed #

Moved from pyenv/nvm/rbenv to mise
Updated neovim config to use lazy.nvim
Refactored zsh configuration for faster startup

2024-12 #

Added #

Hyprland configuration for Wayland
Waybar configuration
Starship prompt configuration

Changed #

Migrated from X11/Awesome WM to Wayland/Hyprland on main machine
Updated terminal configuration for Wayland compatibility

2024-11 #

Added #

Delta integration for git diffs
Lazygit configuration
Custom workspace management scripts

Fixed #

Fixed tmux clipboard integration for Wayland
Resolved neovim LSP configuration issues

Older changes are tracked in the repository's git history.

Awesome Window Manager

2026-02-07T00:00:00Z

Awesome is a highly configurable, next-generation window manager for X11 written in Lua.

Features #

Dynamic tiling - Automatic window tiling with multiple layouts
Tag-based workspaces - Up to 9 virtual tags per screen
Lua configuration - Fully programmable in Lua
Low resource usage - Minimal memory and CPU footprint
Extensible - Widgets, menus, and themes via Lua

Setup #

Install via package manager:

# Ubuntu/Debian
sudo apt install awesome

# Arch Linux
sudo pacman -S awesome

# Fedora
sudo dnf install awesome

Configuration #

Config file: ~/.config/awesome/rc.lua

Key sections:

Tags - Virtual workspaces
Layouts - How windows are arranged
Key bindings - Keyboard shortcuts
Rules - Window behavior by application
Widgets - Status bar elements

Default Key Bindings #

Awesome uses Mod4 (Windows/Super key) as modifier:

Key	Action
`Mod4+Enter`	Open terminal
`Mod4+r`	Run prompt
`Mod4+Shift+q`	Quit Awesome
`Mod4+Ctrl+r`	Restart Awesome
`Mod4+j/k`	Focus next/previous window
`Mod4+Shift+j/k`	Swap with next/previous window
`Mod4+h/l`	Change master width
`Mod4+Space`	Next layout
`Mod4+Shift+Space`	Previous layout
`Mod4+1-9`	Switch to tag
`Mod4+Shift+1-9`	Move window to tag

Layouts #

Built-in layouts include:

tile - Master and stack layout
tile.left - Master on right
tile.bottom - Master on top
tile.top - Master on bottom
fair - Equal window sizes
max - Fullscreen
magnifier - Master magnified
floating - Free-form windows

Widgets #

Create custom widgets in Lua:

-- Clock widget
mytextclock = wibox.widget.textclock()

-- Battery widget
battery = awful.widget.watch(
    "acpi -b",
    30,
    function(widget, stdout)
        local status = stdout:match("Battery %d: (%a+), (%d+)%%")
        widget:set_text(" BAT: " .. status .. " ")
    end
)

Atuin

2026-02-07T00:00:00Z

Atuin replaces your existing shell history with a SQLite database and records additional context for better search and sync.

Features #

SQLite database - Fast, searchable history
Context - Records directory, exit code, duration
Sync - Encrypted sync across machines
Fuzzy search - Find commands easily
Stats - View command usage statistics

Setup #

Install via package manager:

# Via mise (recommended)
mise install atuin

# Or install script
curl --proto '=https' --tlsv1.2 -sSf https://setup.atuin.sh | sh

# Arch Linux
sudo pacman -S atuin

# macOS
brew install atuin

Shell Integration #

Add to ~/.zshrc:

eval "$(atuin init zsh)"

For bash, add to ~/.bashrc:

eval "$(atuin init bash)"

Key Bindings #

Key	Action
`Ctrl+R`	Open Atuin history search
`Up`	Search history by prefix
`Down`	Navigate results
`Enter`	Execute command
`Tab`	Edit command
`Alt+Enter`	Execute and keep open

Search #

Atuin provides powerful search:

# Fuzzy search
atuin search --interactive

# Search by directory
atuin search --cwd /path/to/project

# Search by exit code
atuin search --exit 0

# Search by time range
atuin search --after "2024-01-01"

Sync #

Sync history across machines:

# Register account
atuin register -u username -e email@example.com -p password

# Login
atuin login -u username -p password

# Sync
atuin sync

Stats #

View command statistics:

# Overall stats
atuin stats

# Stats for specific command
atuin stats --cmd git

# Daily stats
atuin stats -d

Configuration #

Config file: ~/.config/atuin/config.toml

Example:

sync_address = "https://api.atuin.sh"
sync_frequency = "10m"
search_mode = "fuzzy"
style = "compact"
inline_height = 10
show_preview = true

AI

2026-02-07T00:00:00Z

The content on this site is primarily AI-generated, but it documents dotfiles I've spent over a decade hand-curating. I've always wanted to create this documentation site but never took the time until AI made it possible.

My Approach #

AI as a multiplier, not a replacement. These dotfiles represent years of careful tuning and personal preference. AI helps me document them, but the configurations themselves are the result of a decade of refinement.

Tools I Use #

Code Assistants #

opencode - AI agent in my terminal for development tasks
GitHub Copilot - Inline code suggestions in my editor
ChatGPT - For brainstorming, debugging, and research

Writing #

AI assistance - For generating documentation from my configs
Grammar/spell check - AI-enhanced proofreading

Image Generation #

Occasionally for diagrams and illustrations when needed

Principles #

Hand-curated configs - The dotfiles are mine, refined over 10+ years
AI for documentation - AI helps explain and organize what I've built
Review all AI output - I verify everything before publishing
Use AI for tedious tasks - Documentation, formatting, and organization

On This Site #

Most content on this site is AI-generated:

Documentation written from my configuration files
Keybinding references extracted from my configs
Explanations of how tools work together
Organization and structure of the site

All content is based on my actual dotfiles and reviewed by me before publishing.

AI and My Dotfiles #

AI now heavily helps me:

Create documentation I never had time to write
Debug configuration issues faster
Develop new features and improvements
Organize years of accumulated configuration

Without AI assistance, this site would not exist. The configurations themselves are the product of years of personal refinement, but the documentation that makes them accessible is AI-enabled.

Defaults