nexgo-website

Go 1.22+ Zero Dependencies 200k+ req/s ~10MB binary SSR + SSG + Islands

Performance Metrics

Real-world benchmarks across DOM speed, load time, bundle size and developer experience.

Metric	React	Next.js	NexGo ✦	Angular
DOM update speed	72/100	68/100	91/100	65/100
First render	60/100	75/100	88/100	58/100
Memory usage	~120 MB	~180 MB	~18 MB	~200 MB
Concurrent requests	Limited	Medium	Goroutines ∞	Limited
CPU usage (idle)	Medium	High (Node)	Very low	High

Metric	React	Next.js	NexGo ✦	Angular
TTFB	~300ms	~200ms	~20ms	~350ms
First Contentful Paint	~1.8s	~0.9s	~0.3s	~2.1s
Time to Interactive	~3.5s	~1.5s	~0.5s	~4s
Startup time (server)	~2s (Node)	~4s (Node)	~80ms (Go)	~5s (Node)
WASM load (client)	No WASM	No WASM	~50–200ms	No WASM

Metric	React	Next.js	NexGo ✦	Angular
JS bundle (min+gzip)	~45 KB	~80 KB+	~0 KB JS	~130 KB
WASM size (TinyGo)	None	None	~15–50 KB	None
Server binary	Node + deps	~200MB Node	~8 MB binary	~200MB Node
Docker image size	~900 MB	~1.2 GB	~15 MB	~1.1 GB
npm dependencies	~1000+	~2000+	0 (pure Go)	~1500+

Feature	React	Next.js	NexGo ✦	Angular
SSR support	Manual	Built-in	Go templates	Plugin
File-based routing	No	Yes	In progress	No
Hot reload	Yes	Yes	Yes (SSE)	Yes
Language	JS / TS	JS / TS	Pure Go	TypeScript
Deploy complexity	Medium	High	1 binary	High
Learning curve	Medium	Medium	Low (if Go)	High
SEO Package	Manual (next-seo)	next/metadata	Built-in (pkg/seo)	Manual
Streaming SSR	React Suspense	Built-in	Built-in (pkg/stream)	No
ISR	No	Built-in	Built-in (pkg/isr)	No
Worker Pools	No	Node threads	Built-in (pkg/worker)	No
Response Caching	No	Manual	Built-in (pkg/api)	No
Parallel Data Loading	Promise.all	Built-in	Built-in (pkg/renderer)	No
Template Caching	No	React cache	Built-in (pkg/renderer)	No
JWT Auth	Manual	next-auth	Built-in (pkg/auth)	Manual
Session Management	No	Manual	Built-in (pkg/session)	No
WebSocket	Manual	Manual	Built-in (pkg/websocket)	Manual
Database/ORM	No	Prisma (ext)	Built-in (pkg/orm)	No
i18n	react-intl	next-intl	Built-in (pkg/i18n)	Built-in
Rate Limiting	No	Manual	Built-in (pkg/ratelimit)	No
Deployment Adapters	No	Vercel only	8 platforms built-in	No
Plugin System	No	No	Built-in (pkg/plugin)	No
Cluster Mode	No	No	Built-in (pkg/cluster)	No
Islands Architecture	No	No	Built-in (pkg/islands)	No
Selective Hydration	React Suspense	Partial (RSC)	5 strategies	No
Zero-JS Pages	No (~85KB min)	No (~80KB min)	Yes (0 KB)	No

New in v2.2.1

SEO Killer Mode: NexGo vs The World

22 SEO features compared across 4 frameworks. NexGo has them all built-in.

Feature	NexGo v2.2.1 ✦	Next.js 15	Hugo	Astro
Auto sitemap.xml	Built-in	Convention file	Built-in	Plugin
Auto robots.txt	Built-in	Convention file	Built-in	Plugin
Auto canonical URLs	Built-in	Manual	Manual	Plugin
JSON-LD structured data	10+ types	Manual	Manual	Plugin
OpenGraph + Twitter Cards	Built-in	`metadata` API	Manual	Plugin
Article OG tags	Built-in	Manual	Manual	Manual
Hreflang alternates	Built-in	Manual	Built-in	Plugin
RSS feed generation	Built-in	Manual	Built-in	Plugin
BreadcrumbList schema	Auto from URL	Manual	Manual	Manual
FAQ schema	Built-in	Manual	Manual	Manual
Product schema	Built-in	Manual	Manual	Manual
Core Web Vitals tracking	Built-in	Package	N/A	Plugin
SEO audit/validation	Built-in	Plugin	N/A	Plugin
Title templates	Built-in	Manual	Built-in	Manual
301/302 redirects	Config-based	Config	Config	Config
Trailing slash normalization	Built-in	Config	Config	Config
Preload/prefetch hints	Template func	Manual	Manual	Manual
URL slug helpers	Built-in	Manual	Built-in	Manual
SEO HTTP headers	Auto	Manual	N/A	Manual
HSTS header	Built-in	Manual	N/A	Manual
Content-Language header	Auto	Manual	Manual	Manual
Default SEO scaffold	`nexgo create`	N/A	N/A	N/A

NexGo vs Next.js vs React: Deep SEO Comparison

A deep 3-column comparison across 11 SEO categories.

Category	NexGo v2.2.1 ✦	Next.js 15	React SPA
Rendering & Crawlability
Server-Side Rendering	Built-in (Go templates)	Built-in (RSC)	✗ Client-only
Static Site Generation	Built-in	Built-in	✗ No
Zero-JS pages	Yes (0 KB default)	✗ ~80KB min	✗ ~45KB min
Islands Architecture	5 hydration strategies	✗ No	✗ No
Meta Tags & Head Management
Title templates	Config-based	Manual in `metadata`	Manual (react-helmet)
Meta description	seoTags() auto	`metadata` API	Manual
Canonical URL	Auto from route	Manual	Manual
OpenGraph (all tags)	1 function call	`metadata.openGraph`	Manual / react-helmet
Twitter Cards	Auto with OG	`metadata.twitter`	Manual
Article OG tags	ArticleMeta()	Manual	Manual
Structured Data (JSON-LD)
WebSite schema	websiteSchema()	Manual JSON	Manual JSON
Organization schema	orgSchema()	Manual JSON	Manual JSON
Article schema	ArticleSchema()	Manual JSON	Manual JSON
BreadcrumbList	Auto from URL	Manual JSON	Manual JSON
FAQ schema	faqSchema()	Manual JSON	Manual JSON
Product schema	ProductSchema()	Manual JSON	Manual JSON
Review schema	ReviewSchema()	Manual JSON	Manual JSON
HowTo schema	HowToSchema()	Manual JSON	Manual JSON
LocalBusiness schema	LocalBusinessSchema()	Manual JSON	Manual JSON
Generic JSON-LD	jsonld() template	Manual JSON	Manual JSON
Sitemap & Indexing
Auto sitemap.xml	From route table	Convention file	✗ No
Auto robots.txt	Config-based	Convention file	✗ No
Sitemap index (50k+)	Built-in	Manual	✗ No
Hreflang in sitemap	Built-in	Manual	✗ No
Internationalization
Hreflang alternates	Meta + Sitemap	Manual	Manual
Content-Language header	Auto	Manual	Manual
i18n routing	Built-in (pkg/i18n)	next-intl	react-intl
Feeds
RSS 2.0	RenderRSS()	Manual	✗ No
Atom feed	Planned	Manual	✗ No
URL & Routing
Trailing slash normalization	Middleware	Config	Manual
301/302 redirects	Config + middleware	next.config.js	Manual
URL slugify	slugify() built-in	Manual	Manual
Performance & Core Web Vitals
LCP / CLS / INP tracking	Built-in script	web-vitals pkg	Manual
Preload hints	preload() template	Manual	Manual
Prefetch / prerender	Built-in	Link prefetch	Manual
Server response time	~20ms TTFB	~200ms TTFB	~300ms+ TTFB
HTTP Headers & Security
SEO headers (auto)	4 headers auto	Manual	Manual
HSTS	Middleware	Manual	Manual
X-Content-Type-Options	Auto	Manual	Manual
Referrer-Policy	Auto	Manual	Manual
Developer Experience
SEO scaffold on create	nexgo create	✗ No	✗ No
SEO audit in code	AuditMeta() + AuditHTML()	Plugin (lighthouse)	Plugin
SEO template functions	22+ functions	~5 (metadata API)	0
Lines of SEO code needed	0 (zero config)	~50-200 per page	~100-500 per page
Pagination SEO
rel=prev / rel=next	Built-in	Manual	Manual
Paginated canonical	Auto	Manual	Manual

The Bottom Line

Quick-glance summary: how much work does SEO take in each framework?

Metric	NexGo v2.2.1 ✦	Next.js 15	React SPA
Built-in SEO features	50+	~10	0
npm/Go packages needed	0 packages	5-10 packages	10-15+ packages
Lines of SEO code	0 lines	200-500 lines	500-2000+ lines
Time to production SEO	Minutes	Hours — Days	Days — Weeks
JSON-LD schema types	10+ built-in	0 (manual JSON)	0 (manual JSON)
Core Web Vitals	1 config flag	web-vitals pkg	web-vitals + setup
SEO audit in tests	AuditMeta() built-in	External tools only	External tools only

Feature Comparison

Feature	NexGo	Next.js	Gin	Echo	Fiber
Language	Go	JS/TS	Go	Go	Go
File-Based Routing	✓	✓	✗	✗	✗
Server-Side Rendering	✓	✓	~	~	~
Static Site Generation	✓	✓	✗	✗	✗
Hot Reload (HMR)	✓	✓	✗	✗	✗
Built-in Data Loaders	✓	✓	✗	✗	✗
API Routes	✓	✓	✓	✓	✓
Layouts System	✓	✓	✗	✗	✗
Zero Runtime Deps	✓	✗	~	~	~
Single Binary Deploy	✓	✗	✓	✓	✓
Built-in DevTools	✓	✓	✗	✗	✗
No Node.js Required	✓	✗	✓	✓	✓
Template Engine	Go html/template	JSX / React	Any	Any	HTML
Built-in Middleware	✓	~	✓	✓	✓
XSS Safe by Default	✓	~	~	~	~
JWT Authentication	✓	~	✗	✗	✗
WebSocket Support	✓	~	✗	✗	✓
Database/ORM	✓	✗	✗	✗	✗
i18n / RTL	✓	~	✗	✗	✗
Plugin System	✓	✗	✗	✗	✗
Deployment Adapters	✓	~	✗	✗	✗
Health Checks	✓	✗	✗	✗	✗
Cluster Mode	✓	✗	✗	✗	✗
Islands Architecture	✓	✗	✗	✗	✗
Selective Hydration	✓	~	✗	✗	✗
Zero-JS Static Pages	✓	✗	✗	✗	✗

✓ Native support ~ Partial/Plugin ✗ Not included

NexGo vs Next.js

N

NexGo

✓ No Node.js, no npm, no runtime
✓ Single ~10MB binary
✓ 200,000+ requests per second (cluster mode)
✓ Go's type safety and performance
✓ Zero external dependencies
✓ Built-in auth, sessions, CSRF
✓ WebSockets, ORM, plugin system
✓ Islands Architecture — 0 KB JS by default
✓ 5 hydration strategies (load/visible/idle/media/none)
✓ Deploy anywhere Go runs
✗ No React ecosystem
✗ Smaller community (for now)

N

Next.js

✓ Huge React ecosystem
✓ Large community & resources
✓ TypeScript first-class support
✓ Rich component ecosystem (shadcn, etc.)
✗ Requires Node.js runtime
✗ Heavy node_modules (~300MB+)
✗ Slower cold starts
✗ ~85KB JS minimum per page (React runtime)
✗ Full-page hydration — no per-component control
✗ Lower throughput vs Go

NexGo vs Go Frameworks

Aspect	NexGo	Gin	Echo	Fiber
Focus	Full-stack framework	HTTP router	HTTP router	HTTP router
Template / Views	✓ Built-in layout system	Manual setup	Manual setup	Manual setup
Route Discovery	✓ Automatic (filesystem)	Manual register	Manual register	Manual register
Dev Experience	Next.js-like DX	Low-level API	Low-level API	Express-like
Hot Reload	✓ Built-in SSE HMR	Use Air/reflex	Use Air/reflex	Use Air/reflex
DevTools	✓ Built-in panel	✗	✗	✗
Static Site Generation	✓	✗	✗	✗
Islands Architecture	✓ 5 hydration strategies	✗	✗	✗
Performance	~200k+ req/s (cluster)	~80k req/s	~80k req/s	~120k req/s

💡 Note: Gin, Echo, and Fiber are excellent HTTP routers. NexGo is a full-stack framework — the comparison is about developer experience for building complete web applications, not raw routing performance.

Islands Architecture Comparison

NexGo v2.2.0 ships zero JavaScript by default with Islands, and pushes 200k+ req/sec with cluster mode.

Blog page with 1 like button — JS shipped

Next.js (React) 87.5 KB

react.min.js (42KB) + react-dom.min.js (40KB) + _app.js (3.4KB) + component (1.8KB)

NexGo v2.2.0 (Islands + Cluster) 1.8 KB

runtime (1KB) + island (0.8KB)

48x smaller

Feature	NexGo v2.2.0 ✦	Next.js	Astro	Fresh (Deno)
Islands Architecture	Yes	No	Yes	Yes
Zero-JS by default	0 KB	~85 KB	0 KB	0 KB
Hydration strategies	5 (load/visible/idle/media/none)	None	5 (same set)	2 (load/visible)
Server language	Go	Node.js	Node.js	Deno
SSR + SSG + ISR	All built-in	All built-in	SSG + SSR	SSR only
Cold start	~15ms	~800ms	~400ms	~300ms
Memory (idle)	~12 MB	~120 MB	~80 MB	~60 MB
Deploy artifact	Single binary (~12 MB)	Node + node_modules	Static files + Node	Deno runtime
Dependencies	0 (pure Go)	~2000+ npm	~500+ npm	0 (Deno)
Built-in ORM/Auth/WS	All included	External pkgs	External pkgs	External pkgs

💡 Why Islands? Every Next.js page ships ~85KB of React runtime even for a static blog post. With NexGo Islands, static pages ship 0 KB of JavaScript. Only interactive components load JS — and you control when with 5 hydration strategies.

Real-World Comparison

This Same App,
3 Frameworks

What if this exact NexGo documentation website — 6 pages, dark/light theme, animated hero, docs sidebar, interactive comparisons — was built with React or Next.js? Here's what changes.

This App Has:

6 Pages Dark/Light Theme SPA Navigation Animated Hero Docs Sidebar Code Highlighting Copy Buttons Scroll Reveal Mobile Menu Counter Animations Tab Switching API Route

Build & Deploy Comparison

Metric	NexGo v2.2.0 ✦	React (CRA / Vite)	Next.js 14
Install time	~3 sec go install (single binary)	~45 sec npm install (1,200+ packages)	~60 sec npm install (2,000+ packages)
node_modules size	0 MB No npm. No node_modules.	~280 MB react, react-dom, webpack, babel…	~350 MB react, next, swc, postcss…
Build time	~8 ms Go template compilation	~12 sec Webpack/Vite bundle + minify	~18 sec SWC compile + SSR/SSG + optimize
Build output size	~85 KB 6 HTML + 1 CSS + 1 JS	~1.2 MB JS bundles + HTML shell + assets	~2.4 MB .next/ with chunks, manifests, SSR
Deploy artifact	~10 MB binary Single file, zero runtime deps	Static files + CDN No server — client-side only	~350 MB Node.js + node_modules + .next/
Cold start	~15 ms Compiled binary, instant boot	N/A (static files)	~800 ms Node.js startup + module loading
Memory usage (idle)	~12 MB	N/A (static)	~120 MB
Requests/sec (server)	200k+ req/sec Cluster mode, 4 cores	N/A (static CDN)	~3k req/sec Node.js single-thread SSR

JavaScript Shipped to Browser

Page	NexGo ✦	React (CRA)	Next.js 14
Landing page Hero, stats, features, code blocks	~5 KB app.js (vanilla, no framework)	~185 KB react + react-dom + app bundle + framer-motion	~145 KB react runtime + _app + page + chunks
Docs page Sidebar nav, code examples, tables	~5 KB Same app.js (shared across pages)	~210 KB + syntax highlighter + MDX compiler	~170 KB + rehype/remark + page bundle
Compare page Tabs, tables, animated stats	~5 KB Same app.js	~195 KB + chart library + tab component	~155 KB + page-specific bundle
Blog page Post grid, tags, static content	~5 KB Same app.js	~175 KB react + page component	~135 KB + SSR hydration bundle
Total JS (all pages)	~5 KB 1 file, shared	~420 KB Unique bundles per route	~310 KB Shared chunks + page bundles

Total JS Shipped — Visual

React (CRA / Vite) ~420 KB

react (42K) + react-dom (40K) + webpack runtime + app bundle + vendor chunks

Next.js 14 ~310 KB

react runtime + framework.js + _app + page chunks + hydration

NexGo v2.2.0 ~5 KB

app.js (vanilla)

84x less JS than React 62x less JS than Next.js

Developer Experience

DX Metric	NexGo ✦	React	Next.js
Files to build this app	12 files 6 pages + 1 layout + 1 CSS + 1 JS + 1 config + main.go + 1 API	~35 files components, hooks, contexts, utils, CSS modules, package.json…	~40 files + app router, loading.tsx, layout.tsx, metadata, middleware…
Lines of code (app)	~2,800 lines HTML templates + Go + vanilla JS	~5,500 lines JSX + hooks + state + CSS-in-JS	~4,800 lines TSX + server components + API routes
Config files needed	1 nexgo.config.json	6+ package.json, tsconfig, vite.config, postcss, eslint, prettier	7+ + next.config.mjs, middleware.ts
Learning curve	Go templates + file-based routing	JSX, hooks, state management, bundlers, CSS-in-JS, routing library	All of React + App Router, Server Components, data fetching patterns, caching
Hot reload speed	~50 ms SSE-based, no bundler	~200 ms Vite HMR	~300 ms Next.js Fast Refresh
TypeScript required?	No (Go is typed)	Optional but expected	Optional but expected

Production Costs

Infra Metric	NexGo ✦	React (static)	Next.js (SSR)
Minimum server	512 MB / 1 vCPU $2.50/mo (DigitalOcean)	CDN only Free (Vercel/Netlify)	1 GB / 1 vCPU $5-12/mo (needs Node.js)
Handles 10k users/day	$2.50/mo Single $2.50 droplet	Free Static hosting	$5-12/mo Vercel Pro or VPS
Handles 100k users/day	$5/mo Same server + cluster mode	Free-$20/mo CDN bandwidth	$20-50/mo Vercel Pro or multiple instances
SSR at scale	Built-in 200k req/sec, same server	Not possible Client-side rendering only	~3k req/sec Need multiple instances
Docker image size	~15 MB Alpine + binary	N/A (static CDN)	~500 MB Node + deps + .next

Feature Parity

What this app uses — and what each framework provides out of the box vs requiring external packages.

Feature Used	NexGo ✦	React	Next.js
File-based routing	Built-in	react-router (ext)	Built-in
Server-side rendering	Built-in	No (client only)	Built-in
Static site generation	Built-in	No	Built-in
API routes	Built-in	Need Express/Fastify	Built-in
Dark/light theme	CSS + vanilla JS	useState + Context	next-themes (ext)
SPA navigation	Built-in (fetch)	react-router (ext)	Built-in (Link)
Hot reload	Built-in (SSE)	Vite HMR	Fast Refresh
Islands / partial hydration	Built-in (5 strategies)	No	No (full hydration)
Cluster mode	Built-in	N/A	PM2 / external
Auth / JWT / Sessions	Built-in	auth0/firebase (ext)	next-auth (ext)
Database / ORM	Built-in	prisma/drizzle (ext)	prisma/drizzle (ext)

Bottom Line: This App in Numbers

NexGo

5 KB JS

0 npm deps

8ms build

10 MB deploy

200k req/sec

React

420 KB JS

1,200+ npm deps

12s build

Static CDN

No SSR

Next.js

310 KB JS

2,000+ npm deps

18s build

350 MB deploy

~3k req/sec

When to use NexGo

✓ Use NexGo when...

→ You want Next.js DX with Go performance
→ You want zero-JS pages with Islands Architecture
→ You're building a content site, blog, or docs
→ You want a single binary with no Node.js
→ You need SSR + SSG + API in one framework
→ You want zero external dependencies
→ You deploy to resource-constrained servers
→ Your team knows Go

✗ Consider alternatives when...

→ You need React components and ecosystem
→ Your team only knows JavaScript/TypeScript
→ You need a complex SPA with rich UI
→ You need maximum raw routing performance
→ You need native mobile app support

Convinced? Start building.

Get NexGo running in under 2 minutes. One install, one command.

Get Started → Read the Docs

NexGo vsThe Alternatives

Performance Metrics

SEO Killer Mode: NexGo vs The World

NexGo vs Next.js vs React: Deep SEO Comparison

The Bottom Line

Feature Comparison

NexGo vs Next.js

NexGo

Next.js

NexGo vs Go Frameworks

Islands Architecture Comparison

Blog page with 1 like button — JS shipped

This Same App,3 Frameworks

This App Has:

Build & Deploy Comparison

JavaScript Shipped to Browser

Total JS Shipped — Visual

Developer Experience

Production Costs

Feature Parity

Bottom Line: This App in Numbers

When to use NexGo

✓ Use NexGo when...

✗ Consider alternatives when...

Convinced? Start building.

NexGo vs
The Alternatives

This Same App,
3 Frameworks