Dotfiles Management

https://mitxela.com/projects/dotfiles_management

by threeme3 • 4 years ago

311 138 4 years ago

bennyp101• 4 years ago

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/

txprog• 4 years ago

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!

pstuart• 4 years ago

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

theshrike792• 4 years ago

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

CamJN• 4 years ago

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...

saintfiends• 4 years ago

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.

lucideer3• 4 years ago

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.

eviks3• 4 years ago

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

Barrin922• 4 years ago

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.

twp4• 4 years ago

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...

snapsnail• 4 years ago

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.

wkdneidbwf3• 4 years ago

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?

k4j83• 4 years ago

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?

watusername• 4 years ago

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

__MatrixMan__4• 4 years ago

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).

unshavedyak2• 4 years ago

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)

zeorin• 4 years ago

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.

kaba04• 4 years ago

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.

wkdneidbwf3• 4 years ago

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.

zamalek3• 4 years ago

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.

__MatrixMan__4• 4 years ago

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

tjoff2• 4 years ago

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.

colordrops5• 4 years ago

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

unicornmama• 4 years ago

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.

__MatrixMan__4• 4 years ago

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.

gandalfgeek• 4 years ago

You win this thread.

satiric• 4 years ago

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

colordrops5• 4 years ago

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.

rgoulter• 4 years ago

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.

TheFreim• 4 years ago

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`.

l0b0• 4 years ago

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

amarshall• 4 years ago

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.

senorsmile• 4 years ago

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.

fileeditview• 4 years ago

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

SuperCuber• 4 years ago

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

l00sed• 4 years ago

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!

g0xA52A2A• 4 years ago

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.

echelon• 4 years ago

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?

hermanradtke• 4 years ago

The git ignore file set up prevents accidental pollution.

A script and/or symlinks is overhead.

nerdponx• 4 years ago

  # 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

ZeroGravitas• 4 years ago

"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/

josephd79• 4 years ago

This is what I do also.

twp4• 4 years ago

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...

sureglymop• 4 years ago

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

brechtm• 4 years ago

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.

tomphoolery• 4 years ago

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.

j1elo• 4 years ago

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.

chadlavi2• 4 years ago

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.

jonwest2• 4 years ago

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

doubleunplussed• 4 years ago

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

chadlavi2• 4 years ago

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?

jacobsenscott2• 4 years ago

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.

jonwest2• 4 years ago

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.

davidhay• 4 years ago

Second dotbot.

masto• 4 years ago

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.

ericvsmith• 4 years ago

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.

Karellen• 4 years ago

    ~/.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`?!)

jacobsenscott2• 4 years ago

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.

leipert• 4 years ago

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.

base698• 4 years ago

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

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

spudlyo• 4 years ago

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

twp4• 4 years ago

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....

nverno• 4 years ago

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

nirvdrum• 4 years ago

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.

_0xdd• 4 years ago

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.

neeh0• 4 years ago

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

djhworld• 4 years ago

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

dewey• 4 years ago

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.

layer8• 4 years ago

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

agumonkey• 4 years ago

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.

sudhirkhanger2• 4 years ago

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.

gillh2• 4 years ago

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

firstSpeaker• 4 years ago

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?

gillh2• 4 years ago

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...

sudhirkhanger2• 4 years ago

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

pprotas2• 4 years ago

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

wooptoo• 4 years ago

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.

ckolkey• 4 years ago

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

jsmeaton• 4 years ago

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

snhly2• 4 years ago

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.

Waterluvian• 4 years ago

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...

snhly2• 4 years ago

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`.

andersonvaz• 4 years ago

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

asix66• 4 years ago

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

pyrophane• 4 years ago

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.

timetraveller26• 4 years ago

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

auraham• 4 years ago

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

justaj• 4 years ago

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

pprotas2• 4 years ago

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.

Oxidation• 4 years ago

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

andrewla• 4 years ago

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.

blueflow• 4 years ago

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.

cassepipe• 4 years ago

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

bxfhjcvu• 4 years ago

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.

drexlspivey• 4 years ago

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.

wadkar• 4 years ago

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.

res0nat0r• 4 years ago

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

palijer• 4 years ago

I've been using this which is pretty rad

https://github.com/cszatmary/dot

DavideNL• 4 years ago

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...

Touche• 4 years ago

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.

sontek• 4 years ago

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)

theknarf• 4 years ago

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

npteljes• 4 years ago

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.

mattpallissard• 4 years ago

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.

shreyshnaccount• 4 years ago

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

GrqP• 4 years ago

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

redraw• 4 years ago

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

Dotfiles Management

Related Stories