GoFrame is an MIT-licensed, production-ready application framework for the Go programming language that provides a full-stack toolkit — HTTP server, ORM, logging, tracing, and command-line scaffolding — in a single dependency, aimed at Go teams that want one coherent framework instead of assembling many separate libraries.

What it is

GoFrame is a general-purpose development framework for Go, distributed as the module github.com/gogf/gf/v2 and complemented by a gf command-line tool. It sits in the Go ecosystem and is published at github.com/gogf/gf under the MIT licence, with the official site and documentation hosted at goframe.org and API reference at pkg.go.dev. The project describes itself as usable either as a full application framework or as a set of individual components that can be picked as needed, so a team can adopt the HTTP server alone or take the whole stack.

The concrete problem it solves is fragmentation in Go application development. A Go team building a service would otherwise choose and wire together separate libraries for HTTP routing, database access through an ORM, logging, and distributed tracing, then maintain the glue between them. GoFrame replaces that assembly work with one framework whose packages share conventions and configuration. The topic list confirms the intended scope: framework, go-framework, goframe, orm, logging, microservice, opentelemetry, tracing, and kubernetes.

Key capabilities

• Serves HTTP applications through the ghttp package using g.Server(), s.BindHandler("/", func(r *ghttp.Request) {...}), s.SetPort(8000), and s.Run().
• Ships a gf CLI that scaffolds and runs projects, with gf init hello to create a project and gf run main.go to execute it.
• Includes an ORM component for database access, as listed in the repository topics.
• Provides a logging component, also listed in the repository topics.
• Supports OpenTelemetry and distributed tracing, per the repository topics.
• Targets microservice and Kubernetes deployments, per the repository topics.
• Runs on Go 1.23 or later.

Who uses it and how

• Go teams building microservices that want one framework covering routing, data access, and observability rather than five independent dependencies.
• Teams deploying to Kubernetes, where the framework's microservice orientation and tracing support fit service-oriented architectures.
• Teams that need distributed tracing and OpenTelemetry instrumentation in their services without bolting tracing onto a plain router afterwards.
• Developers who want to start from a scaffolded layout, using gf init hello to generate a project skeleton and gf run main.go during development.
• Teams that adopt incrementally, importing only the specific github.com/gogf/gf/v2 components they need at first.

Getting started

Add the framework to an existing module with go get -u github.com/gogf/gf/v2, and install the CLI with go install github.com/gogf/gf/cmd/gf/v2@latest. A minimum program creates a server with g.Server(), binds a handler, sets the port to 8000, and calls s.Run(); alternatively, scaffold a project with gf init hello and start it with gf run main.go. Go 1.23 or later is required.

How it compares

No list of paid or commercial products that GoFrame replaces is provided in the available facts, and the README names no comparable frameworks. On the evidence here it stands alone in this registry, with no stated alternatives to position it against.

When to use it — and when not to

GoFrame is a library and CLI, not a hosted service, so there is no managed control plane to hand off to and no database, object storage, or SMTP infrastructure that the framework itself requires someone to operate. Teams on Go versions earlier than 1.23 cannot use it, and teams that prefer to compose their own small set of Go libraries may find a full framework imposes conventions and a larger API surface than they want. The README is short and points largely to external documentation, so evaluation depends on reading goframe.org rather than the repository alone.

go get -u github.com/gogf/gf/v2

go install github.com/gogf/gf/cmd/gf/v2@latest

package main

import (
	"github.com/gogf/gf/v2/frame/g"
	"github.com/gogf/gf/v2/net/ghttp"
)

func main() {
	s := g.Server()
	s.BindHandler("/", func(r *ghttp.Request) {
		r.Response.Write("Hello World!")
	})
	s.SetPort(8000)
	s.Run()
}

go mod init hello
go mod tidy
go run main.go

gf init hello
cd hello && gf run main.go