Dotfiles Management | Hacker News Reader

Dotfiles Management

mitxela.com

311 pointsthreeme3138 comments

I do something similar, albeit a bit more bare-bones. I keep my dotfiles in a dotfiles folder that is a git repo and then just have a simple script to symlink everything.

I have a couple of submodules in there (zplug, pyenv) and a bash script to keep them up to date, and then a few self managed binaries, like fnm. That's about it.

I don't bother trying to manage anything outside of home or deal with secret values by using something like git-secret.

Overall, it works great and has allowed me to keep track of how my core tools are configured without too much hassle.

Stow (https://www.gnu.org/software/stow/) may be useful for the linking part

Using GNU Stow to manage your dotfiles (2022) https://news.ycombinator.com/item?id=32253018

I use Homeshick for this, which also allows me to have multiple repos: https://github.com/andsens/homeshick

This is exactly my setup. Add onto this a simple install script and you have an easy way to quickly provision (is that the right word?) a new laptop.

Mine uses Homebrew to install my favorite binaries and also runs a zsh script to configure macOS defaults how I like it.

Chezmoi[1] has been working well for me recently, replacing a set of Stow-able directories in a simple Git repo.

I haven't started using templates and things, for now it's just environment variables.

[1]: https://chezmoi.io

Nice hack, but I still believe that home-manager [0] should be the way to go. It's the gateway drug to the Nix ecosystem and cleanly solves the composability problem which this "one-size-fits-all repo checked out to root" approach will have some trouble with.

[0] https://github.com/nix-community/home-manager

It's definitely a gateway drug worth taking since Nix solves all kinds of other problems too.

Just don't expect to become an expert overnight, it takes a while to sink in (or it did for me).

It's sad though - there's almost nothing in Nix (in my experience) that has to be that difficult if you know any programming. It's a perfect storm of bad documentation, bad tooling and unintuitive UX.

I've been half tempted to try and bridge Nix with some simplified UX. Something resembling blasphemy but nonetheless focused on user experience above all else. At least doing that would be a natural project to learn Nix better, too heh.

(disclaimer: I use Nix[OS] on two machines and my macbook. I know it decently.. but far from where i'd expect given it's my primary OS and package manager)

I've just (literally a few hours ago) started a tool trying to follow those principles.

https://github.com/woile/npt

I still don't know if it's worth, I have to experiment a bit more with it.

I have to say I'm still struggling with the flake:/

https://snowflakeos.org/

That looks really cool, though for me it's the language and API that makes it awkward.

A really good LSP could do wonders for user experience.

For me the killer feature of home-manager versus other dotfiles managers is that it also installs any software your dotfiles depend on or assume to be present on the machine.

To me it is marking what is “garbage” vs what isn’t in the .config folder. I like to experiment on linux a lot, like switching to plasma and back to Gnome and it always leaves like 20 mostly-empty folders trashed. I can then just remove the folder and go on my way with home-manager.

If you're running NixOS there's an impermanence plugin that allows you to specify specific directories and files you need to persist outside of what NixOs/HM builds for you and then use a tmpfs in-memory partition for root and/or home. Then at boot you're loading up the NixOS/HM config and then the persistent files are symlinked or mounted to where they need to be, but otherwise you have a fresh system on each reboot. It's a bit painful and manual to figure out exactly what to keep (unless you just want to keep the entire .config, for instance, which I don't) but it's amazing to know that you can mess up your home directory as much as you want and then it'll automatically clean itself with a reboot.

the read has “words of warning” almost immediately at the top about being familiar with nix first. it’s the gateway drug to nix?

bad docs and difficult to grok error messages seem to be a consistent theme that comes up learning nix.

You're only likely to screw things up once you start digging deeper into the Nix language/stdlib. I was put off by the warning at first as well, but it's honestly awesome having functional dotfiles that work reasonably consistently across NixOS (personal)/Ubuntu (work)/MacOS (work).

> bad docs

Yeah, pretty damned awful.

> error messages

That too.

I honestly think that inventing a language was a huge mistake. Guix took a much more sensible approach, but a libre kernel is unusable for 99.9999% of people.

Honestly, it really is not the language that’s the problem. While there are a few cases where it can trip you up at first, you wouldn’t be singing package descriptors even if it were Python — it simply has a business domain which is non-trivial. This non-triviality and organic growth show on the standard library of nix packages, but I fail to see how a lisp language or whatever be immune to it, besides having learned from some early abstractions mistakes.

Nix is building a package manager AND a programming language. Guix is building a package manager only. It's a resourcing thing.

And one might even argue the opposite, a DSL made for creating packages may well be better. Especially that plenty of package descriptions are basically reads like JSON.

Fair enough, that's a really good point.

It's kind of like LSD, your just gonna be unprepared the first time, and the second time...

Nix is a huge dependency though, in a lot of sense (have to learn a new programming language rather than invest in your git skills etc.). Even if you are mostly running nixos.

It's a one time investment though, and the payback is huge.

I'd like to agree, but my experience has been different. Basically...

1. invest a lot of time in learning nix (nixos in my case)

2. set up a system that works great

3. a year or two go by

4. need to make a change, modification, or set up another system

5. relearn everything from step 1

That said, I really do like the system. Just wish it were more user friendly and better documented.

Well, step 3 just shows how great it is.

But ideally no year will go by without using it, because you do install it to another system, tweak your home config, etc. The same way one doesn’t forget most of git, even though that one has some arcane UX.

If you are only changing your system once ever year or two, then perhaps it's not for you.

I'm running nix-build daily...

The payback isn't much compared to a regular git repo.

I love nixos but home-manager is just too much to force into all my other machines.

Nix is like sailing from Oakland to San Francisco on an aircraft carrier for your daily commute.

Most stuff I care about factors out into .config which I turn into a git repo, push to GitHub and slap on a CI checks for secrets.

Most engineers don’t need to forge a demonic pact with the Nix gods who demand I upend and replace everything from my operating system to my wife.

95% of the time if I'm making nix a dependency it's just to install the correct version of python and poetry, then I let poetry handle the other dependencies. So it's totally possible to just use nix a little. My coworkers haven't even noticed the flake.nix in our repo, they just install those things by hand.

But then there's that 5% case where you do have to forge a demonic pact with the nix gods, and it's handy to have your summoning circle all warmed up and ready to go.

I had problems installing python dependencies with compiled library dependencies this way, eg pandas. Does that generally work for you?

Pandas is one of those for which poetry alone doesn't do the job. So I have nix install pandas alongside poetry so that when poetry tries to install pandas, the non-python dependencies are all lined up.

Here's a (too verbose, sorry) example: https://stackoverflow.com/a/74944857/1054322

It works well on all of my linux boxes. On my mac it takes forever because it wants to rebuild the linux universe. Given that the system architecture is a parameter, I think there should be a way to rewrite my flake (or update the nixpkgs numpy) to just rely on bsd tools in those cases, but I haven't found it yet.

That's what's holding me up from recommending it to my team. I'm happy to just use linux everywhere, but they aren't.

You win this thread.

Well, the USS Hornet is stationed right there in Alameda, and it's not being used for anything else... :)

Yes, in that it's military-grade technology that needs to be more accessible to the public. Otherwise I don't agree with your analogy.

Actual "military grade tech" assumes field service by minimally trained personnel and an efficient logistic chain of supply. This is is the opposite of Nix, which requires months of self-training futzing around with obscure commands and an obscurer language, backed by an out of date unsorted mound of documentation and recipes.

An F-18 is military-grade tech and no minimally trained personnel are getting anywhere near it. It's all just bad analogies is my point.

Learning Nix just do manage your dotfiles*, yes.

But, now that you're using Nix, ... you could use Nix to describe an OS setup, write Docker images, declare the tooling for a dev environment, etc.

My current dotfile management makes heavy, near complete, usage of home-manager. If I want to do a redeployment I can simply install home-manager on a fresh installation, checkout my repository, and perform `nixos-rebuild switch`.

Any home-manager users on NixOS here? Are there any killer features in home-manager for you? I tried home-manager for a bit, but just went back to plain NixOS after I couldn't find anything it did better than what I was already using ([1], [2]).

[1] https://gitlab.com/engmark/tilde

[2] https://gitlab.com/engmark/root

Easy integration between the two. I pass config from the system config to home config for some things and it’s quite seamless. Also one command to apply config for system and home is nice.

I use NixOS and do not use home-manager. I have synchthing managed by NixOS and it syncs all of my config and files between all my machines.

Btw, am I the only person annoyed at calling configuration files dotfiles? Not all hidden files/folders are configuration, and not all configuration files are hidden.

From this HN comment from 2016 https://news.ycombinator.com/item?id=11071754

I use:

    git init --bare $HOME/.myconf

    alias config='/usr/bin/git --git-dir=$HOME/.myconf/ --work-tree=$HOME'

    config config status.showUntrackedFiles no

where my ~/.myconf directory is a git bare repository. Then any file within the home folder can be versioned with normal

commands like:

    config status

    config add .vimrc

    config commit -m "Add vimrc"

    config add .config/redshift.conf

    config commit -m "Add redshift config"

    config push

And so one…

No extra tooling, no symlinks, files are tracked on a version control system, you can use different branches for different computers, you can replicate you configuration easily on new installation.

Checkout chezmoi, I’ve been using it for a few years and it ticks every box for me - various machines, different configs, scripts, passwords etc

https://www.chezmoi.io/

I discovered chezmoi a few days ago after getting a new laptop and a wish to normalize my configuration across multiple computers.

Templating is awesome when having computers with differents DPI or screens attached, OS, etc.

Edition with --watch is a breeze, auto commit too!

On my list of new years resolutions is to finally embrace dotfiles management. This looks like just the ticket. Thanks!

And best of all: it's a single executable that doesn't need any specific installing.

I was interested in chezmoi, but they don't want you[1] managing files outside your home directory which made it a non-starter. I need to manage /etc/ and /usr/local/ too.

[1] https://www.chezmoi.io/user-guide/frequently-asked-questions...

I've been using chezmoi too and this is the only feature I miss. It'd be interesting to know what solutions folks are using. Chezmoi has some discussions around it, mostly recommending to use run scripts.

I haven't needed to keep track of dotfiles per se, but for servers I need to track changes to /etc and for that I use Etckeeper[1]

1 https://wiki.archlinux.org/title/Etckeeper

You can use chezmoi to manage files outside your home directory if you really want to.

For an example, see https://github.com/felipecrs/dotfiles:

The `home` directory contains home directory files.

The `root` directory contains root directory files (e.g `/etc`).

I've partially adopted `aconfmgr` for the other stuff, but haven't put in the effort to refine my config, partly because I only have one applicable (arch-based) system at the moment.

I didn't discover Chezmoi until seeing this thread (sigh). I developed a tool, filetailor, with an almost identical goal (dotfile management while accounting for differences across machines). It uses Python and YAML, but from what I can tell is similar in concept to Chezmoi.

https://github.com/k4j8/filetailor

One thing I like about filetailor I didn't see in Chezmoi was the ability to surround code with a comment specifying which machines it should be commented/uncommented for. It's easier than templates in some situations.

It works great, but there's probably tons of bugs that occur when used by someone other than me. I don't have a CS background and this was my first big hobby project.

I'm curious about, specifically, which files you (and the sibling commenter) want to manage outside of the home directory. Is it OS package-manager configs?

This is highly dependent on distro, but for any use-cases where editing /etc/ is the recommendation, I have found that either:

(a) It's a development environment thing (e.g. httpd vhosts) & thus I see it as quite separate to "my dotfiles" (a personal machine env thing): I try my best to manage dev env stuff from project-specific repos wherever I can (i.e. a bash script to dispatch required local /etc/ changes in a repo "./scripts" dir or similar), or otherwise if it's a more significant set of configs, Ansible.

(b) It's a specific app that is recommending doing things the "Wrong Way™". There's often a workaround to get it to use $HOME or $XDG.

(c) It's OS package configs. I've found that things like repo & key installs are well suited to chezmoi run_ scripts. For anything more advanced or esoteric, I guess that may be an exception.

On macOS I often have the need to place stuff in /Library.

What kind of stuff? I'm genuinely curious, as I've never once had to touch /Library manually.

Launch Daemons, mostly

these go in ~/Library/LaunchAgents

Not if they need to run as root

regular config files in ~/Library/Application Support/ Sure there are (b) workarounds, including chezmoi templates and run_ scripts with symlinks, but that's cumbersome (and some issues were only resolved recently)

Not sure what you mean? That is in your home directory...

You're right, I confused it with a different issue requiring symlinking "workarounds"

they don't want you, but they also "allow you, in theory, to use chezmoi to manage any file in your filesystem, "

settled on this as well because of its very good cross-platform support. Only thing that took some time getting used to was the model of having a source directory distinct from your actual dotfiles unlike most of the symlink based tools.

Fair point. If you're interested in why chezmoi took this particular approach, I wrote a few FAQs on its design:

Why chezmoi doesn't use symlinks: https://www.chezmoi.io/user-guide/frequently-asked-questions...

General design FAQs: https://www.chezmoi.io/user-guide/frequently-asked-questions...

That's honestly very helpful. I wasn't aware of edit.watch which is pretty much what I wanted.

I'm in the process of migrating over to this. I find it much simpler and easier to configure than dotbot (which I had be using for many years). If you're only using your dotfiles on one platform, really anything will work. Where things get hairy is when you want slight tweaks or configuration changes depending on platform. Chezmoi gets this right out of the box.

been using chezmoi for the past 3 months across 4 machines. i like the template support, but i constantly feel like there's complexity hiding. im finding myself needing to relearn various bits of how it works after not touching it for a few weeks at a time.

by far, my favorite thing about chezmoi is that you're managing a separate set of files and syncing then to your homedir, making it reallllllly easy to switch tools or otherwise do something else.

its better than the home-rolled symlink solution i was using before it, and certainly better than some of these turn-your-home-dir-into-a-git-repo solutions.

but if im being honest, i hate every one of these tools in different ways. i dont have the answer, but i feel like im endlessly searching for something that feels like the right balance of simple and flexible.

anybody wanna join my dotfiles-aas startup?

My homebrew solution uses comments surrounding or in-line with the code that is machine-specific. The program then uncomments/comments the code appropriately as it is backed up and restored.

What do you think of this approach? Would that remove the complexity hiding?

i'd have to see it to have much of an opinion. have a GitHub link by chance?

See the example usage via the link below.

https://github.com/k4j8/filetailor#example-usage

The program works great for my use case, but I don't have a CS background and this was my first big project, so I'm sure it's full of bugs and poor coding practices.

Dotbot (https://github.com/anishathalye/dotbot) has worked extremely well for me. It’s simple to setup, has minimal dependencies, and it is also easy to run arbitrary commands if I want to get tricky with things. I would highly recommend it.

Second dotbot.

I always start out with the best of intentions for dotfile mangement etc, using tools like stow, git and so on.

Eventually I get lazy and don't bother checking stuff in and forget where half of the stuff is.

Might try this solution but I'm too cynical to think it'll be something I'll stick with

Exactly the same for me, at some point I realized that just copying over some config files from a backup is easier than trying to keep things neat and tidy for years just to be prepared for setting up a new computer every few years.

It’s more for when you change a setting, that you don’t have to manually change it on n accounts/machines.

I often think I need to have weekly backups done for me so I can skip managing at times without accumulating too much untracked cruft.

It's useful if you have a second machine or even work machine where you want to keep your bash profile, IDE settings, etc. in sync.

    ~/.dotfiles

Really? Just as so many utilities are finally moving away from `~/.foo` to `$XDG_CONFIG_DIR/foo` (default `~/.config/foo`) to reduce home directory pollution, does a new tool have to start using `~/.foo`?

Heck, even the `dot` output demo'd by TFA shows 8 legacy `~/.foo` files, but 10 `~/.config/foo(/bar)*` files. (But is missing `~/.dotfiles`?!)

This isn't a new tool. It is just a single convenient shell alias for any file on the system with git. You can put the repo in $XDG_CONFIG_DIR/dotfiles or wherever you want. ~/.dotfiles is just a common place to put that repo.

YADM[0] is another great tool for this very purpose which I've been using for years in combination with homebrew to setup any new (Mac) machine that I get and have everything from dotfiles to Applications installed in no time.

[0] https://yadm.io

I was unhappy with existing solutions, especially I wanted the ability to handle differences between machines. So I built my own! You're welcome to see if you like it :)

https://github.com/SuperCuber/dotter

I've been using dotter for over a year and it's incredible. I use the same dotfiles repo for Mac and Linux, and dotter is super easy to change variables or subscribe a machine to specific configs. Thanks a lot for dotter @Supercuber!

I'm a fan of just having my $HOME as a plain git repo with "*" in ~/.gitignore. Having to force add new files is a minor chore but one I'm more than happy to live with.

That's clever, but it also seems like a bit of a hassle. It also seems incredibly non-hermetic and prone to accidental pollution.

What about putting all configs into a single git managed directory and using tooling to install the appropriate symlinks?

The git ignore file set up prevents accidental pollution.

A script and/or symlinks is overhead.

  # Save the repo to `~/.dotfiles`; the `--bare` option prevents Git from making
  # a mess of your home directory.
  git clone --bare ... ~/.dotfiles

  # Set up an alias for this shell session (it's also in ~/.config/aliasrc).
  alias dots='git --git-dir=$HOME/.dotfiles --work-tree=$HOME'

  # Make sure we don't show untracked files in `git status` output.
  dots config --local status.showUntrackedFiles no

  # Checkout all local files.
  # NOTE: This might overwrite existing files, or you might need to stash files
  # before proceeding. Look before you leap. If you have an existing setup,
  # consider checking out individual files as needed and testing the
  # configuration piecemeal, instead of doing a complete checkout.
  dots checkout

  # Make sure we can access remotes properly. The `--bare` option requires us to
  # do this manually.
  dots config remote.origin.fetch "+refs/heads/*:refs/remotes/origin/*"

  # Make sure we are set up to track the remote `master` branch. Again, this is a
  # consequence of cloning with `--bare`.
  dots branch --set-upstream-to=origin/master master
  dots switch master

  # Fetch to make sure everything is configured correctly.
  dots fetch origin

"yadm" effectively does this, just replace "git" with "yadm" and it'll act on your $HOME

Has a couple of other nice things specific to this use case, like letting you have slightly different files based on username or platform.

https://yadm.io/

This is what I do also.

Bare git repos have lots of limitations, namely:

* Maintaining per-machine configurations is a hassle, usually involving a lot of manual branch juggling.

* There's no support for storing secrets in a password manager or in encrypted files.

Read more reasons why dotfile managers are better than bare git repos at https://www.chezmoi.io/why-use-chezmoi/#i-already-have-a-sys...

Been using chezmoi for years and it's great! If you are the person who created this I just want to say thank you! :)

I started out with yadm but ended up symlinking its .git directory to ~/.git to be able to browse/stage/commit in Fork (https://fork.dev).

To make this manageable, I added this .gitignore:

  \*
  !.\*
  !.hammerspoon/\*/\*
  !.config/\*/\*
  !.ssh/config
  .DS_Store
  .bash_history
  .tig_history
  .lesshst
  .python_history
  .wget-hsts
  .zsh_history
  .CFUserTextEncoding
  .Xauthority
  /.config/mcd/.cache/
  /.config/mcd/.local/
  /.config/legendary/

This makes use of the fact that .gitignore patterns are evaluated in order. It basically makes git only care about dotfiles in the home directory, files under .config, .ssh and .hammerspoon. Specific files/dirs that match that filter can still be ignored (e.g. .bash_history).

This is very straightforward and works quite well, so I don't see the need for yadm anymore. The one issue I have with it, is that in the terminal I'm always in a git context (shown in the shell prompt) in any directory under $HOME.

At our startup (FluxNinja), we provide MacBooks and Linux Desktops (System76) to our engineering staff. We have invested in common dotfiles[0] to help them keep dev experience consistent across machines. We use chezmoi for dotfiles management.

Really recommend investing in common dotfiles at the organization level. For young developers, a standard setup provides a big productivity boost.

[0] https://github.com/fluxninja/dotfiles

Interesting, thanks for sharing. Two questions:

Does this make a backup of an existing set of .files?

Does this also install required packages using brew?

1. It doesn't do a good job in making a backup of existing files as it's meant to be setup on a new machine. However, the setup script can be quickly modified to backup existing files. See [0].

2. Yes, it installs required packages via brew both on macOS and Linux. See [1].

[0] https://github.com/fluxninja/dotfiles/blob/master/sw/assets/...

[1] https://github.com/fluxninja/dotfiles/blob/master/sw/bin/exe...

How is Chezmoi compared to Stow? Currently using Stow but Chezmoi seems to be interesting.

Is the usage of these standard dotfiles required for all developers? Personally I would always prefer to use my own dotfiles at work

I also use this trick to manage my dotfiles. Here is another good tutorial about it: https://www.atlassian.com/git/tutorials/dotfiles

How do people here handle secrets like e.g. passwords / env variables / ssh keys in their dotfiles?

I've written simple encrypt/decrypt with PGP, but since I've kinda lost trust into Keybase I have no simple way to bootstrap PGP.

Pass: https://wiki.archlinux.org/title/Pass

Emacs uses .authinfo transparently: https://www.reddit.com/r/emacs/comments/7jhcq8/authinfogpg/

Emacs' auth-source.el can work directly with the macOS keychain, which if you're on a Mac is pretty useful.

https://www.chezmoi.io/ supports:

* Keeping secrets in your password manager (all major password managers are supported), see https://www.chezmoi.io/user-guide/password-managers/.

* Encrypting entire files with gpg or age, see https://www.chezmoi.io/user-guide/encryption/.

You can also bootstrap your gpg/age private key on a new machine with a passphrase, see https://www.chezmoi.io/user-guide/frequently-asked-questions....

I do the same, just copy .gnupg folder over via ssh / usb / yubikey.

I use git-crypt with VCSH for dotfiles and Ansible for provisioning, using Ansible's built-in encryption for some data. It works pretty well, but to make things less annoying, I prompt for decrypt passwords up front and if typo it, you won't know until much later when bringing a machine up from scratch.

I very recently put some effort into tidying up my dotfiles, and have a brief writeup at https://chatwithsysop.com/blog/2022/12/31/dotfiles-cleanup (none of this was done with the academic rigor required to withstand a deconstruction by HN, it is just a log of one person's experience with a weekend project).

I chose to use yadm (http://yadm.io) for no particular reasons beyond that I found it first, and it seemed reasonable. It's more just a wrapper around putting GIT_DIR elsewhere.

I can't say enough good things about yadm. I found a yadm bug under Cygwin years ago, and the author had a patch for me within a day. I'll grant that Cygwin is an odd platform.

I use yadm to manage dotfiles across Windows (via Cygwin), macOS, and Linux.

As more applications migrate to xdg, I have simply taken to having my .config directory be a git repository.

Inside that directory I have a “dotfiles” subdirectory that has managed versions of my home directory dotfiles which I symlink in.

This is the obvious no-code solution that adds no extra maintenance burden to anyone. And it works with any VCS or tarballs.

I've been using git and tarballs to synchronize my ~/.config across half a dozen hosts.

Cool, but I don't need everything versioned and I like it simple.

    ~/usr/src/p/dotfiles  git worktree list                                                   
  /home/matt/usr/src/p/dotfiles  160721b5e3 [master]
  /home/matt/.config             e195a59c7b [config]
  /home/matt/.gnupg              b50725b47c [gnupg]
  /home/matt/.mozilla            b5d0d07b74 [mozilla]
  /home/matt/.mutt               f3d4a14d99 [mutt]
  /home/matt/.tmux               a93aa509af [tmux]
  /home/matt/.vim                68fd61921c [vim]
  /home/matt/.weechat            ef3d4c761f [weechat]
  /home/matt/.zsh                228ee42367 [zsh]
  /home/matt/bin                 b05de7d9d7 [bin]
  /home/matt/usr/venvs/shell     6a3b7e4c6a [shell/venv]
  /home/matt/usr/venvs/npm       d2065c68bf [shell/npm]

And only two symlinks I manually manage

  /home/matt/.vimrc -> .vim/.vimrc
  /home/matt/.zshrc -> .zsh/zshrc

Everything else isn't versioned. I rely on btrfs snapshots and back ups.

In case it's useful for someone (xkcd.com/1053) I use stow for handling config files. Lastly featured in HN here: https://news.ycombinator.com/item?id=32253018

It does however need a bit of preparation for complex things like Electron-based apps. I don't want to stow non-essential files and dirs, so I ended complementing it with a small script to do some preparation before the stowing itself.

I see a lot of people mentioning home-manager / nix in the comments. I tried drinking the nix kool-aid and home-manager and all that was a little too much more me and landed on a hybrid approach:

https://github.com/sontek/homies

1. I use a `justfile` that calls `nix profile install ...` to install my packages, rather than using a nix configuration file. This allows me to use a standard package manager workflow rather than going "all in".

https://github.com/sontek/homies/blob/master/justfile#L24-L2...

2. I then use GNU Stow to install my dotfile configuration:

https://github.com/sontek/homies/blob/master/justfile#L93-L9...

I think this is a great middle ground where I can utilize `nix` as my package manager across Linux and Mac and have consistency while not having to learn the whole configuration language or change my workflow.

The other tools I use heavily in my environment:

- https://asdf-vm.com/: I find this better than installing python/node/etc from nix.

- https://github.com/casey/just: I use this as my command runner (similar to make but cleaner in my opinion)

I also track my dotfiles in a Git repo, but I only track my home directory. Made a tool to help out with some of the more arcane commands: https://github.com/tubbo/homer. I'm currently rewriting it in Rust, which is mostly done but I still have to work out a couple kinks on Linux machines . So far, I haven't needed to mess with too many top-level configs on each machine, most of the stuff I do is relatively contained (and uses the XDG standards thankfully). It got a little hairy when I tried to configure certain file paths on both a Linux and macOS environment, as there are different default conventions and other nuances that make the two not fully compatible at times. But it definitely saves a lot of time when setting up a new machine from scratch, `homer bootstrap $REPO_URL` does all the hard work and gets my home directory loaded up with configuration the way I'd expect.

I just use yadm: https://yadm.io/

I did something similar here https://github.com/redraw/dotfiles, along with some installation scripts

although, nice idea on tracking the whole / instead of just ~/!

the only thing I miss after aliasing dotfiles to git, is that you lose git's autocompletion features. I once tried to set it up in zsh with autocomp, but without success, should review that

The biggest pain point I have with dotfile management is that none of my computers are exactly the same, so if I start pulling dotfiles from a repo I get unwanted configuration on a machine. It could be something as simple as a Vim theme not looking right on another computer because it's using a different terminal.

I guess what I should be doing is adding if statements into all of my config files, but instead I wind up just copy/pasting the parts of config that I like from my github repo and never actually doing real dotfile management. Which just leads to the repo becoming stale.

A similar post on HN:

- "The best way to store your dotfiles: A bare Git repository" : https://news.ycombinator.com/item?id=19591033

- Also see: "The best way to store your dotfiles: A bare Git repository EXPLAINED" : https://www.ackama.com/what-we-think/the-best-way-to-store-y...

Hourly snapshots for history.

I hardly ever need to sync things between machines since vscode manages that itself.

I get why some people need this but it's a net time sync for a lot of people that probably don't need it.

Willing to bet it's mostly due to a lack of backups and ability to restore them to a new machine when you upgrade.

One nice thing about this is that you can keep a central repo for multiple machines and use branches with rebase and merge to sync changes while keeping specific differences separate.

I used to put a lot of effort into trying to sync dot files. And you know what? I don't see a reason to do it. I only have one work computer and one personal computer.

What happens when one of those computers blows up and you need to get back to being productive quickly?

Not the person you asked, but if that happens I restore from backup.

I don't need to sync between computers to accomplish that. Could just use something as simple as Dropbox.

BUT ALSO: There's nothing that important in my personal dot files. And anything work related is in specific git repos. I could be productive with the default zsh on a fresh install of macOS by installing home brew and a few packages.

I also haven't had a mac "blow up" in... 20 years?

I used to run several VMs for several projects, and it was convenient. But now I really just have a single work project, and don't really code on my personal computer. So I no longer need it.

I moved away from using a dotfiles repo a few years ago because I kept forgetting to add/commit files as I changed them.

Instead I use mackup[0] which automatically manages symlinks to your Dropbox/Drive/Share and has support for a huge amount of software by default. You can also manually add “extra” files you wish to track if you like.

[0] https://github.com/lra/mackup

I use something similar but call it cfg: https://gist.github.com/radupotop/c1d2b77c24ddfcfae93d840f51...

Each local user has its own branch so this works: cfg push -u origin $USER

It's limited to the $HOME config files only, /etc has a separate git repo.

I have a similar system: I manage my dot files and a bunch of other configs by placing a git repository in my operating system's root directory, i.e. file:///.git. I use a .gitignore file to exclude most things from consideration while adding things to git. Transferring to another OS is as simple as copying the .git dir over.

Before your comment I never considered the inverse of .gitignore but apparently it’s very easy to do! https://stackoverflow.com/questions/987142/make-gitignore-ig...

This is cool, but I actually place ignored paths into the gitignore manually. This way I will always see reminders when a new file needs to be tracked or ignored. Otherwise I would forget to track new config files. E.g. when a new program is installed, its binary will be ignored by a previous rule added to gitignore (/use/bin/*), but its newly created config files in /etc will come up red when I run `git status`.

I found that most tooling was overkill and now just use a single <100 Bash script [0].

[0] https://github.com/TheKnarf/configs/blob/master/setup

I personally value Out Of Box Experience, and so, my personalization is more like installing software, instead of tweaking them. So I back up my /home, and on a new system, I just look at the backup, if I need settings for a program.

This isnt a vcs based solution, but I've been using syncthing to track my configs, with the help of a small home server. The bonus is that it automatically synchronises my work and personal laptops without me needing to do anything

Looks similar to what I’m doing to manage my dotfiles [0]

I’ll be refreshing this thread to see what others are using.

[0] https://github.com/andersix/dotfiles

I'm a BSD user, so I tend to gravitate towards using rcs. Took a little while to get the muscle memory down, but it does work well for keeping track of my dotfiles.

I previously found the same idea there : https://github.com/Snaipe/dot-git

nix home-manager is really great at this (and declarative!)

Does this approach work with submodules? The reason I ask is because some of my configs rely on configs from other repos.

I've been using this which is pretty rad

https://github.com/cszatmary/dot

Is there a name for oft-repeating content/post and the overall discussion on a given topic (dotfile management in this case) on HN?

I am not complaining about the repeat. It’s just that I find it very amusing to see different people kinda-sorta reinventing the wheel (and discussing the nuts and bolts) again.

That's nice, i just dump them in a GH repo. I get a backup too :)

Reply on news.ycombinator.com