Stop Designing the Same Data Over and Over Again

Most teams still re-implement the same entities, events, forms, and payloads in every codebase. Those copies drift, libraries lose leverage, and every language ends up with slightly different contracts.

GitHub made code reusable, reviewable, and shared. Rusl applies that same model to data design: start from common data structures, formalize them as schemas, build on shared primitives, annotate them with UI or audit meaning, and use your validators to require the same shape everywhere.

Publish Your First Schema Sign In

user-event.schema.json

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$id": "https://rusl.app/schemas/example/user-event",
  "$version": "0.1.2",
  "title": "UserEvent",
  "type": "object",
  "properties": {
    "event_type": {
      "type": "string",
      "enum": ["signup", "login", "purchase"]
    },
    "user_id": {
      "type": "string",
      "format": "uuid"
    },
    "timestamp": {
      "type": "string",
      "format": "date-time"
    },
    "metadata": {
      "type": "object"
    }
  },
  "required": ["event_type", "user_id", "timestamp"]
}

Composable Schemas and Open Annotations

Composable Schemas

Schemas can reference other schemas, so teams can build on shared primitives instead of copying slightly different versions of the same data structures into every service.

Open Annotations

Anyone who can see a schema can publish structured annotations for it. UI libraries can describe rendering, auditors can stamp approvals, storage systems can declare rules, and organizations can publish annotation types that others learn to trust.

Schema Proposals

Review schema changes before they ship. Proposals give shared contracts diffs, discussion, and approval workflows so breaking changes are explicit.

Versioned Bundles

Package related schemas into versioned bundles with dependency constraints so every consumer resolves the same contract graph from one source of truth.

The Rusl CLI

Install schemas and bundles with the Rusl CLI, then pair them with the validators and codegen tools you already use so code can require conformity instead of merely assuming it.

How Reuse Compounds

Publish Shared Primitives

Define foundational schemas once under a personal or organization account, version them semantically, and make them public or private.

Compose Bigger Structures

Reference existing schemas inside new ones so teams build upward from shared axioms instead of cloning local variants.

Review and Bundle

Use proposals to review changes, then publish bundles that pin compatible schema versions across a system.

Annotate and Enforce

Publish annotations for UI, audit, storage, or internal policy, and use your validators to require that data actually conforms.

Public Registry, Private Contracts

Some schemas belong in the open. Others should stay inside your organization. Rusl lets you do both in one registry with the same workflow and tooling.

Organizations and Roles

Create an organization, invite your team, and manage ownership in one namespace built for shared schema maintenance.

Visibility Controls

Set schemas and bundles to public or private individually. Keep internal contracts internal while exposing the pieces you want to share.

One Workflow for Both

Use the same CLI, proposals, and versioning model for public packages and org-only contracts. Consumers only resolve what they are allowed to access.

One Contract, More Leverage

When every service validates against the same versioned schema, code does not have to guess at a shape. It can require it. Rusl turns schemas into reusable infrastructure that other schemas, tools, libraries, and organizations can build on.

Publish Your First Schema