fest@arch:~$
immutable config · arch linux · go

$ declarative, immutable system configuration for Arch Linux

All the power of declarative infrastructure, none of the complexity. Describe your whole machine in Go — packages, services, files, users — then sync any Arch box to match.

~/mysystem/main.go — go
package main

import "github.com/emad-elsaid/fest"

func main() {
    // Declare your entire system in Go
    fest.Package("vim", "git", "docker", "firefox")
    fest.SystemService("docker")
    fest.Timedate("America/New_York", true)

    fest.Main() // That's it. Seriously.
}
why arch + go over nixos
Fest+8 additions
  • Familiar Language: use Go, not a custom DSL
  • Type Safety: compiler catches errors first
  • Zero Learning Curve: know Go, you're ready
  • Keep Your Distro: stay on Arch Linux
  • Access to AUR: 80,000+ packages via yay
  • Pacman Speed: no rebuilding everything
  • Standard Tools: systemd, pacman, familiar
  • Rolling Release: always latest packages
NixOS+8 removals
  • Custom Nix language to learn
  • Steep learning curve (weeks/months)
  • Must switch entire distro
  • Limited repo compared to AUR
  • Long rebuild times
  • Non-standard filesystem layout
  • Different package manager
  • Reproducible, but complex

// the philosophy

NixOS forces you to learn a new language, adopt a new distro, and rewire your mental model of Linux. Fest gives you immutable infrastructure without the friction.

You already know Go. You already love Arch. Why compromise? Get declarative configuration, reproducible systems, and version-controlled infrastructure — while keeping the Arch ecosystem you trust.

FeatureFestNixOSAnsible
Language✓ Go (mainstream)Nix (custom DSL)YAML (no types)
Type Safety✓ Full compiler validation✓ Some checking✗ Runtime only
Learning Curve✓ Low (standard Go)✗ High (new paradigm)Medium
Keep Your Distro✓ Works on Arch✗ Requires NixOS✓ Distro-agnostic
AUR Access✓ Full 80,000+✗ Limited✓ Via manual tasks
Speed✓ Fast binary installsSlow (rebuilds)Medium (SSH)
Single Binary✓ Compiled Go binary✗ System-level✗ Python + modules
Declarative Config✓ Full support✓ Full support✓ Idempotent playbooks
Reproducibility✓ Version-controlled✓ Fully reproducibleDepends on idempotency
key features
📦

Unified Package Management

Manage pacman, AUR, Flatpak, npm, Go packages and Ruby gems from a single declarative config.

🔄

Declarative Everything

Services, timers, sockets, system files, user groups, dotfiles — declare once, sync everywhere.

🛡️

Type-Safe Configuration

Go's compiler catches typos, missing imports and logic errors before you run a single command.

⚡

Preview Changes

go run . diff shows exactly what would change — no surprises, no accidents.

🧹

Automatic Cleanup

Tracks what it installed. Remove a package from config, it gets removed from your system.

🔗

Dependency Aware

Won't remove packages that other wanted packages depend on. Intelligent resolution.

📝

State Capture

go run . save converts current system state into Go code. Perfect for migrations.

🎯

Lifecycle Hooks

Run custom logic before/after specific resources sync. Full programmatic control.

⬆️

One-Command Updates

go run . update upgrades every package manager, skipping version-locked packages.

🤖

LLM Agent Friendly

Go's simplicity and tooling make Fest perfect for AI-assisted system management and its compiler.

real-world example
main.go
package main

import "github.com/emad-elsaid/fest"

func main() {
    // Base system packages
    fest.Package(
        "base-devel", "vim", "git", "htop",
        "docker", "kubectl", "terraform",
    )

    // Development tools
    fest.GoPackage("github.com/golangci/golangci-lint/cmd/golangci-lint@latest")
    fest.NpmPackage("typescript", "@vue/cli", "eslint")

    // Flatpak apps
    fest.Flatpak("com.slack.Slack", "us.zoom.Zoom")

    // System configuration
    fest.Timedate("America/New_York", true)
    fest.Locale("en_US.UTF-8 UTF-8")

    // Services & groups
    fest.SystemService("docker", "sshd")
    fest.Service("syncthing")
    fest.Group("docker", "wheel", "audio")

    // System files (from system/ directory)
    fest.SystemFilesDir("system")

    fest.Main()
}
That's it. Commit to git, run go run . apply on any Arch machine. Your whole system state is now reproducible, version-controlled and portable.
install in 60 seconds
bash
# 1. Create your system configuration
mkdir ~/mysystem && cd ~/mysystem
go mod init mysystem
go get github.com/emad-elsaid/fest

# 2. Create main.go (see examples above)

# 3. Preview what would change
go run . diff

# 4. Apply your configuration
go run . apply

# 5. Update installed packages (skips version-pinned ones)
go run . update

# 6. Commit to git and deploy anywhere
git init && git add . && git commit -m "Initial system config"