An opinionated Go framework: DI container, router, layered config, health checks, migrations and ordered shutdown, plus around twenty extensions you switch on when you need them: Postgres and Mongo, Kafka, MQTT, gRPC, GraphQL, WebRTC, Raft consensus, MCP. `forge init` scaffolds, `forge dev` hot-reloads. Everything else at xraph is built on it.
AI, auth, cache, consensus, database, events, GraphQL, gRPC, Kafka, MQTT, queue, search, storage and streaming. Every one registers the same way, so learning the first teaches you the rest.
Migrations, health and route registration are optional interfaces found by type assertion. The first version required seven methods, and most implementations satisfied five of them with empty bodies.
Services declare what they depend on and the container derives a start order, then reverses it for shutdown. A failed start halts the boot naming the dependency it needed.
Product platformRuns on the Forge runtime end to end: routing, dependency graph, configuration and shutdown ordering all come from the framework rather than from application code.
Product platformBuilt on Forge, with the same extension set carrying persistence, observability and lifecycle so the product code stays about the product.
Product platformRuns on the Forge runtime, so routing, the dependency graph, configuration and shutdown ordering come from the framework.
Shipping something on Forge? The list is only as complete as the people who tell me. Ask to be on it, or just say what got in your way.
Get listed →The decisions every backend service makes before it serves a request, made once and applied the same way in every service that adopts the framework.
Generic type-safe resolution with uber/dig-style constructor injection, and circular-dependency detection at registration time rather than at first resolve. It is the same container every extension registers into, so a service and a framework module look identical to it.
Services declare what they depend on. The container computes a start order from the graph and reverses it for shutdown, so nothing is torn down while something still needs it. A failed start halts the boot naming the dependency it needed, which is the error message I wanted every time I wrote this by hand.
YAML, JSON or TOML with environment overrides and hot reload. Auto-discovery walks up the tree to find a monorepo’s config, which removes the one piece of per-service boilerplate that never survived a directory move.
Any service implementing the interface appears at /_/health with no list to maintain. The registry that used to hold that list was the thing most often out of date in the services this replaced.
Structured logs, Prometheus at /_/metrics and trace propagation are mounted before any application code runs, so there is no version of the service that exists without them.
Each one registers and starts the same way, so the shape you learn on the first is the shape of all of them. The interface has one required method and everything else is optional.
LLM integration, agent scaffolding and inference behind one registration.
OAuth, JWT and SAML, sharing the framework’s context rather than carrying their own.
Redis, Memcached and in-memory behind a single interface.
Raft, for the services that have to agree on something before acting.
Postgres, MySQL, SQLite and MongoDB, with the migration runner wired in.
A bus and an event-sourcing path sharing one serialisation contract.
Schema mounting that reuses the router’s middleware chain.
Server with reflection enabled, health reported through the same interface.
Producer and consumer groups under the container’s lifecycle ordering.
Background work with retry and dead-lettering, shut down in dependency order.
Elasticsearch and Typesense, indexed from the events extension when both are on.
S3, GCS and local disk, with the same put and signed-URL surface across all three.
WebSocket, SSE and WebRTC, holding connections across a graceful shutdown.
Type-safe dependency injection with cycle detection at registration.
Services declare dependencies; start and shutdown order is computed, not written.
Layered sources with typed access and hot reload.
Everything beyond the core is opt-in behind one interface.
Forge is the Go framework the rest of this stack is built on. It bundles the decisions every backend service makes before it serves a request, covering dependency injection, routing, configuration, health checks, migrations, observability and shutdown ordering, then puts everything else behind an extension interface you opt into.
The premise is that those decisions are not interesting and I had made all of them before, slightly differently each time. Deciding them once and living with the consequences across every service turned out to be worth more than the flexibility I gave up.
Around twenty ship in-tree, each with the same registration and lifecycle shape, so learning one teaches you the others: AI (LLM integration, agents, inference), Auth (OAuth, JWT, SAML), Cache (Redis, Memcached, in-memory), Consensus (Raft), Database (Postgres, MySQL, SQLite, MongoDB), Events (bus and sourcing), GraphQL, gRPC with reflection, HLS, Kafka, MCP, MQTT, oRPC, Queue, Search (Elasticsearch, Typesense), Storage (S3, GCS, local), Streaming (WebSocket, SSE, WebRTC).
The extension interface has one required method. Anything else, including migrations, health and route registration, is an optional interface detected by type assertion. That was a correction: the first version required seven methods and most implementations satisfied five of them with empty bodies.
forge init scaffolds a project from a template. forge dev runs it with hot reload. There is code generation for handlers, controllers and services, a migration runner with versioning and cross-module ordering, and a test runner with coverage.
The industrial work I do runs on it, with each capability as a separate extension so a deployment only starts the parts it uses. Bastion, Authsome, Cortex, Weave, Warden, Vault, Keysmith, Chronicle, Ledger, Dispatch and Relay all ship a Forge extension alongside a standalone constructor.
The standalone path is not a courtesy. If those libraries only worked inside Forge, Forge's assumptions would leak into their designs without anything failing to warn me.