I'm building FGOTHS: A Go + Templ + HTMX project generator with SSE/FlatBuffers and HMR

I'm building FGOTHS (For The GOTH Stack) for my own studio because I needed a way to bootstrap production-ready Go webapps with zero cloud overhead, no heavy JS frameworks, and a fast dev loop. It generates single static binaries (<10MB) targeting bare FROM scratch containers while delivering 100k+ req/s.

Key Features

Two Presets: api (Flat JSON API) and webapp (MVC + Templ + HTMX).
True HMR: Uses SSE + FlatBuffers to swap Templ HTML fragments in real-time, keeping form states, focus, and scroll position intact.
Zero CGO & Minimal Footprint: Compiles to a ~8.8MB binary with a low dependency surface area.
Embedded Runtime: Native reverse proxy, circuit breaker, health-checked failover, and deployment policies built right into the binary. The project is released under the Apache 2.0 license. I’d love to get feedback from the community on the architecture, the SSE/FlatBuffers HMR implementation, or the embedded runtime design!

📊 Benchmarks & Technical Metrics

FGOTHS is engineered for sustained high throughput, low tail-end latency, and predictable memory overhead.

Below are the metrics captured from load testing environments:

Metric	Measured Value	Architectural Context
Throughput	100,000+ req/s	Sustained load under concurrency
Tail Latency (p99)	~2.2ms	Low tail latency under saturation
Binary Footprint	~8.8 MB	Zero-CGO fully static binary
Container Footprint	< 10 MB	Bare `FROM scratch` deployment

How FGOTHS compares to traditional web frameworks and monolithic stacks:

Feature / Metric	FGOTHS	Go + Fiber / Gin	Next.js / Node	Laravel / Rails
Architecture	Go + Templ + HTMX	Go + Templates	JS / SSR / React	Monolith (PHP/Ruby)
HMR Mechanism	SSE + FlatBuffers	Air / Basic Reload	Fast Refresh / HMR	Livewire / Inertia
State Preservation	Scroll, Focus & Forms	Full Page Reload	React State	Full / Partial
Binary / App Size	~8.8 MB (Static)	~15-20 MB	~150 MB+ (Node)	~50 MB+ (Runtime)
Container Base	`FROM scratch` (<10MB)	Alpine (~20MB+)	Node Alpine (~200MB+)	PHP/Ruby (~300MB+)
CGO / Dependencies	Zero CGO / Minimal	Varies	Massive `node_modules`	Heavy Extensions
Built-in Governance	Proxy, Breaker & Failover	Manual / External	External (Vercel/Nginx)	External (Nginx/Envoy)
Throughput (req/s)	100k+ req/s	~80k-100k req/s	~10k-20k req/s	~2k-5k req/s
p99 Tail Latency	~2.2ms	~3-5ms	~20-50ms	~50-150ms

Why FGOTHS?

Vs. JS Frameworks (Next.js/SvelteKit): You drop the node_modules bloat, complex build pipelines, and high memory footprint while keeping a modern reactive frontend experience using HTMX and SSE-driven hot reloading.
Vs. Standard Go Frameworks (Gin/Fiber): FGOTHS isn't just a router or micro-framework; it's a project generator and embedded runtime that wires up Templ SSR, state-preserving HMR, and production-grade proxy/governance out of the box.

Reproducibility: Benchmark suites, execution scripts, and load profiles are available in the repository under the /benchmarks directory.

Github repo: https://github.com/WhoseBiasDoYallSeek/fgoths-framework