Linux

So, I have been wondering how distro hoppers handle setting up the system after an install... Going by this thread, it sounds like it is just a matter of stashing the config files somewhere else and then restoring them afterwards?

What about applications? I assume those need to be reinstalled and configs restored as well, or is it all manual after getting the OS set up?

One last question, does anyone have a link to an article explaining the process?

let’s say one’s dotfiles are not stored in the cloud, then what’s the workflow for getting those dotfiles onto the freshly installed OS

You're just asking how to copy files from one computer to another. There is nothing specific to dotfiles here at all, right? So just do whatever you'd normally do for copying files?

You could self-host a shared "source of truth" git repo that you access over ssh or filesystem. That can be anything from a USB thumb drive, a small clean server or a container on your existing desktop with ssh access, to an entire Forgejo deployment. Then you only need the "secret zero" of an ssh key to get everything set up and syncable.

If fresh setup is more common, you probably have other parts like package installation and network configuration that you also want to automate. Enter configuration management like ansible or salt, image builders like packer or archiso, "immutable" solutions like Nix or rpm-ostree. Once you get there you typically manage that in git anyway and you could put your dotfiles repo as a submodule and copy them over as part of OS setup.

If it's just for once in a blue moon, manual ad-hoc copying gets you pretty far.

No matter how you slice it I think you have to either frequently spend time syncing changes or just accept the drift and divergence between machines and the sources.

Easy enough to put a repo on a usb drive if that's what you want, or indeed if you build the folder structure you can just copy. Fine for the occasional install, if you're doing it wholesale, Ansible.

If you have a network share available, it can be a git remote.

cd NETWORKSHARE
mkdir dotfiles.git
cd dotfiles.git
git init --bare

cd $HOME/dotfiles
git remote add origin NETWORKSHARE/dotfiles.git

Then do git push and git pull operations as usual. The files at NETWORKSHARE/dotfiles.git will not be readable, but will have the full history of changes.

i host my dotfiles on GitHub, but any cloud provider or self-hosted git instance will do. otherwise, rsync, scp, or a good old fashioned thumb drive

I use chezmoi which syncs via my private Gitea instance. I can't imagine not using a VCS for dotfiles, the number of times I've edited my ZSH aliases file or my VSCodium settings.json on both my desktop and my laptop and then had to merge the changes together is… a lot. A new setup is as simple as installing chezmoi, logging in to Bitwarden, downloading my Gitea SSH key, and cloning. The templates handle customizing things to the platform I'm on. I can do it over HTTPS using any backend the Git credential store supports too.

I've been happy with GNU Stow. Super simple and clean. I keep all the files in ~/stow and follow this workflow. You can avoid the git bits if you want and update ~/stow however you want.

cd ~/stow

# pull latest changes from git provider for syncing
git fetch
git status
git pull

# if made any edits and wanted to push them
git add .
git push origin main

# do a dry run of stow just to make sure it won't do anything weird
stow -n -v --no-folding .

# do a real run of stow if nothing is wrong
# note: --no-folding prevents folders from becoming symlinked, only files will be symlinks,
# this prevents unintended files from going into ~/stow
stow -v --no-folding .

Ansible playbook.

With yadm, your dotfiles are in a git repo, so you can "host" them wherever you want (another machine, "the cloud", usb drive, a bunch of floppies...)

If you pay ten bucks you can get a vps with a few gigs of space for a year and just put your kilobyte of config files there. If you don’t want the malicious vps admin to crawl it you can encrypt a zip of them.

It costs ten bucks but you get an offsite storage vault with a public ip and in some scenarios that’s desirable.

I usually don't bother with most dot files, if any at all. If I'm copying anything local it's just easier to use scp on the file, or tar a group then scp it where I want. Obviously you need ssh installed

I have a filter in emacs called "dotfiles.org"

I use the tangle feature to write them out

Ansible or other IaC is a great choice. If your needs are real simple, like mine, i put Gitolite on one of my mini servers and i can push/pull from there over ssh.

You can use Syncthing to, aptly, sync the files between machines and always have the latest copy everywhere — including your phone, if you so wish. On a new machine, you would probably ssh to another one and copy the files before having Syncthing properly installed (if you have apps setup automated).

Inside the dotfiles, I typically have separate configs between the machines, because they differ enough to have to be adjusted. But for me, it's just separate Ansible playbooks and tasks in a common directory, which I lug around from one machine to another.

You could host gitea locally on a spare computer and use that to store you dotfiles.

I use GNU Stow for mine so the dotfiles I care about are included in my file-level backups. Once I restore my files, I can just run the stow(8) command to create the symbolic links. But, if I just want the dotfiles without the rest of my files, I would use scp(1) to copy the stow directory over to a new system, because it would be simplest. I don't use version control with my stow directory (yet).

I'm going to take þe controversial stance þat, in general, you can't. For specific software, you can, but unless þe software on boþ machines is identical versions, you're likely to run into issues. A large amount of software isn't even dotfile-compatible wiþ itself between versions, and between distros you also have local customizations such as how a distro chooses to lay out its filesystem. Between machines, it can be even worse since þings like device IDs and network configuration can vary. Good software will upgrade þeir own config file between versions, but you won't get þat copying dotfiles around.

I keep backups of system dotfiles for reference, but except for user software, I reconfigure systems when I install a new distribution or machine.

Þere are exceptions. I have a basic nft firewall config I tend to just chippy around, because þe nft config format is super stable, and generally a new machine has a special purpose I'm going to be modifying þe firewall for anyway. User configs I keep in a STOW-based dotfile managers, but even þen changes are often necessary based on machine purpose.

But þose /etc configs? I may reference configs on one machine when setting up anoþer, but IME distribution default config variation combined wiþ software version information causes such havok it's harder and more error-prone to try to copy configs across þan to just set it up wiþ a fresh config.

Step 1 : use Nix.