A new Go stack for reactive web apps

Server-driven reactivity

Front-end framework capabilities in server-side Go. Build rich UIs without writing JS.

No public API layer

Private transport is handled under the hood. No endpoint design required.

Unified control flow

State, routing, and interaction flow stay in Go, with automatic real-time client sync.

Integrated web stack

Bundle assets, build scripts, serve private files, and ship in one binary.

Your Go server is a UI runtime

The web application runs on a stateful server, while the browser acts as a remote renderer and input layer.

Engineered from syntax to socket

From the template engine to the way bytes reach the browser — each layer was designed to push server-driven UI further than it's ever gone.

The right environment for AI-assisted coding

A single Go execution flow removes frontend/backend drift, while server-side execution limits exposure of data, logic, and privileged operations.

Built on better definitions

Composable primitives to use independently or combine into custom abstractions. Modern frontend framework capabilities without sacrificing clarity.

...and explicit by design

Templates are GoX — a typed Go superset with its own parser, LSP, and editor plugins.

Clair KuhnJaime ParkerKaci ZiemeKris JohnstonMaggie MitchellNasir LabadieOlen TerryOrion HillsReece BinsRoel SchmidtShayna WilliamsonSydnie Paucek
type Search struct {
  query doors.Source[string] // reactive state
}

elem (s *Search) Main() {
  <input
    (doors.AInput{
      // debounce requests
      Scope: &doors.ScopeDebounce{Duration: 300 * time.Millisecond},
      On: func(ctx context.Context, r doors.RequestInput) bool {
        s.query.Update(ctx, r.Event().Value) // update state
        return false
      },
    })
    type="search"
    placeholder="search">

  ~(s.query.Bind(s.results)) ~// re-renders on query changes
}

elem (s *Search) results(query string) {
  ~~
  users := DB.SearchUsers(ctx, query) // hit the DB mid-render
  ~~
  <ul>
    ~(for _, u := range users {
      <li>~(u.Name)</li>
    })
  </ul>
}

This is the whole feature — no endpoint, no JSON contract, no fetch call, no client-side state, no JS build step. Debounce is one attribute, and the permission check happens where you render.

You probably have questions

How is it different from HTMX?

HTMX coordinates behavior through HTML attributes and endpoints. Doors lets you write interactive flow directly in Go. HTMX is HTML enhancement; Doors is a UI runtime.

How is it different from React, Next.js, and similar stacks?

With JS stacks, user flow and much of the business logic live in the browser, while the server is mostly a read/write backend. Doors runs that flow on the server in Go, with the browser as a display and input layer.

Where does it fit best?

SaaS, business systems, customer portals, admin panels, internal tools, and realtime apps — especially those with heavy user flows and complex business logic.

Where is it not the right fit?

Static non-iteractive pages, client-first apps with simple routing, and offline PWAs.

Can I use JavaScript?

Yes. Doors keeps JavaScript optional, but gives you the tools to integrate it cleanly for small UI enhancements or embedded micro-apps.

Can it scale behind a load balancer?

Doors is stateful, so load balancing requires sticky sessions. Doors includes the mechanics for uninterrupted rollouts: server IDs, a sticky cookie, and drain mode. The doors-caddy plugin puts them to work with Caddy — use it, or build your own setup on the same basis.

Does it cost more to run?

Typically not. Live page memory usage depends on app complexity and state design, usually between 100KB and 500KB.

Is it production-ready?

Yes, Doors is used in production. Breaking changes are still happening, but they make life easier and are straightforward to migrate — each one is documented in the release notes.