Renoxium Docs Pricing Sign in Sign up

02 — Comparison with other frameworks and platforms

Users choose a platform for its ecosystem, time-to-product, risk, and cost, not for its runtime. The matrices below map the needs of Renox's target users (01-business.md) against the available options.

Legend: ✅ present and mature · ⚠️ partial or needs work · ❌ absent.

A. Application frameworks vs needs

NeedNext.jsRemix / RR7SvelteKit / NuxtAstroDeno FreshLaravelRailsDjangoPhoenixAdonisJSRenox
Logic in TypeScript✅✅✅✅✅❌❌❌❌✅✅
SSR + static✅✅✅✅✅✅✅✅✅✅✅
HTML-first without SPA❌⚠️⚠️✅⚠️✅ Livewire✅ Hotwire⚠️ HTMX✅ LiveView⚠️✅ htmx
Built-in auth❌❌❌❌❌✅✅✅⚠️✅✅ module
Built-in admin, billing❌❌❌❌❌⚠️ packages⚠️ gems✅ admin❌❌✅ modules
Composable modules (install = done)❌❌❌⚠️ integrations❌✅ packages✅ engines✅ apps⚠️⚠️✅
No build step for the developer❌❌❌❌✅✅✅✅✅❌✅
Production memory per app❌ 200–500 MB⚠️⚠️⚠️⚠️⚠️⚠️⚠️✅⚠️✅ 2–10 MB
Easy self-hosting⚠️✅✅✅✅✅✅✅✅✅✅ (hosted)
Ecosystem and hiring✅ largest✅✅✅❌✅✅✅⚠️❌❌ new
Long-term API stability❌ churn⚠️⚠️✅⚠️✅✅✅✅⚠️❌ new

Conclusion: the combination "TypeScript + HTML-first + batteries-included + modules + low memory" is empty. The closest competitors by model are Laravel/Rails (different language) and AdonisJS (no modules, no hosting).

B. Hosting platforms vs needs

NeedVercelCloudflare WorkersDeno DeploySupabaseFly.ioRailway / RenderPocketBase (self-host)Renox
Deploy TS without Docker✅✅✅✅ fn⚠️⚠️❌✅
Sandbox for third-party code✅✅ isolate✅ isolate✅ isolate✅ microVM✅ container❌✅ isolate + process
Idle tenants nearly free⚠️✅✅⚠️⚠️ scale-to-zero❌✅✅
Built-in per-tenant database❌✅ D1✅ Deno KV✅ Postgres❌⚠️✅ SQLite✅ SQLite
Built-in HTML-first SSR❌❌❌❌❌❌❌✅
Installed auth/billing/admin modules❌❌❌⚠️ auth, storage❌❌⚠️ auth, admin✅
UAE local payments, BNPL, FTA tax invoices❌❌❌❌❌❌❌✅ GCC modules
AED pricing, data in the UAE❌❌❌❌❌❌n/a✅
Node compatibility✅⚠️✅✅✅✅n/a✅ via Deno

Supabase and Cloudflare are the closest architectural comparables (isolates + per-tenant DB). The difference is in the application model (SSR + modules) and the market (local pricing and payments).

C. Isolation models for hosting third-party code

ModelMemory per idle tenantCold startIsolation strengthnpm compatibilityUsed byDecision
Process per tenant (Bun/Node) + cgroups~30–50 MB~10–30 msStrong (OS)BestFly.io/Railway patternRejected: 5–10x less dense
MicroVM per tenant (Firecracker)~100 MB+~100 ms+ (faster with snapshots)Very strongBestAWS Lambda, Fly.ioOnly for the top tier / suspicious tenants
V8 isolate per tenant~2–10 MB (F1 measured 7.4 MB hello, 11.1 MB shop, provisional)~1–10 ms to create; F1 cold start p50 22 ms including the tenant file and the first request (provisional)Adequate; must be layered with a process sandboxGood via DenoCloudflare, Deno Deploy, Supabase, Vercel EdgeChosen (D2, D3, D6)
Wasm per tenant (wasmtime)< 1 MB< 1 msVery strongPoor for JSFermyon, FastlyFuture option for non-JS functions

Numbers are ranges from those platforms' publications; Renox targets are in 14-benchmarks.md.

D. JavaScript engines for the data plane

EngineMemory per instanceSpeedCompatibilityPer-tenant sandboxDecision
V8 via Supabase Edge Runtime / deno_runtime~2–10 MB (F1 measured 7.4–11.1 MB, provisional)JIT, fastestnpm:, node:*, Web APIs✅ heap limit, terminate, op permissionsChosen (D3)
V8 via raw deno_core~2–5 MBSameWeb APIs and Node compat must be built✅Rejected: scope
Bun (JavaScriptCore)~30–50 MB per processJIT, on par with V8Very good❌ no isolatesUsed for the control plane (D4), not for tenants
QuickJS (rquickjs)< 1 MB10–50x slower (no JIT)Many npm packages fail✅Rejected: SSR and libraries need speed
Boa (pure Rust)SmallSlower, incompleteLimited✅Watching

E. Databases for tenant data

OptionTenant isolationIdle tenant costLatencyPer-tenant backupWrite concurrencyFeaturesDecision
SQLite per tenantFile per tenant (strongest)0µs, in-processCopy file / Litestream1 writer per fileFTS5, JSON, sqlite-vec; no RLSChosen (D5)
Postgres, schema per tenantRLS/search_path (1 bug = leak)Catalog bloat at tens of thousands of schemasHundreds of µs–msHardHighCompleteRejected as default
Postgres, DB per tenantGood5–10 MB per backend connectionHundreds of µs–mspg_dumpHighCompleteUpgrade path for large tenants
Shared Postgres + tenant_idWeakSmallHundreds of µs–msHardHighCompleteRejected
Managed Turso/libSQLFile per tenantSmallNetworkBuilt-in1 writerSQLite-likeOperational alternative if we do not want to run replication ourselves

F. Template engines

OptionSyntaxRuntime-loadableSpeedSafety for tenant templatesDecision
minijinjaJinja✅Very fast, built-in fuelDSL, no codeUsed as the transpile target (D8)
HTML attributes (r-if, r-for)Valid HTML✅Follows the targetSameChosen as the syntax (D8)
AskamaJinja, compile-time❌Fastestn/aRejected: requires a Rust compile
TeraJinja✅Slower than minijinjaDSLRejected
JSX/TSX in the isolateJS✅Charged to the tenant quotaFull codeSecondary option
Custom engineAny✅UnknownMust be builtRejected: scope

G. Policy engines for authorization

OptionHost languageRBACABACRelationsSchema validationDecision
Cedar (cedar-policy)Rust✅✅✅✅Chosen (D15)
OPA / RegoGo (sidecar)✅✅⚠️⚠️Rejected: separate process
Casbin (casbin-rs)Rust✅⚠️⚠️❌Rejected: ABAC not expressive enough
OpenFGA / ZanzibarGo (service)⚠️❌✅✅Rejected: separate service, overkill
TypeScript predicatesJS✅✅✅❌Rejected: not analyzable, charged to tenant quota

H. "Why not just use X?"

QuestionShort answer
Why not Bun + Hono + HTMX?For our own apps that is enough and 3–5x cheaper to build. For hosting other people's code Bun has no isolates: one process per tenant means 5–10x lower density. Renox uses Bun for the control plane (D4).
Why not fork Supabase?Supabase is Postgres + functions. Renox adds the application model (SSR, modules), SQLite per tenant for density, and the local market. Its Edge Runtime is in fact our foundation (D3).
Why not PocketBase?A single Go binary without multi-tenancy, SSR, or modules. It proves demand; it is not a direct competitor.
Why not Postgres with RLS?For multi-tenant with a long tail, idle-tenant cost and the risk that one RLS bug leaks every tenant are worse than a file per tenant. Postgres remains the upgrade path (D5).
Why not run Next.js on Renox?Next.js depends on Node internals and a Vercel-centric build. Web-standard frameworks (Hono, SvelteKit, Remix) can technically run in an isolate but are not an initial focus.
Why Rust if V8 does the JS work?Rust controls the isolates: heap limits, watchdog, op permissions, scheduling, in-process SQLite, rendering outside the tenant quota. That is the part that sells.

Source on GitHub