Ask HN: How do you sync your computer’s development configurations/environment?

Yeah, mixed environments are really tough. Though (most) of my machines are Linux, they often have _some_ stuff that should be the same and _some_ stuff that should not. My solution has been to use the fine-grained GNU Stow approach, which allows me to apply only the bits I need for a particular machine.

The files you're managing don't even need to be text, though, of course, it makes versioning, etc. a lot easier.

I also check the host name in some of the scripts to modify behavior depending on the machine.

I did a write-up about my whole setup (emphasis on GNU Stow + Git) here:

https://ratfactor.com/setup2

I just have a dotfiles repository and in it an installation script, one for Mac and one for Linux.

Might be bad of me, but I definitely share it between professional and personal - it's just dotfiles after all.

The biggest difficulty is making sure that the installation script actually matches what you want to happen because it is difficult to test on already finished system. so every so often I spin up a Digitalocean droplet and try to configure my system from scratch using the dotfiles.

I wrote a utility for this problem. I had 3 computers -- Linux with HiDPI, Linux with a normal DPI, and Mac. They all used the same dotfiles with slight differences. It was impossible to keep them in sync. I created a super simple template utility designed for working with dotfiles.

https://github.com/kesslern/dot-templater

Sounds like a good opportunity for building a tool that syncs dotfiles in a smart way across different environments. Bonus points for managing what gets synced at a granular level, i.e. including/excluding certain files/configurations.

Check out Unison [0]. I use it to sync between macOS and Linux box.

[0] https://www.cis.upenn.edu/~bcpierce/unison/

Not just with development environments, but all computer configuration, I stick with the defaults as much as possible. Instead of changing the configuration of the computer, I change myself.

For example, let's say an app has a default keyboard shortcut I don't like. I won't change it. Instead, I'll just get used to it until it becomes muscle memory.

Now the default configurations are my preferred configurations. Of course, there are still a few things I change from the defaults. But since there are so few I can just configure them by hand, because how often am I setting up a new computer? Not very often. And there are so few config changes, it only takes a minute.

The only thing I have to actually sync is my vim config. It's a very small config, but it's still more than nothing. I just store it in a Git repository.

It's probably awful but I sorta really just rely on system backups for my configs. Download and restore anything I'm missing from the latest backup when I reinstall the system.

I do keep my ~/scripts/ directory in a git repo (also this directory is in my $PATH) because they're all very hack and slash "I need to do a thing repeatedly, quickly" scripts. Sometimes I might want to go back a step or two when I really break everything. This repo auto pulls/commitpushes every now and then as this one is more useful to be up to date on all machines than to have useful commit messages

As for live syncing devices I do have unison running on my laptop frequently to sync (when its on) a few directories I might need offline. Mostly everything I need as a dev is in git repos though, so I use manual git push/pulls to sync everything else

I did previously use mackup (https://github.com/lra/mackup) to sync configs but if I'm honest I forgot I had it set up the last time I reinstalled so it got removed from the process unintentionally

It isn't what you asked, but we use Gitpod to have identical environments across our team and between different laptops. I used to avoid writing code on my Macbook (using it only for administrative stuff I can do in Chrome), but now that it's identical to my main Ubuntu driver it's actually pretty nice. I also used to hate Windows/Mac developers complaining that scripts don't work for them because bash/coreutils are different on their machines.

Basically I use git for .local/dotfiles/ which are then symlinked to the relevant files like .zshrc or .emacs.d/init.el. Then I just keep that repo up to date with git pulls. Works across 2 macbooks, a Fedora workstation, and a Fedora headless server.

Couple of bits from a guide I wrote recently: https://gist.github.com/aclarknexient/0ffcb98aa262c585c49d4b...

    # store stuff here that you don't want in github
    [[ -f $HOME/.zshenv-local ]] && source $HOME/.zshenv-local

    # depends on 'brew install grep'
    [[ $OSTYPE =~ ^darwin.* ]] && alias grep='ggrep --colour=auto --exclude-dir={.bzr,CVS,.git,.hg,.svn,.idea,.tox}'

That OSTYPE is great for all those little bits that are unique to each operating system. The zshenv-local is in .gitignore, so you can keep tokens, api keys, etc etc in there. OSTYPE could even be used to import specific files like .zshenv-darwin or .zshenv-linux-gnu

If you're ssh'ing between your hosts, you can use something like this:

    if [[ -n $SSH_CONNECTION ]]; then
      ZSH_THEME="afowler"
    else
      ZSH_THEME="powerlevel10k/powerlevel10k"
    fi

It's not fancy and doesn't use cool tools, but my setup works for me just fine.

    git clone <repo> .dotfiles && cd .dotfiles
    stow --target=$HOME --dir=packages shell-config
    stow --target=$HOME --dir=packages work-stuff

I symlink a few files in place via Dropbox, but have most of my local configs in a dot files repo: https://github.com/geerlingguy/dotfiles

Then for more systemwide configuration, I have an Ansible playbook I run every now and then (configures apps, dock item order, etc): https://github.com/geerlingguy/mac-dev-playbook

For the MacOS users out there, Mackup is pretty nice.

https://github.com/lra/mackup

I've been using Ansible for years now to do this.

Right now all my computers run fedora so there's not much difference between them but for some time I used Ansible on macOS too. It worked but was a pain to make my roles compatible for both linux and macOS.

In my experience Ansible is good when dealing with text files or if there's already a module for what you're trying to do (for example managing postgresql users). If what you're trying to do is complex enough that you need to write a custom module or plugin, it is a pain in the ass: we had to do that at work and it was terrible.

Ansible works on Windows but I have no experience with it.

I just use Goodsync personally. I used to have it sync to a WebDAV server in my house, but these days I just use a cloud provider.

I use Nix: https://bou.ke/blog/nix/

I'm able to have the same shell with all my Vim plugins across macOS and Linux with changes committed to git. It's been so good, setting up all my command-line tooling now takes about 15 minutes from scratch.

    #!/usr/bin/env bash

    readonly gitsha="..."
    nix shell nixpkgs/${gitsha}#bash nixpkgs/${gitsha}#{foo-pkg} nixpkgs/${gitsha}#{bar-pkg} -c bash foo.sh $@

mackup + syncthing

- Dotfile repo hoested on GitHub

- `git clone` said repository to my machines

- `ln` from repository folder to `~/` (can be done in an install script or piecemeal)

- `git pull` to update

I also purposely try and use as many default configurations as possible. I use a lot of remote machines that do not have my configs on them, so I do not want to become too reliant on custom setups.

Dotfiles in my home directory go in a repo that gets cloned and "installed" (I use a shell script that I wrote to make all the symlinks, but GNU Stow is probably better better). System level configuration and package installation is handled by ansible, with a certain amount of stuff controlled by conditional statements based on the distro and host name of the machine to allow arbitrarily local overrides.

All that said, if I was starting today I would strongly consider just putting everything into nix with home manager and carry that config around in a git repo that installed my packages and their configuration and encapsulated my entire environment.

home-manager and nix: https://github.com/legendofmiracles/dotnix

This allows me to abstract logic easily, have it all modular and have everything be nix.

You could use a dotfiles manager like https://yadm.io/

It's more or less a wrapper of git, but it comes with a bunch of features that allow you to do the things you describe.

    yadm_diff=$(yadm --no-pager diff --name-only --exit-code)
    if [ $? -ne 0 ]; then
        echo -e "\e[1m\e[91m[yadm] \e[0m\e[92mThese config files have been modified:\e[39m"
        echo "$yadm_diff"
    fi

I use Strap (https://github.com/MikeMcQuaid/strap) to manage everything and it works pretty dang well for me on macOS. Homebrew brewfiles were a game-changer.

I have a custom repo which my .config folder will have symlinks to. It gets synced to remote git (~GITHUB). For new devices, I use stow[0] to create symlinks...

[0] - http://www.gnu.org/software/stow/

I used to use a git repo of dotfiles which used a script to symlink into $HOME: https://github.com/RyanGibb/dotfiles

But there were a few problems with it: - installed packages needed to be managed separately (the mechanisms for which varied by platform) - managing differing configs for different machines (e.g. headless servers, hardware quirks) was done by managing different branches of this repo and rebasing, which was a pain - it was generally brittle and hard to change

I've started to use https://nixos.org/ and it's been like night and day: https://github.com/RyanGibb/nixos/

My config is version controlled, reproducible, manages packages, and is very composable.

Using the nix package manager and https://github.com/nix-community/home-manager this should work on other Linux distributions, MacOS, and even Windows Subsystem for Linux. Although I haven't tried this for myself yet.

Personally I'm in Emacs for almost anything so different environments are just different set of org-mode files with things to tangle, different org attach and roam directories etc, common staff sync-ed with unison.

That's work VERY well, but might not fit your needs depending on what you need to use for work...

the main question here is, do you really need to change the settings once you have a baseline?

I'm another one using a private GitHub repo for this. But I don't need to pull, update, sync or whatsoever. I've been using the same config for years, and in the eventual case that I would change / add something, I can do that quickly in a few computers, no need to have any sort of sync.

For VSCode settings I just use the built-in service.