RPP is a 28-bit semantic addressing protocol that encodes meaning directly into addresses. Route data based on what it is and who can access it - not just where it lives.
Memory addresses are opaque. They tell you where data is, but nothing about what it means.
Address 0x7F3A2100 tells you nothing. Is it sensitive? Personal? Shareable? You need separate systems to track this metadata.
Consent and permission logic gets duplicated across every service. Each system reinvents the wheel for access decisions.
To route data correctly, you query databases, check permissions, consult policies. The address itself provides no guidance.
A 28-bit address that encodes what data is, how accessible it is, and where to route it.
+----------------------------------------------------------------+
| 28-BIT RPP ADDRESS |
+--------+-------------+-------------+---------------------------+
| Shell | Theta | Phi | Harmonic |
| 2 bits | 9 bits | 9 bits | 8 bits |
+--------+-------------+-------------+---------------------------+
Example: 0x0182801
Shell = 0 (Hot) -> Route to: in-memory storage
Theta = 12 (Gene) -> Data type: genetic/identity data
Phi = 40 (Grounded) -> Access: open, no consent needed
Harmonic = 1 -> Resolution mode
WHERE it's stored
Hot / Warm / Cold / FrozenWHAT type it is
Gene / Memory / Dream / Bridge...WHO can access it
Grounded / Transitional / EtherealHOW to handle it
Resolution / frequency / modeThree simple operations. Deterministic results. No AI, no magic.
Pack semantic meaning into a 28-bit address. Shell, theta, phi, and harmonic become a single value.
Query the address with an operation (read/write). Get back: allowed, denied, or route to storage.
Follow the route to your storage backend. Memory, filesystem, archive - RPP tells you where.
RPP eliminates entire categories of distributed systems complexity by encoding decisions into addresses.
Encode: 4 bit shifts + 3 ORs. Decode: 4 bit shifts + 4 ANDs. No database, no network, no cache lookups. Billions of operations per second.
Fits in a single 32-bit integer. Embeddable in URLs, headers, logs, QR codes. Passes through any system that handles integers.
Pure arithmetic. Works on microcontrollers to mainframes. No runtime, no libraries, no external services required.
Same input always produces same output. Unit testable, formally provable. No hidden state or side effects to debug.
Address reveals intent without documentation lookup. Decode any address to see its semantic meaning instantly.
GDPR/privacy compliance built into addressing. Phi encodes access level - consent isn't bolted on, it's intrinsic.
| Operation | Traditional Approach | RPP Approach |
|---|---|---|
| Routing | Query database, check ACLs, consult policies | Decode address → instant decision |
| Consent Check | Separate permission system, user lookup | Read phi field (bits 16-8) |
| Storage Tier | Manual configuration, migration scripts | Read shell field (bits 27-26) |
| Data Type | Metadata lookup, schema registry | Read theta field (bits 25-17) |
| Cross-Service | API contracts, translation layers | Same 28-bit format everywhere |
Address tells you where. You must ask elsewhere for what and who.
Address tells you where, what, and who in one 28-bit value.
This eliminates an entire class of distributed systems problems - the "what is this and can I access it?" lookup that every service currently implements independently.
Every RPP address is a deterministic bit-packed integer. No hashing, no lookups - pure arithmetic.
Pack four semantic values into a single 28-bit integer:
Each field occupies a fixed bit range, allowing instant extraction via bit masking:
| Field | Bits | Range | Mask |
|---|---|---|---|
| Shell | 2 | 0-3 | 0x0C000000 |
| Theta | 9 | 0-511 | 0x03FE0000 |
| Phi | 9 | 0-511 | 0x0001FF00 |
| Harmonic | 8 | 0-255 | 0x000000FF |
Total: 28 bits = 268 million unique addresses, each with intrinsic semantic meaning.
RPP addresses map to points on a conceptual sphere. Theta and Phi aren't arbitrary - they're angular coordinates.
North Pole (Phi = 0)
Ethereal
|
| . - ~ ~ ~ - .
.-~ ~-.
/ Abstract \
/ \
West ----+-------- O --------+---- East
Theta=0 | Transitional | Theta=511
\ /
\ Grounded /
` - . _ _ _ .-'
|
|
South Pole (Phi = 511)
Grounded
Theta (0-511): Rotation around vertical axis
= Semantic sector (Gene, Memory, Dream...)
Phi (0-511): Angle from pole to equator
= Grounding/consent level
Traditional memory addresses are linear - just offsets from zero. RPP uses spherical geometry because semantic relationships aren't linear. Data has type (where on the sphere) and accessibility (how far from the pole).
RPP is infrastructure. Here's what becomes possible when addresses carry meaning.
When identity data has semantic addresses, federation becomes trivial. Two systems can exchange addresses knowing exactly what consent level applies without additional negotiation.
AI systems can be given access to specific theta sectors while being blocked from others. No complex ACLs - just resolve the address and the consent requirement is built in.
Mobile app, web service, embedded device - all can use the same 28-bit addresses. A single address means the same thing everywhere, enabling true data portability.
Instead of bolting consent onto existing systems, build applications where consent is intrinsic. Every data access automatically respects the phi grounding level.
When data is self-describing, markets can form around data types. Query for all "Dream sector, transitional grounding" data and get consistent results across providers.
Storage systems that automatically tier data based on shell values. Hot data stays in memory, cold data migrates to archive - no manual configuration needed.
Multiple avatar fragments, each with their own address ranges, all coherent back to a verified human identity. RPP provides the addressing layer for identity coherence.
A formal specification enables academic study of semantic addressing. Proofs about address space coverage, consent guarantees, and routing correctness become possible.
RPP behavior is defined by exactly three scenarios. Everything else is implementation detail.
Low phi (grounded) - Data is accessible without special consent.
allowed: true
route: memory://gene/grounded/12_40_1
reason: read permitted via memory
High phi (ethereal) - Sensitive zone requires explicit consent.
allowed: false
route: null
reason: Write to ethereal zone requires consent
Cold shell - Data routes to archive storage.
allowed: true
route: archive://dream/transitional/200_128_32
reason: read permitted via archive
Where semantic addressing makes a difference.
Build systems where data access respects user consent by design, not as an afterthought.
Route data to the right storage tier automatically based on its semantic properties.
Replace scattered routing logic with a single, deterministic addressing layer.
Manage avatar fragments and identity data with built-in coherence and consent.
Get up and running in 60 seconds. Zero dependencies.
pip install rpp-protocol
# Encode an address rpp encode --shell 0 --theta 12 --phi 40 --harmonic 1 [ENCODE] [OK] 0x0182801 | Hot | Gene | Grounded # Resolve (get routing decision) rpp resolve --address 0x0182801 [RESOLVE] [OK] allowed: true route: memory://gene/grounded/12_40_1 # Run the interactive demo rpp demo
from rpp import encode, decode, resolve, from_components # Encode an address addr = encode(shell=0, theta=12, phi=40, harmonic=1) print(hex(addr)) # 0x182801 # Decode an address shell, theta, phi, harmonic = decode(addr) # Resolve with operation result = resolve(addr, operation="read") print(result.allowed) # True print(result.route) # memory://gene/grounded/12_40_1
CLI output available in 5 languages.
rpp --lang es encode --shell 0 --theta 12 --phi 40 --harmonic 1 [CODIFICAR] [OK] 0x0182801 | Caliente | Gen | Arraigado
Open source. Zero dependencies. Works on Windows, Linux, and macOS.