DEV Community

Tony Miller
Tony Miller

Posted on • Edited on

Achieving 30ms Zsh Startup

#zsh #performance #nvm #dotfiles

Me and Claude went on a dotfiles journey the other day...

The Flex 💪 

🍎 time zsh -i -c exit zsh -i -c exit 0.02s user 0.01s system 87% cpu 0.033 total
Enter fullscreen mode Exit fullscreen mode

33 milliseconds. That's faster than most people can blink. While others wait half a second
for their shell to load, we're already productive.

The Challenge

Most zsh configurations suffer from slow startup times ranging from 200ms to 500ms or more. Heavy frameworks like Oh-My-Zsh can push startup times beyond 1 second. Our goal was to achieve blazingly
fast shell initialization while maintaining full functionality for a modern development environment.

The Result

Final startup time: 33ms - putting us in the top 0.1% of shell performance.

Core Optimization Strategy

1. KISS Philosophy: Single-File Architecture

Instead of fragmenting configuration across multiple files, we organized everything within .zshrc using clear section headers:

### BREW ### FZF  ### COMPLETIONS ### NVM ### DOCKER ### KUBE ### PYTHON ### RUBY
Enter fullscreen mode Exit fullscreen mode

This eliminates the overhead of sourcing multiple files while keeping code organized and maintainable.

2. Aggressive Lazy Loading

The biggest performance wins came from deferring expensive operations until actually needed:

NVM (Node Version Manager) 

load_nvm() { unset -f npm npx yarn nvm load_nvm 2>/dev/null || true [ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh" [ -s "$NVM_DIR/bash_completion" ] && \."$NVM_DIR/bash_completion" } npm() { load_nvm; npm "$@"; } npx() { load_nvm; npx "$@"; } yarn() { load_nvm; yarn "$@"; } nvm() { load_nvm; nvm "$@"; }
Enter fullscreen mode Exit fullscreen mode

Python Environment (pyenv) 

function load_pyenv() { if command -v pyenv &> /dev/null; then eval "$(pyenv init --path)" eval "$(pyenv init - --no-rehash)" if which pyenv-virtualenv-init > /dev/null; then eval "$(pyenv virtualenv-init -)" fi pyenv virtualenvwrapper unset -f load_pyenv fi } alias pyenv='load_pyenv && pyenv'
Enter fullscreen mode Exit fullscreen mode

The Fuck (command correction) 

function init_thefuck() { unalias fuck unset -f init_thefuck eval $(thefuck --alias) fuck } alias fuck="init_thefuck"
Enter fullscreen mode Exit fullscreen mode

3. Strategic Performance Settings

Completion Optimization 

# Fast completion initialization compinit -C # Skip security checks for speed # Completion caching zstyle ':completion:*' use-cache on zstyle ':completion:*' cache-path ~/.zsh/cache zstyle ':completion:*' accept-exact '*(N)'
Enter fullscreen mode Exit fullscreen mode

Disable Expensive Features 

# Turn off features that slow startup unsetopt AUTO_CD unsetopt AUTO_PUSHD unsetopt PUSHD_IGNORE_DUPS unsetopt FLOW_CONTROL
Enter fullscreen mode Exit fullscreen mode

4. Smart Git Branch Caching

Instead of running git commands on every prompt render, we cache branch information:

function git_ps1 { if ! git rev-parse --is-inside-work-tree >/dev/null 2>&1; then return fi # Use cached branch info if [[ -n $GIT_BRANCH_CACHE ]]; then echo -n "($GIT_BRANCH_CACHE)" else local branch=$(git rev-parse --abbrev-ref HEAD 2>/dev/null) if [[ -n $branch && $branch != "HEAD" ]]; then export GIT_BRANCH_CACHE="$branch" echo -n "($branch)" fi fi } # Clear cache when changing directories function git_branch_cache_clear() { unset GIT_BRANCH_CACHE } add-zsh-hook chpwd git_branch_cache_clear
Enter fullscreen mode Exit fullscreen mode

5. Conditional Loading

Only load completions and tools that are actually installed:

### KUBE if command -v kubectl &> /dev/null; then source <(kubectl completion zsh) fi ### DOCKER if command -v docker &> /dev/null; then fpath=("$HOME/.docker/completions" $fpath) fi
Enter fullscreen mode Exit fullscreen mode

6. Smart Hooks

Use hooks sparingly and efficiently:

# Auto-load NVM when entering projects with .nvmrc maybe_nvm_after_cd() { local dir dir=$(pwd) while [ "$dir" != "/" ]; do if [ -f "$dir/.nvmrc" ]; then load_nvm nvm use 2>/dev/null || true return fi dir=$(dirname "$dir") done } add-zsh-hook chpwd maybe_nvm_after_cd
Enter fullscreen mode Exit fullscreen mode

Key Principles Applied

  1. Lazy Everything: Defer expensive operations until needed
  2. Cache Aggressively: Store computation results and reuse them
  3. Conditional Loading: Only load what's installed and needed
  4. Single File: Avoid sourcing overhead by keeping everything in one organized file
  5. Profile and Measure: Use time zsh -i -c exit to validate improvements

What We Avoided

  • Oh-My-Zsh: Adds 200-400ms overhead
  • Multiple sourced files: Each source adds ~5-10ms
  • Synchronous tool initialization: NVM, pyenv, etc. add 50-200ms each
  • Complex prompt calculations: Git status checks on every render
  • Unnecessary zsh options: Many defaults are performance killers

The Outcome

With these optimizations, we achieved:

  • 33ms startup time (top 0.1% performance)
  • Full development environment (Node, Python, Docker, Kubernetes)
  • Rich completions for all tools
  • Maintainable single-file configuration
  • Zero functionality compromised

The key insight: aggressive lazy loading combined with smart caching and conditional execution can
deliver both speed and functionality without compromise.

Full config

Top comments (0)