sigMAX Core

sigMAX Core

sigMAXCoreopen sourcecontractsruntime

sigMAX Core is the open source foundation of the sigMAX ecosystem.

It provides the contract-first generation engine, the standardized runtime model, the WebAssembly execution layer, validation mechanisms, and a minimal Studio interface for local inspection.

Open source foundation

sigMAX Core is designed to be the community edition of sigMAX.

It focuses on the essential building blocks required to describe, generate, execute and validate applications locally or in a self-managed environment.

What sigMAX Core Provides

sigMAX Core includes the core technical capabilities required to generate and run a contract-first application.

Capability	Description
Application Contracts	Define the expected global architecture of the generated application.
Component Contracts	Define each application component, its responsibilities, APIs, capabilities and runtime expectations.
Binary Contracts	Define the expected behavior, inputs, outputs and allowed primitives of each WASM executable.
Agreements	Describe what was actually generated, compiled, packaged or observed.
Contract and Agreement validation	Detects drift between expected architecture and produced artifacts.
Controlled pseudo-code DSL	Provides a compact, validated intermediate representation before code generation.
Deterministic C generation	Transforms controlled pseudo-code into a constrained C subset.
WASM compilation model	Produces isolated WebAssembly binaries from deterministic code.
Rust runtime	Executes WASM modules, routes requests and exposes standardized runtime behavior.
Runtime primitives	Provides controlled host functions for input, output, storage, logging, metrics and formatting.
ObjectIR / DocIR	Standardizes structured API responses and document generation.
OpenAPI generation	Produces API specifications from contracts and generated routes.
Generated documentation	Exposes component documentation and API documentation.
Minimal Studio interface	Provides the lightweight interface bundled with Core for inspecting local projects, generated documentation and runtime status.
Light frontend exposure	Uses Nginx to expose the minimal Studio interface and FrontMark-based content. This is not a generated full application frontend.
Local container execution	Supports local execution through Docker or Podman-based generated stacks.
Basic observability	Provides logs, health endpoints and runtime metrics.

What sigMAX Core Is For

sigMAX Core is intended for:

• developers experimenting with contract-first application generation;
• open source contributors;
• architects exploring AI-assisted software generation;
• DevOps engineers evaluating reproducible generation pipelines;
• teams wanting a local, inspectable and self-managed runtime;
• researchers interested in controlled LLM generation and WASM isolation.

What sigMAX Core Is Not

sigMAX Core is not intended to be a fully managed enterprise platform by itself.

It does not aim to provide, by default:

• managed SaaS hosting;
• multi-tenant project management;
• enterprise RBAC;
• managed runners;
• private component registries;
• advanced Kubernetes orchestration;
• commercial support;
• enterprise audit dashboards;
• marketplace distribution;
• distributed policy governance;
• a reverse proxy layer for generated services;
• multiple selectable storage backends;
• the full professional Studio experience.

These capabilities belong outside the Core scope unless they are explicitly implemented in another edition or integration.

Boundary

sigMAX Core provides the open source engine and runtime foundation.

Studio is the sigMAX interface. Core includes a minimal version of Studio so local projects remain inspectable without a professional edition.

Nginx in Core is used to expose that lightweight interface and FrontMark-based content. It should not be described as a reverse proxy for the generated application.

Core should also not be described as offering multiple storage choices. Storage behavior is part of the controlled runtime surface, not a menu of interchangeable storage products.

Core Design Principles

sigMAX Core is built around a few strict design rules:

• LLM outputs must remain controlled and validated;
• executable artifacts must be generated deterministically;
• business logic should run inside a WASM sandbox;
• runtime capabilities must be explicit;
• generated artifacts must be observable;
• contracts and agreements must remain separate;
• drift must be detectable;
• components must be discoverable;
• local execution must remain reproducible;
• the open source part must stay useful without requiring the SaaS layer.

Multiple Editions

sigMAX CoresigMAX StudiosigMAX Enterprise

sigMAX Core is the open source foundation.

It provides:

• contracts;
• agreements;
• deterministic generators;
• WASM runtime;
• runtime primitives;
• local container execution;
• OpenAPI generation;
• generated documentation;
• a minimal Studio interface exposed through Nginx;
• FrontMark-based content;
• validation;
• drift detection.

sigMAX Studio is the graphical interface for sigMAX projects.

Core embeds a minimal Studio interface. The complete Studio experience is documented in the Studio edition page.

Studio focuses on:

• visualizing applications;
• inspecting components;
• browsing generated artifacts;
• following generation and runtime status.

sigMAX Enterprise is intended for professional and managed usage.

It adds professional, SaaS, governance and managed infrastructure capabilities around Core.

Its detailed scope is documented in the Enterprise edition page.

Core vs Professional Editions

Area	sigMAX Core	sigMAX Enterprise
Core engine	✅ Included	✅ Included
Contract model	✅ Included	✅ Included
Agreement validation	✅ Included	✅ Included
Drift detection	✅ Included	✅ Included
WASM runtime	✅ Included	✅ Included
Runtime primitives	✅ Controlled surface	✅ Controlled surface
Studio interface	⚠️ Minimal Studio	✅ Full Studio
FrontMark content	✅ Exposed	✅ Exposed or integrated
Self Hosted	✅ Supported	✅ Supported
Managed	❌ Not included	✅ Supported
Nginx	✅ Light frontend exposure	✅ Full frontend exposure
Reverse proxy	❌ None	✅ Traefik or equivalent
TLS termination	❌ Not managed	✅ Managed
Kubernetes	❌ Not included	✅ Supported
Ingress rules	❌ Not included	✅ Supported
Local containers	✅ Docker / Podman	✅ Supported
Managed runners	❌ Not included	✅ Supported
Extended storage	❌ Not selectable	✅ MinIO / object storage
Other databases	❌ Not default	✅ Redis or others if required
Component registry	❌ Not included	✅ Private registry
RBAC	❌ Not included	✅ Enterprise RBAC
Audit logs	⚠️ Basic evidence	✅ Full audit trail
Observability	⚠️ Logs / health / metrics	✅ Dashboards / alerts
Governance	⚠️ Validation and drift	✅ Policies and approvals
Support	❌ Community / self-managed	✅ Professional support

Core boundary

In Core, Nginx exposes the lightweight Studio interface and FrontMark-based content. It is not a reverse proxy for generated services.

Enterprise can add Traefik or an equivalent reverse proxy, Kubernetes, ingress rules, TLS termination, extended storage such as MinIO, and additional services such as Redis when the architecture requires them.

Summary

sigMAX Core is the open source engine that makes the sigMAX approach possible.

It provides the minimum complete foundation to:

• describe an application through contracts;
• generate components and binaries;
• execute business logic inside WebAssembly;
• expose APIs and documentation;
• expose a minimal Studio interface and FrontMark-based content through Nginx;
• observe generated artifacts;
• compare expected and produced outputs;
• detect generative drift.

https://sigmax.dev/docs/editions/core/