Kynetra FX
Get started
Zero Hono. 100% Web Standards.

The edge-native
backend framework.

Kynetra FX is an original TypeScript backend engine built on Request, Response, Headers & Fetch. The Hono replacement for AI-native SaaS backends — build once, run on Cloudflare, private cloud, or self-hosted.

Get startedView on GitHub
$npm i @kynetra/fxedge · node · bun · deno
app.ts
import { createFX } from '@kynetra/fx'
 
const app = createFX({
  name: 'resolve-api',
  runtime: 'cloudflare',
  mode: 'edge'
})
 
app.use(requestId())
app.use(secureHeaders())
app.use(cors())
app.use(logger())
 
app.get('/health', (ctx) => {
  return ctx.json({
    status: 'ok',
    engine: 'Kynetra FX'
  })
})
 
app.group('/api', (api) => {
  api.use(auth())
  api.use(tenant())
  api.use(rbac())
 
  api.get('/issues', IssueController.list)
  api.post('/issues', validate(CreateIssueSchema), IssueController.create)
})
 
export default app

Feature set

Everything a production backend needs — natively.

No wrappers, no Hono underneath. Each capability is implemented from first principles on the Fetch API.

Ultra-fast native router

Static, dynamic params, wildcards, route groups, and nested routers — a trie-based matcher with zero per-request allocations on the hot path.

Onion-style middleware

A Koa-inspired pipeline with true pre/post symmetry. Compose request-id, CORS, secure headers, auth, and rate limits with predictable ordering.

Typed request context

One ctx object: typed params, query parser, body & multipart parsing, cookies, headers, and response helpers — json, text, html, redirect, stream, file.

End-to-end contracts

Schema-based routes infer input and output types. No codegen step — your client types follow your server the moment you save.

Typed RPC client

Generate a fully-typed fetch client from your route contracts. tRPC-style ergonomics over plain HTTP, with autocomplete across the wire.

OpenAPI, automatically

Every contract emits an OpenAPI 3.1 document. Ship a live spec and Swagger UI without writing YAML by hand.

Plugin lifecycle & hooks

Fastify-grade plugins with decorators and app/route hooks: onRequest, preHandler, postHandler, onError, onResponse.

Secure defaults

hapi-style hardening out of the box: secure headers, CORS, CSRF, JWT / API-key / session auth, tenant resolver, RBAC and permission guards.

AI & vector native

First-class adapters for Workers AI, OpenAI & Anthropic, plus Vectorize / pgvector / Qdrant — built for AI-native SaaS workloads.

The DNA

The best ideas from 11 frameworks, rebuilt as one engine.

Kynetra FX studied a decade of backend design and synthesized it into a single, coherent, edge-native runtime.

01

Hono

Speed, Web Standards, multi-runtime simplicity

02

Express

Minimal routing & familiar DX

03

Fastify

Plugins, hooks, decorators, schema validation, fast logging

04

Koa

Onion-style middleware pipeline

05

Elysia

End-to-end type safety, typed client, OpenAPI

06

NestJS

Modules, providers, services, guards, clean architecture

07

AdonisJS

Batteries-included auth, ORM, validation, queues, cache

08

Oak

Cross-runtime middleware architecture

09

hapi

Secure defaults, mature auth, enterprise plugin model

10

tRPC

Procedures, routers, type inference, no-codegen contracts

11

Nitro

Deployment portability & universal server output

Contracts

Define once. Typed everywhere.

A single contract drives validation, the OpenAPI spec, and a typed client — with full inference and no code generation step.

server.ts
import { contract, fx } from '@kynetra/fx'
 
export const createIssue = contract({
  method: 'POST',
  path: '/issues',
  input: fx.object({
    title: fx.string().min(1),
    priority: fx.enum(['low', 'high'])
  }),
  output: fx.object({
    id: fx.string(),
    title: fx.string()
  })
})
 
app.handle(createIssue, async (ctx) => {
  const { title } = ctx.input
  return ctx.json({ id: 'iss_1', title })
})
client.ts
import { createClient } from '@kynetra/fx-client'
import type { App } from './server'
 
const api = createClient<App>({
  url: 'https://fx.kynetra.dev'
})
 
// fully typed — input + output inferred
const issue = await api.issues.create({
  title: 'Ship Kynetra FX',
  priority: 'high'
})
 
issue.id    // string
issue.title // string

Run anywhere

One codebase. Every runtime.

Write your app once against the FX core. Swap the adapter to deploy to the edge, a VM, or a Kubernetes cluster — no rewrites.

Cloudflare

Workers · edge

D1, KV, R2, Queues, Durable Objects, Vectorize, Workers AI, Turnstile.

Node.js

self-host

A native http server adapter with streaming and Web Standards bridging.

Bun

self-host

Runs on Bun.serve with first-class performance and zero shims.

Deno

self-host

Deno.serve adapter — secure by default, npm and JSR friendly.

Docker

self-host

Production container templates for private cloud and on-prem.

Kubernetes

self-host

Health probes, graceful shutdown, and horizontal scaling baked in.

Built-in adapters

D1PostgresSQLiteRedisKVR2 / S3QueuesBullMQpgvectorQdrantWorkers AIOpenAIAnthropic

SaaS Kernel

A batteries-included core for multi-tenant products.

Stop rebuilding the same primitives. The @kynetra/fx-saas kernel ships the modules every serious SaaS needs — tenancy, RBAC, audit trails, billing-ready entities — wired into the FX context and guards.

Users
Organizations
Workspaces
Memberships
Roles
Permissions
Sessions
API keys
Audit logs
Feature flags
Notifications
Files
Queues
AI jobs
Reports
Admin settings

Honest comparison

Not a Hono wrapper. A replacement.

Kynetra FX keeps what made the edge generation great and adds the enterprise layer they leave to you.

CapabilityKynetra FXHonoExpressFastify
Web Standards core (Request/Response)——
Edge-native (Workers, no shim)——
Onion-style middlewarepartial——
Plugin lifecycle + decorators——
End-to-end typed contractspartial—partial
Typed RPC client (no codegen)partial——
OpenAPI generationpluginpluginplugin
Built-in auth / RBAC / tenancy———
SaaS kernel modules———
AI / vector adapters———
Multi-runtime adapters——

Comparison reflects core, out-of-the-box capabilities. “plugin” = available via an ecosystem add-on; “partial” = supported with caveats.

Build once. Run on Cloudflare, private cloud, or self-hosted.

Kynetra FX is the edge-native execution engine for AI-native SaaS backends. Start in minutes — ship to the edge today, your own cluster tomorrow.

$npx @kynetra/fx-cli new my-api
Read the docsStar on GitHub