Open-Source Distributed JavaScript Runtime
CoCreateJS combines HTTPS, WebSockets, CRUD, API orchestration, clustering, telemetry, autoscaling, self-healing, and multi-cloud coordination in one lightweight, framework-agnostic runtime.
Run any application, or pair it with the optional CoCreateJS Client for realtime, offline-capable interfaces built with JavaScript or HTML.
Building a distributed application should not require assembling and maintaining an entire collection of infrastructure products before application development can begin.
Load balancers, ingress controllers, proxies, service discovery, process managers, queues, caches, and orchestration systems all require configuration and maintenance.
Behavior becomes scattered across JavaScript, YAML, cloud dashboards, ingress rules, pipelines, service meshes, and provider-specific configuration.
Every additional service consumes CPU, memory, networking, storage, and engineering time—even when the application itself is small.
Every dependency, exposed service, plugin, and management layer adds another component that must be audited, patched, and protected.
As systems grow, engineering effort shifts away from application features and toward maintaining the infrastructure surrounding them.
Teams must learn multiple products, frameworks, formats, deployment systems, and operational models to run one application.
What if the infrastructure surrounding the application could become part of one small runtime?
Every node can receive traffic, run workers, serve applications, communicate with peers, monitor itself, and participate in scaling decisions.
There is no dedicated global master, ingress tier, or load-balancer tier. Every node is a complete peer with its own local worker orchestration.
Anycast or GeoDNS directs the initial connection. Once traffic arrives, JavaScript and stored policy can make application-aware routing decisions.
Definitions, workflows, permissions, files, and operational state live in shared storage, so nodes can be created, replaced, or removed.
Host or support applications built with any frontend or server-side framework without changing the runtime model.
Operate across providers, regions, bare metal, private infrastructure, or any combination of them.
CoCreateJS combines the infrastructure required to operate distributed applications into one compact, extensible runtime.
Complete peer nodes coordinate traffic, workers, communication, recovery, and scaling.
Define routing, APIs, storage, schedules, and policy as structured application data.
Use consistent objects and events across CRUD, sockets, APIs, storage, and runtime operations.
Run close to users across regions, providers, private infrastructure, and bare metal.
Observe health, cordon overloaded workers, redistribute traffic, recover, and scale.
Inspect, self-host, extend, or replace capabilities through familiar JavaScript primitives.
CoCreateJS stores application definitions as structured data. The runtime stays stateless and generic while shared storage remains the source of truth.
HTML · JavaScript · AI
CLI · Visual Editor
APIs · Endpoints · AST · Cron Jobs
Permissions · Files · Configuration
Runtime Nodes · External APIs
Databases · Events · Automations
Providers, workflows, files, permissions, runtime configuration, and scheduled jobs are centrally available to every node.
Updating configuration or an AST definition changes behavior without rebuilding or redeploying the runtime.
Development, staging, and production can use separate hosts and databases while running the same runtime.
The runtime handles credentials, authorization, headers, transport, and execution without replacing the request format providers already document.
Send a provider-native body directly to a configured API. An endpoint is not required.
Save, name, secure, and reuse multi-step server workflows composed from AST operations.
Cron jobs use the same AST execution model without adding a separate scripting framework.
Endpoints are optional server-side macros for workflows such as creating a customer, reading organization data, sending a message, writing an audit record, and returning a unified response.
Capabilities are exposed through ordinary objects, functions, maps, events, and payloads—not proprietary method trees or another routing language.
import server from "@cocreate/server";
await server.init();
server.routes.set("/health", (req, res) => {
res.writeHead(200, {
"Content-Type": "application/json"
});
res.end(JSON.stringify({ status: "healthy" }));
});
await server.crud.send({
method: "object.read",
array: "users",
filter: { limit: 1 }
});
server.wsManager.on("message", callback);server.routesA native Map for application request handlers. Method, host, tenant, and geographic policy remain ordinary JavaScript.
server.api and server.filesBuilt-in handlers that applications can use directly, call from a route, wrap, or replace.
server.crudA unified object-based interface for data operations across storage providers.
server.wsManagerRealtime messages through a consistent event-driven interface.
server.storageShared runtime state and coordination across workers through IPC.
Authentication, authorization, geographic routing, tenant placement, request transformation, caching, and provider selection stay under application control.
Telemetry, worker coordination, node communication, and autoscaling operate inside the runtime rather than through separate orchestration services.
Track resources, connections, traffic, and health.
Stop new work while preserving active connections.
Direct new clients toward healthy capacity.
Create capacity according to demand and geography.
Uncordon workers or safely retire drained nodes.
Work with universal application concepts instead of rewriting logic around collections, tables, rows, records, or documents.
await server.crud.send({
method: "object.read",
array: "users",
filter: {
query: {
email: "user@example.com"
},
sort: {
created: -1
},
limit: 1
}
});Adapters translate unified operations into efficient native database operations such as findOne, LIMIT 1, or the provider equivalent.
Target multiple providers in parallel for replication, migration, backup, edge synchronization, analytics, or redundant writes.
The same vocabulary carries across declarative HTML, JavaScript, browser storage, sockets, and server databases.
Optional Client Runtime
Build realtime, offline-capable interfaces through declarative HTML, a headless JavaScript API, or both. The server runtime does not require the client.
Add data, state, rendering, actions, files, and realtime behavior through readable attributes.
<input
array="users"
object=""
key="name"
realtime />Consume the same capabilities programmatically with React, Vue, Angular, Svelte, Solid, plain JavaScript, Web Components, or your own renderer.
A frontend framework controls rendering. CoCreateJS can provide realtime data, sockets, storage, APIs, files, and the distributed runtime beneath it.
HTML, components, files, and application assets can live in shared storage for collaboration, AI editing, permissions, metadata, versioning, and realtime synchronization.
Assets can carry cache control, TTL, content type, visibility, host rules, paths, modification data, and validation metadata.
CoCreateJS relies primarily on native Node.js capabilities and adds external packages only where transport or protocol complexity makes them valuable.
Designed for fast replication and consistent deployment.
A smaller graph to audit, patch, and maintain.
HTTP, sockets, workers, telemetry, files, APIs, and coordination together.
Operate directly behind Anycast or GeoDNS.
IPC and runtime communication without required Redis.
Minimal local state makes nodes easier to replace and distribute.
Use a shared set of runtime primitives across applications, infrastructure, and deployment models.
Multi-tenant applications across regions and clouds.
Editors, chats, dashboards, and shared workspaces.
Structured prompts, providers, tools, and workflows.
Data-heavy systems with any frontend or CoCreateJS Client.
Provider requests, macros, cron jobs, and CRUD.
Declarative components, configuration, and workflows.
Browser caching, IndexedDB, and synchronization.
Complete nodes across providers without fixed roles.
Open Source
Foundational infrastructure should be inspectable, auditable, extensible, and community-driven. Read the same source that powers the runtime and help refine it.
Available under AGPL-3.0 with alternative commercial licensing where required.
Inspect the implementation, architecture, dependencies, and behavior.
Improve source, documentation, performance, and compatibility.
Management tools use the same capabilities available to applications.
The same concepts connect the client, server, storage, sockets, APIs, and HTML interfaces.
Run your first node and application.
Understand runtime capabilities and lifecycle.
Explore nodes, workers, peers, and traffic.
Attach policy with ordinary JavaScript.
Build realtime application flows.
Use one data model across providers.
Compose requests and workflows.
Use declarative HTML or headless JavaScript.
Move from local development to multiple clouds.
Learn how the runtime, client, storage model, deployment architecture, and open-source project fit together.
Email UsHave a question about runtime integration, architecture, storage adapters, deployment, or contributing? Tell us what you are building.
Runtime · Client · Self-hosting · Architecture · Storage adapters · Open source · Documentation
Start locally, inspect the source, and grow into a distributed system.