Guide

Full-stack frameworks for Go, compared

Most comparisons of this kind are a list of routers with a benchmark attached. That is not the question people are asking when they search for a full-stack framework for Go. The question is: what do I not have to build?

Go has no Rails. It has an excellent standard library, a handful of very good routers, and a culture that prefers assembling libraries to adopting a framework. That is a real strength and a real cost, and the cost lands on whoever has to produce auth, an admin screen, migrations, background jobs and a frontend before anybody can use what they built.

Star counts and activity dates checked against each project's source on 13 November 2026. Numbers move; the reasoning does not.

What "full-stack" means in Go

The phrase covers three different architectures, and most arguments about it are two people meaning different ones. Decide which you want before you read any comparison, including this one.

1. Go renders the HTML

The Rails shape. Templates on the server, forms that post back, a sprinkle of JavaScript. In Go this is html/template, or templ for typed components, usually with HTMX for interactivity. Fastest to a working page, hardest to reuse when a mobile app turns up.

2. Go serves an API, JavaScript renders the UI

The majority of new work. A Go API plus React, Vue or Svelte, talking over JSON. The framework question becomes a two framework question, and the interesting problems move to the boundary: keeping types in step, auth across two origins, and shipping two build artefacts that have to agree. Covered in detail here.

3. A batteries-included application framework

Something that gives you auth, an admin, migrations, jobs and a project layout on the first day, whichever of the two above you picked. This is the part Go is thinnest on, and the reason this page exists.

The options at a glance

Eight projects that genuinely attempt more than routing. Dates are the last commit on the branch you get when you clone, not GitHub’s "last pushed", which counts a push to any of a project’s branches and reads as much more recent. Stars and dates are a proxy for whether you will be alone when something breaks, not for quality.

Go full-stack frameworks compared
ProjectFrontend modelAdmin UIStarsLast activity
BuffaloGo templates8.4kMarch 2026
BeegoGo templates32.4kMarch 2026
PagodaGo components, HTMX3.0kOctober 2026
BudSvelte, server rendered5.6kApril 2023
templ + HTMXGo templates, typed10.6kNovember 2026
EncoreBring your own12.7kNovember 2026
PocketBaseBring your own61.6kOctober 2026
GritReact, generatedSee repoNovember 2026

"Admin UI" means a working screen for your own tables on day one, not a dashboard you assemble. It is the single biggest difference between these projects in practice, and only three of the eight have one.

The eight, in detail

1. Buffalo

8,424 stars · last push March 2026 · MIT

The closest thing Go has to Rails, and it says so. Buffalo gives you a generator, a project layout, Pop for the database, migrations, asset pipelines and sessions. If you want the Rails shape in Go, this is the most complete attempt at it.

Strengths

  • A real convention-over-configuration project layout
  • Generators for resources, models and migrations
  • Pop and Fizz give you migrations without choosing a library

Trade-offs

  • Development has slowed markedly; last push March 2026
  • Server-rendered templates first, so a React frontend is your own problem
  • The asset pipeline predates the current JavaScript tooling world

Best for: A server-rendered Go app by a team that likes Rails conventions and accepts a quiet project.

2. Beego

32,435 stars · master last updated March 2026 · Apache 2.0

The oldest and largest of these. Beego is a full MVC framework with its own ORM, router, cache, task scheduler and a command-line tool. It is genuinely batteries included, and it is also an older idea of what a Go framework looks like: a lot of the API predates modules, generics and the standard library's routing improvements.

Strengths

  • The most complete feature list of any Go framework here
  • Still actively maintained after more than a decade
  • Very large installed base, especially in China

Trade-offs

  • Opinionated in ways that feel dated against modern Go
  • Its ORM is a world of its own rather than GORM or sqlc
  • Documentation in English lags the Chinese original

Best for: A team that wants one vendor for everything and is comfortable with its conventions.

3. Bud

5,586 stars · main last updated April 2023 · MIT

The most interesting idea on this list. Bud generated the glue between a Go backend and a Svelte frontend as you added files, the way Vite generates a dev server. It deserved to win. Its main branch has not moved since April 2023, so it belongs here as prior art rather than as a recommendation.

Strengths

  • Genuinely novel: generated glue rather than hand-wired plumbing
  • Excellent developer experience when it worked

Trade-offs

  • Its main branch has not moved since April 2023
  • Svelte only, with the frontend choice baked in
  • Do not start new work on it

Best for: Reading, if you are designing something in this space.

4. Pagoda

2,964 stars · main last updated October 2026 · MIT

A starter kit rather than a library: you clone it and it is your application. Echo, Ent, SQLite, HTMX and gomponents, with authentication, sessions, email verification, a task queue and an admin panel already wired. The admin is the clever part: a generated extension reads Ent's schema graph and produces admin screens for every entity, so adding a field to the schema adds it to the admin.

Strengths

  • A working application on the first clone, not a library to assemble
  • An admin generated from the Ent schema, so the two cannot drift
  • Type-safe HTML in pure Go with gomponents, and no JavaScript build

Trade-offs

  • A starter kit, so you inherit the code rather than upgrade a dependency
  • SQLite and Ent are baked in, not choices
  • Its admin is explicitly beta: no filters or sorting yet

Best for: A server-rendered Go application where you want the whole thing scaffolded and are happy owning it.

5. templ with HTMX

10,608 stars · active November 2026 · MIT

Not a framework, and that is the point. templ compiles typed components to Go, HTMX gives you interactivity without a build step, and you assemble the rest. It has become the default answer in the Go community for "I want to ship HTML", and the typed templates are a real improvement on html/template.

Strengths

  • Typed templates, checked at compile time
  • No JavaScript build, no second deployment artefact
  • Composes with any router you already use

Trade-offs

  • You still build auth, admin, migrations and jobs yourself
  • A mobile app later means writing the API you skipped
  • HTMX hits a ceiling on genuinely interactive screens

Best for: Content-shaped applications where the UI is forms and tables and will stay that way.

6. Encore

12,712 stars · active November 2026 · MPL 2.0

Encore is a backend framework built on a strong idea: declare your databases, queues and cron jobs in Go, and it provisions and wires them, locally and in the cloud. It also gives you distributed tracing out of the box, which nothing else here does. Frontend is explicitly not in scope.

Strengths

  • Infrastructure from code, with local and cloud environments
  • Built-in distributed tracing and a service catalogue
  • Type-safe service-to-service calls

Trade-offs

  • No admin UI and no frontend story
  • Its model is opinionated enough to be hard to leave
  • Best value is tied to its own cloud

Best for: Backend teams building several services who want infrastructure and observability handled.

7. PocketBase

61,597 stars on its GitHub mirror · active, now developed on its own git host

One Go binary containing SQLite, a REST API, auth, file storage, realtime subscriptions and an admin dashboard. You define collections in the dashboard and it alters the real tables underneath. For an internal tool or a prototype it is the fastest path on this page by a wide margin.

Strengths

  • Download one file, run it, you have a backend with an admin
  • Realtime subscriptions and 32 OAuth providers included
  • Extensible in Go or JavaScript

Trade-offs

  • SQLite only, which rules out some deployments
  • Your schema lives in the database, not in your repository
  • Still pre-1.0 and says so

Best for: Internal tools, prototypes, and anything where one file on one server is the right answer.

8. Grit

Active November 2026 · MIT · this site

Ours, so read it with that in mind. Grit is a Go API (Gin and GORM) plus a React frontend and a generated admin panel, from one command. grit generate resource Order writes the Go model, service, handler, routes, the Zod schema, the TypeScript types, the React Query hooks and the admin screen, all typed against each other.

Strengths

  • An admin panel for your own tables on day one
  • Types generated from the Go model through to the React form
  • Auth, RBAC, jobs, storage, migrations and Docker included

Trade-offs

  • A larger project than a router: more to learn on day one
  • Opinionated about Gin, GORM and React
  • Younger than Beego or Buffalo

Best for: Teams that want a Go backend and a real UI for it without assembling the stack first.

How to choose

Start with who renders the HTML

This decides more than anything else on the page. If the answer is Go, you are choosing between templ, Buffalo and Beego, and the admin question is yours to solve. If the answer is React or Vue, half this list stops applying and the real work moves to the boundary between the two.

Then ask what you are not willing to build

Be specific about it. Authentication with password reset and sessions is a fortnight. Role-based permissions is another. An admin table with search, filters, sorting, pagination, bulk actions and CSV export is a month, and it is the part nobody budgets for because it is "just CRUD". A framework is worth adopting exactly when it removes work you would otherwise do badly.

Then check the project is still alive

Two of the eight above are effectively dormant. For a dependency you will carry for years, the date of the last commit tells you more than the star count. Open the repository and look before you commit to anything on any comparison page, including this one.

Finally, consider not choosing one

Gin or Chi plus a handful of libraries is a legitimate answer, and for a single service with no UI it is usually the right one. The framework question only becomes pressing when there are screens, users and roles. That comparison is here.

Where Grit fits

Grit is the third shape: a batteries-included application framework, built for the case where a Go backend needs a real user interface and an admin.

It is the right answer when you would otherwise spend the first month on auth, roles, an admin table and the types between Go and TypeScript. It is the wrong answer for a single stateless service with no UI, where Gin and four libraries will serve you better, and for an internal tool that one SQLite file would solve, where PocketBase is faster.

We publish side-by-side comparisons against Rails, Laravel, Django, Next.js, NestJS, Encore and the MERN stack, including where each of them wins.

Frequently asked questions

Does Go have a Rails equivalent?

Not one with Rails' standing. Buffalo is the closest in design and its development has slowed; Beego is the largest and is a different, older idea of a framework. The Go community has largely preferred composing libraries, which is why the gap persists.

Is Gin a full-stack framework?

No. Gin is an HTTP router with middleware, and an excellent one. It does not give you auth, an admin, migrations, background jobs or a frontend. Several projects on this page, Grit included, are built on top of it.

Can I use Go with React?

Yes, and it is the most common shape for new Go web work. The problems to solve are keeping types in step across the boundary, authentication across two origins, and whether you ship one artefact or two. We go through each of them here.

What is the fastest way to get an admin panel for a Go app?

PocketBase if a single SQLite file suits you, since the admin is the product. Grit if you need Postgres and the admin generated into your own repository. The full comparison is here.

Should I just use the standard library?

For a service with no user interface, very often yes. Go 1.22 added method and wildcard routing to net/http, which removed the main reason to reach for a router at all. The calculation changes when you have screens, users and roles.

Keep reading