Yokai is a simple, modular, and observable Go framework for backend applications, aimed at Go engineers who want production-grade logging, tracing, metrics, and dependency injection without writing the wiring boilerplate themselves.
What it is
Yokai is an open-source Go framework that assembles a backend application from prebuilt modules. Its core modules preload instrumentation for logging, tracing, metrics, and health checks, and expose a private HTTP server for infrastructure and debugging needs. Extension modules add public HTTP and gRPC servers, workers, ORM support, and other features. Everything the framework constructs is registered in a dependency injection system that application code uses to resolve its own dependencies. The project is built on established Go libraries: Echo for HTTP servers, gRPC-go for gRPC servers, Viper for configuration management, OpenTelemetry for observability instrumentation, and Uber's Fx for dependency injection.
The concrete problem it solves is boilerplate. Building a production-grade Go backend normally requires hand-wiring configuration loading, dependency graphs, structured logging, tracing exporters, metrics endpoints, and health checks before any business logic exists. That work is not related to the application's purpose, but it is required for the application to be operable. Yokai places that wiring in core and extension modules, so the developer starts from a working skeleton and writes only application logic. It occupies the space that a hand-rolled main.go plus a pile of internal packages would otherwise fill.
Key capabilities
- Core modules preload logging, tracing, metrics, and health check instrumentation before application code runs.
- A private HTTP server is exposed for infrastructure and debugging needs, separate from the public HTTP server.
- Extension modules provide public HTTP servers via Echo and gRPC servers via gRPC-go.
- Worker pool modules support background and asynchronous job execution.
- Configuration management is handled through Viper.
- Observability instrumentation is built on OpenTelemetry, with a Prometheus topic listed in the repository metadata.
- An extension system allows enrich with built-in modules, the separate contrib modules repository, or self-authored modules.
- Dependency injection is provided by Fx, and modules are made available through it for application logic.
Who uses it and how
- Backend teams building gRPC services in Go, starting from the gRPC application template and extending with their own modules.
- Teams building HTTP APIs, starting from the HTTP application template, with the private infrastructure server kept separate from the public one.
- Teams deploying MCP servers, using the MCP application template and the MCP demo in the showroom repository.
- Teams running background processing, using the worker application template and the worker demo for job execution patterns.
- Kubernetes deployments, indicated by the
kubernetes topic, where the health check instrumentation and metrics endpoints are consumed by cluster tooling.
Getting started
Yokai provides ready-to-use application templates for gRPC, HTTP, MCP, and worker projects, documented at https://ankorstore.github.io/yokai. The showroom repository at https://github.com/ankorstore/yokai-showroom holds runnable demo applications for each of those four templates.
How it compares
Yokai does not replace a competitor product; it composes libraries that a Go developer would otherwise select and wire individually. Echo, gRPC-go, Viper, OpenTelemetry, and Fx all remain underneath it and remain directly reachable, so adopting Yokai is a decision about prebuilt wiring rather than about swapping out those foundations. Teams that prefer to assemble those libraries by hand, or that already maintain their own internal framework, gain little from the layer.
When to use it — and when not to
The framework is licensed MIT and written in Go, so it suits teams already committed to the Go ecosystem; projects in other languages get nothing from it. A self-hoster adopting it takes on ownership of the application's own infrastructure concerns, including the private HTTP server the core modules expose and whatever exporter endpoints the OpenTelemetry instrumentation points at. The README excerpt here is truncated and the project shows 842 stars, 31 forks, and 3 open issues, which suggests a small but active user base rather than a widely deployed standard; teams needing a large support community or long release history should weigh that before standardising on it.
project readme (upstream, from github) — read inline
Yokai
Simple, modular, and observable Go framework for backend applications.
Goals
Building backend applications with Go is amazing.
But to build production-grade applications, you need to put in place a bunch of efforts and boilerplate code, introducing complexity not even related to the logic of your application (like dependencies wiring, configuration management, observability instrumentation, etc.).
To solve this, Yokai was created with the following goals in mind:
Simple: it is easy to use, configure and test, enabling you to iterate fast and deliver quickly maintainable applications.Modular: it can be extended with the available Yokai modules, or with your own, to build evolvable applications.Observable: it comes with built-in logging, tracing and metrics instrumentation, to build reliable applications.
In other words, Yokai lets you focus on your application logic, while taking care of the rest.
Documentation
Yokai's documentation is available at https://ankorstore.github.io/yokai.
Overview
Architecture
- Yokai
core modules preloads logging, tracing, metrics and health check instrumentation, and expose a private HTTP server for infrastructure and debugging needs.
- Yokai
extensions modules can be added to enrich your application features, like public HTTP / gRPC servers, workers, ORM, etc. You can also add the contrib modules or your own.
- Those are made available in Yokai
dependency injection system, on which you can rely to build your application logic.
Foundations
Yokai was built using robust and well known Go libraries, such as:
- Echo for HTTP servers
- gRPC-go for gRPC servers
- Viper for configuration management
- OTEL for observability instrumentation
- Fx for dependency injection system
- and more.
Extensions
Yokai's extension system enables you to enrich your application features with:
Getting started
Yokai provides ready to use application templates to start your projects:
Showroom
Yokai provides a showroom repository with demo applications, ready to run, to see it in action:
Contributing
This repository uses release-please to automate Yokai's modules release process.
[!IMPORTANT]
You must provide atomic and conventional commits, as the release process relies on them to determine the version to release and to generate the release notes.