# bext > bext is a TLS-terminating Rust HTTP frontend that masquerades as nginx, then routes each host through whatever framework the site declares. PRISM, bext's native zero-runtime TSX framework, compiles JSX to direct HTML strings (no React, no Virtual DOM). bext also ships server-side includes, nginx config compatibility, a plugin system, built-in capabilities (auth, sessions, mailer, storage, and more), extra wire protocols, a companion app, a terminal UI, and a managed cloud. This is the documentation for bext, hosted at https://docs.bext.dev. The pages below are grouped exactly as the docs sidebar. The full text of every page, concatenated into one file, is at https://docs.bext.dev/llms-full.txt. ## Getting Started - [Installation](https://docs.bext.dev/getting-started/installation): Install the bext binary via the install script, Cargo, or Docker. - [Quickstart](https://docs.bext.dev/getting-started/quickstart): Build and run your first bext app in 5 minutes — PRISM (bext's native TSX framework) is the recommended starter. ## Configuration - [bext.config.toml](https://docs.bext.dev/configuration/bext-config-toml): Complete configuration reference for bext. - [CLI Reference](https://docs.bext.dev/configuration/cli-reference): Every CLI command and flag. - [Endpoints & Credentials](https://docs.bext.dev/configuration/endpoints-and-credentials): Control which built-in endpoints are exposed and manage admin credentials from the CLI. - [Build & Feature Flags](https://docs.bext.dev/configuration/build-flags): Cargo feature flags for building bext-server with only the features you need. - [V8 Render Engine](https://docs.bext.dev/configuration/v8-engine): bext's V8 server-side rendering pipeline — heap snapshots, TurboFan JIT, layered shared bundles. - [Rust CSS Engine](https://docs.bext.dev/configuration/rust-css-engine): Rust-native Tailwind v4 CSS generation — no Node.js, no Bun, sub-millisecond builds, per-route minimal CSS, live production reloads. - [Environment Variables](https://docs.bext.dev/configuration/environment-variables): Complete reference of all environment variables bext reads, with precedence rules, defaults, and examples. - [Docker](https://docs.bext.dev/configuration/docker): Official Dockerfile, docker-compose with Redis, volume mounts, health checks, and production container best practices. ## Server-Side Includes - [Overview](https://docs.bext.dev/includes/overview): Compose pages from independent fragments at the server level — caching, streaming, auth gating, experiments, and realtime updates — all with a single `` HTML primitive. Full SSI and ESI compatibility included. - [Caching & TTL](https://docs.bext.dev/includes/caching): Give each include its own TTL, stale-while-revalidate window, and cache tags — backed by bext's tiered L0/L1/L2 cache with stampede protection, adaptive TTL, and grouped invalidation. - [Vary-aware caching](https://docs.bext.dev/includes/vary): Declare which request dimensions an include varies on — role, locale, geo, device — and bext maintains a separate cache entry per combination. One tag, N cached variants. - [Auth-gated includes](https://docs.bext.dev/includes/auth): Server-side conditional rendering based on authentication and role. Show admin toolbars only to admins, CTAs only to anonymous users — without client-side flicker or leaked markup. - [Streaming (lazy)](https://docs.bext.dev/includes/streaming): Progressive delivery via `loading="lazy"` — the page shell arrives immediately, heavy or slow includes stream in as later chunks. React Suspense semantics for any HTML. - [Experiment variants](https://docs.bext.dev/includes/experiments): A/B test include content at the server level — weighted variant assignment, sticky cookies, per-variant caching. No client-side experiment SDK required. - [Realtime includes](https://docs.bext.dev/includes/realtime): Live-updating HTML fragments via SSE. Initial SSR on first load; subsequent updates re-fetch automatically when the server publishes to the channel. Dashboards without a state library. - [File-based partials](https://docs.bext.dev/includes/file-partials): Include static HTML from the site's `_partials/` directory. Mtime-based cache invalidation — edit the file, cache busts automatically. SSI `file=` and `virtual=` both supported. - [Timeout & Fallback](https://docs.bext.dev/includes/fallback): Resilience for unreliable include sources — per-include timeouts, multi-level fallback chains, `onerror="continue"` silent failure, and a circuit breaker that skips persistently failing sources. - [Component rendering](https://docs.bext.dev/includes/render): Render React/JSX components as includes using bext's V8 (or QuickJS) engine. Props, hydration, bundle caching — no Bun process required. - [SSI & ESI compatibility](https://docs.bext.dev/includes/ssi-esi): Full support for nginx/Apache SSI (``) and W3C ESI (``, ``, ``). Existing configs migrate to bext without code changes. - [Configuration reference](https://docs.bext.dev/includes/config): Full `[include]` configuration surface in bext.config.toml — global defaults, per-source rules, security limits, experiments, custom vary dimensions, and env-var interpolation. - [Plugin API](https://docs.bext.dev/includes/plugins): Custom include resolvers and lifecycle hooks. Register pattern-matched resolvers (CMS, database, API) and transform hooks (analytics, minification, validation) without forking bext. ## nginx Compatibility - [Overview](https://docs.bext.dev/nginx/overview): Drop-in nginx replacement — bext reads your nginx.conf and serves all traffic without config changes - [Config Parser](https://docs.bext.dev/nginx/config-parser): How bext parses nginx.conf files — lexer, recursive-descent parser, include expansion, and AST - [Directive Coverage](https://docs.bext.dev/nginx/directive-coverage): Complete reference of all nginx directives supported by bext's compatibility layer - [Migration Guide](https://docs.bext.dev/nginx/migration-guide): Step-by-step guide to migrating from nginx to bext - [Masquerade Mode](https://docs.bext.dev/nginx/masquerade): Full nginx impersonation — shim binary, PID file, SIGHUP reload, systemd override - [Cache Purge API](https://docs.bext.dev/nginx/cache-purge): Drop-in replacement for nginx's NJS cache purge module - [Preflight Dashboard](https://docs.bext.dev/nginx/preflight-dashboard): Web-based UI for inspecting your nginx config before migrating to bext - [Takeover Process](https://docs.bext.dev/nginx/takeover): Atomic traffic migration from nginx to bext with automatic rollback ## PRISM (bext-native) - [Overview](https://docs.bext.dev/frameworks/prism): A zero-runtime, string-builder TSX framework. JSX compiles to direct HTML strings (no React, no Virtual DOM). A build-time compile pass folds whole component trees into a single growing-accumulator IIFE, rendering in microseconds — far below React's renderToString on the same Tailwind fixture. - [JSX Runtime](https://docs.bext.dev/frameworks/jsx-runtime): bext's built-in JSX runtime renders JSX directly to branded HTML strings — no React, no Virtual DOM, with safe-by-default dynamic text and a compile pass for static structure. - [Compile Pass](https://docs.bext.dev/frameworks/prism-compile-pass): Build-time fold of static and prop-driven JSX subtrees into direct string concatenations. Default-on for PRISM sites; markedly faster SSR with no API change. - [Routing](https://docs.bext.dev/frameworks/routing): File-based nested routing with layout composition, dynamic segments, catch-all routes, and API handlers for bext template sites. - [Islands](https://docs.bext.dev/frameworks/islands): Progressive enhancement with islands — server-render static HTML, hydrate only interactive components. Zero JavaScript for non-interactive pages. - [Signals](https://docs.bext.dev/frameworks/signals): bext's signals runtime: server-renders to HTML with resumability markers, client picks up the existing DOM and binds signals — no virtual DOM, no re-render, sub-3KB hydration runtime. - [PRISM Data (loader/action)](https://docs.bext.dev/frameworks/prism-data): Remix-style loader/action exports in PRISM routes — server-side data fetching and mutations co-located with the component. - [Templates](https://docs.bext.dev/frameworks/template): Build server-rendered sites with pure HTML string rendering — no React required. The @bext-stack/framework package provides createSite(), typed pages, templates, route handlers, and SEO helpers. - [Tailwind Integration](https://docs.bext.dev/frameworks/tailwind): Build-time Tailwind CSS generation for bext sites — scan source files, generate optimized CSS, and use Tailwind classes in JSX components. - [Bridge (server↔client)](https://docs.bext.dev/frameworks/bridge): Direct access to the filesystem, HTTP, SQLite, environment variables, and structured logging from bext's V8 runtime via native bridge globals. - [Client Runtime](https://docs.bext.dev/frameworks/client-runtime): Client-side navigation, prefetching, view transitions, and live reload — a 2-6KB script for instant page transitions. - [Live Reload](https://docs.bext.dev/frameworks/live-reload): PHP-like live reload — change a file, the browser updates automatically. File watch, rebuild, atomic pool swap, client-side refresh. - [React / Preact / Solid adapters](https://docs.bext.dev/frameworks/react-preact-solid): SSR adapters for rendering React, Preact, and Solid components inside bext template sites — mix frameworks in a single page. ## Application Toolkit - [Overview](https://docs.bext.dev/toolkit/overview): The TypeScript app-developer layer of bext — validation, auth, data, notifications and more, importable from @bext-stack/framework. - [Validation](https://docs.bext.dev/toolkit/validation): Typed, dependency-free schema validation for PRISM server actions and API routes — coerces FormData, reports every field error in one pass. - [Authentication](https://docs.bext.dev/toolkit/authentication): Cookie utils, tamper-proof HMAC-signed sessions, and OAuth/OIDC PKCE helpers — the reusable auth core, in pure-JS crypto that runs in any isolate. - [Authorization](https://docs.bext.dev/toolkit/authorization): Gates & policies for PRISM apps — answer 'can this user do this?' in a loader, an action, or a component, with a null-safe TypeScript API. - [Data & Migrations](https://docs.bext.dev/toolkit/data): A typed model / query-builder over bext's embedded SQLite, plus a tracked, idempotent migration runner — no more lazy CREATE TABLE or out-of-band db push. - [Notifications](https://docs.bext.dev/toolkit/notifications): One notify() that fans a message out to email, SMS, Slack, an in-app feed, or a webhook — each channel rendered from the same Notification, transports pluggable. - [Feature Flags](https://docs.bext.dev/toolkit/feature-flags): Code-defined feature flags & experiments — deterministic sticky percentage rollouts, in-code rules, with an optional fall-through to the Rust flag engine. - [Billing](https://docs.bext.dev/toolkit/billing): Cashier-style Stripe subscriptions for PRISM apps — checkout, portal, subscription queries, and constant-time webhook signature verification, no Stripe SDK. - [Events](https://docs.bext.dev/toolkit/events): A typed, in-process domain event bus for PRISM apps — decouple 'a thing happened' from 'what should happen', with async fan-out and typed payloads. - [Localization (i18n)](https://docs.bext.dev/toolkit/i18n): Per-language message catalogs with interpolation and pluralization, a fallback locale, and request locale detection — the shared TS replacement for per-site i18n copies. - [Jobs & Queue](https://docs.bext.dev/toolkit/jobs): Typed background jobs with dispatch() over the bext SDK queue — declare a job, enqueue it from anywhere, and process with automatic retries. - [Cache](https://docs.bext.dev/toolkit/cache): A key/value cache facade — cache.remember(key, ttl, fn) plus get/put/forget/pull/add over a pluggable store (SDK KV or in-memory). - [Rate Limiting](https://docs.bext.dev/toolkit/rate-limiting): Fixed-window rate limiting for PRISM actions and API routes — check/attempt/peek/reset over a pluggable store, with allowed / remaining / retry-after. - [Mailables](https://docs.bext.dev/toolkit/mail): Transactional email templating — renderMailable(spec) produces a responsive inline-styled HTML email plus a plaintext version, composing with the notifications mail channel. - [Testing](https://docs.bext.dev/toolkit/testing): Model factories and a route test client (@bext-stack/framework/testkit) plus a component render/query library — test app logic and components in plain bun test, no server. ## Framework Integrations - [Overview](https://docs.bext.dev/frameworks/overview): PRISM (bext's native TSX framework) plus first-class adapters for Next.js, Hono, Express, Laravel, Symfony, and PHP. - [Next.js](https://docs.bext.dev/frameworks/nextjs): Use bext's cache invalidation, real-time pub/sub, KV store, queues, and tasks from Next.js - [Next.js on-demand](https://docs.bext.dev/frameworks/nextjs-on-demand): Point bext at a Next.js folder — pages compile on first request, no build step needed. PHP-like development with React. - [Astro](https://docs.bext.dev/frameworks/astro): Run Astro SSR on bext via @astrojs/bext — islands, content collections, and file-system routing served through bext's cache, WAF, and plugin pipeline. - [SolidStart](https://docs.bext.dev/frameworks/solidstart): Run SolidStart SSR on bext via solidjs-bext — fine-grained reactivity, file-system routing, and server functions served through bext's cache, WAF, and plugin pipeline. - [SvelteKit](https://docs.bext.dev/frameworks/sveltekit): Run SvelteKit SSR on bext via @sveltejs/adapter-bext — file-system routes, form actions, and prerendered pages served through bext's cache, WAF, and plugin pipeline. - [Qwik](https://docs.bext.dev/frameworks/qwik): Run Qwik City SSR on bext via qwik-bext — resumable hydration, file-system routing, and Qwik's O(1) JS payloads served through bext's cache, WAF, and plugin pipeline. - [Hono](https://docs.bext.dev/frameworks/hono): Hono middleware and standalone client for bext's platform services - [Express](https://docs.bext.dev/frameworks/express): Express middleware for bext's cache, real-time, KV, queue, and task services - [Django](https://docs.bext.dev/frameworks/django): Front a Django project with bext: TLS, WAF, cache, tracing, and static file serving in front of a Gunicorn or Uvicorn upstream. - [Phoenix](https://docs.bext.dev/frameworks/phoenix): Front a Phoenix application with bext — TLS, HTTP/2/3, WAF, cache, and observability on top of an unchanged Cowboy + Phoenix stack. LiveView-safe. - [Rails](https://docs.bext.dev/frameworks/rails): Front a Rails application with bext — TLS, HTTP/2/3, WAF, cache, and observability on top of an unchanged Puma + Rails stack. - [Laravel](https://docs.bext.dev/frameworks/laravel): Serve a Laravel application inside bext — embedded PHP runtime, worker-mode kernel, TLS, HTTP/2/3, WAF, cache, and observability with no php-fpm. - [Symfony](https://docs.bext.dev/frameworks/symfony): Auto-registering Flex bundle with dependency injection, worker mode, and React SSR - [WordPress](https://docs.bext.dev/frameworks/wordpress): Serve real WordPress + WooCommerce behind bext's edge cache, plus the Bext for WordPress plugin (purge-on-change, Action Scheduler taming, multisite, WP-CLI) and the Inklura plugin suite. - [PHP Micro-Framework](https://docs.bext.dev/frameworks/php): Run PHP apps on bext — embedded runtime, FastCGI proxy to PHP-FPM, and WordPress hosting ## Guides - [Deployment Modes](https://docs.bext.dev/guides/deployment-modes): Single-app, multi-app, and edge mode: choosing the right deployment topology for your workload. - [Routing](https://docs.bext.dev/guides/routing): File-based routing, dynamic segments, catch-all routes, rewrites, redirects, and route priority. - [Caching](https://docs.bext.dev/guides/caching): ISR with TTL and stale-while-revalidate, stampede guard, tiered L1/L2 cache, negative caching, and vary-aware cache keys. - [Compression](https://docs.bext.dev/guides/compression): Brotli and Gzip response compression negotiated from Accept-Encoding, nginx-compat tuning, per-route overrides, and pre-compressed static assets. - [TLS & HTTPS](https://docs.bext.dev/guides/tls-and-https): Auto-TLS via ACME, OCSP stapling, SNI routing, self-signed certificates, custom cert paths, and HTTPS redirect behavior. - [HTTP/3 & QUIC](https://docs.bext.dev/guides/http3-and-quic): HTTP/3 over QUIC with 0-RTT resumption, transport parameters, Alt-Svc advertising, browser compatibility, and fallback behavior. - [WebSockets & SSE](https://docs.bext.dev/guides/websockets): Built-in pub/sub hub with topic wildcards, SSE and WebSocket transports, Redis relay for multi-instance sync, authentication hooks, and event replay. - [Image Optimization](https://docs.bext.dev/guides/image-optimization): On-the-fly image resize, WebP conversion, quality tuning, and caching via the image-optimization plugin. - [Multi-App Hosting](https://docs.bext.dev/guides/multi-app): Serve multiple applications from one bext instance with hostname routing. - [Security](https://docs.bext.dev/guides/security): Web Application Firewall with IP filtering, GeoIP blocking, SQL injection and XSS detection, bot detection, DDoS protection, rate limiting, CORS, and security headers. - [SEO](https://docs.bext.dev/guides/seo): Automatic sitemap.xml generation, robots.txt, RSS/Atom feeds, JSON-LD structured data, Open Graph image generation, meta tag management, and canonical URLs. - [Server Actions](https://docs.bext.dev/guides/server-actions): Define POST endpoints with the `\"use server\"` directive — no client proxy, no codegen, plain exported functions dispatched by name. - [Server Islands](https://docs.bext.dev/guides/server-islands): Deferred SSR with parallel fetch for partial page hydration. - [Task Scheduler](https://docs.bext.dev/guides/task-scheduler): Built-in cron-style task scheduler with interval and one-shot tasks, failure handling, retry policies, status monitoring, and durable flow integration. - [Background Jobs](https://docs.bext.dev/guides/background-jobs): Run AI calls, report generation, and batch work that exceeds the request render deadline by moving it off the isolate — with a durable job queue, a scheduled worker, and live status over SSE. - [Durable Flows](https://docs.bext.dev/guides/durable-flows): Crash-recoverable workflow engine backed by SQLite WAL with step definitions, retry policies, timeout handling, compensation, and real-time streaming. ## Plugins - [Overview](https://docs.bext.dev/plugins/overview): Three-tier sandbox architecture for bext plugins — QuickJS for lightweight scripting, WASM for high-performance isolation, and nsjail for full process-level sandboxing. - [Building a Plugin](https://docs.bext.dev/plugins/building-a-plugin): Step-by-step guide to scaffolding, testing, and publishing your first bext plugin with the QuickJS sandbox. - [WASM Plugins](https://docs.bext.dev/plugins/wasm-plugins): Build high-performance bext plugins in Rust, Go, or C using the wasmtime sandbox with fuel budgets and host function imports. Pro feature. - [QuickJS Plugins](https://docs.bext.dev/plugins/quickjs-plugins): Write bext plugins in JavaScript using the embedded QuickJS sandbox with controlled memory, time limits, and a restricted API surface. - [V8 Plugins](https://docs.bext.dev/plugins/v8-plugins): Write bext plugins in JavaScript on V8 — the same runtime bext uses for PRISM and Next.js SSR — with a warm isolate pool, fuel-based preemption, and a JSON-over-host-functions ABI. - [Lua Plugins](https://docs.bext.dev/plugins/lua-plugins): Write bext plugins in Lua 5.4 via the mlua runtime — tiny footprint, ~1ms cold start, fuel-based preemption, and a JSON-over-host-functions ABI. - [Python Plugins](https://docs.bext.dev/plugins/python-plugins): Write bext plugins in Python via the Pyodide sub-mode of bext-plugin-wasm — designed for scheduled batch work, data pipelines, and report generation rather than the request path. - [nsjail Plugins](https://docs.bext.dev/plugins/nsjail-plugins): Run plugins with full process-level isolation using Linux namespaces, cgroup limits, and JSON-over-stdio IPC. Pro feature. - [Publishing](https://docs.bext.dev/plugins/publishing): Publish your bext plugin to plugins.bext.dev — versioning, security audit, quality scoring, and monetization via Stripe Connect. ## Capabilities - [Overview](https://docs.bext.dev/capabilities/overview): What a bext capability is, why it exists, how it graduates from experimental to default, and how you install one — the shared shapes that let you swap auth, session, mailer, and tracing backends without touching application code. - [Auth](https://docs.bext.dev/capabilities/auth): The Auth capability — a shared shape for resolving a request to an authenticated user, driving login and logout flows, and staying vendor-neutral across JWT, OAuth, magic-link, and passkey backends. How it fits with the Session capability, what the reference @bext/auth-jwt plugin does, and how you wire it up in bext.config.toml. - [Session](https://docs.bext.dev/capabilities/session): The Session capability — a storage-agnostic shape for session records that accommodates both server-backed stores (Redis, Postgres) and stateless client-side stores (signed-and-encrypted cookies) behind the same trait. How the opaque SessionId enables both models, what the reference @bext/session-cookie and @bext/session-redis plugins do, and how you wire up the [session] block in bext.config.toml. - [Mailer](https://docs.bext.dev/capabilities/mailer): The Mailer capability — a vendor-neutral shape for sending transactional email that accommodates both SMTP relays and cloud APIs behind the same trait. How pre-rendered bodies keep templating out of scope, how the `MailerError` variants classify failures so callers know whether to retry, what the reference `@bext/mailer-smtp` and `@bext/mailer-ses` plugins do, and how you wire up the [mailer] block in bext.config.toml. - [Scheduled](https://docs.bext.dev/capabilities/scheduled): The Scheduled capability — how plugins declare cron schedules, how bext fires them, what the missed-run and locking policies mean, and how a reference implementation like @bext/cron plugs the shape into your site. - [Locking](https://docs.bext.dev/capabilities/locking): The Locking capability — a distributed mutual-exclusion shape for bext plugins. Covers the try_lock / renew / release trait, the three reference backends (memory / Redis Redlock / Postgres advisory), how the Scheduled capability uses it to make multi-instance cron safe, and the Redlock-vs-advisory tradeoffs that inform which backend to pick. - [Tracer](https://docs.bext.dev/capabilities/tracer): The Tracer capability — a shared shape for emitting spans and events from bext's runtime and from plugins, designed to round-trip cleanly through OpenTelemetry without leaking the `opentelemetry` crate into the trait. How the handle-based design keeps the trait object-safe and Send + Sync, what the INVALID sentinel is for, and how the two reference plugins — `@bext/tracer-stdout` for dev and `@bext/tracer-otlp` for production — fit together. - [I18n](https://docs.bext.dev/capabilities/i18n): The I18n capability — a shared shape for translating keys into localized strings with typed variables, designed so the same application code can sit on top of a JSON-file backend in dev and a Mozilla Fluent bundle in production without a single line of change. How the typed `I18nValue` enum lets ICU and Fluent do plural selection correctly, why missing keys never error, and how BCP 47 locale negotiation is a default method every backend inherits. - [Storage](https://docs.bext.dev/capabilities/storage): The StorageClient capability — how plugins talk to object stores like S3, R2, MinIO, and Backblaze B2 through one sync trait, with typed errors, paginated listing, and presigned URLs. - [Feature Flag](https://docs.bext.dev/capabilities/feature-flag): The Feature Flag capability — one evaluation shape that covers static config files, OpenFeature providers, and vendor SDKs like LaunchDarkly and Unleash. How FlagValue keeps the ABI flat, why missing flags return defaults instead of errors, how per-user rollouts stay deterministic across calls, and how the reference @bext/flags-static and @bext/flags-openfeature plugins map onto the same trait. - [Search Client](https://docs.bext.dev/capabilities/search): The Search Client capability — one shape that covers Meilisearch, Elasticsearch, Typesense, and Postgres full-text. How the minimal SearchQuery avoids vendor DSL lock-in, why JSON-string payloads keep the ABI flat across sandboxes, how errors classify into four recoverable categories, and how the reference @bext/search-meili and @bext/search-pg plugins map onto the same trait. - [Webhook](https://docs.bext.dev/capabilities/webhook): The Webhook capability — a vendor-neutral shape for verifying inbound webhook deliveries behind the same trait. How the verify-only contract keeps vendor event shapes out of the trait, how HMAC-SHA256 and HMAC-SHA1 schemes map onto one surface, what the reference `@bext/webhook-verifiers` plugin does for Stripe/GitHub/Shopify/Slack/Twilio, and how to wire a verifier into a route. - [AuthzPolicy](https://docs.bext.dev/capabilities/authz-policy): The AuthzPolicy capability — externalised authorization policies for bext plugins. Covers the evaluate/reload_policies trait, the Allow/Deny/Mutate decision enum, the two reference backends (Cedar and CEL), the fail-closed engine-error contract, and the distinction between AuthzPolicy and Auth. - [Workflow (Sagas)](https://docs.bext.dev/capabilities/workflow): Long-running coordinated steps with retries and compensation — the saga pattern in bext. - [Payment Providers](https://docs.bext.dev/capabilities/payment): Vendor-neutral checkout, subscription, and webhook shape over Stripe, Lemon Squeezy, Paddle, and friends. - [Request Validator](https://docs.bext.dev/capabilities/validator): Validate request bodies, configs, and messages against a schema with structured error reports. - [Template Engines](https://docs.bext.dev/capabilities/template): Server-rendered HTML via pluggable template languages: Tera, Handlebars, Liquid. - [Custom Router](https://docs.bext.dev/capabilities/router): Plugin-driven routing layer that runs before the built-in router — legacy URLs, label-based routing, redirect tables. - [Experimentation](https://docs.bext.dev/capabilities/experimentation): Deterministic variant assignment, exposure tracking, and outcome recording across any A/B backend. ## Protocols - [gRPC](https://docs.bext.dev/protocols/grpc): Native gRPC serving on the same port as HTTP, with grpc-web transcoding and plugin compatibility. - [Server-Sent Events](https://docs.bext.dev/protocols/sse): First-class SSE with named channels, backpressure handling, and reconnection replay. - [WebTransport](https://docs.bext.dev/protocols/webtransport): HTTP/3-based WebTransport with reliable streams and unreliable datagrams. - [WebRTC Signaling](https://docs.bext.dev/protocols/webrtc-signaling): Built-in signaling server for SDP and ICE candidate exchange between WebRTC peers. - [MQTT Gateway](https://docs.bext.dev/protocols/mqtt): MQTT 5 gateway broker for IoT devices with HTTP publish bridge and plugin integration. - [CalDAV (Calendars)](https://docs.bext.dev/protocols/caldav): CalDAV server for calendar synchronization with iCalendar event storage and efficient sync tokens. - [CardDAV (Contacts)](https://docs.bext.dev/protocols/carddav): CardDAV server for contacts synchronization with vCard storage and address book queries. ## Migration - [From nginx](https://docs.bext.dev/migration/from-nginx): Replace nginx with bext — zero-config auto-detection or manual config translation. - [From Next.js](https://docs.bext.dev/migration/from-nextjs): Step-by-step guide to migrating a Next.js standalone app to bext, with feature mapping and common gotchas. - [From Express](https://docs.bext.dev/migration/from-express): Translate Express.js middleware, routing, and patterns to bext equivalents, or run Express behind bext as a reverse proxy. - [From Vercel](https://docs.bext.dev/migration/from-vercel): Move from Vercel to self-hosted bext or bext Cloud with feature-by-feature mapping and DNS cutover checklist. ## Operations - [Logging](https://docs.bext.dev/operations/logging): Structured JSON logging with request tracing, configurable levels, rotation, and forwarding to Loki, ELK, or Datadog. - [Monitoring](https://docs.bext.dev/operations/monitoring): Prometheus metrics endpoint, Grafana dashboards, alerting rules, and OpenTelemetry integration. - [Scaling](https://docs.bext.dev/operations/scaling): Horizontal scaling with Redis cache sync, distributed rate limiting, sticky sessions, and load balancer configuration. - [Performance & Budgets](https://docs.bext.dev/operations/performance): Budget framework, history store, and regression gate. - [Throughput Benchmarks](https://docs.bext.dev/operations/throughput-benchmarks): TechEmpower-style throughput — a single serialized worker vs the performant default, and vs Next.js / Remix / Astro / Qwik. - [Zero-Downtime Upgrades](https://docs.bext.dev/operations/upgrades): Upgrade bext-server to a new version without dropping a single connection. - [Invalidation & Restarts](https://docs.bext.dev/operations/invalidation-and-restarts): How to purge any cache layer, flush any V8 pool, reload TLS, or restart any one site without dropping unrelated services or co-hosted sites. - [Error Codes](https://docs.bext.dev/operations/error-codes): Structured error code reference — every E_ code bext can emit. - [Troubleshooting](https://docs.bext.dev/operations/troubleshooting): Common issues, diagnostic commands, and fixes for TLS, SSR, cache, plugin, and performance problems. ## Deploying - [Infrastructure Generators](https://docs.bext.dev/deploying/generators): Generate Dockerfile, GitHub Actions, systemd unit, and docker-compose from your bext project. ## Companion App - [Overview](https://docs.bext.dev/companion/overview): Native desktop app for managing, inspecting, and debugging your bext instances. - [Download](https://docs.bext.dev/companion/download): Download bext companion for macOS, Linux, or Windows. - [Connecting Instances](https://docs.bext.dev/companion/connecting): Connect bext companion to local and remote bext instances. - [Request Inspector](https://docs.bext.dev/companion/request-inspector): Inspect live HTTP requests flowing through your bext instance. - [Cache Explorer](https://docs.bext.dev/companion/cache-explorer): Browse, inspect, and invalidate cached content in your bext instance. - [MCP Server](https://docs.bext.dev/companion/mcp-server) ## Terminal UI - [Overview](https://docs.bext.dev/tui/overview): Ratatui-based terminal dashboard for managing bext over SSH or locally — no browser required. - [Installation](https://docs.bext.dev/tui/install): Build and install the bext-tui terminal dashboard. - [Connection Modes](https://docs.bext.dev/tui/connection-modes): Three ways to point bext-tui at a bext instance — remote, local, or multi-instance. - [Views](https://docs.bext.dev/tui/views): Screen-by-screen walkthrough of every bext-tui view. - [Keybindings](https://docs.bext.dev/tui/keybindings): Full keyboard reference for bext-tui — vim-style navigation, view shortcuts, and per-view actions. - [Command Palette](https://docs.bext.dev/tui/command-palette): Fuzzy-searchable command palette for bext-tui — every action available with two keystrokes. - [Configuration](https://docs.bext.dev/tui/configuration): CLI flags, environment variables, and config files for bext-tui. ## Licensing - [Overview](https://docs.bext.dev/licensing/overview): bext is open-core — the engine and the basics are free and source-available. A single Pro add-on covers the advanced capabilities; Cloud and Enterprise include it. - [Setup](https://docs.bext.dev/licensing/setup): How to configure and verify a bext license key. The open core needs no key — a key unlocks the Pro add-on or carries Enterprise / OEM entitlements. - [Feature Reference](https://docs.bext.dev/licensing/features): Every bext feature, whether it's free (open core) or part of the Pro add-on, and its Cargo build flag. - [FAQ](https://docs.bext.dev/licensing/faq): Common questions about bext's open-core license — what's free, what's in Pro, and how keys work. ## Architecture - [Overview](https://docs.bext.dev/architecture/overview): How bext is organized as a multi-crate Rust workspace — dependency graph, build profiles, and module responsibilities. - [Request Lifecycle](https://docs.bext.dev/architecture/request-lifecycle): Detailed flow of an HTTP request through bext — from TLS termination to response delivery, with timing at each stage. - [PRISM Rendering Pipeline](https://docs.bext.dev/architecture/prism-rendering-pipeline): The end-to-end path of a PRISM page render in bext — from route match through the tsc-rs frontend, the compile-fold pass, the Turbopack bundle, and the V8 render pool, to the HTML response. - [Transform Pipeline](https://docs.bext.dev/architecture/transform-pipeline): The source-code transforms bext applies at compile time — Next.js compat path, the PRISM compile pass, and the post-bundle / HTML response stages. - [TypeScript Frontend (tsc-rs)](https://docs.bext.dev/architecture/typescript-frontend): How bext uses tsc-rs — a from-scratch Rust TypeScript compiler — as the parser, AST, and emitter behind PRISM compilation, the source transforms, and the V8 bundle pipeline. - [V8 Render Pool](https://docs.bext.dev/architecture/v8-render-pool): The architecture of bext's V8 render pool — process topology, the cooperative multiplex driver, admission and backpressure, the watchdog and circuit breaker, and the 2026-06-10 pool-wide freeze post-mortem. - [Crate Reference](https://docs.bext.dev/architecture/crate-reference): Reference for every crate in the bext workspace — responsibilities, key modules, feature flags, and where each lives. - [Contributing](https://docs.bext.dev/architecture/contributing): Development setup, build commands, test suite, PR guidelines, and how to add new features to bext. ## Cloud - [Overview](https://docs.bext.dev/cloud/overview): Manage servers, sites, and clients from the bext cloud dashboard - [Admin Panel](https://docs.bext.dev/cloud/admin): Managing bext instances, SSL certificates, and platform health from the cloud dashboard.