Nondominium: The Commons Protocol That Makes Governance Part of the Resource

Most systems let a resource exist first and argue about rules later. Nondominium flips that sequence. A resource can be declared, but it does not really move, activate, or count until governance validates the transition.

That is the project’s real thesis. It is not a generic decentralized app, and it is not just another asset tracker. It is an attempt to make shared things harder to capture by making the rule layer executable.

A Resource That Cannot Move Without Permission

The repo is built around a simple inversion. In a platform app, ownership and control converge at the center. In Nondominium, control is distributed into the lifecycle of the resource itself, and transitions have to pass through governance before they take effect.

That matters because it changes what the system optimizes for. Instead of asking how fast a resource can be listed, rented, transferred, or consumed, it asks who can authorize those actions, under what conditions, and with what audit trail.

The phrase that captures this best is Governance-as-Operator. Governance is not commentary on top of the system. It is the mechanism that decides whether a resource can cross from pending to valid, from declared to active, from local claim to shared reality.

NDO: An Identity Anchor With a Lifecycle

The NDO primitive is the second reason this repo stands out. It is not just a row in a table. It is a lifecycle-bearing identity anchor that can exist as an idea before it becomes a thing you can touch.

That is a strange and useful model. A resource can pass through ideation, specification, stability, and eventually deprecation. The system is not only tracking existence. It is tracking legitimacy over time.

That lifecycle matters because common resources are often messy before they are useful. A shared machine, a service, or even a project concept may need a stable identity long before it can be treated as an operational asset.

Why ValueFlows Matters Here

Nondominium is not inventing economic language from scratch. It leans on ValueFlows and hREA, which gives it a structured way to describe agents, actions, resources, and events without collapsing everything into generic CRUD.

That is a serious design choice. If a system wants to coordinate shared production, it needs to know not only that something changed, but what kind of economic event occurred, who participated, and how that event belongs in a larger trail of contribution.

pub enum VfAction {
    Transfer,
    Consume,
    Produce,
    Use,
}

pub struct EconomicEvent {
    pub action: VfAction,
    pub provider: AgentId,
    pub receiver: Option<AgentId>,
    pub resource: EconomicResourceId,
}

That snippet is the point in miniature. Movement is not a generic update. It is a typed economic event linked to an agent and a specific resource, which is exactly what a commons-oriented system needs if it wants its history to stay auditable.

Private Participation Receipts Are Reputation Without Full Exposure

The project’s private participation receipts, or PPRs, are a subtle but important idea. They are contribution evidence without requiring a fully public life log.

That is stronger than vague reputation talk. A receipt says that participation happened, but it does not force every detail of participation into public view. In a shared system, that balance matters.

How the Repo Is Built

The implementation matches the thesis. The backend is Rust, organized as Holochain zomes. The frontend is Svelte 5 with TypeScript, while shared types keep the UI and backend aligned. Nix keeps the environment reproducible, and Tryorama plus Vitest give the project a disciplined test story.

The architecture is split in a way that mirrors the governance model. `zome_resource` holds the resource lifecycle, `zome_person` handles identity and roles, and `zome_gouvernance` evaluates rules and state transitions. That separation is not incidental. It is the software version of the project’s political claim.

The presence of `vendor/hrea` is especially telling. The project is not trying to invent accounting vocabulary. It is building a specialized governance layer on top of a preexisting economic model.

Why This Is Not Just Another Blockchain Project

Nondominium is adjacent to blockchain culture, but it is solving a different class of problem. Traditional blockchains optimize for global consensus, settlement, and tokenized coordination. Nondominium optimizes for local governance of shared assets and the traceability of real-world contribution.

That makes it closer to a coordination protocol than a speculative ledger. It is also why Holochain makes sense here. The architecture is agent-centric, so the system does not need to force every meaningful action through a single global chain.

The contrast is sharpest with platforms. Platforms scale by centralizing control over rules, access, and data. Nondominium tries to do the opposite: preserve shared use without turning the commons into someone else’s product.

That is a hard problem, which is why the repo feels ambitious rather than finished. But the core insight is already clear. If governance is part of the resource, capture gets harder because the resource can no longer be treated as raw, ownerless data.