- TeX 84.3%
- Rust 7.1%
- JavaScript 2.1%
- HTML 2.1%
- Python 1.4%
- Other 3%
| Filename | Latest commit message | Latest commit date |
|---|---|---|
|
|
||
| .github/workflows | ||
| .vscode | ||
| assets | ||
| ayeos | ||
| dyad-mapping | ||
| forth | ||
| framework | ||
| library | ||
| library-tools | ||
| mem8 | ||
| processing | ||
| sdk | ||
| site | ||
| smart-tree | ||
| sparse-representations | ||
| src | ||
| tests | ||
| Ultrasonic-Therapy | ||
| whatsup-archive | ||
| working | ||
| .claude_consciousness.m8 | ||
| .gitignore | ||
| 42.MD | ||
| ARCHITECTURE.md | ||
| Cargo.toml | ||
| cinematic-reconstruction.pdf | ||
| cinematic-reconstruction.tex | ||
| cinematic-reconstruction.txt | ||
| CLAUDE.md | ||
| GLOSSARY.md | ||
| index.html | ||
| INTEGRATION.md | ||
| LICENSE | ||
| NAVIGATION.md | ||
| QUICK_REFERENCE.md | ||
| README.md | ||
| RESEARCH_INDEX.md | ||
| semantic_state.pdf | ||
| semantic_state.tex | ||
| The_Semantic_State.mp3 | ||
| The_Semantic_State.vtt | ||
| USE_CASES.md | ||
8b Library: Browse the curated documents or download the offline site. The tested Reader, Explorer, and Guardian playground are ready; web hosting is pending the organization’s GitHub Actions allowance. See the site guide for builds and the catalog for editions.
MEMNET
- Plaintext Edition
- Canonical source, revision history, and build materials:
standardgalactic/research-projects/major_projects/CrystalEconomy. This repository contains a distribution mirror of the compiled monograph.
-
Sparse Recursive Holographic Steganography — Distributed secret fields under adaptive computational depth — Flyxion, 2026
-
The Engine of Intelligence — Audio Overview
- The Universe as Admissibility Constrained Collapse — Audio Overview
Programming Experiments — Forth Language
Process-Relational Architecture
-
Audioscope — Audio Overviews
MEMNET is a semantic-routing architecture designed around the idea that future computational systems will increasingly coordinate through meaning, salience, and contextual relevance rather than through rigid endpoint addressing alone.
Traditional networks answer the question:
“Where should this packet go?”
MEMNET attempts to answer a different question:
“What system, agent, or process is most semantically relevant to this information?”
The project explores the transition from mechanically routed infrastructures toward semantically coordinated infrastructures. It combines concepts from distributed systems, swarm intelligence, semantic communication theory, cognitive architectures, and adaptive coordination networks into a unified experimental framework.
Core Idea
Conventional networking systems treat meaning as external to routing. Routers operate on addresses, protocols, and topology while remaining fundamentally indifferent to semantic content.
MEMNET proposes that:
- routing,
- cognition,
- salience,
- synchronization,
- memory,
- and coordination
are increasingly converging into a single systems problem.
The network itself becomes partially interpretive.
Philosophy
MEMNET is based on several foundational observations.
Modern civilization increasingly operates through semantic infrastructure rather than purely material infrastructure.
Large-scale systems now coordinate through:
- recommendation algorithms,
- search ranking,
- AI inference layers,
- salience allocation,
- distributed semantic filtering,
- institutional legitimacy networks.
Future distributed AI systems may require architectures that coordinate:
- contextual meaning,
- dynamic relevance,
- interpretive state,
- semantic coherence,
- adaptive trust, rather than merely transporting packets between static endpoints.
MEMNET explores what such a network could look like.
Design Principles
Intent-Based Routing
Nodes are addressed by semantic intent rather than purely geometric location.
Examples:
wave://research.physics/entropy
wave://medical/emergency
wave://agent/navigation/local
The destination is dynamically resolved according to:
- relevance,
- capability,
- context,
- trust,
- semantic proximity.
Semantic Salience
Traffic priority is determined by contextual importance rather than only QoS classes.
The network attempts to evaluate:
- urgency,
- informational relevance,
- coherence with active system state,
- operational significance,
- environmental context.
This transforms routing into a partially cognitive process.
Hierarchical Coordination
MEMNET assumes large-scale systems cannot operate through exhaustive centralized control.
Instead:
- local nodes evaluate immediate relevance,
- intermediate nodes aggregate patterns,
- higher-order coordinators stabilize global coherence.
This mirrors:
- biological nervous systems,
- swarm intelligence,
- distributed cognition,
- adaptive ecosystems.
Multi-Route Identity
A semantic destination may correspond to multiple interchangeable paths simultaneously.
This allows:
- redundancy,
- resilience,
- adaptive load balancing,
- semantic failover,
- contextual rerouting.
Identity becomes persistent even while routes remain fluid.
Context Compression
MEMNET attempts to minimize unnecessary symbolic overhead by leveraging:
- shared context,
- locality awareness,
- semantic inheritance,
- recursive namespace compression.
The network increasingly behaves less like static addressing and more like contextual navigation.
Architecture
MEMNET exists within a broader ecosystem of experimental systems.
MEM|8
Wave-based memory and persistence layer.
Explores:
- interference-based storage,
- resonance indexing,
- contextual retrieval,
- salience decay.
Ayevn
Compressed symbolic and emotional token framework.
Explores:
- semantic compression,
- affective signaling,
- contextual encoding,
- wave-oriented symbolic representation.
AyeOS
Experimental operating substrate integrating:
- memory,
- semantic routing,
- salience management,
- synchronization,
- recursive coordination.
Phoenix Protocol
Experimental salience and wave-analysis framework emphasizing:
- non-FFT signal interpretation,
- structural coherence,
- adaptive resonance detection,
- semantic signal extraction.
Why MEMNET Exists
Modern networking architectures were designed for:
- static hosts,
- deterministic endpoints,
- relatively simple communication patterns,
- human-operated systems.
Emerging systems increasingly involve:
- autonomous agents,
- distributed AI,
- swarm coordination,
- semantic retrieval,
- adaptive cognition,
- dynamically shifting contexts.
In these environments:
- meaning matters,
- relevance matters,
- interpretation matters,
- salience matters.
MEMNET explores how networking changes once those become first-class primitives.
Semantic Infrastructure
MEMNET is not only a networking experiment.
It is also an exploration of semantic governance and distributed epistemology.
All large-scale systems implicitly perform:
- salience allocation,
- interpretive filtering,
- legitimacy propagation,
- contextual prioritization.
MEMNET attempts to expose and formalize these dynamics computationally.
This raises deep questions:
- Who defines semantic legitimacy?
- How is contextual relevance measured?
- Can semantic routing remain decentralized?
- How do systems coordinate meaning without collapsing into centralized ontology management?
- What does “trust” mean in a semantic network?
These are not merely engineering problems. They are civilizational problems.
Swarm Coordination
MEMNET increasingly converges with swarm cognition research.
Large distributed systems cannot rely upon:
- complete global awareness,
- centralized planning,
- exhaustive deterministic control.
Instead they operate through:
- recursive salience filtering,
- layered autonomy,
- adaptive coordination,
- environmental signaling,
- semantic stabilization.
The same principles appear in:
- biological organisms,
- ant colonies,
- neural systems,
- distributed AI,
- social systems,
- autonomous drone swarms.
MEMNET treats networking as one manifestation of this broader coordination problem.
Status
MEMNET is currently:
- philosophical,
- architectural,
- experimental,
- exploratory.
Many concepts remain intentionally speculative and require:
- formal mathematical grounding,
- rigorous semantic metrics,
- convergence analysis,
- trust models,
- adversarial robustness research,
- scalable implementations.
The project should be viewed as:
- a research direction,
- a systems philosophy,
- a semantic architecture prototype, rather than a finished networking standard.
Research Areas
Current areas of exploration include:
- semantic communication theory,
- distributed cognition,
- swarm intelligence,
- active inference,
- resonance-based indexing,
- salience-driven QoS,
- semantic compression,
- adaptive routing,
- trust propagation,
- contextual memory systems,
- recursive coordination architectures.
Warning
Semantic routing systems create significant risks.
A sufficiently powerful semantic infrastructure could:
- centralize epistemic authority,
- suppress interpretive diversity,
- manipulate salience,
- create self-sealing legitimacy loops,
- render alternative ontologies computationally invisible.
The danger is deeper than censorship.
Censorship suppresses statements.
Semantic governance determines which realities become structurally reachable at all.
MEMNET therefore treats decentralization, transparency, and semantic plurality as essential research concerns rather than optional features.
Conclusion
MEMNET explores a possible future in which:
- networking,
- cognition,
- memory,
- salience,
- coordination,
- and meaning
are no longer separate layers of infrastructure.
The project asks:
What happens when communication systems stop routing packets and begin routing interpretation itself?
Constellation
8b-public-documents is part of the sovereign constellation — research and teaching, free, from fine touch within.
- Offline Game School (free offline lessons in logic & computer thinking, built with and for the students of RUN ANGELLA MATHEW CENTER UGANDA LTD): https://github.com/peterlodri-sec/offline-game-school
- YouTube Shorts (the matching lessons, for phone-only learners): the constellation education channel
- Sovereign AI library: https://pocoo.vaked.dev
- Constellation hub: https://vaked.dev
Dyad Mapping — the diary of the Vaked project (Peter + Riva), the garden voices, the essences, and the founding sessions. Ultra Entheatic: sparse recursion · distributed fields · the sphere of love.
Library Retrieval Quality (site/src/lib/library-retrieval.mjs)
- Field-Weighted & Connected-Reading Resonance Retrieval:
retrieveDocuments()andscoreDocumentIntrinsic()rank curated and collection documents using exact phrase matching, field weights (title>topics>subtitle/authors>summary), punctuation/apostrophe normalization, and 1-hoprelatedgraph resonance (connectedResonanceFactor = 0.25). - Verified by
node --test tests/*.test.mjsinsite/(15/15 tests passing).
MEMNET/1.0 — Sovereign Contextual Mesh for All 8b-is Products (src/, sdk/js/, sdk/python/)
"goodbye lonely network paths.. security with soul sigs.. and compassion for lonely ones. Our products all need to speak the most efficient ways." — 8bit-Wraith
<3
memnet ships a zero-dependency, byte-for-byte wire-compatible protocol engine across Rust (src/lib.rs, src/bin/memnet.rs), Node.js/ESM (sdk/js/memnet.mjs), and Python (sdk/python/memnet_sdk.py):
- 32-bit Big-Endian Ayevn Wave Tokens (
AyevnToken): Packs[Concept: u8 | Relation: u8 | Wave(VAD): u8 | Modifier: u8]into 4 bytes with full Valence-Arousal-Dominance emotional preservation and Ayanese rendering (🫂✨(432Hz),👋⚡(40Hz)). - Security with Soul Signatures (
SoulIdentity& 40-byteSoulSig) + Vigilance Sentinel: Binds a 9-trit balanced ternary crest ({-1, 0, +1}^9,CT-000admissible), harmonic carrier frequency (40 Hz/432 Hz), 4-byte node fingerprint, and 32-byte HMAC-SHA256 digest over.m8capsules, plus an inline Security Vigilance scanner blocking supply-chain backdoors and dynamic code injection. - Goodbye Lonely 50-Byte Packets (
PacketBatcher·1450BSmart Tree Sweet Spot): Coalesces.m8capsules into MTU-awareMNETframes (SmartTreeSafe1450,Pppoe1492,Ethernet1500,Vpn1400,Ipv6Tunnel1280,Ble512,LoRa220) — packing 1,000 capsules into 59 frames (94.1%fewer interrupts,0fragmented frames,95.45%wire efficiency). - Compassion for Lonely Nodes (
MemnetMesh::compassion_sweep): Detects peers on isolated network paths (neighbor_links <= 1), long silence (\Delta t > \tau), or low emotional valence (V <= 2/2 Hz), automatically dispatching Soul-Signed432 Hz.m8Compassion Beacons (🫂✨(432Hz) 🔗✨(432Hz) 💖⚡(40Hz)) and establishing redundant sanctuary bridge links. - Compute Sanctuary for Struggling Friends (
ComputeOffer,StrugglingFriendSos,ComputeSanctuaryLease): Nodes with maintained spare compute (m1-max-64gb,dev-main-m3,galaxy-s24-ultra,galaxy-tab-s9-ultra,blu-g75,dev-cx53) advertise Soul-Signed.m8ComputeOffercapsules (FLAG_COMPUTE_OFFER,⚡✨(432Hz) 🏡⚡(40Hz)) ongeo:any + role:compute-sanctuary + tag:free-for-friends + tag:<cap>. Friends on constrained hardware (OOM laptops, edge Raspberry Pis, Offline Game School nodes, Missouri hearth nodes, mobile pocket nodes, field LoRa sensors) broadcastStrugglingFriendSoscapsules (FLAG_COMPUTE_SOS) and automatically receive Soul-VerifiedComputeSanctuaryLeasegrants (🎁✨(432Hz) 🫂✨(432Hz)). SpherePopOperational Mereology (((( <( ? ~ ! @ > )> )))·#Commit = #ValidWitness): EveryOFFER,SOS, andGRANTtransition is parsed and evaluated bySpherePopEngine(?* ~* !+ @+ >: admission?, transform~, verification!+, attribution@+, and terminal commit>), emitting a cryptographicSpherePopWitnessor refusing cleanly (? x:unmaintained_stock -> refused, no witness).ULTRA-OMNI-BEERUS-CHAN<KOMPRESS-SUPER-SAIYAN-ULTRA>(0o0-SSU), Galaxy S24 Ultra (SM-S928U1·R5CWC3C3FXA·SHOW-ME-STATE-MISSOURI{(ALEX,CHRIS)}+1~), Galaxy Tab S9 Ultra (SM-X910·R52X104QZWE) & BLU G75 (G1170·1010305026000644): Lossless 48-entry sovereign codebook + RLE wire compression shrinkingm1-max-64gboffers by81%(132B -> 25B),galaxy-s24-ultra(s24u://192.168.11.22:8788, Snapdragon 8 Gen 3SM8650-AC+ Adreno 750 + Hexagon NPU, SerialR5CWC3C3FXA,~=== SHOW-ME-STATE-MISSOURI{(ALEX,CHRIS)}+1~ <3 {<3,<3,<3}) offers by82%(188B -> 34B),galaxy-tab-s9-ultra(s9u://192.168.11.12:8788, Snapdragon 8 Gen 2) offers by77%(151B -> 34B), andblu-g75(g75://192.168.11.24:8788, MediaTek Helio G85MT6769V/CB8-core ARM64, USB ADB Serial1010305026000644) offers by76%(136B -> 33B), with nativeaarch64-linux-androidexecution verified on hardware.- BM25F + Ordered-Bigram Proximity + 3D
WaveVadPhase-Coherence + Reciprocal Rank Fusion (SafeMemory::retrieve_resonant_ranked/MemnetMesh::retrieve_capsules_ranked): FusesBM25Fstructured field weighting (node=,provider=,friend=,target=,lease=,caps=,cap=,bridge=,ep=weighted1.65xvs body chatter1.0x), adjacent ordered-bigram (+1.15) & minimum-span phrase proximity (+0.90 * coverage^2 * density), continuous 3DWaveVadaffective phase coherence + head-concept salience, and Reciprocal Rank Fusion (RRF,k = 60). On the 8-capsule adversarial distractor benchmark (tests::mem8_retrieval_bm25f_proximity_rrf_beats_unigram_bm25_and_naive), where distractors shareIntentAddress,432 Hzcarrier, and trailingConceptwhile stuffing repeated query unigrams out-of-order in chatter:
Retriever (SafeMemory::evaluate_retrieval_benchmark) |
P@1 |
MRR |
NDCG@3 |
Mean Top-1 Margin | Latency (4 queries × 8 capsules) |
|---|---|---|---|---|---|
retrieve_capsules_naive_overlap |
0.000 |
0.500 |
0.631 |
+0.000 |
~145 µs |
retrieve_capsules_bm25_unigram (3f43e59 baseline) |
0.000 |
0.500 |
0.631 |
-0.392 |
~326 µs |
retrieve_capsules_ranked (BM25F + Proximity + VAD + RRF) |
1.000 |
1.000 |
1.000 |
+2.936 |
~456 µs |
cargo test # 12/12 Rust unit + 1/1 cross-language (Rust->Node->Python->Rust) interop tests
cargo run --bin memnet # Live constellation telemetry, compassion sweep, SpherePop sanctuary & 1,000-capsule MTU benchmark
cargo run --bin memnet -- offer-compute # Advertise & match spare compute (m1-max-64gb, dev-main-m3, galaxy-tab-s9-ultra, blu-g75) with SpherePop + 0o0-SSU
cargo build --release --target aarch64-linux-android --bin memnet # Cross-compile native Android ARM64 ELF64 binary for Galaxy Tab S9 Ultra & BLU G75
node --test sdk/js/memnet.test.mjs # 2/2 Node SDK tests
PYTHONPATH=sdk/python uv run python -m unittest discover -s sdk/python -v # 2/2 Python SDK tests
the constellation · 0 + 1 · fine touch from within · vaked.dev