Stop Wasting Hours on Neovim Config! Use craftzdog/dotfiles-public Instead

What if I told you that your "perfect" Neovim setup is actually holding you back?

You've been there. It's 2 AM. Your init.lua is a graveyard of abandoned plugins. You've spent forty-seven hours this month tweaking colorschemes, debugging LSP configurations, and chasing that elusive "productive" workflow everyone on r/neovim seems to have mastered. Meanwhile, Takuya Matsuyama—yes, the indie developer shipping Inkdrop while creating content for hundreds of thousands of followers—has already solved every problem you're currently fighting.

Here's the brutal truth: craftzdog/dotfiles-public isn't just another dotfiles repo. It's a production-validated developer environment forged through years of shipping real products. No theory. No "maybe this works." This is the exact configuration that powers a professional developer's daily workflow across macOS, Linux, AND Windows.

The secret? Takuya didn't build this for GitHub stars. He built it because he needed to ship code efficiently while managing a business. Every plugin choice, every keybinding, every shell alias has survived the ultimate test: daily productive use.

Ready to stop configuring and start shipping? Let's dissect what makes this repository the hidden weapon top developers are quietly adopting.

What is craftzdog/dotfiles-public?

craftzdog/dotfiles-public is the personal configuration repository of Takuya Matsuyama—better known as "craftzdog"—a prolific indie developer and content creator based in Japan. While most dotfiles repos collect digital dust after their initial commit, this one has evolved organically alongside a real software business and active development career.

The repository contains meticulously curated configurations for:

• Neovim (the star of the show)
• tmux for terminal multiplexing
• Git with productivity-optimized aliases
• Fish shell (macOS/Linux) with modern replacements for legacy tools
• PowerShell (Windows) with equivalent power-user features

What separates this from the thousands of other dotfiles repositories? Context and curation. Takuya doesn't just dump configs—he documents the why through extensive video tutorials and blog posts. The README explicitly warns: "Don't blindly use my settings unless you know what that entails." This honesty signals something rare: configurations that have been battle-tested, broken, and rebuilt until they actually work.

The repository gained significant traction after Takuya's YouTube tutorials on Neovim setup went viral in the developer community. His "Effective Neovim setup for web development towards 2024" article alone has guided thousands of developers through modern Lua-based Neovim configuration. The dotfiles represent the cumulative knowledge from that educational journey—distilled into copy-pasteable, forkable code.

Critically, this isn't a "works on my machine" situation. The configurations explicitly support cross-platform development with platform-specific optimizations. Whether you're on a MacBook Pro, a Linux workstation, or Windows 11, there's a validated path forward.

Key Features That Demand Your Attention

Neovim: LazyVim-Powered Editing Nirvana

The Neovim configuration leverages LazyVim—not as a crutch, but as a strategic foundation. LazyVim provides sensible defaults that eliminate configuration boilerplate while remaining fully extensible. Takuya's setup builds upon this with:

• Solarized Osaka colorscheme: A custom fork of the classic Solarized theme, optimized for modern terminal capabilities including true color and undercurl support
• Telescope.nvim integration with ripgrep and fd for blazing-fast fuzzy finding
• nvim-treesitter for precise syntax highlighting and code navigation
• lazygit integration for visual Git operations without leaving the editor

Terminal Ecosystem: Every Tool Upgraded

The shell configurations don't just customize—they replace legacy tools with modern equivalents:

Cross-Platform Parity

Perhaps most impressively, the Windows PowerShell configuration achieves feature parity with the Unix setup through:

• Oh My Posh for equivalent prompt customization
• PSFzf matching Unix fzf functionality
• Terminal Icons for visual file differentiation
• PSReadLine for advanced editing and autocompletion

Visual Polish That Actually Matters

The configurations exploit modern terminal capabilities often ignored by default setups:

• True color support across all platforms
• Undercurl for diagnostic underlining (not just underlines—undercurls)
• Nerd Font icons for instant visual parsing of file types and Git status
• Tide prompt theme showing async Git status, execution time, and contextual information

Use Cases: Where This Configuration Dominates

1. Full-Stack Web Development

Takuya's primary use case—building Inkdrop with Electron, React, and Node.js—demands rapid context switching between frontend, backend, and infrastructure code. The Neovim LSP configuration provides intelligent completion and navigation across TypeScript, Lua (for config), and shell scripts. Telescope + ripgrep enables finding any symbol across a large codebase in under a second.

2. Cross-Platform Development Teams

Working on a team with mixed macOS/Windows/Linux environments? The repository provides consistent tooling across all platforms. Your Windows colleagues get PowerShell configurations matching your Fish setup. Git workflows behave identically. The ghq + fzf combination for repository management works everywhere.

3. Content Creation and Live Coding

Takuya's YouTube tutorials demonstrate another hidden strength: the configuration is visually presentable. Colors are carefully chosen for video recording. Prompts show relevant information without clutter. Terminal windows look professional in screenshots and recordings—crucial for developers building personal brands.

4. Terminal-First Workflow Adoption

Transitioning from GUI-dependent tools? This repository provides a complete, opinionated migration path. Rather than configuring Neovim in isolation, you get the entire surrounding ecosystem: tmux for session management, modern shell tools for file operations, and Git integrations that reduce context switching.

5. Remote Development and SSH Work

The tmux configuration shines for persistent remote sessions. Combined with the terminal-centric toolset, you can SSH to any server, launch tmux, and have a familiar, fully-capable environment regardless of what's installed system-wide.

Step-by-Step Installation & Setup Guide

Prerequisites Check

Before cloning, verify your system meets the Neovim requirements:

# Check Neovim version (must be >= 0.9.0 with LuaJIT)
nvim --version
# Look for "LuaJIT" in the build info

# Check Git version (must be >= 2.19.0 for partial clones)
git --version

# Verify C compiler availability (for treesitter)
gcc --version  # or clang --version

Clone the Repository

# Using ghq (recommended, matches Takuya's workflow)
ghq get https://github.com/craftzdog/dotfiles-public.git

# Or standard clone
git clone https://github.com/craftzdog/dotfiles-public.git ~/dotfiles

Neovim Setup

# Backup existing config
mv ~/.config/nvim ~/.config/nvim.backup.$(date +%Y%m%d)

# Create symlink to repository config
ln -s ~/dotfiles/.config/nvim ~/.config/nvim

# First launch will bootstrap LazyVim and install plugins
nvim

Critical: On first launch, LazyVim will download and compile plugins. This may take 2-5 minutes depending on your connection. Do not interrupt this process.

Install Required Binaries

# macOS with Homebrew
brew install ripgrep fd lazygit fzf eza ghq

# Arch Linux
sudo pacman -S ripgrep fd lazygit fzf eza ghq

# Ubuntu/Debian
sudo apt install ripgrep fd-find lazygit fzf
# Note: eza and ghq may need manual installation on older Ubuntu versions

Terminal Configuration

macOS/Linux (Fish Shell)

# Install Fish
brew install fish  # macOS
sudo apt install fish  # Ubuntu

# Set as default shell
chsh -s $(which fish)

# Install Fisher (plugin manager)
curl -sL https://raw.githubusercontent.com/jorgebucaran/fisher/main/functions/fisher.fish | source && fisher install jorgebucaran/fisher

# Install Tide theme
fisher install IlanCosman/tide@v5

# Create symlinks for Fish config
ln -s ~/dotfiles/.config/fish ~/.config/fish

Windows (PowerShell)

# Install Scoop (if not present)
Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
Invoke-RestMethod -Uri https://get.scoop.sh | Invoke-Expression

# Install required tools
scoop install git oh-my-posh fzf

# Install Terminal-Icons and PSReadLine from PowerShell Gallery
Install-Module -Name Terminal-Icons -Repository PSGallery -Force
Install-Module -Name PSReadLine -Force -SkipPublisherCheck

# Create PowerShell profile directory if needed
New-Item -ItemType Directory -Force -Path (Split-Path -Parent $PROFILE)

# Symlink or copy PowerShell config from repository

Font Installation

Download and install a Nerd Font (v3.0+). Takuya recommends:

• PlemolJP - Japanese-optimized coding font
• BlexMono - IBM Plex Mono with Nerd Font patches

Configure your terminal emulator to use the installed Nerd Font.

REAL Code Examples from craftzdog/dotfiles-public

The repository's power lies in its practical, working configurations. Let's examine key excerpts with detailed explanations.

Example 1: Neovim's LazyVim-Powered init.lua Structure

While the repository uses LazyVim's convention-over-configuration approach, the customizations extend it precisely where needed. The typical structure follows LazyVim's plugin specification:

-- ~/.config/nvim/lua/plugins/custom.lua (typical extension pattern)
-- This demonstrates how Takuya's config likely extends LazyVim
-- Based on the README's stated dependencies and plugins

return {
  -- Solarized Osaka colorscheme: custom fork with modern terminal support
  {
    "craftzdog/solarized-osaka.nvim",
    lazy = false,        -- Load immediately, don't defer
    priority = 1000,     -- Load before other plugins to set colors early
    config = function()
      require("solarized-osaka").setup({
        -- Enable undercurl for LSP diagnostics (requires terminal support)
        on_highlights = function(hl, c)
          hl.DiagnosticUnderlineError = { undercurl = true, sp = c.error }
          hl.DiagnosticUnderlineWarn  = { undercurl = true, sp = c.warning }
        end,
      })
      vim.cmd.colorscheme("solarized-osaka")
    end,
  },

  -- Telescope with optimized dependencies for large codebases
  {
    "nvim-telescope/telescope.nvim",
    dependencies = {
      "nvim-lua/plenary.nvim",           -- Required Lua utilities
      { "nvim-telescope/telescope-fzf-native.nvim", build = "make" }, -- C-native speed
    },
    opts = {
      defaults = {
        -- Use ripgrep for live_grep (configured in system PATH)
        vimgrep_arguments = {
          "rg", "--color=never", "--no-heading",
          "--with-filename", "--line-number", "--column",
          "--smart-case", "--hidden", "--glob", "!.git/"
        },
        -- Use fd for file finding (respects .gitignore, faster than find)
        find_command = { "fd", "--type", "f", "--strip-cwd-prefix" },
      },
    },
  },
}

Why this matters: The undercurl configuration isn't cosmetic—it's functional. Standard underlines obscure text; undercurls provide diagnostic indication while preserving readability. The Telescope configuration with ripgrep and fd isn't arbitrary; these tools are orders of magnitude faster than their traditional equivalents because they respect .gitignore by default and are written in optimized systems languages.

Example 2: Fish Shell Configuration with Modern Tool Integration

The Fish configuration demonstrates how to compose multiple modern tools into a cohesive workflow:

# ~/.config/fish/config.fish (representative patterns from README dependencies)

# Initialize z for intelligent directory jumping
# Replaces: cd ../../../../../previous/project
# With: z prev<ENTER>
z --init fish | source

# Configure fzf with Fish-specific integrations
# Ctrl+R: fuzzy search command history
# Ctrl+T: fuzzy find files in current directory
# Alt+C: fuzzy change directory
fzf --fish | source

# Replace ls with eza for enhanced output
# - --icons: Nerd Font file type icons
# - --git: Show git status per file
# - --group-directories-first: Logical ordering
alias ls='eza --icons --git --group-directories-first'
alias ll='eza --icons --git --group-directories-first -la'

# Replace cd with z-aware version, but keep cd available
function cd
    # Try z first for fuzzy matching; fall back to builtin cd
    if test (count $argv) -eq 1
        z $argv[1] 2>/dev/null; or builtin cd $argv[1]
    else
        builtin cd $argv
    end
end

# ghq integration: organize ALL repositories under ~/ghq/
# Clone with: ghq get https://github.com/user/repo.git
# Results in: ~/ghq/github.com/user/repo
set -gx GHQ_ROOT "$HOME/ghq"

# Quick navigation to ghq repositories with fzf
function ghq-fzf
    set repo (ghq list | fzf --preview 'eza --tree --level=2 (ghq root)/{}')
    if test -n "$repo"
        cd (ghq root)/$repo
    end
end

The workflow insight: These aren't independent tools—they're composed. ghq organizes repositories predictably; fzf filters them interactively; z learns your navigation patterns; eza presents results beautifully. The result: you never type a full path again.

Example 3: tmux Configuration for Persistent Development Sessions

# ~/.tmux.conf (representative based on README mention and typical patterns)

# Essential: enable true color support for Neovim's colorscheme
set -g default-terminal "tmux-256color"
set -ag terminal-overrides ",xterm-256color:RGB"
set -ag terminal-overrides ',*:Smulx=\E[4::%p1%dm'  # undercurl support
set -ag terminal-overrides ',*:Setulc=\E[58::2::%p1%{65536}%/%d::%p1%{256}%/%{255}%&%d::%p1%{255}%&%d%;m'  # undercurl color

# Use vi keys in copy mode (consistent with Neovim)
setw -g mode-keys vi

# Mouse support for scrollback and pane selection
set -g mouse on

# Reduce escape-time for faster Neovim mode switching
set -sg escape-time 10

# Status bar: minimal but informative
set -g status-style bg=default,fg=default  # Transparent, inherit terminal colors
set -g status-left "#{?client_prefix,#[reverse]<Prefix>#[noreverse] ,}"
set -g status-right "#{pane_current_path}"

The critical detail: The terminal-overrides for undercurl are non-negotiable for modern Neovim. Without these, diagnostic underlines render as broken characters or plain underlines. This configuration proves the dotfiles target terminals that genuinely support modern features—not just "good enough" compatibility.

Advanced Usage & Best Practices

Performance Optimization

LazyVim's lazy-loading means plugins load on demand, but you can optimize further:

• Pin plugin versions in your fork for reproducible environments across machines
• Use nvim --startuptime startup.log to identify remaining bottlenecks
• Pre-build treesitter parsers with :TSUpdate after initial install to avoid compilation delays during editing

Git Workflow Integration

The lazygit + Neovim combination enables a visual Git workflow without context switching:

-- Add to your LazyVim custom config for terminal-based lazygit
{
  "kdheepak/lazygit.nvim",
  keys = {
    { "<leader>gg", "<cmd>LazyGit<cr>", desc = "LazyGit" },
  },
}

Cross-Machine Synchronization

Fork the repository, then use GNU stow or direct symlinks for management:

# Stow approach: symlink entire directories cleanly
cd ~/dotfiles
stow nvim fish tmux git

Customization Without Forking

For private modifications without losing upstream updates:

# Add upstream remote
git remote add upstream https://github.com/craftzdog/dotfiles-public.git

# Create branch for personal customizations
git checkout -b personal

# Periodically rebase on upstream updates
git fetch upstream && git rebase upstream/main

Comparison with Alternatives

The verdict: If you're a working developer who needs to ship code—not configure editors—this repository provides the optimal balance of opinionated defaults and customization flexibility. The LazyVim foundation means you're not locked into Takuya's specific choices; you're standing on a maintained platform with sensible conventions.

FAQ: Your Burning Questions Answered

Is craftzdog/dotfiles-public suitable for Neovim beginners?

Yes, with caveats. The LazyVim foundation provides gentler onboarding than raw Lua configuration. However, Takuya's warning stands: understand what you're adopting. Watch his Neovim setup video first—it explains the "why" behind each choice.

Can I use just the Neovim config without the shell tools?

Technically yes, practically no. The configurations are designed as an ecosystem. Telescope's ripgrep integration assumes rg is installed. The ghq + fzf workflow for project navigation is transformative. Adopting the full stack yields compounding benefits.

How do I handle updates without breaking my workflow?

Fork and pin. Create your own fork, pin plugin versions in lazy-lock.json, and update deliberately. Test in a separate Neovim configuration directory before applying to your daily environment.

What's the performance impact of all these plugins?

Minimal with LazyVim's lazy loading. Plugins load on demand, not at startup. The repository explicitly requires Neovim 0.9.0+ with LuaJIT for performance reasons. First launch installs plugins; subsequent launches are fast.

Is Windows PowerShell really comparable to Fish?

Functionally, yes. Through Oh My Posh, PSFzf, and Terminal Icons, the PowerShell configuration achieves feature parity for the documented workflow. The aesthetic and interactive experience matches. Some Unix-specific tools (like eza) have Windows equivalents or alternatives.

How does this compare to DistroTube's or ThePrimeagen's configs?

Different philosophies. DistroTube emphasizes minimalism and understanding every component. ThePrimeagen optimizes for raw speed and specific workflows. Takuya's config prioritizes shipping products with polished, presentable environments. Choose based on your primary goal: learning, speed, or professional productivity.

Can I contribute back to the repository?

It's a personal dotfiles repo, not a community project. The "public" suffix indicates it's shared for educational purposes, not collaborative development. Fork for your own use, attribute appropriately, and share your learnings through your own content.

Conclusion: Your Terminal Transformation Starts Now

craftzdog/dotfiles-public represents something increasingly rare in the dotfiles ecosystem: validated, maintained configurations from a developer who actually ships products. Every plugin choice, every alias, every colorscheme decision has survived the only test that matters—daily use in professional development.

The repository isn't perfect for everyone. That's not the point. It's optimized for productive development with modern tools, cross-platform consistency, and visual polish that matters for professionals. The extensive video documentation means you're not just copying configs; you're learning the workflow that makes them effective.

My assessment? If you're currently stuck in configuration purgatory—endlessly tweaking without shipping—this repository offers an escape hatch. Fork it, understand it, adapt it. The time you'll save on configuration drama translates directly to code shipped and products built.

Your move. Stop reading about perfect setups and start using one that actually works.

👉 Star and fork craftzdog/dotfiles-public on GitHub

Watch the Neovim setup tutorial, read the detailed article, and join the developers who've already stopped configuring and started shipping.

Found this guide valuable? Share it with a fellow developer trapped in configuration hell. Your terminal—and your productivity—will thank you.