Native · Rust on GPUI · macOS / Windows / Linux

Every branch,
drawn before
you blink.

A very fast, native Git client. switchhead reads history in process with gitoxide, streams the commit graph while it is still being read, and runs every change through your own git, so hooks, credential helpers, SSH agents, signing and LFS behave exactly like the command line.


      
    

    

  


  

    
94ms
first graph rows on git/git, 85,000+ commits

    
1.3s
whole history laid out, about 2× faster than git log --all --date-order

    
0
process spawns on hot paths: log, graph, refs and diffs read in process

    
1
Rust binary, GPU-rendered. No Electron, no web view.

  







  

    Live sample · themed by the picker · click a commit
    

  


  

    

      
      Repositories
      switchhead main×
      switchyard main×
      +
    

    

      Fetch
      Pull
      Push
      
      Stash
      Pop
      Branch
      
      Refresh
      Terminal
      Assistant
    

    

      

        
        
        
        
      

      
      

        

          Graph
          Description
          AllCurrent
          Head
          Author
          Date
          Commit
        

        

        

          

          

        

      

    

    

      main
      
      0 commits
      reading…
      ~/code/switchhead
    

  

  
A replica built from the app's own palettes and lane colors. The rows stream in batches like the real log walk; use ↑ ↓ to move.







  Works with
  






  

    
A tour of the graph.

    
Twenty screens from the app as it is today, from the commit graph to the reflog. Click a shot to see it full size.

  

  

    
    
    
    
      
      
    
    
    
  
    

    



    
  
    How it stays fast
    
  
    Reads in process.
    Writes through git.
    
  
    The two halves of a Git client want opposite things. Reading history wants raw speed; changing a repository wants to behave exactly like your terminal. switchhead does both on purpose.
    
  
    
    
    
      
    gitoxide · in process
    
      
    Read
    
      
      
        
    • Log walk in date order with the commit-graph file, sent in batches with their graph rows
      • 
        
    • Refs, commit diffs and blob diffs (histogram, word-level highlights)
      • 
        
    • Columnar commit store: ids, times, interned authors, summaries in one arena
      • 
        
    • Pure, incremental lane layout, unit-tested on synthetic histories
      • 
      
    
    
    
    
    
    
      
    system git · child process
    
      
    Write
    
      
      
        
    • Commit, stage, checkout, merge, rebase, push, stash, tag: all through git
      • 
        
    • Status with --porcelain=v2: fsmonitor and the untracked cache
      • 
        
    • Progress streamed to the status bar; cancel kills git's whole process group
      • 
        
    • Your hooks, signing, LFS and credential prompts behave like the command line
      • 
      
    
    
    
  
    

    



    
  
    
    
    
      
    Performance budgets
    
      
    Fast where it matters.
    
    
    
    
    Every git operation logs its time, and the status bar shows how long the first rows took. These are the budgets the app is built against.
    
  
    

  
    
    
    Whole history of git/git, all refs, date order
    
    
    switchhead
    1.3 s
    
    
    git log
    ≈2.6 s
    
    
    First rows appear in 94 ms; the list is usable long before the walk finishes. Without a commit-graph file gix needs 1.9 s before the first batch, so switchhead uses it whenever git wrote one.
    
  
    

  
    
    
    < 300 mscold start
    
    
    < 100 msopen a repo to first graph rows
    
    
    < 500 msfirst rows on a 1M-commit repo
    
    
    < 30 msswitch commits, file list shown
    
    
    < 50 msa typical file diff
    
    
    < 300 msstatus of a 100k-file work tree
    
    
    < 16 msswitch repo tabs, state stays in memory
    
    
    < 200 msscan a folder of ~1,000 directories
    
  
    

    



    
  
    Fork-class
    
  
    Everything you reach for,
    none of the waiting.
    
  
    Built feature by feature against Fork's checklist. Everything below works today.
    
  
    

    



    
  
    
    
    
      
    Local changes
    
      
    Stage a line,
    not a guess.
    
      
    Stage, unstage or discard whole files, single hunks, or individual lines picked in the diff. The commit box counts your subject (amber past 50, red past 72), loads the last message on Amend and restores your draft when you turn it off. When a hook says no, its full output sits right under the box.
    
      
      
        
    • Space or Enter stages, Tab switches lists, Ctrl/Cmd+Enter commits
      • 
        
    • Ignore a file, its extension or a folder in one click
      • 
        
    • Assume-unchanged and skip-worktree from the context menu
      • 
        
    • Destructive actions always ask first
      • 
      
    
    
    
    
    
      Picking lines to stage in the diff
      A pre-commit hook's error output under the commit box
    
    
  
    

    


    
  
    
    
    Three-way merge conflict helper
    Conflicts, card by card. Ours, base and theirs for each region; take a side, both, or edit the result, then Mark Resolved.
    
    
    Interactive rebase editor
    Rebase by dragging. Reorder with the mouse or Alt+↑/↓, and press P R E S F D to pick, reword, edit, squash, fixup or drop.
    
    
    Image diff in swipe mode
    Images that diff. Side by side, swipe, or an onion skin that follows the pointer, with pixel and file sizes.
    
  
    

    



    
  
    
    
    
      
    Coming next · AI assistant
    
      
    Bring the coding CLI
    you already use.
    
      
    Claude Code, Codex CLI, Gemini CLI or your own. It writes commit messages from the staged diff, proposes conflict resolutions, explains git commands and reviews branches. You review and apply every proposal.
    
      
    Safety lives in the server
    
      
      
        
    • The CLI runs in a private, empty temp folder, never in your repository
      • 
        
    • Its own shell and file-edit tools are turned off
      • 
        
    • Its only tools are switchhead's read-only git MCP server, scoped to one repository
      • 
        
    • It returns proposals; the app applies them only after you review them
      • 
        
    • switchhead never reads, stores or proxies a CLI's credentials
      • 
      
    
    
    
    
    
      
    
        
    Generate commit message
    
        
    
      
    
      
    
        Read-only MCP tools
        
    statuslogshowdiffbranchesblameconflicts
    
      
    
    
    
  
    

    



    
  
    
    
    
      
    Themes · Follow Omarchy
    
      
    Ten themes.
    Your desktop's, too.
    
    
    
    
    The same design system as Switchyard. Pick one below and the whole page and the sample above follow it. On Linux, Follow Omarchy reads your active Omarchy theme and rebuilds the palette, every text color kept readable at 7:1.
    
  
    
  
    
  
    You're looking at switchhead Dark. Zoom the whole UI with Ctrl + − 0.
    

    



    
  
    
    
    Keyboard first.
    
    
    
  
    
  
    

    



    
  
    
    
    
      
    Status
    
      
    In active development.
    
      
    Everything above the "coming next" line works today. The rest is tracked in PLAN.md.
    
    
    
    
    
      
    Assistant
    Commit messages, conflict resolutions, git command help and branch reviews through a read-only git MCP server.
    
      
    History
    File tree at any revision, open or save a file at a commit, and undo for hard resets, discards and cleans.
    
      
    Advanced
    Git LFS, submodule and worktree management, git-flow, custom commands, bisect, a diff minimap and identity profiles.
    
      
    Hosting
    GitHub, GitLab, Bitbucket and Azure DevOps accounts, clone from an account and pull requests.
    
      
    Release
    AppImage, macOS and Windows installers, and performance CI on git/git and linux.
    
    
    
  
    

    



    
  
    Build from source.
    
  
    Rust 1.97 or newer (pinned in rust-toolchain.toml) and git on your PATH.
    
  
    
    
    Linux dependencies (Debian / Ubuntu)
    $ sudo apt-get install -y libxkbcommon-dev libxkbcommon-x11-dev libwayland-dev \
    libxcb1-dev libvulkan-dev libfontconfig-dev libfreetype-dev libssl-dev pkg-config
    
    
    Run
    $ git clone https://github.com/jeremielumandong/switchhead
$ cd switchhead
$ cargo run --release -p switchhead-app -- ~/code
    
    
    Checks
    $ cargo fmt --all
$ cargo clippy --workspace --all-targets -- -D warnings
$ cargo test --workspace
    
  
    
  
    Pass a repository to open it, or a plain folder to scan it for every repository inside.