An AI-native, distributed JavaScript runtime for building, executing, connecting, deploying, and operating applications across any infrastructure.
CoCreateServer brings application execution, real-time communication, databases, security, workflows, distributed computing, and cloud orchestration together in one extensible runtime.
Run APIs. Connect databases. Execute workflows. Deploy infrastructure. Scale across regions. Give authorized AI agents the tools to operate your applications and business.
Built as the server-side foundation of CoCreateJS, CoCreateServer enables developers to move beyond traditional application hosting toward a connected environment where applications, services, data, infrastructure, and intelligent agents operate together.
One runtime. From application logic to distributed infrastructure.
- Why CoCreateServer?
- What Is CoCreateServer?
- Quick Start
- Core Architecture
- Primary and Worker Processes
- Distributed Runtime Mesh
- Networking and Application Services
- Unified Data and Database Adapters
- CoCreateDB Integration
- AI-Native Runtime and CoCreateMCP
- Business Automation and Application Workflows
- Structured Execution with CoCreateAST
- Security and Key Management
- Infrastructure Orchestration
- Distributed Scaling and Geographic Routing
- Real-Time Communication and Synchronization
- Modularity and Extensibility
- Self-Contained Application Infrastructure
- Architecture Overview
- Use Cases
- Design Philosophy
- CoCreateJS Ecosystem
- Contributing
- License
- Resources
Modern applications require far more than an HTTP server.
Developers often need to assemble and maintain independent systems for:
- Application hosting
- HTTP and WebSocket communication
- API routing
- Database connectivity
- Authentication and authorization
- Key and secret management
- Background jobs
- Scheduled automation
- Distributed workers
- Service discovery
- Cluster coordination
- Deployment pipelines
- Cloud provisioning
- Load balancing
- Monitoring and autoscaling
- AI integrations
- Business automation
Each introduces additional configuration, dependencies, operational complexity, and integration overhead.
CoCreateServer takes a different approach.
Instead of treating these responsibilities as unrelated infrastructure services, CoCreateServer provides a common JavaScript runtime where application capabilities can be connected, executed, and coordinated through consistent interfaces.
The objective is not to eliminate every external service.
It is to make fewer services mandatory while preserving the freedom to integrate with existing infrastructure.
CoCreateServer is designed to function as:
- An application server
- An API server
- A real-time communication server
- A distributed worker runtime
- A database connectivity layer
- A workflow execution environment
- An infrastructure orchestration platform
- An AI-accessible capability platform
Applications can use these responsibilities independently or together.
Traditional development often separates writing application code from deploying, managing, and operating it.
CoCreateServer connects these stages through a shared runtime environment.
Application Code
|
v
CoCreateServer
|
+-- APIs and Networking
|
+-- Data and Storage
|
+-- Workflows and Automation
|
+-- Security and Permissions
|
+-- Distributed Execution
|
+-- Infrastructure Operations
|
+-- AI-Accessible Tools
Build the application. Run the application. Operate the application.
CoCreateServer is a modular JavaScript runtime built on Node.js.
It provides application-level interfaces for executing services, managing workers, connecting storage, coordinating distributed nodes, and integrating infrastructure.
Unlike a conventional web server focused primarily on handling HTTP requests, CoCreateServer is designed to coordinate the broader application environment.
A framework generally provides conventions and APIs for building an application.
A runtime provides the environment in which application capabilities execute.
CoCreateServer extends that execution environment with reusable operational capabilities.
Applications can interact with the runtime to:
- Register routes
- Execute APIs
- Communicate over WebSockets
- Access databases
- Load modules
- Schedule tasks
- Coordinate workers
- Execute workflows
- Manage runtime configuration
- Connect infrastructure providers
- Expose authorized capabilities to AI clients
CoCreateServer can operate independently of CoCreateClient.
It can support:
- Plain JavaScript applications
- Existing frontend frameworks
- REST APIs
- Real-time applications
- Backend services
- Business applications
- Distributed workloads
- AI-connected applications
Developers do not need to rebuild their frontend to adopt the runtime.
CoCreateServer uses JavaScript modules to extend its capabilities.
Applications can load only the functionality required for their environment.
Different processes and nodes can execute different responsibilities while participating in the same distributed system.
- Node.js
- npm or another compatible package manager
- A supported operating system
Specific Node.js version requirements depend on the release.
npm install @cocreate/serverimport server from '@cocreate/server';
await server.init();The runtime initializes its configured capabilities and prepares the application environment.
import server from '@cocreate/server';
await server.init();
if (server.isWorker) {
server.routes.set('/health', async (req, res) => {
res.writeHead(200, {
'Content-Type': 'application/json'
});
res.end(JSON.stringify({
status: 'healthy'
}));
});
}import server from '@cocreate/server';
await server.init();
if (server.isPrimary) {
console.log('Primary process initialized');
}
if (server.isWorker) {
console.log('Worker process initialized');
}if (server.isPrimary) {
await import('@cocreate/cron-jobs');
}
if (server.isWorker) {
await import('@cocreate/users');
await import('@cocreate/organizations');
}Modules can be assigned to the processes responsible for executing them.
The examples illustrate the runtime's JavaScript API conventions. Consult the installed version and individual modules for configuration and available methods.
CoCreateServer is built around a modular runtime object.
The runtime provides access to configured application capabilities through JavaScript interfaces.
CoCreateServer
|
+---------------+---------------+
| | |
v v v
Primary Workers Modules
| | |
Coordination Application Extensions
Lifecycle Execution Integrations
| | |
+---------------+---------------+
|
v
Runtime APIs
|
+---------------+---------------+
| | |
v v v
Networking Storage Workflows
| | |
+---------------+---------------+
|
v
Distributed Mesh
|
Infrastructure
The runtime can coordinate several categories of functionality.
Execution
Application processes, workers, jobs, and services.
Connectivity
HTTP, HTTPS, WebSockets, events, and server-to-server communication.
Data
CRUD operations, database adapters, native storage, and synchronization.
Security
Authentication, permissions, credentials, and protected operations.
Automation
Structured workflows, scheduled jobs, and application events.
Infrastructure
Provisioning, deployment, cluster coordination, scaling, and recovery.
AI Integration
Discoverable, authorized tools exposed through CoCreateMCP.
These responsibilities are modular and depend on the installed components and configured integrations.
CoCreateServer distinguishes between primary and worker processes.
The primary process coordinates responsibilities associated with the local runtime node.
Depending on configuration, these may include:
- Worker lifecycle management
- Process coordination
- Runtime initialization
- Scheduled services
- Infrastructure operations
- Local resource management
- Cluster communication
Workers execute application responsibilities.
Depending on configuration, workers may handle:
- HTTP requests
- WebSocket connections
- Application routes
- API operations
- Business logic
- Database requests
- Real-time events
- Background workloads
Modules can be loaded according to process responsibilities.
if (server.isPrimary) {
await import('@cocreate/cron-jobs');
}
if (server.isWorker) {
await import('@cocreate/users');
}This avoids requiring every process to initialize every application capability.
Primary and worker describe local process responsibilities.
They do not imply that one permanent global server must control every node in a distributed deployment.
Each runtime node can manage its local processes while participating in the broader mesh.
CoCreateServer is designed to coordinate multiple runtime nodes across servers, regions, and infrastructure providers.
A distributed deployment may contain multiple CoCreateServer nodes.
Each node can provide application execution, networking, and configured services.
Nodes communicate through supported mesh and messaging mechanisms.
CoCreate Mesh
|
+---------------+---------------+
| | |
v v v
Node A Node B Node C
| | |
Primary Primary Primary
| | |
Workers Workers Workers
| | |
+---------------+---------------+
|
Shared Services
The mesh architecture is intended to support:
- Node discovery
- Server-to-server communication
- Distributed messaging
- Worker coordination
- Service routing
- Application synchronization
- Health monitoring
- Workload distribution
- Node provisioning and recovery
Nodes may operate across different cloud providers and regions.
A node can maintain local execution responsibilities while communicating with other nodes.
The architecture aims to avoid unnecessary dependence on a single centralized execution server.
The mesh provides a foundation for distributed application capabilities, including synchronized data, shared events, workload routing, and infrastructure automation.
The guarantees of each distributed service depend on its implementation, consistency model, and failure-handling strategy.
CoCreateServer provides networking capabilities for building connected applications.
The runtime supports HTTP-based application services and secure communication through TLS-enabled configurations.
Applications can register routes and implement custom request handling.
server.routes.set('/api/status', async (req, res) => {
res.writeHead(200, {
'Content-Type': 'application/json'
});
res.end(JSON.stringify({
service: 'CoCreateServer',
status: 'running'
}));
});WebSocket communication enables persistent connections between clients and servers.
Applications can use configured socket modules for:
- Real-time updates
- Messaging
- Notifications
- Subscriptions
- Collaborative applications
- Presence
- Event distribution
CoCreateServer can expose APIs for:
- CRUD operations
- Authentication
- User management
- Organization management
- Business operations
- File handling
- Custom application logic
- Workflow execution
- Infrastructure management
CoCreateServer can operate alongside existing application stacks.
Developers can use its APIs, real-time communication, or infrastructure capabilities without adopting CoCreateClient.
CoCreateServer is designed to connect applications to multiple database technologies through a consistent data-access model.
Its storage architecture includes more than 27 adapter and provider mappings, including compatibility layers for related database systems.
Supported database families and integrations include:
- MongoDB
- PostgreSQL
- MySQL
- SQLite
- MariaDB
- CockroachDB
- Amazon DynamoDB
- Google Firestore
- Azure Cosmos DB
- Amazon DocumentDB
- FerretDB
- PlanetScale
- Amazon Aurora
- Oracle Database integrations
- Other compatible storage systems
Some providers share a common underlying driver or protocol adapter.
CoCreateServer uses consistent concepts across supported storage integrations.
array— a collection or group of objectsobject— an individual structured recordkey— a property, including nested pathsfilter— criteria for selecting datasort— ordering criterialimit— result constraints
Applications can perform structured data operations through compatible modules.
crud.send({
method: 'object.read',
array: 'users',
filter: {
query: {
active: true
},
sort: {
created: -1
},
limit: 25
}
});The objective is to separate application behavior from database-specific implementation details.
Applications can use a supported database provider without rewriting their entire data-access layer.
Individual adapters may differ in supported operators, transactions, consistency guarantees, and performance characteristics.
Different applications and services can use different storage backends.
A deployment might combine:
- MongoDB for application documents
- PostgreSQL for relational workloads
- SQLite for local persistence
- DynamoDB for managed key-value access
- CoCreateDB for native document storage
CoCreateServer provides the application-level integration layer.
CoCreateDB is the storage-agnostic JavaScript database engine developed for the CoCreateJS ecosystem.
It provides an alternative to operating an independent database service for every application deployment.
CoCreateDB is designed around JSON documents, configurable storage backends, and first-class indexing.
The architecture targets storage environments such as:
- Local filesystems
- Attached storage
- Cloud object storage
- S3-compatible providers
- Distributed storage environments
CoCreateDB's indexing model organizes indexes by database, array, and key.
Indexes are segmented and maintain metadata used to narrow candidate sets and support ordered retrieval.
The indexing primitive is designed to remain independently accessible.
CoCreateDB integrates with CoCreateServer's runtime object.
This allows configured application services and authorized tools to access database operations and supported structural metadata.
Potential capabilities include:
- Querying objects
- Inspecting arrays
- Discovering indexed keys
- Examining index metadata
- Accessing storage configuration
- Diagnosing query behavior
Through authorized runtime tools, AI agents can work with CoCreateDB data and metadata.
For example, an agent could inspect application records, analyze index organization, or assist with identifying inefficient queries.
The same application-level approach can apply to external databases through supported adapters.
CoCreateDB is not required to use CoCreateServer.
Developers can choose the native database engine or continue using compatible external providers.
Repository: CoCreateJS/db
Package: @cocreate/db
CoCreateServer provides the operational foundation for AI-native applications.
Rather than limiting AI agents to generating code or recommending commands, CoCreateServer can expose application and infrastructure capabilities as executable tools.
CoCreateMCP connects compatible AI clients to these capabilities through the Model Context Protocol.
An AI agent can reason about an objective, discover available tools, and invoke authorized operations.
AI Client / CoCreateAI
|
v
CoCreateMCP
|
Tool Discovery
|
v
Authorization
|
v
CoCreateServer
|
+---------------+---------------+
| | |
v v v
Application Business Infrastructure
APIs Workflows Operations
| | |
+---------------+---------------+
|
v
Execution Result
CoCreateMCP can expose selected operations from the CoCreateServer environment.
These may include:
- Application data queries
- Customer and contact operations
- Business workflows
- File operations
- Scheduled jobs
- Runtime inspection
- Database metadata
- Deployment workflows
- Infrastructure configuration
- Monitoring and diagnostics
Compatible AI clients can connect to CoCreateMCP and interact with the tools made available by the server.
This enables developers to use existing AI interfaces while working with CoCreateServer's application capabilities.
CoCreateAI is the AI pillar of the CoCreateJS ecosystem.
It provides declarative AI interfaces, model connectivity, and agentic application experiences.
CoCreateAI can use the runtime's exposed capabilities to coordinate workflows across applications, business data, and infrastructure.
A shared MCP-based tool architecture provides a path toward using the same capabilities from internal and external AI experiences.
The runtime's application capabilities are independent of the AI model selected.
AI clients use structured tools, while CoCreateServer executes the corresponding operations.
This separation allows models, interfaces, and runtime implementations to evolve independently.
AI access must be governed by application permissions and tool-level authorization.
Sensitive operations should support validation, auditing, execution limits, and human approval when appropriate.
The AI reasons about the objective. CoCreateServer executes the capability.
CoCreateServer is not limited to development and infrastructure operations.
It can provide the execution foundation for business applications and automated workflows.
The CoCreateJS ecosystem includes application capabilities and modules for areas such as:
- Customers
- Contacts
- Organizations
- CRM
- Invoices
- Payments
- Messaging
- Notifications
- Files
- Application content
- Scheduled jobs
- External API integrations
These capabilities can be exposed through application interfaces, APIs, and authorized AI tools.
Consider a workflow that reviews incoming customer messages.
New Messages
|
v
Read Customer Records
|
v
Evaluate Priority
|
v
Generate Draft Responses
|
v
Request Approval
|
v
Send Approved Messages
|
v
Update Application Records
CoCreateServer can coordinate the underlying data operations and configured communication APIs.
CoCreateAI can provide reasoning, prioritization, and response generation.
Applications can connect supported marketing and communication APIs to scheduled workflows.
Examples include:
- Campaign preparation
- Content scheduling
- Social media publishing
- Email campaigns
- Lead follow-ups
- Reporting
- Performance analysis
Applications can use connected payment and accounting services for supported operations involving:
- Invoices
- Payment records
- Transaction status
- Customer balances
- Financial reports
- Notifications
Financial operations should use appropriate authorization, verification, and audit controls.
CoCreateServer can coordinate recurring workflows through cron jobs and other configured scheduling mechanisms.
A scheduled workflow may query application data, invoke external APIs, update records, and notify users.
AI can participate when a workflow requires reasoning, classification, summarization, or content generation.
The same server environment can support sales, marketing, finance, customer service, development, and operations.
Business automation and infrastructure automation share the same execution foundation.
CoCreateAST provides structured execution capabilities within the CoCreateJS ecosystem.
It allows application behavior and workflows to be represented as data.
A workflow can describe a sequence of operations:
Receive Request
|
v
Validate Identity
|
v
Resolve Variables
|
v
Query Data
|
v
Evaluate Conditions
|
v
Execute Actions
|
v
Return Results
Structured workflows can coordinate:
- Application APIs
- Database operations
- Conditional logic
- External integrations
- Notifications
- Background jobs
- Infrastructure operations
Workflows can provide defined operations that AI clients invoke through authorized tools.
This is preferable to giving agents unrestricted arbitrary-code execution for every task.
Larger operations can coordinate smaller workflows.
For example, an application onboarding workflow might coordinate:
- Organization creation
- Application configuration
- Database initialization
- Security setup
- Infrastructure provisioning
- Deployment
- Verification
This creates a foundation for reusable, inspectable automation.
Security is central to operating applications and exposing capabilities to AI agents.
CoCreateServer supports security patterns including:
- Authentication
- Organization and tenant isolation
- Role-based permissions
- Object-level access control
- Field-level permissions
- API authorization
- Secure network communication
CoCreateKMS provides key-management capabilities for the ecosystem.
Its architectural responsibilities include:
- Cryptographic key management
- Application secrets
- Service credentials
- Infrastructure credentials
- Encryption integration
- Key lifecycle operations
Specific guarantees depend on the implementation and deployment configuration.
Infrastructure automation often requires access to cloud provider APIs, DNS providers, storage systems, and deployment services.
Credentials should be managed through protected configuration and appropriately scoped permissions.
AI-connected operations require explicit controls.
Recommended safeguards include:
- Authenticated tool access
- Scoped permissions
- Tool-level authorization
- Input validation
- Rate and resource limits
- Audit logging
- Human approval for consequential operations
- Restricted credential access
Data access must respect application authorization regardless of whether an operation originates from a user interface, JavaScript API, workflow, or AI client.
The same security model should govern all supported interfaces.
CoCreateServer is designed to coordinate infrastructure through application-level operations.
Rather than relying entirely on external deployment systems, configured runtime modules can manage parts of the application infrastructure lifecycle.
Supported integrations may provide capabilities for:
- Provisioning servers
- Configuring cloud resources
- Installing runtime dependencies
- Deploying application code
- Managing workers
- Configuring storage
- Managing TLS
- Coordinating DNS
- Monitoring runtime health
- Scaling resources
- Replacing failed nodes
- Executing recovery workflows
CoCreateServer's infrastructure architecture targets providers such as:
- AWS
- Google Cloud
- Microsoft Azure
- Oracle Cloud Infrastructure
- DigitalOcean
- Compatible self-managed environments
Provider-specific functionality depends on installed integrations and configured credentials.
Application Definition
|
v
Runtime Configuration
|
v
Infrastructure Provisioning
|
v
Server Initialization
|
v
Application Deployment
|
v
Storage and Security Setup
|
v
Health Verification
|
v
Monitoring and Scaling
CoCreateMCP can expose authorized infrastructure workflows to compatible AI clients.
An agent may analyze an infrastructure requirement, propose a plan, execute approved operations, and inspect results.
This connects operational reasoning with runtime execution.
CoCreateServer is designed for distributed applications that operate across multiple nodes and regions.
Applications can increase capacity by adding workers or runtime nodes.
Configured infrastructure integrations may support changing resource allocations for individual nodes.
Applications can place workloads closer to users and services.
Geographic routing strategies may consider:
- User location
- Network latency
- Regional traffic density
- Available capacity
- Infrastructure health
- Service availability
The infrastructure architecture includes geographically aware DNS and edge-routing strategies.
These can help direct users toward suitable application regions and provide failover paths.
Workloads may be assigned across workers, nodes, and regions according to runtime configuration and coordination capabilities.
An AI agent could examine telemetry and evaluate whether to:
- Add workers
- Provision a new node
- Expand an existing cluster
- Create a new regional cluster
- Relocate workloads
- Adjust capacity
- Change routing configuration
With the appropriate tools and permissions, approved changes could be executed through CoCreateServer.
The architectural objective is to allocate resources according to application demand rather than maintaining unnecessary infrastructure.
Scaling policies should account for capacity, cost, availability, latency, and workload requirements.
CoCreateServer provides the server-side foundation for connected applications.
Persistent connections support low-latency application interactions.
Applications can use configured modules to distribute events and updates between connected clients and services.
Supported data modules can notify clients when relevant application state changes.
CoCreateJS includes capabilities for collaborative editing and synchronized application state.
Server nodes can communicate through mesh and messaging mechanisms.
CoCreateClient can store application data locally through IndexedDB.
When connectivity returns, configured synchronization mechanisms can exchange changes with CoCreateServer.
Distributed synchronization requires explicit consistency and conflict-resolution strategies.
Different workloads may use different guarantees, including eventual consistency where appropriate.
CoCreateServer is designed to be extended through JavaScript modules.
await import('@cocreate/users');
await import('@cocreate/organizations');
await import('@cocreate/notification');Modules can be assigned to primary or worker processes according to their responsibilities.
server.routes.set('/api/custom', async (req, res) => {
res.writeHead(200, {
'Content-Type': 'application/json'
});
res.end(JSON.stringify({
message: 'Hello from CoCreateServer'
}));
});Developers can integrate compatible database and storage systems through adapter interfaces.
Applications can define reusable operations through supported workflow mechanisms.
Supported server capabilities can be exposed through structured MCP tools for authorized AI clients.
Additional providers and services can be connected through modular integrations.
Extend the runtime without rebuilding the application architecture.
CoCreateServer is designed to bring common application infrastructure capabilities into one coordinated runtime environment.
A deployment may combine:
- Application execution
- HTTP and WebSockets
- Database access
- Native storage
- Authentication
- Key management
- Background jobs
- Workflow execution
- Distributed coordination
- Monitoring
- Infrastructure automation
- AI tool access
CoCreateServer can use integrated components where appropriate while preserving compatibility with external services.
For example:
- Use CoCreateDB or an external database.
- Use built-in runtime networking or integrate with existing infrastructure.
- Use supported key-management capabilities or external services.
- Use CoCreateAI or compatible external AI clients.
- Use native workflows or connect existing automation systems.
The architectural objective is to give developers greater control over the systems required to operate their applications.
Self-contained infrastructure does not imply that every deployment must run every capability locally.
It means applications can choose which responsibilities to manage directly and which to delegate to external providers.
CoCreateJS
|
+----------------+----------------+
| |
v v
CoCreateClient CoCreateAI
| |
Applications Intelligence
Declarative UI Agentic Workflows
Real-Time Business Automation
| |
+----------------+----------------+
|
v
CoCreateMCP
|
Authorized AI Tools
|
v
CoCreateServer
|
+-----------------+-----------------+
| | |
v v v
Networking Execution Data
| | |
HTTP / HTTPS Primary / Worker CRUD
WebSockets Jobs / Workflows Adapters
Routing Cluster / Mesh CoCreateDB
| | |
+-----------------+-----------------+
|
v
Runtime Services
|
+-----------------+-----------------+
| | |
v v v
Security Infrastructure Automation
| | |
CoCreateKMS Cloud / DNS CoCreateAST
Permissions Deployments Scheduled Jobs
Credentials Scaling Business APIs
| | |
+-----------------+-----------------+
|
v
Distributed Applications
This is a conceptual architecture rather than a strict dependency diagram.
CoCreateServer can operate independently of CoCreateClient and CoCreateAI.
CoCreateMCP exposes selected server capabilities to compatible AI clients.
Supporting modules are loaded according to application requirements.
Run websites, APIs, backend services, and custom JavaScript applications.
Operate multi-tenant applications with data, permissions, networking, and distributed services.
Support customer records, contacts, organizations, invoices, payments, and business workflows.
Connect intelligent agents to application data and tools for customer support, marketing, finance, and operational workflows.
Build messaging, collaboration, dashboards, and synchronized application experiences.
Connect third-party services through reusable application APIs and workflows.
Execute workloads across processes, nodes, and regions.
Coordinate application deployments across compatible cloud providers.
Expose authorized tools for monitoring, provisioning, deployment, scaling, and diagnostics.
Use CoCreateDB for integrated document persistence and indexing.
Add networking, data operations, workflows, AI tools, or distributed infrastructure capabilities without replacing the entire application stack.
Operate applications using integrated runtime services where supported.
Provide a consistent execution environment for applications, services, workflows, and infrastructure operations.
Use JavaScript modules, objects, promises, events, and familiar platform primitives.
Load only the capabilities required by each application and process.
Support multiple storage providers through consistent application interfaces.
Allow applications to operate across compatible cloud providers and deployment environments.
Support multiple nodes, workers, regions, and coordinated workloads.
Make authorized application and infrastructure capabilities accessible to compatible intelligent agents.
Support customer operations, application workflows, and infrastructure automation through the same runtime.
Apply permissions and operational controls across users, APIs, workflows, AI tools, and infrastructure.
Expose reusable capabilities directly rather than introducing avoidable layers.
Allow developers to adopt individual capabilities without replacing their existing applications.
Reduce the complexity required to deploy, operate, and scale useful applications.
CoCreateServer is one of the three primary pillars of CoCreateJS.
| Pillar | Tagline | Purpose |
|---|---|---|
| CoCreateClient | One code. Build anything. Run anywhere. | Build and interact |
| CoCreateServer | One runtime. Any app. Every cloud. | Execute and operate |
| CoCreateAI | One intelligence. Any role. Every task. | Understand and orchestrate |
| Component | Purpose |
|---|---|
| CoCreateDB | Native data persistence and indexing |
| CoCreateMCP | AI-accessible runtime tools |
| CoCreateAST | Structured workflow execution |
| CoCreateKMS | Key and secret management |
| CoCreateCluster | Distributed coordination |
| CoCreateCLI | Development and operational commands |
| CoCreateDevice | Device and cross-platform integration |
These components can operate independently or as part of the broader CoCreateJS ecosystem.
CoCreateServer is part of the open-source CoCreateJS ecosystem.
Contributions are welcome in areas including:
- Runtime performance
- Networking
- WebSocket communication
- Database adapters
- Storage integrations
- Distributed coordination
- Worker management
- Infrastructure providers
- Security
- AI tool integration
- MCP capabilities
- Workflow execution
- Documentation
- Tests and examples
Before contributing, review the repository's existing issues, documentation, and contribution guidelines.
We encourage implementations that preserve modularity, JavaScript-first development, consistent APIs, and infrastructure independence.
CoCreateServer is distributed under the GNU Affero General Public License v3.0 (AGPL-3.0).
Review the repository's license file for the applicable terms and notices.
For commercial licensing, enterprise support, integrations, or deployment inquiries:
Email: info@cocreatejs.com
Website: https://cocreatejs.com
- CoCreateJS: https://github.com/CoCreateJS/CoCreateJS
- CoCreateServer: https://github.com/CoCreateJS/server
- CoCreateClient: https://github.com/CoCreateJS/Client
- CoCreateDB: https://github.com/CoCreateJS/db
- GitHub Organization: https://github.com/CoCreateJS
- Website: https://cocreatejs.com
- Documentation: https://cocreatejs.com/docs
- Contact: info@cocreatejs.com
From application APIs and business workflows to distributed infrastructure and AI-driven operations, CoCreateServer provides the execution foundation that connects them.
Run applications. Connect data. Execute workflows. Coordinate infrastructure. Empower intelligent agents.
One runtime for applications, business operations, and infrastructure.
Part of CoCreateJS.
Developed by CoCreate.