NexGo Versions

Multiple HTTP workers sharing one TCP listener. Auto-detects CPU cores. Zero-downtime restart.

Buffered channel (8,192 entries) with background writer. Non-blocking I/O on the hot path.

In-memory full response cache with TTL. X-Cache: HIT/MISS headers. Microsecond response times.

sync.Map-based cache skips regex matching for known paths. 15ns vs 800ns lookups.

Lock-free template reads via sync/atomic.Value. O(1) constant time regardless of concurrency.

Configurable buffer sizes, timeouts, and keep-alive settings for high-throughput scenarios.

Full island registry with template rendering, JS serving, and hydration runtime.

client:load, client:visible, client:idle, client:media, client:none — fine-grained control over when JS loads.

Render islands in templates with island "name" (props "k" "v") "client:visible".

/_nexgo/islands/{name}.js endpoint serves individual island JS files as ES modules.

Lightweight runtime using IntersectionObserver, requestIdleCallback, and matchMedia for efficient hydration.

Create reusable components without a .js file — rendered server-side, zero JS shipped.

Hot reload support for island templates and JS files during development.

Configure the islands directory in nexgo.config.json. Defaults to "islands".

Built-in JWT authentication with sign, verify, and refresh token support.

Cookie-based and store-backed session management with configurable expiry.

Automatic CSRF token generation and validation middleware.

Per-route and global rate limiting with sliding window algorithm.

Unified database layer supporting both JSON file storage and SQL databases.

Lightweight ORM with model definitions, relations, queries, and migrations.

Schema migrations with up/down support and automatic version tracking.

Redis-backed caching with TTL, invalidation, and pub/sub support.

Native WebSocket support with rooms, broadcasting, and auto-reconnect.

Multi-process clustering with shared state and automatic load balancing.

One-command deploy to Vercel, Fly.io, Railway, Render, AWS, GCP, Azure, and Docker.

Built-in /healthz and /readyz endpoints with custom check registration.

Extensible plugin architecture with lifecycle hooks and dependency injection.

Define server-side mutations directly from templates with automatic form handling.

Test helpers for routes, middleware, and handlers with request mocking.

JSON-structured logging with levels, context fields, and log rotation.

Prometheus-compatible metrics endpoint with request duration, error rates, and custom counters.

Internationalization with locale detection, translation files, plurals, and RTL layout support.

Automatic image resizing, format conversion (WebP/AVIF), and lazy loading.

CSS/JS bundling, minification, fingerprinting, and cache-busting.

Custom error pages (404, 500) and error boundaries that catch panics gracefully.

Attach middleware to individual routes or route groups with chaining support.

Content Security Policy header generation with nonce support for inline scripts.

Typed environment variable loading from .env files with validation and defaults.

Meta tags, OpenGraph, Twitter Cards, sitemap.xml, robots.txt, and JSON-LD structured data generation.

Send HTML progressively as it's ready — show the shell immediately, stream content later. Includes SSE support.

Cache pages and rebuild them in the background after a configurable interval — like Next.js ISR.

Run tasks concurrently with controlled parallelism. Map, ForEach, and global pool support.

Cache GET responses in memory with TTL. Automatic X-Cache: HIT/MISS headers.

Load multiple data sources concurrently and merge results — like Promise.all() in JS.

Templates compiled once and cached. Parallel template loading with worker pool.

IsHTMX, HTMXHTML, HTMXTrigger, HTMXHeader — send HTML fragments and fire client events.

Thread-safe global state with SetState, GetState, DeleteState, and NewState for isolated sessions.

Escape() for XSS-safe output and HTML() for raw HTML responses.

Complete HTMX-powered todo app in the docs with CRUD operations.

Automatic route discovery from pages/ directory with dynamic segments.

SSR, SSG, and SPA modes with data loaders like getServerSideProps.

SSE-based file watching with instant browser refresh.

REST endpoints with method routing, JSON helpers, and pagination.

Built-in debug panel with route inspector, request logs, and performance metrics.

Recover, Logger, SecurityHeaders, Gzip, CORS, and Cache middleware.