AWA–CORE is a disciplined architecture for serving structured state over HTTP. AWA defines what the system is. CORE determines how it behaves. AWA governs structure. CORE provides the deterministic runtime that executes it. Together they serve websites, applications, APIs, automation, files, administrative interfaces, and AI-facing systems. Structure is explicit. Mutation is governed. Execution is disciplined. Behavior is predictable.
Why AWA–CORE Exists
Modern systems often separate data, business logic, rendering, APIs, administration, automation, and integrations into independent layers that repeatedly translate the same information and become increasingly difficult to reason about. AWA–CORE approaches this differently: it defines canonical structure once, governs its evolution, and executes that structure through one disciplined runtime.
Philosophy
HTTP is the universal service boundary of AWA–CORE.
Browsers, applications, services, automation, APIs, and AI all interact with AWA–CORE through the same disciplined HTTP boundary.
One boundary. One request model. One governed response.
Canonical structure is explicit, inspectable, and governed.
JSON is a primary representation throughout AWA, but the principle is broader than one storage format. CORE interprets defined domain state and structural configuration without repeatedly translating the same information through unnecessary intermediate representations. Mutation follows contracts, validation, snapshots, and revision discipline.
The structure you store is the structure CORE interprets.
AWA–CORE does not depend on arbitrary hook-based runtime injection.
Extension occurs through explicit architectural boundaries: mods, handlers, services and resolvers, templates, blocks, themes, collections, and forms. Each extension has a known place, responsibility, and contract.
Extend by design, not by patch.
AWA and CORE have distinct responsibilities joined by defined contracts and compatible releases.
AWA establishes architecture, structure, governance, authoring systems, and shared application facilities. CORE performs disciplined runtime initialization, orchestration, dispatch, and execution. Their separation is responsibility, not arbitrary interchangeability.
Authority defines. Runtime executes.
pantaServ — Serve Everything
Panta is the Greek word for “everything.” Within AWA–CORE it expresses a simple architectural idea: anything that can be delivered through HTTP can be served through one disciplined runtime.
HTML, JSON, APIs, calculators, files, images, administration, booking systems, ERP interfaces, automation, and AI interactions are different expressions of the same disciplined runtime.
AWA defines authority. CORE provides execution. The kernel unifies both into one predictable runtime.
Systems
AWA is the architectural authority and application framework.
It establishes canonical structure and data governance together with Pages, Collections, Forms, configuration, menus, authentication and users, shared UI, mods, themes, events, tasks, and other common application services. It governs import and mutation discipline and defines versioning and release contracts. Data authority is central to AWA, but AWA is broader than a data editor.
Authority over structure. Discipline over mutation.
CORE is the execution engine.
The kernel initializes and governs the request. Routing and security occur at defined boundaries. Handlers coordinate execution, services and resolvers interpret domain state, and templates and blocks render prepared output. CORE returns the appropriate HTTP response and faithfully executes canonical structure while leaving architectural authority to AWA.
Orchestrated execution. Clear boundaries.
request → kernel → handler → domain/service → template/block → response
Every request belongs to the kernel before it belongs to the application. index.php loads the kernel; the kernel owns runtime initialization and dispatch. Entry points do not independently bootstrap application services. Each stage receives prepared responsibility and passes a disciplined result to the next.
No hidden logic. No improvisation.
Canonical application structure is explicit and inspectable.
JSON is used extensively as a primary representation, while domain data and structural configuration remain governed through defined contracts. Imports and mutations preserve integrity and support validation, snapshots, and revisions. External tools may propose structure; AWA governs its acceptance.
Determinism over convenience. Integrity over automation.
AWA-Core.dev is the canonical source of truth for shared AWA development.
Shared changes belong in AWA-Core first. Calculator.com, Kardamili Cars, Polytropon Arts, and future installations consume defined AWA/Core release versions, including AWA Core and public reusable mods and components, then add their own private site code. Documentation and specifications preserve the shared contracts.
Shared development moves upstream first, then downstream through released versions.