MetacoreDeclarative addons. Zero-glue UI.

Build a CRUD addon, get a working multi-tenant app — without writing the wiring.

📜

Manifest, not boilerplate

Declare tables, columns, capabilities and actions in one JSON file. Get migrations, REST endpoints, metadata and a typed UI for free.

🔒

Capability-first security

Permissions are part of the addon contract. The kernel enforces them at every CRUD call, the UI gates components automatically.

🦀

WASM sandbox

Addons run isolated in wazero. No more vendoring untrusted Go into your binary.

⚡

Hot install

Drop a signed bundle, the installer migrates the schema, mounts the handlers, registers UI metadata. No restart required.

📡

Real-time by default

A WebSocket hub is part of the runtime. Push CRUD changes and custom events to clients with a single method call.

🧱

Two repos, one platform

The kernel runs the runtime in Go. The SDK declares the contract in TypeScript. The portal you're on connects them.

What's Metacore?

Metacore is a runtime + SDK for building modular, multi-tenant business applications out of small declarative addons. The kernel is a Go library you embed in your app: it owns the database schema, the REST surface, permissions, lifecycle, and a WebSocket hub. The SDK is a set of npm packages: it lets you describe an addon — its models, capabilities and UI — in a single manifest.json (the Module Contract v3), and renders the result as a typed React experience inside any host.

Together, they turn a manifest into a working CRUD app. Any host you build on the same primitives — an operator panel, a customer portal, an embedded admin — picks that up automatically.

The four-line pitch

manifest.jsonendpointsui.tsx

json

{
  "apiVersion": "asteby.com/v3",
  "kind": "Addon",
  "metadata": { "key": "tickets", "name": "Tickets", "version": "0.1.0" },
  "capabilities": [
    { "kind": "db:read",  "target": "addon_tickets.*" },
    { "kind": "db:write", "target": "addon_tickets.*" }
  ],
  "models": [{
    "key": "Ticket",
    "table": "tickets",
    "columns": [
      { "name": "id",       "type": "uuid", "primary_key": true, "default": "gen_random_uuid()" },
      { "name": "title",    "type": "text", "not_null": true },
      { "name": "status",   "type": "text", "default": "'open'" },
      { "name": "assignee", "type": "text" }
    ]
  }]
}

bash

# Mounted by the kernel, no handler code needed.
GET    /api/dynamic/tickets
GET    /api/dynamic/tickets/:id
POST   /api/dynamic/tickets
PUT    /api/dynamic/tickets/:id
DELETE /api/dynamic/tickets/:id
GET    /api/metadata/table/tickets

tsx

import { DynamicTable } from '@asteby/metacore-runtime-react'

// Reads the same metadata, gets list + paginate + sort + filter.
export default function Tickets() {
  return <DynamicTable model="tickets" />
}

That's the whole loop. Add a column, the table updates. Add a capability, the permission middleware enforces it. Ship a bundle, the installer hot-loads it.

Get the right entry point

I'm building an addon → You write a manifest, the SDK does the rest. Ship a `.mcbundle` to any host running the kernel. I'm embedding the runtime in my Go app → Drop the kernel into a Fiber server, get dynamic CRUD, permissions and WebSockets out of the box. I'm building a host → A Vite + React frontend over a Go backend that mounts the kernel. The SDK provides every primitive.

Or jump straight into the deep docs

SDK reference → The published npm packages, the manifest spec, dynamic UI, the cookbook, capabilities, publishing. Kernel reference → Embedding the runtime, the dynamic CRUD framework, the HTTP API, permissions, and contributor setup.

What's open

Both Metacore repositories are public and Apache-2.0:

Repo	What it is
`asteby/metacore-kernel`	The Go runtime. WASM sandbox, dynamic CRUD, permissions, lifecycle, WebSockets.
`asteby/metacore-sdk`	The TypeScript SDK and CLI. Manifest schema, React runtime, addon scaffolder.
`asteby/metacore`	This portal. Documentation only.

The kernel and SDK each ship their own deep documentation — this site routes you to the right one and explains the platform end-to-end.