gobake: The Build Orchestrator Go Was Missing

If you've spent any significant time in the JavaScript ecosystem, you know the comfort of package.json. It's the source of truth for your project—metadata, dependencies, and a unified task runner. If you're coming from C++, you might have a love-hate relationship with CMake. But what about Go?

Go has an incredible toolchain (go build, go test, go install), but it lacks a standardized orchestrator. When your project grows beyond a single binary, you inevitably reach for Makefile or a collection of brittle .sh scripts.

That's why I built gobake.

Go is famous for its "batteries included" philosophy. However, once you need to manage:

1. Project Metadata: Versioning, authors, and descriptions.
2. Task Orchestration: Running tests, then building, then tagging a release.
3. Cross-Platform Binaries: Building for multiple architectures with specific flags.
4. Dev-Tool Management: Ensuring everyone on the team has the same linting tools.

...you're suddenly out of the Go world and back into the wild west of shell scripts. gobake fixes this by allowing you to write your build logic in the language you already love: Go.

gobake is a Go-native build orchestrator. It replaces static configuration with a type-safe Recipe.go file. It's inspired by projects like nob.h, but tailored specifically for the Gopher workflow.

Failed to render diagram. Check syntax.
graph TD
    A["recipe.piml (Metadata)"] --> B["gobake Engine"]
    C["Recipe.go (Logic)"] --> B
    B --> D{Task Runner}
    D --> E["Build Binary"]
    D --> F["Run Tests"]
    D --> G["Git Tag/Release"]
    D --> H["Auto-Versioning"]

A gobake project centers around two files:

1. recipe.piml: A PIML file for project metadata.
2. Recipe.go: A Go file where you define your tasks and logic.

Instead of worrying about tab vs. space in a Makefile, you define tasks with a clean Go API. Since version 0.3.0, we use the //go:build gobake tag to ensure your recipe stays separated from your main application logic while remaining perfectly valid Go:

EXPANDCOPY
go
//go:build gobake
package bake_recipe

import (
    "fmt"
    "github.com/fezcode/gobake"
)

func Run(bake *gobake.Engine) error {
    bake.LoadRecipeInfo("recipe.piml")

    bake.Task("build", "Builds the binary", func(ctx *gobake.Context) error {
        ctx.Log("Building v%s...", bake.Info.Version)
        return ctx.Run("go", "build", "-o", "bin/app", "./cmd/main.go")
    })

    bake.TaskWithDeps("release", "Build and Tag", []string{"build"}, func(ctx *bake.Context) error {
        return ctx.Run("git", "tag", "v"+bake.Info.Version)
    })

    return nil
}

If you know Go, you know gobake. You don't need to learn the esoteric syntax of make or the sprawling configuration of a CI/CD YAML just to run a local build.

Managing semantic versions is a chore. gobake handles it natively:

EXPANDCOPY
bash
gobake bump patch  # Increments 1.0.0 to 1.0.1 in recipe.piml

gobake can manage your go get dependencies and development tools (like golangci-lint) directly through the CLI, keeping your recipe.piml updated as the source of truth. The init command now automatically handles go mod setup and library acquisition.

Baking binaries for different platforms is a first-class citizen:

EXPANDCOPY
go
ctx.BakeBinary("linux", "amd64", "dist/app-linux")

To use gobake, you need two things: the CLI tool for running tasks and the library as a dependency in your project (since your Recipe.go will import it).

EXPANDCOPY
bash
go install github.com/fezcode/gobake/cmd/gobake@latest

The easiest way to get started is with the init command (refined in v0.3.0):

EXPANDCOPY
bash
gobake init

The init command is smart: it handles go mod init (if needed), scaffolds your recipe.piml and Recipe.go, and runs go mod tidy to automatically pull in the github.com/fezcode/gobake library as a dependency.

If you are adding it to an existing project and want to do it manually:

EXPANDCOPY
bash
go get github.com/fezcode/gobake

And run your first task:

EXPANDCOPY
bash
gobake build

Go deserves a build system that feels like Go. gobake aims to provide that missing orchestration layer—giving you the "package.json feel" without sacrificing the performance and type-safety of the Go ecosystem.

Check it out on GitHub: github.com/fezcode/gobake Or visit the project page: /projects/gobake

Happy baking! 🥐