r/dotfiles • • May 21 '23

When you're too used to vim

Post image
56 Upvotes

r/dotfiles • • Feb 27 '26

wrote a blog post on my neovim config. supports go, elixir, js/ts, c/cpp and python!

Post image
33 Upvotes

r/dotfiles • • Feb 22 '26

Hyprland Glass Rice (Arch)

Thumbnail
gallery
32 Upvotes

r/dotfiles • • Feb 07 '26

Why I stuck with GNU Stow instead of chezmoi or yadm

28 Upvotes

Saw the "chezmoi vs yadm vs stow" posts and wanted to share why I've stuck with Stow after investigating all three.

Context: I manage dotfiles across a personal linux box, a work laptop, and occasional fresh VMs. Nothing fancy, just want configs versioned and easy to deploy.

I tried chezmoi first. Its genuinely powerful. Go templates, secrets management with 1Password/Bitwarden, machine-specific conditionals built in. But I already use Ansible for provisioning my machines, and chezmoi's templating overlapped with what Ansible was doing. I was learning a second templating system to solve problems Ansible already handled. Felt wrong. If you dont already have Ansible in your stack, chezmoi is probably the right call though. It does everything in one tool.

yadm was closer to what I wanted. Bare git repo under the hood, lighter weight than chezmoi. But I kept bumping into its alternate files system when I just wanted to exclude a config from one machine. And having everything in one flat repo meant my Claude config lived next to my email config with no logical grouping. I wanted packages.

Stow won because it does one thing and stays out of the way. No config files for the tool itself. No template syntax. Your dotfiles repo has "packages" (just directories that mirror your home structure). Thats the whole mental model.

~/dotfiles/
├── bash/
│   └── .bashrc
├── git/
│   └── .gitconfig
└── nvim/
    └── .config/nvim/init.lua

Then stow bash git nvim and done. I've got 29 packages now. Bash, git, tmux, nvim, email stack (mbsync/notmuch/aerc), and more.

The selective deployment is what keeps me on it. Work laptop doesnt need personal email configs? Just dont stow those packages. No conditionals, no templates, just choose what to stow. Want to remove something cleanly? stow -D package and its gone.

One thing that took me a while to find. If you've got existing files blocking stow, stow --adopt bash pulls them into your package first, then creates the symlink. Handy for initial migration.

What it doesnt do: secrets, machine-specific configs, templating. Thats fine. Unix philosophy - do one thing well. Stow manages symlinks. Ansible handles my templating, secrets and machine-specific stuff. Each tool does what its good at and I dont have overlapping systems fighting each other.

Full write-up: https://simoninglis.com/posts/gnu-stow-dotfiles

Starter gist: https://gist.github.com/simoninglis/98d47f3107db65d0a33aa2ecc72bba85

Curious what made others pick chezmoi or yadm over stow. Was it the templating? Machine-specific conditionals? Secrets?


r/dotfiles • • Apr 12 '20

dotcommon - what do people have in their dotfiles?

Thumbnail
github.com
28 Upvotes

r/dotfiles • • Apr 23 '21

A complete guide to managing, configuring, and customizing your own system dotfiles

Thumbnail
leeked.medium.com
26 Upvotes

r/dotfiles • • Apr 26 '25

Chezmoi vs yadm vs stow

24 Upvotes

For those who've at lest tried all three, you could you give me a hand in deciding on one of these?

Prior to I've done my own script but I don't think that's the best way and, to make things more confusing, that seems to have stopped working when Mac OS changed how it protects is core elements.

I've tried all these but none have seemed to click with me. But I want to try again. What I'm looking for is:

  • easy to use

  • can store as a git repo (public is fine)

  • dead simple (if there is a bug or quick, I tend to find it)

  • well documented

  • OS

  • works with m1 mac, as well as linux systems

Thanks


r/dotfiles • • May 13 '25

I made a new dotfile manager

21 Upvotes

Yes... I'm github star-hungry... Please check out my project.

It is called 'dotato'.

Goal:

  • a no-brainer dotfile manager

Brief specification:

  • Config file? Yes.

  • Git integration? No.

  • File copy or Symlink? Both.

How it works:

  • You write a directory path in dotato.yaml.

  • You write a ignore rule in .dotatoignore.

  • Run dotato. It will read all files in the directory and select files based on your ignore rule.

Thank you for your attention.

Dotato github repository


r/dotfiles • • May 12 '20

Codespaces uses your dotfiles repository on GitHub to personalize every new codespace that you create.

Thumbnail
help.github.com
19 Upvotes

r/dotfiles • • 15d ago

[dwm] My daily driver Linux desktopr

Post image
18 Upvotes

Repo : https://github.com/tudorioan1/dwm-tudor

Status bar : polybar
Launcher : rofi
+ dunst, picom, and others + live config reload with toml parser.

If you like it, give a star to my repo!
Share your thoughts about this project that I started as a weekend project almost 1 year ago and now I started adding more and more things to it.


r/dotfiles • • Feb 18 '26

Got tired of redoing my Zsh setup on every machine, so I made a bootstrap script (~20ms core startup, <100ms to prompt)

18 Upvotes

So I’ve been obsessively tweaking my Zsh setup for a while and finally cleaned it up enough to share.

Z-SHIFT is just a bootstrap script that sets up my full Zsh environment from scratch. It installs:

  • Zsh + Zinit

  • Starship

  • fast-syntax-highlighting, zsh-autosuggestions, zsh-completions, clipboard, extract, sudo, git

  • eza, bat, ripgrep, fzf, zoxide, tealdeer, fd

  • Nerd Fonts (FiraCode NF)

  • A few opinionated aliases and defaults

Main goals were:

  • One command → usable dev shell

  • Keep startup fast (~20ms core, under 100ms to prompt)

  • No giant 500-line .zshrc monster

I’m using Zinit turbo mode to lazy-load plugins and I ran everything through zsh-bench to test the speed.

It started as my “new machine setup” script and slowly turned into something a bit more structured. There’s also a cleanup (uninstall.sh) script if you want to revert everything.

Repo:
https://github.com/0xdilshan/Z-SHIFT

If you’re into shell performance or just like poking around other people’s dotfiles, feel free to take a look. Open to feedback / improvements / roasts :) 👍

./zsh-bench ==> benchmarking login shell of user 0x0bytes ... 
creates_tty=0 
has_compsys=0 
has_syntax_highlighting=0 
has_autosuggestions=0 
has_git_prompt=1 
first_prompt_lag_ms=98.482 
first_command_lag_ms=99.033 
command_lag_ms=103.715 
input_lag_ms=6.231 exit_time_ms=25.369

r/dotfiles • • Jan 21 '22

YADM dotfile manager can handle system-wide files perfectly.

18 Upvotes

YADM is a very popular dotfile manager with 3.1k stars on Github. It took me a while to find one that keeps a clean track of system-wide files, like on your $HOME, and YADM does the job with the files in their original location, which means you don't need to copy them to your $HOME or create symlinks. It's super clean.

System-wide file tracking is not officially supported, but the developer itself, TheLocehiliosan, told here how to do it and it works almost perfectly. I can't just enable encryption yet, which is 100% dispensable. I would use encryption to keep track of files like /etc/sudoers.

Here are my dotfiles repositories:


r/dotfiles • • Oct 06 '25

Behold, my terrible and over-engineered Dotfiles Excel Sheet for Windows NSFW

Thumbnail
gallery
17 Upvotes

Sometimes, I need to install stuff on a freshly reformatted system (I'm not a sysadmin or anything, just a lab assistant) and I made this excel sheet to select softwares I need to install. Uses winget to install everything, and doesn't quite have configuration files but it's good enough for most things.

Please feel free to heckle or give suggestions!

NSFW tag only because my friends hated this excel sheet when I showed it to them


r/dotfiles • • Feb 16 '19

Blazing fast dotfiles 🏎 rgomezcasas/dotfiles

17 Upvotes

Hey!

Here are my dotfiles https://github.com/rgomezcasas/dotfiles :)


r/dotfiles • • Oct 21 '25

My dotfiles with vscode + vim extension + keybinding improvements + github copilot & chat, kitty, tmux, cmus, gitconfig, zsh and installer shellscript.

15 Upvotes

Here: https://github.com/monoira/.dotfiles

It includes dotfile configs for:

  • vscode with profile for FullStack dev, vim extension, some important keybinding changes that make vscode act exactly like LazyVim and setup.sh script that sets up / symlinks global settings.json

  • kitty with kitty-tabs config

  • tmux

  • cmus aka c music player with vim keybindigs and extreme speed

  • gitconfig

  • zsh As well as scripts that auto install these dotfile configs with GNU/stow.


r/dotfiles • • Mar 29 '25

Forget manual installs—Dotbins makes your CLI binaries part of your dotfiles repo!

15 Upvotes

Hi r/dotfiles,

I've been maintaining my dotfiles for a long time, but one persistent frustration was managing and setting up CLI tool binaries each time I cloned my repository on a new machine. To solve this, I built dotbins, a lightweight Python tool designed specifically for dotfiles enthusiasts.

Dotbins automatically fetches and configures CLI tools directly from GitHub releases, ensuring they're immediately ready to use without any manual setup or admin privileges.

Minimal example configuration:

tools_dir: ~/.dotbins

platforms:
  linux:
    - amd64
    - arm64
  macos:
    - arm64

tools:
  delta: dandavison/delta
  fd: sharkdp/fd
  yazi: sxyazi/yazi

  bat:
    repo: sharkdp/bat
    shell_code: |
      alias cat="bat --plain --paging=never"
  fzf:
    repo: junegunn/fzf
    shell_code: |
      source <(fzf --zsh)

With the above minimal config, dotbins will:

  • ✅ Download and install delta, fd, yazi, bat, and fzf automatically.

  • ✅ Set up the provided shell aliases and integrations (cat becomes bat, and fzf shell integration).

  • ✅ Manage versions and updates effortlessly, all without admin privileges.

Setting up your environment becomes as simple as cloning your dotfiles repo and running:

dotbins sync
source ~/.dotbins/shell/zsh.sh  # or bash.sh, fish.fish, etc.
# Better to add the line above to your `.zshrc`

I keep all my CLI tools managed in a dedicated repository basnijholt/.dotbins. Cloning my dotfiles now instantly provides all my essential CLI tools, ready to go.

Check out dotbins here:

🔗 GitHub Repository

Feedback and contributions are warmly welcomed!


r/dotfiles • • Jan 13 '22

Gitpod now supports dotfiles

Thumbnail
twitter.com
15 Upvotes

r/dotfiles • • May 26 '26

Migrated dotfiles to chezmoi + 1Password CLI. The multi-account op signin gotcha that cost me an hour, plus a side-tool for secrets that aren't in dotfiles.

14 Upvotes

Long-time dotfile lurker, finally bit the bullet on chezmoi this week so I can blow away machines without losing config. Two things to share back, one config gotcha and one related tool.

Gotcha first, because it cost me an hour and I want to save someone else that hour. chezmoi + op CLI setup is great out of the box. The trap is the multi-account case. chezmoi 2.70.x ignores [onepassword].account = "..." in chezmoi.toml when it does the implicit op signin --raw before resolving a secret. So if you have work + personal both signed in (like me), signin dies with multiple accounts found and your template never renders. The fix is to pass the account explicitly to every onepasswordRead call:

export FOO_TOKEN={{ onepasswordRead "op://Employee/Foo/credential" "myaccount" | quote }}

Keep the config setting too, fine for forward-compat, but the per-call arg is the load-bearing piece. Took me embarrassingly long to figure out.

Other thing. Once my home dotfiles were clean, I noticed they were the tip of the iceberg. Repo .env files everywhere, .p8 Snowflake keys, a GCP service-account JSON sitting at mode 644. None of that lives under chezmoi because it's project-local. So I wrote a tool that does the same templating pattern for project files: .env.template with op:// refs that get materialized at runtime via op inject or op run --env-file=, plus op document create for the PEM/JSON blobs you can't really template inline. It's packaged as an agent skill (Claude Code, Cursor, Codex pick it up automatically), but works fine standalone if you don't use agents, the README has the bare op commands.

https://www.skills.sh/idosh9/vault-credentials

Genuine question for the sub: anyone solved the multi-account op signin thing more cleanly? I assumed I was just holding chezmoi wrong but couldn't find a config combo that works without the per-call arg, and the GitHub issue I found on it has been open for a while.


r/dotfiles • • Apr 08 '26

I just released v1.0.0 of store --- a more powerful and simpler alternative to GNU Stow with explicit organization

14 Upvotes

I'm genuinely proud to call it 1.0. store is a CLI tool for managing dotfile symlinks, and the core idea is that your dotfiles repo should be easy to understand just by looking at it.

How it started

This whole thing started because I was using GNU stow. stow is great for what it is, but it requires your repo to mirror the target filesystem hierarchy, it has no config file, and everything is convention-based. I kept running into limitations; no way to send one directory to multiple targets, no conflict handling, no way to skip stores per-platform. I started building store as "stow but with a config file" and it grew from there.

The problem I had with other tools

Along the way I looked at chezmoi and yadm too. They're both solid tools, but they never clicked with me.

yadm turns your entire home directory into a git repo. It works, but it always felt like I was fighting against git's design. There's no real organization; your dotfiles are scattered across the same paths they live in on disk. Looking at the repo doesn't tell you much about what's managed and what isn't.

chezmoi goes the other direction; lots of structure, but it's chezmoi's structure, not yours. Files get prefixed with dot_, private_, executable_. Templates are powerful but add complexity. The source state is an encoded representation of your filesystem, not a human-readable layout. I found myself spending more time learning chezmoi than managing my dotfiles.

What store does differently

store is built around one idea: your dotfiles repo should look like you organized it yourself.

~/dotfiles/
  .store/config.yaml
  nvim/
    init.lua
    lua/
  shells/
    .zshrc
    .bashrc
    config.fish
  git/
    .gitconfig

Each directory is a "store" that maps to one or more targets. The config is one YAML file:

stores:
  nvim:
    target: ~/.config/nvim
  shells:
    targets:
      - target: "~"
        files: [.zshrc, .bashrc]
      - target: ~/.config/fish
        files: [config.fish]
  git:
    target: ~/.config/git

That's it. You look at the repo and you know what's in it. You look at the config and you know where everything goes. No encoding, no conventions to memorize, no source-state translation. It's the explicitness of a config file with the simplicity that stow got right; just symlinks.

What's in 1.0

The feature set has grown well beyond what I originally set out to build, and I'm really happy with where it landed:

  • Symlinks - whole-directory or per-file with glob patterns

  • Multi-target stores - one directory can deploy to multiple locations (like shells above)

  • Conflict resolution - detects existing files and offers to move them into your repo

  • Encrypted secrets - {{ secret "github_token" }} in any config file, encrypted at rest, rendered at symlink time

  • Platform conditionals - when: {os: linux} to skip stores on the wrong machine

  • Ignore patterns - exclude files from symlinking with global defaults for .git/, .store/, etc.

  • store doctor - health checks for orphaned configs, broken symlinks, missing secrets

  • store diff - dry-run preview of what would change

  • store import - scans for existing symlinks and generates config from them

  • Shell completions - bash, zsh, fish, powershell

New machine setup is git clone && cd dotfiles && store. That's it.

Links

Would love to hear what you think, and happy to answer questions about the design decisions.


r/dotfiles • • Dec 31 '24

lazychezmoi thoughts?

Post image
14 Upvotes

r/dotfiles • • Dec 25 '21

Dotfiles management best practices?

14 Upvotes

So how do you all manage your dotfiles? On your local machine and in the cloud (github, dropbox etc.)?

Thank you.


r/dotfiles • • Sep 07 '21

dotlink - Finally found some time to put my dotfile management concept into words and a reference repo

Thumbnail
github.com
14 Upvotes

r/dotfiles • • Aug 05 '26

I built a cross-platform dotfiles setup with Ansible and Chezmoi

13 Upvotes

I got tired of manually rebuilding my development environment whenever I switched machines, so I created a bootstrap system for Linux, macOS and Windows.

It uses:

  • Ansible for packages, SDKs and system configuration

  • Chezmoi for dotfiles and symlinks

  • Separate Personal and Work profiles

  • Bootstrap scripts for all three operating systems

It currently manages my shells, CLI tools, Neovim, tmux, Docker, language runtimes, editors, terminals and AI coding tools.

Repo: https://github.com/Patruxs/dotfiles

Do you think Ansible + Chezmoi is a clean separation, or is it unnecessary complexity?


r/dotfiles • • Jun 03 '26

dotty – a TUI that gives you a unified view of all your dotfiles in one command

13 Upvotes

github.com/RiccardoCataldi/dotty

My home directory has 140+ hidden files and folders. AWS credentials here, SSH config there, Cursor rules somewhere else. Every time I needed to tweak something I had to remember where it lived, cd there, grep around, open it.

So I built dotty: run it from anywhere, get an instant expandable tree of every dotfile and dot-directory in ~, with live preview on the right and fuzzy search (/) to jump to any config in seconds. Press e to open in $EDITOR.

Built with Go + Bubble Tea + Lipgloss. Single static binary, zero config, works over SSH and inside tmux.

Would love feedback from the TUI community.