You Lost Two Days Last Month and Didn't Even Notice
New MacBook. Fresh Linux server. A reinstall you've been putting off.
You open Terminal and start typing. brew install... git clone... ln -s... chsh... defaults write...
Three hours in, you realize you forgot that one font. That one Raycast extension. That SSH key config. That Python version your project needs.
Two days later, you're mostly back to where you were. Mostly.
Your coworker asks how to set up the project. You send them a Notion doc from 2023 that's half wrong. They spend a day figuring out what changed.
This is insane. We build tools that deploy apps to millions of users in seconds, but we set up our own machines like cavemen copying commands from Stack Overflow.
What If Your Entire Machine Was a Single File?
install git curl zsh on: [mac, linux]
homebrew mass-rename raycast orbstack warp on: [mac]
homebrew postman tableplus notion on: [mac]
mise node@22 python@3.13 go@1.23 on: [mac, linux]
clone git@github.com:mycompany/api.git to: ~/work/api on: [mac]
clone git@github.com:mycompany/web.git to: ~/work/web on: [mac]
dotfiles git@github.com:me/dotfiles.git on: [mac]
known_hosts github.com gitlab.com on: [mac, linux]
shell zsh on: [mac, linux]
ollama llama3 codellama on: [mac]
That's not pseudocode. That's not YAML. That's not a 400-line bash script you wrote at 2am.
That's a Blueprint file. And it does everything.
blueprint apply setup.bp
Walk away. Make coffee. Come back to a fully configured machine.
"I Already Have a Dotfiles Repo"
Cool. Does it:
Uninstall packages you removed? Blueprint does. Delete a line, re-apply it's gone. No orphan packages cluttering your system.
Track what it installed? Blueprint does. Run blueprint status and see exactly what's on your machine, when it was installed, and from which blueprint.
Work on both macOS and Linux from the same file? Blueprint does. One file, on: [mac, linux] it picks the right package manager automatically.
Run in parallel? Blueprint does. Independent rules execute simultaneously. Your 50-step setup doesn't wait in line.
Show you what changed? Blueprint does. blueprint diff setup.bp shows exactly what's new, modified, or removed since your last apply.
Your dotfiles repo is part of your setup. Blueprint is your entire setup.
# Blueprint even manages your dotfiles
dotfiles git@github.com:me/dotfiles.git on: [mac]
One line. It clones, symlinks, and keeps them updated. Every time.
Zero Dependencies on the Target Machine
Here's where it gets fun.
Need to set up a machine that doesn't have Blueprint installed? A CI runner? A Docker build? A fresh VPS?
blueprint export @github:yourname/setup | bash
That generates a fully standalone shell script and pipes it directly to bash. No Blueprint binary needed on the other end. The script:
- Bootstraps Homebrew, mise, asdf, or Ollama if they're missing
- Checks if each package is already installed before touching it
- Shows colored progress: green for executed, yellow for skipped
- Logs all command output to
~/.blueprint/blueprint.log
You can also save it:
blueprint export setup.bp --output setup.sh
Hand that script to anyone. It works everywhere.
18 Actions. Everything You Need.
Blueprint isn't just brew install with extra steps. It handles your entire environment:
| You want to... | Blueprint |
|---|---|
| Install system packages | install vim git curl |
| Install brew formulas & casks | homebrew node docker raycast |
| Manage runtime versions | mise node@22 python@3.13 |
| Clone & auto-update repos | clone repo.git to: ~/work/repo |
| Symlink your dotfiles | dotfiles github.com/me/dots.git |
| Download binaries | download https://... to: ~/.local/bin/tool |
| Pull AI models | ollama llama3 codellama |
| Run any shell command | run "defaults write ..." unless: "..." |
| Execute remote scripts | run-sh https://install.something.sh |
| Set your default shell | shell zsh |
| Add SSH known hosts | known_hosts github.com |
| Manage SSH authorized keys | authorized_keys ~/.ssh/id_ed25519.pub |
| Create directories | mkdir ~/projects perms: 755 |
| Add apt repositories | gpg_key docker-ce |
| Grant passwordless sudo | sudoers deploy |
| Schedule recurring applies | schedule setup.bp daily |
| Encrypt sensitive files | encrypt ~/.ssh/id_rsa |
| Decrypt on apply | decrypt secrets.enc to: ~/.secrets |
Every single action is idempotent. Run it once. Run it a thousand times. Same result. No duplicates. No errors. No "already installed" warnings flooding your terminal.
Dependency Graph? Handled.
Need Git before you clone repos? Homebrew before your packages? Just say so:
homebrew git id: git-pkg on: [mac]
clone git@github.com:me/api.git to: ~/api after: git-pkg on: [mac]
mise node@22 id: node-runtime on: [mac]
run "npm install" after: node-runtime on: [mac]
Blueprint builds the dependency graph, detects circular dependencies, and executes independent rules in parallel within each wave. It's not running 50 sequential steps — it's running as fast as your dependency tree allows.
Modular By Design
Your setup isn't monolithic. Why should your blueprint be?
# setup.bp — the main entry point
include tools/packages.bp
include tools/runtimes.bp
include tools/repos.bp
include personal/dotfiles.bp
Share the team baseline. Keep your personal config separate. Blueprint resolves includes, detects circular references, and merges everything into a single execution plan.
Full Observability
This isn't a fire-and-forget script. Blueprint gives you complete visibility into your machine state:
# What's installed right now?
blueprint status
# Full history with timestamps and outputs
blueprint history
# What's the slowest step?
blueprint slow
# What would change if I apply now?
blueprint diff setup.bp
# Validate syntax without running anything
blueprint validate setup.bp
# Is your status file healthy?
blueprint doctor --fix
Reads Like English. Runs Like Code.
No YAML indentation hell. No JSON bracket matching. No HCL learning curve.
Blueprint's DSL is plain text that reads like a sentence:
install python3 on: [mac, linux]
clone git@github.com:me/api.git to: ~/work/api after: base-tools on: [mac]
download https://example.com/bin to: ~/.local/bin/tool perms: 0755 on: [linux]
If you can read it, you can write it. If you can write it, your entire team can maintain it.
Get Started in 30 Seconds
# Install Blueprint
curl -fsSL https://install.getbp.dev | sh
# Create your blueprint
cat > setup.bp << 'EOF'
install git curl on: [mac]
homebrew raycast on: [mac]
mise node@22 on: [mac, linux]
dotfiles git@github.com:me/dotfiles.git on: [mac]
shell zsh on: [mac]
EOF
# See what it would do
blueprint plan setup.bp
# Make it happen
blueprint apply setup.bp
That's it. Your machine is now reproducible, shareable, and version-controlled.
Push your .bp file to a repo. Next time you set up a machine — any machine — it's one command:
blueprint apply @github:yourname/setup
The Bottom Line
You spend hours setting up machines. You spend days onboarding teammates. You spend forever maintaining setup scripts that rot the moment you save them.
Blueprint is a single binary. Zero runtime dependencies. Open source. Written in Go.
Your machine setup should be declarative, reproducible, and boring. Blueprint makes it all three.
elpic
/
blueprint
Blueprint is a DSL (Domain Specific Language) based rule engine written in Go. It allows you to define and execute complex rules with conditions and actions in a declarative manner.
Blueprint
Declarative machine setup, one line at a time.
Blueprint is a DSL-based rule engine that lets you define your entire development environment in a plain-text .bp file and apply it with a single command.
install git curl on: [mac]
install python3 ruby on: [mac, linux]
clone https://github.com/user/dotfiles.git to: ~/.dotfiles on: [mac]
dotfiles ~/.dotfiles on: [mac]
Installation
curl -fsSL https://install.getbp.dev | sh
Or download the latest binary from releases.
Quick Start
1. Create a blueprint file (setup.bp):
install git curl on: [mac]
install python3 on: [mac, linux]
2. Preview the plan (dry-run, no changes):
blueprint plan setup.bp
3. Apply the blueprint (execute rules):
blueprint apply setup.bp
4. Check current status (what's installed):
blueprint status
That's it. Blueprint generates the correct package manager commands for your OS, tracks what it installed, and automatically cleans up packages you remove from the file.
Actions
Each line in a .bp file…
Blueprint is open source and free. Star it if you want to stop writing setup scripts forever.