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 and a CLI: it lets you describe an addon — its tables, capabilities and UI — in a single manifest.json, 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

{
  "id": "tickets",
  "name": "Tickets",
  "version": "0.1.0",
  "tables": [{
    "name": "tickets",
    "columns": [
      { "name": "id",       "type": "uuid", "primaryKey": true },
      { "name": "title",    "type": "string", "required": true },
      { "name": "status",   "type": "enum",   "values": ["open","closed"] },
      { "name": "assignee", "type": "string" }
    ]
  }],
  "capabilities": [
    { "kind": "db:read",  "target": "tickets" },
    { "kind": "db:write", "target": "tickets" }
  ]
}

bash

# Mounted by the kernel, no handler code needed.
GET    /api/addons/tickets/tickets
GET    /api/addons/tickets/tickets/:id
POST   /api/addons/tickets/tickets
PATCH  /api/addons/tickets/tickets/:id
DELETE /api/addons/tickets/tickets/:id
GET    /api/addons/tickets/_meta/columns

tsx

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

// Reads the same metadata, gets list + paginate + sort + filter.
export default function Tickets() {
  return <DynamicTable addon="tickets" table="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 Gin/Chi 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 16 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.