A cross-platform multi-target dotfiles manager written in Rust
79 comments
·March 2, 2025glutamate
lionkor
I find Rust super ergonomic for any kind of app. The memory management aspect is trivial and second nature to anyone used to unmanaged languages, and the type system equally is not difficult to understand.
It's a general purpose language, but it does give you full control. Plus, of course, you can encode a large amount of program states in the type system and borrowing checks enforce rules that programmers usually have to check in their head.
I find that when I write Rust, I have to worry about an order of magnitude less about silly things like lifetime bugs, reference bugs, resource cleanup, all of which are 80% of my job when I write C#, or other similar managed languages.
Plus Rust can generate a static executable, which is reasonably small, and doesn't require a third party runtime.
pjmlp
As someone used to unamaged languages since 1986, and with a major focused on systems programing, it isn't that clear cut.
Rust executables are only 100% static on OSes that expose system libraries as static libraries, and there are not many of those around, outside embedded systems.
saghm
As a counterpoint to the parent commenter, I like using Rust for personal stuff (like the project being linked to) for almost everything besides the memory model; I prefer Cargo to any other build tool I've used, and I like how I can eliminate boilerplate with stuff like Serde (for serialization), clap (for argument parsing), and even for how I'm able to write one-off macros to generate code for myself. The documentation for the language and tooling is great, and most packages have fairly good documentatio as well because any package published on crates.io will have it generated from the doc comments into a static site and hosted on docs.rs. The compiler error messages are better than any other language I've used, and at least for my personal use on Linux, I can easily compile with musl and get a fully static binary when libc is my only native dependency; I'm sure that Linux desktops are part of the "not many of those around" you refer to, but the same trick would work just as easily for any Linux server, and I do feel like there are plenty of those around!
If I could get all of those quality of life things in a language with a garbage collector, I'd probably use that for most things instead. Right now though, the closest options would be maybe OCaml or Swift, one of which doesn't really give me nearly as much in terms of quality of life stuff around documentation and tooling, and the other isn't nearly as streamlined to use on my platform of choice as I'd like, so I'm using Rust unless (or until!) something better for my personal projects comes along.
jcelerier
After years navigating this issue, I think the common understanding of "static" binary is just "something that won't give me a dll / dylib error on startup when I copy it to my friend's computer"
ninkendo
> Rust executables are only 100% static on OSes that expose system libraries as static libraries
This seems to be a weird hair to split. GP clearly means “a single executable you can run on any install of the target OS without dependencies.” Whether it’s a truly honest-to-goodness static binary that don’t link to libc or libSystem or whatever is important to approximately zero people, outside of internet pedants.
terminaltrove
Rust is a popular choice for CLI tools as well as Go and I do think the ecosystem is picking up.
In fact there are a bunch of them for the terminal.
sepositus
I've used both, and they are comparable in library support. I happen to write _much_ faster in Go, so it's usually my default choice for CLIs, unless I specifically need to bridge with another Rust program.
K0nserv
Two things:
1. Historically a CLI like this would often be written in C, so Rust isn't that strange of a choice.
2. Rust is know for the borrow checker and being a great low level language. However, it's also an excellent modern general purpose language with a great ecosystem. People end up using it for all kinds of things because it's a joy to use.
"When I tried developing in Rust I came to the conclusion that you pay a heavy price for not having a garbage collector. Was I doing it wrong?"
Rust is tricky to grasp initially, the learning curve goes pretty much vertical immediately, but once you "get it" it's very nice. When I started out I overused borrowing and ran into heaps of lifetime problems. I think limiting yourself to only using references for function arguments and, rarely, return values is a good place to start. As soon as you are start adding references to struct you should stop and think about who owns the data and what its lifetime is. Thinking properly about ownership is the big shift from GC languages. Once you've gotten into that habit, lifetimes are downstream from that.
oguz-ismail
>Historically a CLI like this would often be written in C
*Perl
goku12
Rust is my main programming language and Python the second. Rust is very much useful for application programming - especially these sort of applications. In fact, Rust is the language I sometimes reach for when my shell scripts cross a certain threshold of complexity. Rust even has some tools and an RFC to address the use case of using it like a scripting language (I believe that Go has something similar too).
I don't face much friction from the borrow checker to consider it a 'heavy price for not having a garbage collector'. There are even tools like bacon [1] that can give your real-time feedback on your code. It's even better with the default language server. I sometimes train other developers in Rust - mostly people who are not even into systems programming (JS, Python programmers). However, they don't seem to struggle too much with the borrow checker either. Could you elaborate a bit on what you consider as 'the heavy price'? What sort of issues were you facing frequently?
ForTheKidz
It's BEEN built so the price has been paid. I'm not going to complain that someone over-engineered a useful tool and got away with it.
I will say that rust is pretty damn productive once you organize your brain around ownership. I haven't had to mark a lifetime in over a month.
pkolaczk
Rust is a general purpose programming language not just systems programming language.
thiht
As a user, if I have the choice between 2 apps, I’ll strongly favor a Go, Rust or ANSI C app over a Python, Ruby, Shell or C++ app.
This is because empirically, they usually work better, feel more polished, faster and I can easily contribute patches if I need. If a tool is written in Python, I’ll go out of my way to find a rewrite in another language.
m11a
Syntactically it's a pretty nice language, with a nice and sane ecosystem (crates, etc), and it's fun to write (which is a pro especially for unpaid hobby projects). If you get used to it, it's nice to write various things in it. I'd probably use it for CLI tools at this point.
You do pay a bit in syntactic overhead (lifetimes, borrow checking perplexities), though you get used to it. I'd still not use it for a standard product-y web app. For CLI tools though, it's pretty good.
pinoy420
[dead]
tempodox
I just use a “dotfiles” folder that is a git repo and then hard-link the files in there into the home directory. One for unprivileged user and one for root on each platform. Simple enough and doesn't require an extra tool.
KetoManx64
How do you handle differences between machines? I use cheznoi to manage my dotfiles and share them between 6 different devices, 2 of them are work machines. On my work machine I have maybe a 15% difference in config, primarily my hotkeys through keymapper, my SSH config files, and also the applications I have installed. Chezmoi let's me add logic to my source controlled config files that, based on the hostname/domain/network, etc let's me ouput different settings to the .config files, which I cannot do in the config files themselves.
For example: On my home machine I have the following keymapper hotkey: Windows + T: Activate Telegram On my work machine that's mapped to: Windows + T: Activate Teams
hk1337
I went a different route and use different branches for different OS environments. macOS, macOS-arm, Linux, Windows (wsl)
The environments are basically the same in each but there’s some functionality I can do I one that I cannot do in another
DiabloD3
So, I'm usually the huge Rust promoter, but we already have a lot of dotfiles managers, and Chezmoi, although written in Go, is right there.
What can this one do that the other ones don't?
The README lists features that, well, I'd already expect modern dotfile managers to be able to do.
cquintana92
Looks like we took similar approaches!
https://github.com/cquintana92/dotfilers
Congratulations, you too unlocked the "None of the hundreds that are out there work exactly like I want, so I'll write my own" badge.
protortyp
Completely unrelated, but I recently switched to using nix with home manager and nix-darwin to handle my entire dev setup and dotfiles.
If you work a lot in remote dev environments (I use coder a lot at work) that really does the trick.
indemnity
Likewise. I have two Mac laptops, three home servers, and a Windows desktop managed by Nix.
The home servers are nixOS, the rest basically have the CLI environment managed with nix-darwin and nixos-wsl, all with one flake (Git repo) containing all the configuration.
Case in point - this morning I’m rebuilding one of the servers onto new hardware, and the longest time spent was getting the flake config onto the server with git clone. Now just watching the rebuild switch command output, after which it’s good to go.
dbalatero
I had to switch off nix because my company's security controls made it impossible to use :(
dankobgd
There are many of these tools but i don't like to think of these things like dotfiles. What is a dotfile? A `.something` file in my home dir? is /etc/environment a dotfile? No, but i wan't to manage it still. What about Librewolf policies.json in /usr/lib64/librewolf/policies or similar. It's not a dotfile either. For some tools, i need some other tools to exist already in path. What about zsh where i want to sync 3 git repos for syntax highlighting and other scripts? Also what about secrets, maybe i want some encrypted stuff so i need a solution for that also.
Ansible is the best for these things, no symlinks needed, just configure what you want to exist and where and you can template configs or copy them or use some modules like `git_config` to then generate that ini file etc. Ansible vault also handles encryption easily so i can manage ssh keys, passwords...
Ecco
Dumb yet serious question : what problem is a dotfile manager even trying to solve?
Personally I have a git repo in my home directory and just commit dotfiles to it. The only drawback is that git always think there’s a git repo no matter where I am in my home, so I usually rename the .git folder to .git_hidden. And on the (rare) occasion that I want to update one of my dotfiles I just rename the .git_hidden directory back to .git.
It’s really just two “mv” commands, I can’t believe you need a tool for just that.
What am I missing out on?
para_parolu
I recently learned it. I have personal and work laptops (two work laptops as of now for different companies). 90% of dotfiles should be the same. But rest is pain to sync. I’m using chezmoi that has templating mechanism that helps me.
mdaniel
FWIW, you don't have to do that rename dance; git allows specifying the name of the .git metadata directory via `git --git-dir=$HOME/.git_hidden ...` or `GIT_DIR=$HOME/.git_hidden git ...`
I don't know how big your .gitignore must be when trying to use a tool that wants to own every file and directory to manage your /home but if that works for you, more power to ya
Ecco
Oh, interesting, thanks!
And I don’t even bother with ignoring files! I just git add the ones I want to track :)
bean-weevil
Start with ls -a -w1 > .gitignore, then edit it and delete everything you want to track.
baby_souffle
Is there a concise comparison between other tools?
Specifically looking to see where this differs from chezmoi.
MotiBanana
Pretty cool, I personally just use Stow.
1. git clone my dotfiles repo
2. run `stow .`
3. profit
This pretty much guarantees that if my Mac dies today, I can just get up and running in no time on a new machine.
raaron773
Same. Stow is pretry great! I only recently discovered about the .stowignore very handy!
This looks like it can work with windows as well and you can easily switch between profiles if you have multiple which is great too
metaltyphoon
I need something that works across OSes. Chezmoi works pretty well.
omani
> This project was driven by the personal need of having to manage several dotfiles for different machines/targets.
the functionality OP is searching for is already provided by chezmoi. and many more features.
l00sed
I've used a similar tool, called dotter, by SuperCuber on GitHub. It's actually very similar--uses a handlebars template language and built in Rust. Definitely a must have if you're on multiple *nix systems and you've invested time into developing your configs!
k3vinw
Shameless plug for my bare repo git shell wrapper approach inspired by others: https://github.com/k3vinw/simple-dotfiles-kit
I’ve been using it for a couple years now and it’s worked well for me across multiple machines.
Serious question: why Rust? Sounds like this is not exactly systems level programming or any user would suffer from or even notice garbage collection latency.
Is Rust building up a decent ecosystem now for application programming? When I tried developing in Rust I came to the conclusion that you pay a heavy price for not having a garbage collector. Was I doing it wrong?