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 — access without locks
Every Thing (Dz) in Nebulo has a Guard: a cryptographically enforced access controller that regulates what can read, modify, or reference it. The Guard applies the Guard (Che) Meaning Coordinate to every object, embedding access policy into 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 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.
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 — 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.