Stone.js doesn't just run on multiple platforms, it adapts to them. From frontend to backend, from CLI to cloud, every context becomes a dimension. You write your logic once, and Stone.js unfolds it across environments without losing structure, meaning, or performance.
Stone.js is a future-ready framework designed for full-context development:
cloud, serverless, browser, and beyond.
One mindset across backend, frontend, serverless, and browser. Learn once, build anything.
Designed for the next generation of web development. Run on Node.js, AWS Lambda, Browser, or anywhere, adapt to any platform.
No node_modules. One artifact. Pure ESM. Built for performance and portability. Ship your app as a single file, with zero install-time dependencies.
Choose your style: class-based declarative or function-first programming, Stone.js supports both, natively.
Define routes once, use them everywhere. Same routing logic for backend and frontend.
Use built-in support for React and Vue(soon) with full SSR and hydration, or plug in your own view engine.
Add features through composable plugins. Build microservices, CLI apps, or SPAs without friction.
Create, build, test and deploy with one simple and powerful command line.
From microservices to monoliths, from local to cloud, Stone.js lets you scaffold, shape, and ship your app in minutes. Choose your paradigm, pick your platform, and let Stone.js handle the rest.
import { NodeHttp } from "@stone-js/node-http-adapter"
import { IncomingEvent, IEventHandler, StoneApp } from "@stone-js/core"
@NodeHttp()
@StoneApp()
export class App implements IEventHandler<IncomingEvent> {
/**
* Handle incoming events
*
* @param event Incoming event
* @returns response
*/
handle(event: IncomingEvent): { message: string } {
const message = `Hello ${event.get<string>('name', 'World')}!`
// Return a JSON response
return { message }
}
}
import { defineStoneApp, IncomingEvent } from "@stone-js/core"
import { nodeHttpAdapterBlueprint } from "@stone-js/node-http-adapter"
/**
* Handle incoming events
*
* @param event Incoming event
* @returns response
*/
export const Handler = (event: IncomingEvent): { message: string } => {
const message = `Hello ${event.get<string>('name', 'World')}!`
// Return a JSON response
return { message }
}
export const App = defineStoneApp(
Handler, {}, [nodeHttpAdapterBlueprint]
)
Run npm create @stone-js and pick your flavor: mono-routed or multi-routed, backend or frontend, React or Vue(soon). No templates, just choices.
Prefer functions? Use the imperative API. Love decorators? Go declarative. Stone.js supports both, equally powerful, equally simple.
Whether it’s Node.js, Lambda, or the browser, your app becomes one artifact ready to deploy anywhere. No config hell. Just build and run.
A modern, full-context JavaScript framework designed for speed, portability, and architectural clarity, from edge to core.
One architecture from backend to frontend to cloud, fully aligned.
Node.js, browser, FaaS, Edge… you choose. One artifact runs everywhere.
Bootstrap, build, test, and deploy with zero config.
Same knowledge across frontend and backend. Universal routing, services, config.
Designed for serverless and edge-native deployments from the ground up.
Declarative or imperative, dynamic or static, configure your way.
Small, tree-shaken, lazy-loaded. Zero runtime overhead.
Define, register, and compose behavior easily and transparently.
Just one portable artifact. No baggage. No pollution.
Built for modern tooling with type-safe interfaces everywhere.
No bloat. Bring only what you use, when you use it.
Override, extend, or inject behavior at every lifecycle stage.
Stone.js is more than a framework. It's a movement built around clean architecture, cloud-native principles, and a radically simplified developer experience.
Whether you're building apps, libraries, plugins, or frameworks on top of Stone.js, you're not alone. Meet developers, ask questions, share ideas, and shape the future.
Stone.js isn't built on layers, it's built on a flow, from raw events to rendered experiences. That flow is called the Continuum.
Produce your app’s blueprint by configuring services, features, and plugins, declaratively or imperatively.
Adapt external stimuli (HTTP, CLI, Lambda, browser) into contextual events Stone.js understands.
Populate the app context, register lifecycle hooks, and prepare for execution.
Handle intentions using event handlers to produce responses, domain logic, clean and portable.
Everything you need to build modern, scalable, and flexible applications.
Generate, build, run, and deploy apps with a unified, developer-first command line.
Extend or override core behaviors using reusable, modular plugins.
Abstract platform differences and run your app seamlessly on Node, browser, Lambda, or the unknown.
Universal router for frontend and backend. One routing system. Every dimension.
Enable SSR, hydration, and rendering in React, with full head and layout control.
Manage environment and config variables safely with powerful helpers.
Configure everything through a unified context-aware API, declarative or imperative.
Destructure your services with ease using a fast, extensible, zero-boilerplate DI container.
Kick off with “basic”, “standard”, or “full” blueprints, pick your entry point into the Continuum.
One mindset. One framework. Infinite possibilities.
Embrace the continuum, and deploy everywhere with confidence.
