Migration

Migrate from any framework.

bext auto-detects your framework and applies the right configuration. Most migrations take minutes, not days.

Package manager

From npm / yarn / pnpm

bext includes a full npm-compatible package manager built in Rust. You can replace your existing package manager entirely, or use both side by side.

Drop-in replacement

# Instead of: npm install
bext install

# Instead of: npm install lodash
bext install lodash

# Instead of: npx prettier --write .
bext x prettier --write .

# Instead of: npm run dev
bext ut run dev

# Instead of: npm publish
bext publish

Same lockfile format

bext reads and writes standard package-lock.json files. Switching is seamless — your existing lockfile works as-is.

Full command map

npm install → bext install (alias: bext i)
npm uninstall → bext uninstall (alias: bext un)
npx → bext x
npm run → bext ut run
npm link → bext link (alias: bext ln)
npm view → bext view
npm publish → bext publish
npm init → bext ut init

First-time setup

# Download the package manager companion
bext download ut

# Install dependencies from your existing package.json
bext install

What you gain

Rust-native performance — installs are significantly faster than npm
One binary for everything — no separate Node.js or npm install
Built-in Turbopack bundler via bext pack
Workspace support with topological script ordering

Next.js

From Next.js

bext is designed as a drop-in replacement for Next.js deployments. It implements 25+ Next.js APIs as direct replacements including next/navigation, next/headers, next/cache, next/image, next/link, next/dynamic, next/font/google, and more. Most apps migrate in under an hour.

Step 1: Install bext

curl -fsSL https://bext.dev/install | sh

Step 2: Replace your start command

package.json

{
  "scripts": {
-   "start": "next start",
+   "start": "bext start",
-   "dev": "next dev",
+   "dev": "bext dev"
  }
}

Auto-detection

bext automatically detects Next.js projects and applies the right transforms. No configuration file needed for most apps.

Step 3: Deploy

bext deploy

What changes

Edge Functions → bext server actions
Platform ISR → bext ISR cache (with stampede guard)
Platform Analytics → bext Prometheus metrics
next/image → bext image optimization
Middleware → bext WAF + route rules

Express

From Express

bext detects Express applications automatically. The Express adapter maps your existing route handlers, middleware chain, and error handlers without code changes.

Step 1: Point bext at your project

bext run .

Zero config

bext scans for app.js, server.js, or your package.json main entry. Express routing, middleware, and static file serving are handled automatically.

What you gain

Auto-TLS — no more certbot or manual certificate wrangling
HTTP/2 and HTTP/3 out of the box
Built-in rate limiting, WAF, and DDoS protection
ISR caching for your API responses
OpenTelemetry tracing without adding instrumentation

Hono

From Hono

Hono apps run on bext with no changes. The Hono adapter preserves your existing routing tree and middleware while adding bext's infrastructure layer underneath.

Step 1: Point bext at your project

bext run .

What you gain

Single binary deployment — no Node.js or Bun runtime required on the server
Auto-TLS, HTTP/3, and compression handled at the server level
Built-in WAF, rate limiting, and observability
Multi-app routing — serve multiple Hono apps from one bext instance

nginx

From nginx

This is the killer feature. Point bext at your existing nginx.conf and it just works. bext supports 68 of 70 nginx directives, including location blocks, upstream pools, proxy_pass, try_files, rewrite, SSL configuration, and more.

One-command migration

bext-server run .

Auto-detection

bext-server run . auto-detects nginx.conf in the current directory and serves with zero config changes. Your existing configuration is parsed, validated, and translated to bext's native routing at startup.

nginx masquerade mode

For environments that expect a real nginx process, bext can fully impersonate nginx:

# Install the nginx shim — bext replaces nginx transparently
bext-server nginx install

# bext writes a PID file, responds to SIGHUP for config reload,
# exposes the cache purge API, and installs a systemd override
# so "systemctl restart nginx" controls bext instead.

What you gain

HTTP/3 QUIC — nginx requires a separate build or NGINX Plus
Auto-TLS with ACME — no separate certbot cron job
Built-in WAF, bot detection, and DDoS mitigation
Real-time admin dashboard with SSE streaming
A single static binary — no modules, no dynamic linking

PHP

From Laravel / Symfony

bext includes PHP framework adapters and an embedded PHP runtime with a custom SAPI. No php-fpm, no Apache, no nginx — just bext.

Laravel

cd /path/to/your-laravel-app
bext-server run .

bext detects artisan and composer.json, identifies the Laravel framework, and configures the embedded PHP runtime with the correct document root, rewrite rules, and session handling.

Symfony

cd /path/to/your-symfony-app
bext-server run .

Symfony detection uses bin/console and config/bundles.php. The adapter configures the front controller, environment variables, and cache directory.

PHP micro-framework support

Standalone PHP apps without a framework are also supported. bext serves index.php directly through the embedded runtime — no separate PHP installation required.

What you gain

No php-fpm process manager — bext handles worker pools natively
Auto-TLS and HTTP/2 without configuring Apache or nginx
Built-in ISR caching for rendered PHP pages
Single binary deployment — ship bext, not a LAMP stack

Managed hosting

From Managed Hosting Platforms

bext gives you everything managed platforms offer, but self-hosted on your own infrastructure. One binary replaces the entire platform.

Deploy to your own server

# Build your project as usual
bext build

# Deploy to your server
bext deploy --host your-server.com

Feature mapping

Platform ISR → bext ISR cache with stale-while-revalidate and stampede guard
Edge Functions / Edge Middleware → bext server actions and WAF route rules
Platform Analytics → bext Prometheus metrics endpoint
Platform Image Optimization → bext on-the-fly image resize and format conversion
Form Handlers → bext durable flow engine
Serverless Functions → bext API routes with persistent runtime (no cold starts)
CDN / Edge Network → bext tiered cache (L1 in-memory + L2 Redis)

No vendor lock-in

Your code stays exactly the same. bext implements the same APIs your framework expects — you are migrating your infrastructure, not your application.

Ready to migrate?

Most migrations take under an hour. Start with the quickstart guide.

Get started Documentation