GoGen is a powerful and modern CLI tool for generating Go project templates with best practices, common tools, and proper project structure. It helps developers quickly scaffold new Go projects with industry-standard configurations.

• 🎯 Multiple Project Templates - Web services, CLI apps, libraries, microservices, and gRPC services
• 🎨 Interactive Wizard - Guided project setup with customizable options
• 🏗️ Best Practices - Industry-standard project structure and tooling
• 🐳 Docker Ready - Optional Docker and Docker Compose configurations
• ⚙️ CI/CD Included - GitHub Actions workflows for testing and deployment
• 📦 Common Tools - Makefile, linting, formatting, and more
• 🎭 Beautiful CLI - Colorful and intuitive command-line interface

# Download the latest release (replace with your preferred version)
curl -L https://github.com/username/gogen/releases/latest/download/gogen-linux-amd64 -o gogen
chmod +x gogen
sudo mv gogen /usr/local/bin/

git clone https://github.com/username/gogen.git
cd gogen
go build -o bin/gogen .

go install github.com/username/gogen@latest

gogen generate

# Generate a web service
gogen generate my-api --template web

# Generate a CLI application
gogen generate my-tool --template cli

# Generate a library
gogen generate my-lib --template library

gogen list

gogen generate my-api --template web --interactive=false
cd my-api
go mod tidy
go run main.go

The web service will start on port 8080 with endpoints:

• GET /health - Health check
• GET /api/v1/hello - Hello world
• GET /api/v1/users - List users
• POST /api/v1/users - Create user

gogen generate my-tool --template cli
cd my-tool
go build -o bin/my-tool
./bin/my-tool hello --name "World"

gogen generate my-lib --template library
cd my-lib
go test ./...
go run examples/basic/main.go

gogen generate my-service --template microservice
cd my-service
docker-compose up --build

Access:

• Service: http://localhost:8080
• Metrics: http://localhost:9090/metrics
• Grafana: http://localhost:3000 (admin/admin)

gogen generate my-grpc --template grpc
cd my-grpc
make proto  # Generate protobuf files
go run main.go  # Start server
go run cmd/client/main.go  # Test client

When using interactive mode, you can configure:

• Project Name - The name of your project
• Module Prefix - Go module prefix (e.g., github.com/username)
• Description - Project description
• Docker Support - Include Dockerfile and docker-compose.yml
• GitHub Actions - Include CI/CD workflows
• Makefile - Include build automation

my-api/
├── main.go                # Application entry point
├── internal/
│   ├── api/               # API layer
│   │   ├── handlers/      # HTTP handlers
│   │   ├── middleware/    # HTTP middleware
│   │   └── server.go      # Server setup
│   └── config/            # Configuration
├── .env.example           # Environment template
├── Dockerfile             # Docker configuration
├── Makefile               # Build automation
├── .github/workflows/     # CI/CD pipelines
└── README.md              # Documentation

my-tool/
├── main.go               # Application entry point
├── cmd/                  # Command definitions
│   ├── root.go          # Root command
│   ├── version.go       # Version command
│   └── hello.go         # Example command
├── Makefile             # Build automation
└── README.md           # Documentation

# Build for current platform
go build -o bin/gogen .

# Build for multiple platforms
make build-all

# Run tests
go test ./...

# Run with coverage
go test -cover ./...

1. Create a new template file in internal/templates/
2. Implement the GetXXXTemplate() function
3. Register it in internal/templates/registry.go
4. Add it to the available templates list

Example:

func GetMyTemplate() *Template {
    return &Template{
        Name:        "My Template",
        Type:        "my-template",
        Description: "Description of my template",
        Features:    []string{"feature1", "feature2"},
        Files:       []TemplateFile{
            // Template files here
        },
    }
}

We welcome contributions! Please see our Contributing Guide for details.

1. Fork the repository
2. Create your feature branch (git checkout -b feature/amazing-feature)
3. Commit your changes (git commit -m 'Add some amazing feature')
4. Push to the branch (git push origin feature/amazing-feature)
5. Open a Pull Request

This project is licensed under the MIT License - see the LICENSE file for details.

• Cobra - For the excellent CLI framework
• Survey - For interactive prompts
• Gin - For the web framework used in templates
• All the amazing Go community for inspiration and best practices

• 📧 Email: [email protected]
• 🐛 Issues: GitHub Issues
• 💬 Discussions: GitHub Discussions

Made with ❤️ for the Go community