Rights management

Rather than treating access control as an afterthought, Smallworld makes rights a first-class part of the data model. Every piece of information — from a simple field to an entire application — can carry its own set of rules defining who can create, view, modify, validate, or delete it.

This creates a unified lifecycle model for data, where ownership, collaboration, and control are deeply embedded in the infrastructure.

A unified model for permissions

Permissions in Smallworld are not tied to apps or platforms — they are native to the data itself. That means rights can be applied across users, systems, and domains using a single, consistent model.

Template-level rights

Templates — the blueprints for data — define not only structure but governance.

They can control who can:

• Create the template
• Modify or extend it
• Create instances from it
• Read or discover it

You can express open ecosystems:

“Anyone can create entries from this template and own what they create.”

Or tightly restricted domains:

“Only this specific user can create entries, and cannot edit them afterward.”

Or something in between:

“This group may view the schema but cannot instantiate it.”

Instance-level rights

Every instance created from a template can define its own fine-grained access logic. Rights can govern:

• Who can read, update, or delete the instance
• Which specific fields can be modified
• What validations must occur for updates to succeed
• Whether rights change based on content or time

For example:

“Allow user X to edit the third item in the list of addresses — but only if it matches a verified address.”

This is structural, programmable access control — far beyond simple roles or ACLs.

Rights as programmable objects

Like everything in Smallworld, rights are stored on-chain as structured, queryable objects. They can be:

• Assigned to individuals, groups, or public roles
• Modified or revoked by authorized actors
• Audited and versioned like any other data
• Delegated, inherited, or made conditional

This allows you to build patterns like:

• Timed rights — access expires automatically
• Escrow rights — permissions unlock when a condition is met
• Approval chains — edits require multi-party validation

With rights baked into the data itself, enforcement doesn’t happen in some external backend — it happens on the blockchain.

Templates are governed like data

In Smallworld, even the schema is governed.
Templates themselves are subject to rights and can be collaboratively owned and evolved.

This means you can define:

• Who can propose or approve schema changes
• Which sections of a template belong to which group
• Whether templates are mutable, frozen, or branching
• Governance rules that change over time

Templates aren’t static files — they’re living structures with embedded authority.

Lifecycle management with built-in governance

Rights define more than access.
They define the rules of engagement for data — across its entire lifecycle:

• Creation — who, when, and under what rules
• Update — what can change, and by whom
• Merge — how conflicting edits are resolved
• Deletion — who can retire or archive

Each step in this flow can be scripted, scoped, and enforced by the protocol — no extra code or infrastructure required.

A new foundation for collaboration

Smallworld redefines how access control works in decentralized systems:

• Rights are data — visible, verifiable, and portable
• Policies are programmable — embedded into data, not bolted onto apps
• Enforcement is universal — driven by protocol, not by platforms
• Collaboration is trustless — shared data doesn't require shared infrastructure

Rights in Smallworld are not permissions. They are rules, logic, and structure — natively integrated with how the world’s information is created, shared, and governed.