devup

One command to turn a fresh Ubuntu install into a polyglot development machine.

Built for Go + Rust + Python + TypeScript work on a laptop with a modest CPU and a disk that fills up faster than you expect.

curl -fsSL https://raw.githubusercontent.com/rabinhansda24/devup/main/install.sh | bash

Then just:

devup

---

What it does

• Detects before it installs. Every package has a check command. Run it on a half-configured machine and it only does the missing work.
• Menu-driven. Browse by category, see what is already installed, tick what you want. Or use a profile and go get coffee.
• Auto or manual. --manual prints the commands instead of running them, so you can learn from it or cherry-pick.
• Idempotent. Safe to re-run. Config files use marked blocks and get backed up before being touched.
• Configures, not just installs. Docker log rotation, a shared Cargo target directory, the mold linker, WezTerm leader keys, sane git defaults.

Usage

devup                              # interactive menu
devup status                       # what's on this machine
devup list                         # every package + install state
devup doctor                       # diagnose common problems

devup --profile fullstack --auto   # unattended full setup
devup --dry-run -p fullstack       # preview it, change nothing
devup --manual -p minimal          # print instructions instead

devup install ripgrep fzf lazygit  # just these
devup config shell-integration     # re-run one config step
devup clean                        # reclaim disk from build caches

--dry-run works with everything and is the recommended first run.

Profiles

Profile	What it's for
fullstack	Everything. Go, Rust, Python, Node, Docker, WezTerm, backups.
minimal	Build tools, git, and a usable shell. Nothing else.
terminal-transition	Tools for moving GUI habits into the terminal, gradually.
rust-heavy	Rust with compile-time and disk optimisations maxed out.

Profiles are plain text files in profiles/. Copy one and edit it.

What gets installed

System & build essentials

build-essential, pkg-config, libssl-dev and the other headers that -sys crates and native npm modules need, plus curl/git/unzip and zsh with autosuggestions and syntax highlighting.

Shell ergonomics — do these first

starship (prompt), atuin (fuzzy history), zoxide (smart cd), direnv (per-project env).

A bare shell genuinely is worse than a GUI. These are what make it better.

CLI tools

ripgrep, fd, fzf, bat, eza, jq, dust, ncdu, delta, lazygit, gh, just, tealdeer, yazi, chezmoi.

Language toolchains

mise manages Go, Node and Python versions with per-project auto-switching. Rust comes from rustup, Python packaging from uv, Node packages from pnpm.

Nothing language-related comes from apt — distro runtimes are always stale.

Containers

Docker Engine from Docker's own apt repo. Not Docker Desktop, which runs a VM on Linux and costs you RAM and disk for no benefit. Plus lazydocker.

Terminal

WezTerm from the official .deb (never the snap) and JetBrainsMono Nerd Font, which you need or prompt glyphs render as boxes.

Backups & maintenance

Timeshift (system snapshots), restic (encrypted $HOME backups), smartmontools (SSD health — important on a second-hand drive), and devup-clean.

Design decisions

A few choices that aren't obvious, and why:

Bash, not Go or Rust. A machine-provisioning tool written in a compiled language needs a toolchain to build it, which is circular on a fresh install. Bash runs on a bare Ubuntu box with nothing installed.

A shared Cargo target directory. CARGO_TARGET_DIR=~/.cache/cargo-target deduplicates build artifacts across every project instead of a 3–5GB target/ per repo. On a 500GB disk with several Rust projects this is the single most effective disk saving available.

pnpm over npm. The content-addressable store is the biggest disk win in the Node ecosystem.

Docker log rotation by default. Unrotated container logs will silently consume tens of gigabytes. daemon.json gets max-size: 10m, max-file: 3 and a 20GB cap on the build cache.

mold linker for Rust. On a modest laptop CPU, linking dominates incremental build time. mold plus debug = "line-tables-only" is the biggest compile-time win short of buying a different machine.

No aliasing of cat or du. dust and bat take different flags. Shadowing standard commands is how you end up unable to work on a machine that isn't yours. Aliases here are shortcuts for things you already know how to type.

Snaps avoided. Docker-as-snap has confinement problems with bind mounts; editor snaps have their own. Everything here uses apt repos or vendor .debs.

Requirements

• Ubuntu 22.04, 24.04 or newer (Debian derivatives mostly work)
• x86_64 or aarch64
• sudo access
• git (the bootstrap installs it if missing)

Safety

• Nothing runs without showing you the plan first, unless you pass --yes.
• Existing config files are backed up to <file>.devup-bak.<timestamp>.
• Additions to .zshrc/.bashrc go inside # >>> devup:... >>> markers, so they can be updated or removed without touching the rest of the file.
• Vendor install scripts (rustup, mise, uv, starship, atuin) are piped to sh, which is the officially supported path for those tools. The URL is always printed before it runs. If you'd rather not, use --manual and audit each one.
• Full log at ~/.local/state/devup/devup.log.

Uninstalling

devup doesn't track what it installed for removal — it's a setup tool, not a package manager. To undo its configuration:

rm -rf ~/.config/devup
# then delete the "# >>> devup:shell >>>" block from ~/.zshrc and ~/.bashrc
rm ~/.local/bin/devup ~/.local/bin/devup-clean
rm -rf ~/.local/share/devup

Backups of anything it replaced are alongside the originals as *.devup-bak.*.

Contributing

Adding a tool is usually a 10-line block in a file under modules/. See CONTRIBUTING.md.

License

MIT