Nebulo: Identity, Data & Semantic Memory
Nebulo is Essence's data management layer. It replaces files and databases with Aptivs, storing everything with embedded structure, access rights, and behavior. There are no external data stores: identity, relationships, and policies travel with the data itself.
No files. No databases.
In conventional systems, data lives in files or database tables that are separate from the logic that operates on them. Access control, versioning, and schema enforcement are added as layers on top. When systems evolve, those layers drift out of sync.
Nebulo removes this separation entirely. All data is stored in Aptivs. Structure, access rights, behavior, and policy are embedded in each unit, not managed externally. Nothing is governed by a file path or a table schema that exists independently of the data it describes.
Identity: 128-bit HashIDs
Every unit of information in Nebulo is assigned a 128-bit HashID. These identifiers support high-speed search, duplication prevention, and fuzzy matching across distributed systems. The address space supports up to 10³⁸ unique identifiers, sufficient for any foreseeable scale of objects, behaviors, or versioned states.
Every change to a value is tracked over time using hash-indexed trees, delta compression, and memory-aware distribution. This makes synchronization across devices, simulations, and forks deterministic and auditable, without requiring a central coordination service.
The Guard Meaning Coordinate: access without locks
Every Thing (Dz) in Nebulo carries the Guard (Che) Meaning Coordinate: a cryptographically enforced access rule that regulates what can read, modify, or reference it. Because it applies to every object, access policy is embedded in the data structure itself rather than relying on external permission systems.
Conventional access control uses locking or symbolic ACLs, which introduce performance bottlenecks under concurrency. The Guard Meaning Coordinate avoids this entirely by using job-based scheduling, determining access eligibility through procedural validation rather than through mutex contention or role lookup tables.
Who can access, change, or even know a Thing exists is baked into the structure at creation time. There is no separate permission layer to configure, drift, or be exploited.
Models and APIs: elevated, then governed
Nebulo has no separate path for AI. A large language model, a third-party API, or a compiled binary enters the substrate the same way any other external component does: through Elevate, which wraps it as an Aptiv and attaches Meaning Coordinates, trust enforcement, and semantic traceability. Nothing that has not passed through Elevate can execute inside a [.wv] stream, regardless of origin.
Once wrapped, a model is an Aptiv like any other, and that is what places it under Nebulo. Its inputs and outputs carry 128-bit HashIDs. What it is permitted to read is decided by the Guard Meaning Coordinate on each Thing, resolved through job-based scheduling rather than by a retrieval filter or a prompt-level redaction rule. What it produces enters Nebulo with provenance as a structural property of the unit, which means generated content stays distinguishable from declared content without depending on a labeling convention that can be stripped.
An unelevated model or API cannot act inside a [.wv] stream. Trust is established through declared intent and Elevate validation, not assumed because the source is an approved vendor.
Where a model sits
A large language model is one instrument inside pattern modeling: matching structure in noisy or varied input. It is powerful at that job, and it is one slot in one layer, not a substitute for the other modeling approaches Nebulo expresses, nor for the layers beneath them.
Relevance in Nebulo is graph traversal across Object Relationships rather than comparison of fixed-length vectors, so retrieval here is a different operation from embedding search. Object Inference sits alongside it: thought nodes match verbs, objects, and modifiers to algorithms selected at runtime. That is inference occurring inside a governed structure rather than inference wrapped by one.
Core mechanisms
Nebulo's fourteen foundational mechanisms group into five functional areas.
Identity and lookup
- Unique Identifiers: 128-bit HashIDs enabling high-speed search, deduplication, and fuzzy matching across distributed systems
- Translatable Structures: runtime reordering of data formats (e.g. SOA ↔ AOS) to match I/O conditions or power constraints, trust-enforced via Meaning Coordinates
Structure and synchronization
- The Guard Meaning Coordinate: cryptographically enforced access control via job-based scheduling, avoiding lock-based contention
- Synchronization: hash-indexed trees and delta compression track every value over time and across forks, devices, and simulations
Relationships and behavior
- Object Relationships: classic and fuzzy relationships via Meaning Coordinates: "is-a," "has-a," and "as-a"; stored as formula graphs that can trigger changes based on logic or time
- Object Intention: objects express behavior through Meaning Coordinates and Grok Units, enabling abstract or predictive behaviors to be structured and validated across execution states
- Object Inference: thought nodes match verbs, objects, and modifiers to dynamic algorithms selected at runtime, enabling AI-like inference within a governed structure
- Object Translation: any Idea is translatable to another where meaning overlap exists, allowing behavior and data to transfer across domains without porting code
Parallelism and execution
- Parallelization: every Meaning Coordinate carries dependency information, enabling automatic determination of safe parallel execution paths and exposing computational causality for audit or optimization
- Procedural Programming: traditional logic (if-then, loop, match, sort) expressed using Meaning Coordinates; reproducible, portable, and always aligned with declared intent
- User-level Meaning Expression: users express and edit complex behaviors in natural language or graph form via Synergy and Maven; every edit produces valid executable meaning with no syntax errors
Rendering and sensory output
- Representations of Relationships: Meaning Coordinates act as semantic DNA; reordering them changes behavior, encoding identity, logic, and structure for both humans and machines
- Our Sensory Pipeline: rendering primitives (meshes, voxels, SDFs, point clouds) stored and transformed procedurally, with native level-of-detail scaling across graphics pipelines
- No-file / No-database Data Management: all data stored in Aptivs with structure, access rights, and behavior embedded; nothing managed externally
How Nebulo compares to object-oriented systems
Nebulo is not object-oriented programming, though it shares surface similarities. The distinctions matter for architects evaluating how it fits alongside or replaces existing data layers.
| Concept | OOP (C++ / Java) | Nebulo |
|---|---|---|
| Structure unit | Class with static type definition | Idea (Jy): semantic, dynamic; translatable between representations |
| Data unit | Object with getters / setters | Thing (Dz): access-governed, distributed, timing-controlled |
| Identity | Memory address or database key | 128-bit HashID with level-of-detail access patterns |
| Behavior | Methods compiled to fixed logic | Meaning Coordinates translated to Qcode; contextually resolved at runtime |
| Modules | Packages or namespaces | Aptivs: handle media, data models, localization, and behavior flow |
| Global variables | Permitted; common source of bugs | None: all values use multilevel scope and "when" semantics for updates |
| Concurrency | Threads, mutexes, semaphores | Explicit scheduling; dependency-tracked; side-effects prevented by design |
| Type system | Static signatures declared at compile time | Inferred from structure, timing, and reduction at runtime |
| Parallelism | Manual; error-prone | Automatically safe via Meaning Coordinate dependency tracking |
Nebulo eliminates the boundary between data and the logic that governs it. Identity, access policy, relationships, and behavior are embedded in every unit at creation time, not layered on afterward. For architects evaluating Essence, Nebulo is the replacement for both the database and the ORM: it stores meaning, not rows. Models and APIs brought in through Elevate are governed by the same rules as everything else it holds.