Kessoku

// Before: Sequential (google/wire)
wire.Build(NewDB, NewCache, NewAuth, NewApp)     // Each waits for previous
// After: Parallel (Kessoku)  
kessoku.Inject*App),      // }
    kessoku.Async(kessoku.Provide(NewCache)),   // } All run together
    kessoku.Async(kessoku.Provide(NewAuth)),    // }
    kessoku.Provide(NewApp),                    // waits for all
)                                               // Fastest possible startup

Result: Every restart gets faster. Multiple slow services? Maximum impact.

Why This Matters

Your typical day: Restart your app 10 times during development. Each restart wastes time waiting for services to start one by one.

gantt
    title Sequential vs Parallel Startup
    dateFormat X
    axisFormat %L
    
    section Sequential (slow)
    DB Service    :0, 3
    Cache Service :3, 5  
    Auth Service  :5, 6
    
    section Parallel (fast)
    DB Service    :0, 3
    Cache Service :0, 2
    Auth Service  :0, 1

Perfect for:

• Cold start nightmares: Your Lambda/serverless function times out during initialization
• Dev restart hell: You restart your app 10+ times daily, losing 3+ seconds each time
• Multi-DB apps: PostgreSQL + Redis + S3 + Auth0 = 800ms+ sequential startup pain
• google/wire refugees: You love compile-time DI but hate slow startup times

Quick Start

Install kessoku:

go get -tool github.com/mazrean/kessoku/cmd/kessoku

Create di.go (dependency injection declarations):

package main

import (
    "fmt"
"github.com/mazrean/kessoku"
)
type DB struct{ Addr string }
type Cache struct{ Addr string }
func SlowDB() *DB {
    // time.Sleep(200 * time.Millisecond)
    return &DB{Addr: "db:5432"}
}
func SlowCache() *Cache {
    // time.Sleep(150 * time.Millisecond)
    return &Cache{Addr: "cache:6379"}
}
//go:generate go tool kessoku $GOFILE
var _ = kessoku.Injectstring),
    kessoku.Async(kessoku.Provide(SlowCache)),
    kessoku.Provide(func(db DB, cache Cache) string {
        return fmt.Sprintf("App running with %s and %s", db.Addr, cache.Addr)
    }),
)

Create main.go (application entry point):

package main

import (
    "context"
    "fmt"
    "time"
)
func main() {
    start := time.Now()
    result := InitApp(context.Background())
    fmt.Printf("%s in %v\n", result, time.Since(start))
}

Note: Keep the kessoku.Inject declarations and your main() function in separate files.

kessoku type-checks the whole package before generating code, so if main() calls InitApp

in the same file (or any file) where InitApp is not yet defined, the type-checker will

report undefined: InitApp and no code will be generated — a chicken-and-egg deadlock.

Running go generate on di.go first produces di_band.go (which defines InitApp),

after which go build / go run . succeeds.

Run:

go generate ./...   # generates di_band.go, which defines InitApp
go run .
Shows: App running with db:5432 and cache:6379 in ~200ms (parallel startup)

Installation

Recommended:

go get -tool github.com/mazrean/kessoku/cmd/kessoku

# Download and install (replace with your platform)
curl -L -o kessoku.tar.gz https://github.com/mazrean/kessoku/releases/latest/download/kessoku_Linux_x86_64.tar.gz
tar -xzf kessoku.tar.gz
sudo mv kessoku /usr/local/bin/

# Download and install
Invoke-WebRequest -Uri "https://github.com/mazrean/kessoku/releases/latest/download/kessoku_Windows_x86_64.zip" -OutFile "kessoku.zip"
Expand-Archive -Path "kessoku.zip" -DestinationPath "."
Move-Item "kessoku.exe" "$env:USERPROFILE\bin\" -Force
Add $env:USERPROFILE\bin to your PATH if not already added

kessoku --version

brew install mazrean/tap/kessoku

wget https://github.com/mazrean/kessoku/releases/latest/download/kessoku_amd64.deb
sudo apt install ./kessoku_amd64.deb

wget https://github.com/mazrean/kessoku/releases/latest/download/kessoku_amd64.rpm
For CentOS/RHEL 7 and older
sudo yum install ./kessoku_amd64.rpm
For CentOS/RHEL 8+ and Fedora
sudo dnf install ./kessoku_amd64.rpm

wget https://github.com/mazrean/kessoku/releases/latest/download/kessoku_amd64.apk
sudo apk add --allow-untrusted kessoku_amd64.apk

Coding Agent Integration

Kessoku provides built-in skills for AI coding assistants to help you write better DI code.

Install skills for your coding agent:

go tool kessoku llm-setup <agent>

Supported agents: Claude Code(claude-code), OpenAI Codex(openai-codex), Cursor(cursor), GitHub Copilot(github-copilot), Gemini CLI(gemini-cli), OpenCode(opencode), Amp(amp), Goose(goose), Factory(factory)

# Install to user-level directory (available across all projects)
go tool kessoku llm-setup <agent> --user
Install to custom directory
go tool kessoku llm-setup <agent> --path ./custom/path

Once installed, your coding agent will understand kessoku patterns and can help you:

• Write providers and injectors correctly
• Set up parallel initialization with Async
• Migrate from google/wire
• Troubleshoot code generation issues

API Reference

Full docs: pkg.go.dev/github.com/mazrean/kessoku

Examples: examples/ - basic, async_parallel, sets

• kessoku.Async(provider) - Make this provider run in parallel
• kessoku.Provide(fn) - Regular provider (sequential)
• kessoku.InjectT - Generate the injector function
• kessoku.Set(...) - Group providers for reuse
• kessoku.Value(val) - Inject constants
• kessoku.BindInterface - Interface → implementation

Migrating from google/wire

Already using google/wire? Kessoku provides a migration tool to convert your wire configuration files automatically.

Quick Migration

# on wire config directory
go tool kessoku migrate
or specify wire config directory with patterns
go tool kessoku migrate ./pkg/wire -o ./pkg/wire/kessoku.go

Usage: kessoku migrate [<patterns> ...] [flags]
Migrate wire config to kessoku
Arguments:
  [<patterns> ...]    Go package patterns to migrate
Flags:
  -h, --help                   Show context-sensitive help.
  -l, --log-level="info"       Log level
  -v, --version                Show version and exit.
-o, --output="kessoku.go"    Output file path

Example

Before (wire.go):

//go:build wireinject

package main
import "github.com/google/wire"
func InitializeApp() (*App, error) {
    wire.Build(
        NewApp,
        NewPostgresRepo,
        wire.Bind(new(Repository), new(*PostgresRepo)),
    )
    return nil, nil
}

After (kessoku.go):

//go:generate go tool kessoku $GOFILE

package main
import "github.com/mazrean/kessoku"
var _ = kessoku.Inject*App,
    kessoku.BindRepository),
)

vs Alternatives

| | Kessoku | google/wire | uber-go/dig | |---|---------|-------------|---------| | Startup Speed | Parallel | Sequential | Sequential + runtime | | Learning Curve | Minimal | Minimal | Steep | | Production Ready | Yes | Yes | Yes |

Choose Kessoku if: You have multiple slow services (DB, cache, APIs) and startup time matters Choose google/wire if: You want maximum simplicity and startup speed isn't critical Choose uber/fx if: You need complex lifecycle management and don't mind runtime overhead

Supports

This project receives support from GMO FlattSecurity's “GMO Open Source Developer Support Program” and regularly conducts security assessments using “Takumi byGMO.”

License