Boost

Overview

Boost is a modular and extensible framework for Go application development, designed to simplify the creation of robust, scalable, and observable services. The framework provides a comprehensive set of components that can be used independently or combined to build complete applications.

Key Features

• Modular Architecture: Independent components that can be used as needed
• Dependency Injection: Flexible system for managing dependencies between components
• Integrated Observability: Native support for metrics, logging, and tracing
• Adapters for Popular Libraries: Consistent wrappers for various libraries in the Go ecosystem
• Design Patterns: Implementations of patterns such as Factory, Middleware, and Wrapper
• CloudEvents Support: Native integration with the CloudEvents standard
• Extensibility: Easy to add support for new libraries and frameworks

Project Structure

The project is organized into modular packages, each with specific responsibilities:

• bootstrap: Components for application initialization
• examples: Framework usage examples
• extra: Additional functionalities (health checks, middleware, multiserver)
• factory: Factory pattern implementations for various components
• fx: Dependency injection and lifecycle management
• model: Data structures and interfaces definitions
• utils: Various utilities
• wrapper: Adapters for external libraries (cache, config, log, publisher)

Getting Started

Prerequisites

• Go 1.18 or higher
• Specific dependencies vary according to the components used

Installation

go get github.com/xgodev/boost

Basic Example

package main

import (
	"github.com/xgodev/boost"
	"github.com/xgodev/boost/factory/contrib/go.uber.org/zap/v1"
	"github.com/xgodev/boost/wrapper/log"
	"os"
)

func init() {
	os.Setenv("BOOST_FACTORY_ZAP_CONSOLE_FORMATTER", "JSON")
	os.Setenv("BOOST_FACTORY_ZAP_CONSOLE_LEVEL", "DEBUG")
}

func main() {
	boost.Start()
	log.Set(zap.NewLogger())
	log.Infof("hello world!!")
}

Claude Code plugin

A Claude Code plugin (golang-boost) teaches AI agents how to write boost-shaped Go code — Iron Laws (boost.Start, handler typing, config layer), HTTP APIs with Echo, event-driven functions, and the maintainer-side layout for new contribs. The plugin lives in its own repo, xgodev/boost-claude, so installing it no longer clones this entire framework. Install once in your Claude Code session:

/plugin marketplace add xgodev/boost-claude
/plugin install golang-boost@xgodev-boost

Moved from this repo. The plugin used to be distributed from xgodev/boost directly. If you installed it that way, migrate:

/plugin uninstall golang-boost@xgodev-boost
/plugin marketplace remove xgodev-boost
/plugin marketplace add xgodev/boost-claude
/plugin install golang-boost@xgodev-boost

Update

Inside Claude Code:

/plugin update golang-boost

From the CLI:

claude plugin update golang-boost@xgodev-boost

If it reports Plugin "..." not found, pass the scope explicitly:

claude plugin update golang-boost@xgodev-boost --scope user   # or: project | local | managed

Use claude plugin list to find the scope where the plugin is installed.

Auto-update

Claude Code checks for plugin updates at startup, but third-party marketplaces have auto-update disabled by default — only Anthropic's official marketplaces update on their own. To enable it:

Interactive: run /plugin → Marketplaces → select xgodev-boost → Enable auto-update.

Or declaratively, in ~/.claude/settings.json (global) — add "autoUpdate": true to the marketplace entry under extraKnownMarketplaces:

{
  "extraKnownMarketplaces": {
    "xgodev-boost": {
      "source": {
        "source": "git",
        "url": "git@github.com:xgodev/boost-claude.git"
      },
      "autoUpdate": true
    }
  }
}

The same works in a project's .claude/settings.json to pin auto-update for the team via the repo. Restart Claude Code for the change to take effect.

An update is only recognized when the version in .claude-plugin/plugin.json is incremented. Commits without a version bump do not trigger an update — even with auto-update on, Claude Code reports "already at latest".

Main Components

Bootstrap

The Bootstrap package provides components for application initialization, including support for serverless functions and event processing.

Bootstrap Documentation

Factory

The Factory package implements the Factory design pattern for various components, facilitating the creation and configuration of complex objects.

Factory Documentation

Wrapper

The Wrapper package provides adapters for external libraries, including cache, configuration, logging, and message publishing.

Wrapper Documentation

FX

The FX package provides dependency injection and component lifecycle management functionalities.

FX Documentation

Extra

The Extra package includes additional functionalities such as health checks, middleware, and support for multiple servers.

Extra Documentation

Integration with Popular Technologies

Boost offers extensive integrations with a wide range of technologies:

Cloud Providers

• AWS: AWS SDK integration for various services
• Google Cloud Platform:
  • Pub/Sub
  • BigQuery
  • Firestore
  • API integration
  • gRPC

Databases

• MongoDB: Native driver integration
• PostgreSQL: pgx driver
• Oracle: godror driver
• CockroachDB: Compatible with PostgreSQL drivers
• Cassandra: gocql driver
• BuntDB: In-memory key/value database
• MemDB: In-memory database with immutable radix tree

Caching

• Redis: go-redis client
• BigCache: In-memory caching system
• FreeCache: Zero GC cache library

Messaging & Event Systems

• NATS: Lightweight messaging system
• Kafka: Confluent Kafka Go client
• CloudEvents: SDK for CloudEvents standard
• Go Cloud Pub/Sub: Cloud-agnostic pub/sub API

Web & API

• Echo: High performance web framework
• gRPC: High performance RPC framework
• GraphQL: GraphQL server implementation
• Swagger: API documentation with echo-swagger

Observability

• Prometheus: Metrics and monitoring
• OpenTelemetry: Observability framework
• Datadog: APM and monitoring
• Zap: Structured logging
• Zerolog: Zero-allocation JSON logger
• Logrus: Structured logger

Configuration

• Koanf: Lightweight, extensible configuration management
• Cobra: CLI application library
• Viper: Configuration solution (via Koanf)

Resilience & Patterns

• Hystrix: Latency and fault tolerance library
• Ants: Goroutine pool
• FTP: FTP client
• Kubernetes: Client-go integration
• Vault: HashiCorp Vault client

Serialization

• JSON: Multiple implementations (standard, go-json)
• MessagePack: Binary serialization
• GOB: Go's native binary format

Contributing

Contributions are welcome! To contribute:

1. Fork the repository
2. Create a branch for your feature (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

License

This project is licensed under the terms included in the LICENSE file.

Contact

For questions, suggestions, or contributions, please open an issue in the GitHub repository.

---

Developed with ❤️ by the xgodev community.