# ToGO vs Laravel, Rails and Buffalo: an honest comparison for Go developers

> Is there a Laravel or Rails for Go? Here is what ToGO generates, where it matches the big batteries-included frameworks, where Buffalo fits, and where ToGO is still young.

*2026-11-04T05:01:48Z*

If you came to Go from Laravel or Rails, you probably asked the same question I did: **where is the batteries-included framework?** Go has excellent routers (chi, Gin, Echo, Fiber) and excellent libraries. What it rarely has is one command that gives you a model, a migration, an API, a typed client and a page.

ToGO is my answer to that question. This post compares it honestly with Laravel, Rails and Buffalo so you can decide if it fits your next project.

## The short version

| | Laravel | Rails | Buffalo | ToGO |
|---|---|---|---|---|
| Language | PHP | Ruby | Go | Go + React (TypeScript) |
| Generator CLI | `artisan make:*` | `rails generate` | `buffalo generate` | `togo make:*` |
| API style | REST (you build it) | REST (you build it) | REST / HTML | REST (Huma, OpenAPI 3.1) **and** GraphQL (gqlgen) per resource |
| Data layer | Eloquent ORM | Active Record | Pop ORM | sqlc (typed SQL) + Atlas migrations |
| Frontend | Blade / Inertia / Livewire | ERB / Hotwire | Plush templates | React (Next.js or TanStack) |
| Extensions | Composer packages | Gems | Plugins | Plugins on a microkernel + marketplace |
| AI agents | via packages | via gems | none built in | MCP server in every app |
| Maturity | very mature | very mature | mature, slow-moving | **pre-1.0** |

## What `make:resource` actually generates

```bash
togo new myapp
cd myapp
togo make:resource Post title:string body:text:nullable
togo generate && togo migrate && togo serve
```

One `make:resource` gives you the model, the sqlc schema and queries, the Atlas migration, a GraphQL schema, a Huma REST handler with OpenAPI docs, a seeder, and on the frontend a typed TypeScript client, a hook and a page. Field types: string, text, int, bool, float, decimal, uuid, time, date, json.

That is the Laravel/Rails feeling (one command, a working feature) with Go's type safety end to end.

## Where ToGO is like Laravel

- **An artisan-style CLI:** `make:resource`, `make:model`, `make:controller`, `make:action`, `make:plugin`, `migrate`, `seed`, `dev`.
- **Service-provider style plugins:** a plugin has `Register` and `Boot`, a priority, and hooks into the kernel.
- **Database choice at `togo new`:** SQLite (default), Postgres, a full Postgres stack (togo-postgres), Supabase, MySQL or MongoDB.

If you want the side-by-side command map, read [ToGO for Laravel developers](/en/blog/togo-for-laravel-developers).

## Where ToGO is different

- **No runtime ORM magic.** Queries are SQL compiled to typed Go by sqlc. You see the SQL; the compiler checks it.
- **Two APIs for free.** Every resource gets REST with an OpenAPI 3.1 spec and GraphQL.
- **A real React frontend**, not server templates.
- **Built for AI agents.** Every new app ships a pre-wired `.mcp.json`. Claude Code (or any MCP client) can read your schema, list routes, run read-only queries, generate resources and run migrations through tools like `db_schema`, `list_routes`, `make_resource` and `migrate`. `togo install claude` adds a ready agent team.

## And Buffalo?

Buffalo was the first serious "Rails for Go" and it is still on GitHub with thousands of stars, but development is slow-moving. It is server-rendered first and uses its own ORM (Pop). If you want classic server templates in Go, Buffalo is a fair choice. If you want typed SQL, OpenAPI + GraphQL and a React frontend, ToGO is built for that.

## Where ToGO is still young (read this before you bet on it)

- It is **pre-1.0** (core v0.21, CLI v0.2.x). APIs can still change.
- The community is small. Laravel and Rails have decades of answers on Stack Overflow; ToGO has docs, a marketplace and me.
- The resource generator's SQL schema template is SQLite-first today. If you pick Postgres, check the generated migration before you run it.

I would rather tell you that now than have you find out in production.

## Who should try it

- Laravel or Rails developers moving a service to Go who miss the generator workflow.
- Go teams tired of wiring chi + sqlc + OpenAPI + a React client by hand for every project.
- Anyone building AI-native apps who wants an MCP server in the app from day one.

## Try it in five minutes

```bash
go install github.com/togo-framework/cli/cmd/togo@latest
# or: curl -fsSL https://to-go.dev/install.sh | sh
togo new myapp
```

No Go toolchain? Grab a binary from [GitHub releases](https://github.com/togo-framework/cli/releases).

Then browse the [plugin marketplace](/marketplace), or read the full walkthrough: [ToGO: a Go + React framework with an artisan-style CLI](/en/blog/togo-go-react-framework-artisan-cli). Comparing routers instead of frameworks? See [ToGO vs Gin, Echo and Fiber](/en/blog/togo-vs-gin-echo-fiber).

Need a product built on Go + React by the person who wrote the framework? [Product engineering with Fady Mondy](https://fadymondy.com/en/services/product-engineering).

---

Source: https://to-go.dev/en/blog/togo-vs-laravel-rails-buffalo