A performance-first cross-runtime API framework without the boilerplate
Documentation »
Join Discord
·
Report Bug
·
Request Feature
Every framework promises to be fast and easy. Jetpath got built because most of them aren't.
// This is a complete API endpoint in Jetpath
export const GET_users_$id: JetRoute = async function (ctx) {
const { id } = ctx.params;
const user = await db.users.findUnique({ where: { id } });
return ctx.send(user);
};Jetpath eliminates the cognitive overhead that slows down development. No more router configuration, middleware chains, or callback hell. Just pure functions that map directly to HTTP endpoints through a clean, predictable naming convention.
The tech stack you already trust, but faster:
- Write APIs in TypeScript/JavaScript across Node.js, Deno, or Bun
- ~50% less code than Express with stronger type safety
- Benchmarks show massive throughput compared to Elysia.js.
Jetpath is built with strong opinions on what matters most:
- Zero config by default - Convention eliminates boilerplate
- Runtime agnostic - True support for Node.js, Deno, and Bun (not just compatibility layers)
- Type safety - Full TypeScript support that doesn't get in your way
- Predictable routing - Routes derived from function names (GET_users_$id → GET /users/:id)
- Built for production - Security, validation, and error handling baked in
I am using Jetpath in production and here are the results.
- 40% reduction in API codebase size
- Simplified onboarding for new team members
- Faster iterations on API endpoints
# Create new project
npx jetpath new-project
# Navigate and start the dev server
cd new-project && npm install && npm run devimport { type JetRoute, Jetpath, use } from "jetpath";
const app = new Jetpath();
app.listen(3000);
// GET /products
export const GET_products: JetRoute = async (ctx) => {
const products = await db.products.findMany();
ctx.send({ products });
};
// POST /products with validation
export const POST_products: JetRoute = async (ctx) => {
const data = await ctx.parse();
const product = await db.products.create({ data });
ctx.send({ product }, 201);
};
// Add validation and docs in one step
use(POST_products)
.title("Create a new product")
.body((t) => ({
name: t.string().required().min(3),
price: t.number().required().min(0),
description: t.string()
}));
// Maps to ws://your-host/live
export const GET_live: JetRoute = (ctx) => {
ctx.upgrade();
const conn = ctx.connection!;
conn.addEventListener("open", (socket) => { /* ... */ });
conn.addEventListener("message", (socket, event) => { /* ... */ });
};- Unified dev experience across Node.js, Deno, and Bun
- Auto-generated API documentation with interactive UI
- First-class WebSocket support
- Plugin system for extending functionality
- Schema validation that is part of api documentation
- Request parsing that just works (JSON, forms, multipart)
- Performance-optimized routing and middleware execution
- Security good defaults
It's not just a claim how fast - measure it. In the benchmark suite, Jetpath consistently perform close to raw Bunjs performance matches elysia.js on common API workloads:
| Framework | Requests/sec | Latency (avg) |
|---|---|---|
| Bun | ~40,890 | 12.2ms |
| Elysia | ~33,383 | 13.2ms |
| Jetpath | ~32,339 | 13.7ms |
4-core CPU, 1000 concurrent connections and 1,000,000 requests, simple JSON response
Bunjs being amongst the fastest http runtime.
For existing projects:
npm install jetpath --save- Documentation - In-depth guides and API reference
- Discord Community - Get help from the team and other users
- GitHub Issues - Report bugs or request features
Apache 2.0 - Open source and built for the community.
We welcome contributions! See our contributing guide for details on how to get involved.
By contributing, you agree to license your code under the Apache 2.0 license and confirm that all contributions are your original work.
If Jetpath helps you or your team ship faster and more understandable codebase, consider supporting its development through GitHub Sponsors.
