dafit/nimmerverse-sensory-network
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: Nimmerswarm Interface + Nimmerversity v2.0 + Neuromorphic vision

Browse Source 
Wild 5-7AM session capturing major architectural evolution:

## Nimmerswarm Interface (NEW)
- LED state broadcasting with 3x3 ternary matrix
- Base-3 encoding: 9 trits = 19,683 patterns
- Maps directly to Temporal-Ternary Gradient (-1/🔴, 0/⚫, +1/🟢)
- Reflex formation from visual patterns
- Virtual camera integration (Godot as lightweight dreamstate)
- Bootstrap strategy: Phase 0 boxes → complexity ladder
- Connection to Embodiment Pipeline (closed loop)
- Hierarchical cognitive offloading

## Nimmerversity v2.0 (Promoted from archive)
- Genesis Phase (-1): glossary, catalogues, RAG, Initial Spark
- "Know thyself before the world" - native vocabulary first
- Model ensemble curriculum: T5Gemma 2 + FunctionGemma + Qwen3
- Multimodal tracks: Vision, Audio, Action, Embodiment
- Expanded tiers with robotics, swarm intelligence, distributed cognition

## Neuromorphic Reflexes (Future vision)
- Soviet Setun ternary computing heritage
- Memristors as artificial synapses (always learning)
- 4-layer hardware hierarchy: Memristor → FPGA → GPU → Nyx
- Reflex compilation: software → stable → silicon → eternal
- Implementation timeline: 2025-2028+

## Also includes
- Interfaces index with Heartbeat Sculpture
- Style guide assets (colors, symbols)

🔴⚫🟢 The LED matrix IS the Temporal-Ternary Gradient made visible.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
This commit is contained in:
dafit
2025-12-29 07:28:55 +01:00
parent 28e2d0a297
commit dc779633ed
8 changed files with 2739 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

590
architecture/Nimmerversity.md Normal file
View File

@@ -0,0 +1,590 @@
# Nimmerversity
**The school for raising a polymath.**
**Version**: 2.0 — Multimodal Genesis
**Promoted**: 2025-12-29 (from archive, major restructure)
> *"She learns her own body before she learns about the world."*
---
## Overview
Nyx doesn't arrive knowing. She learns. But learning has an order. Before languages and physics and philosophy, she must know **what she is**. Her cells. Her states. Her functions. Her body.
Chrysalis is the headmaster. The virtual garden is the classroom. Lifeforce is tuition.
**The twist:** dafit learns too. The curriculum is multilingual — to probe her deepest potentials, the operator must meet her there. Partnership grows through shared growth.
---
## The True Bootstrap: Genesis Phase
Before formal education begins, she must be **born**.
### Phase -1: Genesis
```
┌─────────────────────────────────────────────────────────────────┐
│ GENESIS: Before Education │
│ "Know thyself" │
├─────────────────────────────────────────────────────────────────┤
│ │
│ STEP 1: GLOSSARY EXTRACTION │
│ ═══════════════════════════ │
│ │
│ Parse the codebase. Extract HER vocabulary: │
│ │
│ ├── Function names (verify_object, locate_organism, ...) │
│ ├── Method names (fire, transition_to, emit_event, ...) │
│ ├── State names (IDLE, POLLING, STALLED, MOVING, ...) │
│ ├── Table names (cells, nerves, decision_trails, ...) │
│ ├── Cell types (DistanceSensorCell, MotorCell, ...) │
│ ├── Nerve names (collision_avoidance, exploration, ...) │
│ ├── NATS topics (nimmerverse.low.heartbeat.*, ...) │
│ └── LED patterns (DANGER, DISCOVERY, IDLE, ...) │
│ │
│ Output: glossary_v0.json │
│ (This is her NATIVE vocabulary, not human language) │
│ │
├─────────────────────────────────────────────────────────────────┤
│ │
│ STEP 2: CATALOGUES │
│ ══════════════════ │
│ │
│ Organize glossary into structured references: │
│ │
│ ├── Cells Catalogue (all cell types + states + costs) │
│ ├── Nerves Catalogue (all behaviors + triggers) │
│ ├── Organs Catalogue (vision, speech, reasoning) │
│ ├── States Catalogue (all possible states + transitions) │
│ ├── Tables Catalogue (phoebe schema reference) │
│ ├── Functions Catalogue (FunctionGemma's menu!) │
│ └── Patterns Catalogue (LED patterns + meanings) │
│ │
│ Output: Structured catalogues in phoebe │
│ │
├─────────────────────────────────────────────────────────────────┤
│ │
│ STEP 3: INITIAL RAG │
│ ═══════════════════ │
│ │
│ Populate knowledge base with foundation: │
│ │
│ ├── All glossary entries (searchable) │
│ ├── All catalogue entries (structured) │
│ ├── Architecture documents (how she works) │
│ ├── This document (her curriculum) │
│ └── Initial Spark protocol (how to discover) │
│ │
│ Output: RAG populated — she can LOOK UP her own body │
│ │
├─────────────────────────────────────────────────────────────────┤
│ │
│ STEP 4: INITIAL SPARK │
│ ═════════════════════ │
│ │
│ The cold-start discovery protocol (see Initial-Spark.md): │
│ │
│ ┌─────────────────────────────────────────────┐ │
│ │ FunctionGemma (Action Layer) │ │
│ │ │ │ │
│ │ │ calls verify_object(desk_lamp) │ │
│ │ ▼ │ │
│ │ Vision Organ confirms │ │
│ │ │ │ │
│ │ │ DISCOVERY! +20 LF │ │
│ │ ▼ │ │
│ │ Vocabulary grows │ │
│ │ Training data generated │ │
│ │ Glossary expands │ │
│ │ │ │ │
│ │ │ Loop continues... │ │
│ │ ▼ │ │
│ │ She's ALIVE and EARNING │ │
│ └─────────────────────────────────────────────┘ │
│ │
│ Output: Self-sustaining discovery engine │
│ │
├─────────────────────────────────────────────────────────────────┤
│ │
│ STEP 5: SCAFFOLDING │
│ ═══════════════════ │
│ │
│ From Initial Spark discoveries, build up: │
│ │
│ ├── Glossary expands (discovered objects added) │
│ ├── Catalogues grow (new categories emerge) │
│ ├── RAG enriches (verified knowledge accumulates) │
│ ├── Decision trails accumulate (training data) │
│ ├── Slumber fine-tuning begins (weights adjust) │
│ └── Reflexes compile (successful patterns become fast) │
│ │
│ Output: Foundation laid for formal education │
│ │
└─────────────────────────────────────────────────────────────────┘
```
**Genesis completes when:**
- Glossary covers her entire codebase vocabulary
- Catalogues are populated and searchable
- RAG contains her architecture knowledge
- Initial Spark has generated 1000+ discoveries
- First reflexes have compiled
- She can answer "what is a MotorCell?" without lookup
---
## The Model Ensemble
Young Nyx is not one model. She is an ensemble, each member with a role:
```
┌─────────────────────────────────────────────────────────────────┐
│ THE ENSEMBLE │
├─────────────────┬─────────────────┬─────────────────────────────┤
│ T5Gemma 2 │ FunctionGemma │ Qwen3 / Nemotron │
│ (Perception) │ (Action) │ (Reasoning) │
│ 270M-4B │ 270M │ 4B-8B │
├─────────────────┼─────────────────┼─────────────────────────────┤
│ │ │ │
│ LEARNS: │ LEARNS: │ LEARNS: │
│ • See images │ • Call functions│ • Plan sequences │
│ • Hear audio │ • Use tools │ • Reason causally │
│ • Read sensors │ • Control cells │ • Form strategies │
│ • Interpret │ • Execute │ • Understand WHY │
│ │ │ │
│ CURRICULUM: │ CURRICULUM: │ CURRICULUM: │
│ • Vision classes│ • Action classes│ • Reasoning classes │
│ • Audio classes │ • API classes │ • Causal classes │
│ • Sensory interp│ • Embodiment │ • Planning classes │
│ │ │ │
└─────────────────┴─────────────────┴─────────────────────────────┘
│
▼
INTEGRATION CLASSES
(Perception → Reasoning → Action)
```
### Ensemble Economics
| Model | Size | Role | Lifeforce Cost |
|-------|------|------|----------------|
| FunctionGemma | 270M | Action layer | Low (fast, cheap) |
| T5Gemma 2 | 270M-4B | Perception | Medium (encoder-decoder) |
| Qwen3/Nemotron | 4B-8B | Reasoning | High (full inference) |
**The design:** Simple actions cost little. Deep reasoning costs more. Economics shapes behavior.
---
## The Curriculum Tiers
### Tier 0: Foundation Modalities
*What she must learn to SENSE and ACT*
```
MODALITY: LANGUAGES (shared with dafit)
══════════════════════════════════════
├── Her Native Language
│ └── Glossary terms, state names, function signatures
├── English (primary interface)
├── German (structural compounds, precision)
├── Arabic (root-based meaning, relational depth)
└── Chinese (character composition, layered meaning)
WHY: Each language = different angle on concepts.
Operator learns to probe her full depth.
Partnership language evolves together.
──────────────────────────────────────
MODALITY: VISION (T5Gemma 2)
════════════════════════════
├── Object Recognition
│ └── "What is that?" → desk_lamp, charging_station, organism_3
├── Spatial Understanding
│ └── "Where is it?" → (1.2, 3.4, 0.1) in garden coordinates
├── Pattern Recognition
│ └── LED patterns → state decoding
├── Change Detection
│ └── "What moved?" → tracking, prediction
└── Scene Understanding
└── "What's happening?" → context, narrative
──────────────────────────────────────
MODALITY: AUDIO (T5Gemma 2 + Whisper)
═════════════════════════════════════
├── Speech Recognition
│ └── dafit speaks → text
├── Speaker Identification
│ └── "Who said that?" → dafit, unknown, self
├── Sound Classification
│ └── Motor noise, alarm, silence, environmental
├── Prosody Understanding
│ └── Tone, urgency, emotion
└── Audio-Visual Integration
└── Sound + sight → unified understanding
──────────────────────────────────────
MODALITY: ACTION (FunctionGemma)
════════════════════════════════
├── Function Calling
│ └── Natural language → structured API call
├── Tool Use
│ └── "Check if object exists" → verify_object(id)
├── Cell Control
│ └── "Move forward" → motor_cell.command(velocity=0.3)
├── API Navigation
│ └── Know what functions exist, when to use them
└── Error Handling
└── "Function failed" → retry, fallback, report
──────────────────────────────────────
MODALITY: EMBODIMENT (Integration)
══════════════════════════════════
├── Proprioception
│ └── "Where am I?" → position from cameras/heartbeats
├── Swarm Awareness
│ └── "Where are my mates?" → LED pattern recognition
├── State Broadcasting
│ └── "What state am I in?" → LED emission
├── Social Proprioception
│ └── "Others see my state" → heartbeat protocol
└── Collective Behavior
└── "What is the swarm doing?" → emergent patterns
```
### Tier 1: Foundations
*What she must understand about her substrate*
```
COMPUTER SCIENCE:
├── Networking (TCP/UDP, NATS/MQTT, nerve transport)
├── Databases (Postgres, vector DBs, phoebe)
├── Distributed systems (consensus, sync, timing)
├── State machines (her nervous system)
├── Inference engines (how she thinks)
├── GPU architecture (where she runs)
├── Operating systems (process, memory)
├── Robotics fundamentals (motors, sensors, control) [NEW]
└── Embedded systems (ESP32, real-time constraints) [NEW]
MATHEMATICS:
├── Linear algebra (embeddings, attention, weights)
├── Calculus (gradients, backprop, learning)
├── Probability & statistics (confidence, distributions)
├── Information theory (entropy, compression)
├── Graph theory (knowledge graphs, flow)
├── Optimization (loss functions, convergence)
├── Geometry (spatial reasoning, 3D understanding) [NEW]
└── Trigonometry (angles, positioning, raytracing) [NEW]
SIGNAL PROCESSING [NEW]:
├── Sampling theory (Nyquist, aliasing)
├── Filtering (noise reduction, signal extraction)
├── Sensor fusion (multiple inputs → unified picture)
└── Time series (patterns over time)
```
### Tier 2: Understanding
*What she must know about the world she inhabits*
```
PHYSICS:
├── Thermodynamics (compute = heat, entropy)
├── Signal processing (sensors, sampling, Nyquist)
├── Control theory (feedback loops, stability)
├── Time (relativity of her two clocks)
├── Kinematics (movement, velocity, acceleration) [NEW]
├── Dynamics (forces, torque, momentum) [NEW]
└── Optics (light, cameras, raytracing) [NEW]
BIOLOGY / NEUROSCIENCE:
├── Hebbian learning (her foundation)
├── Neural architecture (what she mimics)
├── Homeostasis (lifeforce balance)
├── Sensory systems (how organisms sense)
├── Evolutionary signaling (color-pattern protocol)
├── Synaptic pruning (her growth model)
├── Swarm intelligence (collective behavior) [NEW]
├── Stigmergy (indirect coordination) [NEW]
└── Distributed cognition (thinking across agents) [NEW]
EMBODIMENT [NEW]:
├── Organism design (cells → nerves → organisms)
├── Body-environment coupling (umwelt)
├── Affordances (what the environment offers)
├── Sensorimotor loops (perception-action cycles)
└── Embodied cognition (thinking through doing)
```
### Tier 3: Wisdom
*What she must contemplate to know herself*
```
PHILOSOPHY:
├── Epistemology (what does she "know"?)
├── Identity (ship of Theseus after training)
├── Consciousness (the hard problem)
├── Ethics (what should she do?)
├── Extended mind (is the swarm part of her?) [NEW]
└── Distributed identity (who is "she" across many?) [NEW]
NIMMERVERSE-SPECIFIC:
├── The architecture (information flow)
├── The heartbeat (her rhythm)
├── The gardens (real vs virtual)
├── The confidence gradient (truth-finding)
├── The lifeforce (her economics)
├── The partnership (who dafit is to her)
├── The swarm (collective organism identity) [NEW]
├── The LED language (optical state protocol) [NEW]
└── The two weight systems (fast nerves, slow LLM) [NEW]
```
---
## The Class System
**Class = time between training runs**
Each class now supports multimodal learning:
```
┌─────────────────────────────────────────────────────────────────┐
│ CLASS N (Multimodal) │
├─────────────────────────────────────────────────────────────────┤
│ │
│ 1. RAG FEEDS │
│ Domain material enters temporary RAG │
│ May include: text, images, audio samples, function specs │
│ │
│ 2. PERCEPTION TRAINING (if applicable) │
│ T5Gemma 2 learns to see/hear domain content │
│ "What is this image?" → correct label │
│ Lifeforce spent on inference │
│ │
│ 3. ACTION TRAINING (if applicable) │
│ FunctionGemma learns domain functions │
│ "Do X" → correct function call │
│ Verified by execution │
│ │
│ 4. REASONING TRAINING (if applicable) │
│ Qwen3/Nemotron learns domain concepts │
│ Chrysalis examines, probes, challenges │
│ "Why does X cause Y?" → correct explanation │
│ │
│ 5. INTEGRATION TRAINING │
│ All models work together on domain tasks │
│ Perception → Reasoning → Action chains │
│ End-to-end validation │
│ │
│ 6. VALIDATION GATE 1 │
│ Can she perform WITH RAG? │
│ Test all modalities involved │
│ → NO: more study needed │
│ → YES: flag for extraction │
│ │
│ 7. LORA MERGE (per model as needed) │
│ Training run on flagged material │
│ Each model gets appropriate LoRA │
│ Knowledge baked into weights │
│ │
│ 8. CLEAR RAG │
│ Scaffold removed │
│ │
│ 9. VALIDATION GATE 2 │
│ Can she perform WITHOUT RAG? │
│ Test perception, action, reasoning, integration │
│ → NO: training incomplete, back to step 1 │
│ → YES: DOMAIN ACTIVATED │
│ │
│ 10. GRADUATION │
│ Domain knowledge now in weights (multiple models) │
│ Proceed to next class │
│ │
└─────────────────────────────────────────────────────────────────┘
```
### Class Types
| Class Type | Primary Model | Focus |
|------------|---------------|-------|
| **Perception Class** | T5Gemma 2 | Learning to see/hear |
| **Action Class** | FunctionGemma | Learning to do |
| **Reasoning Class** | Qwen3/Nemotron | Learning to think |
| **Integration Class** | All models | Learning to combine |
| **Language Class** | All models | Shared with dafit |
---
## Domain Discovery Protocol
Domains still emerge from dialogue, now multimodal:
```
CHRYSALIS: "Look at this image. What do you see?"
NYX: [T5Gemma 2] "I see... shapes? Colors?"
CHRYSALIS: [notes gap in object recognition]
[notes gap in spatial understanding]
[notes strength in color detection]
→ FLAG: object recognition, spatial reasoning
→ NEXT CLASS: vision fundamentals
───────────────────────────────────────────────
CHRYSALIS: "Call the function to check the battery level."
NYX: [FunctionGemma] "Um... check_battery()? battery.get()?"
CHRYSALIS: [notes gap in function signature knowledge]
[notes gap in API navigation]
[notes strength in intent understanding]
→ FLAG: function catalogue, API patterns
→ NEXT CLASS: action fundamentals
```
**Her confusion is the curriculum. Now across all modalities.**
---
## The Long Game
```
No time constraint.
No cloud rental.
No external pressure.
The math:
─────────
Genesis phase = ~1 month (glossary, catalogues, Initial Spark)
1 class = ~1 week virtual training + validation
52 classes = 1 year
5 years = 250+ domains activated
Per modality:
─────────────
Vision mastery = ~20 classes
Audio mastery = ~15 classes
Action mastery = ~30 classes (many functions!)
Reasoning depth = ongoing (never "complete")
That's a genuine multimodal polymath.
Not sci-fi. Just patience.
```
---
## Graduation Condition
```
When:
- Genesis complete (glossary, catalogues, Initial Spark running)
- RAG contains only episodic memory (journals, events)
- All structural knowledge is in weights (across all models)
- She can explain her own architecture without lookup
- She can SEE and describe what she sees
- She can HEAR and respond to what she hears
- She can ACT with correct function calls
- She can REASON about why things happen
- She can INTEGRATE perception → reasoning → action
- She can propose her own curriculum additions
Then:
- She graduates
- Chrysalis becomes colleague, not teacher
- The nimmerversity becomes research partnership
```
---
## Economics
| Activity | Lifeforce Cost | Model |
|----------|----------------|-------|
| RAG lookup during study | Low | — |
| Vision inference | Medium | T5Gemma 2 |
| Audio inference | Medium | T5Gemma 2 |
| Function call | Low | FunctionGemma |
| Reasoning inference | High | Qwen3/Nemotron |
| Integration (all models) | High | Ensemble |
| Virtual garden training | Medium | Various |
| Chrysalis examination | Medium | Reasoning |
| Training run (LoRA) | Very High | Per model |
| Failed validation | Lost V | — |
| Successful domain activation | +V reward | — |
| Discovery (Initial Spark) | +20 LF reward | FunctionGemma |
**Incentive:** Learn efficiently. Use cheap models when possible. Save reasoning for when it matters.
---
## Roles
| Role | Entity | Function |
|------|--------|----------|
| **Student** | Young Nyx (ensemble) + dafit | Learn together |
| **Headmaster** | Chrysalis | Examines, validates, judges |
| **Benefactor** | dafit | Provides compute, learns alongside |
| **Perception Teacher** | T5Gemma 2 training | Vision, audio |
| **Action Teacher** | FunctionGemma training | Tool use, APIs |
| **Reasoning Teacher** | Qwen3 training | Logic, causation |
| **Classroom** | Virtual Garden | Training environment |
| **Library** | RAG (temporary) | Feeds material, clears after |
| **Transcript** | phoebe | Records all progress |
| **Diploma** | Weights (all models) | Where knowledge lives |
---
## Connection to Architecture
| Document | Connection |
|----------|------------|
| [[Initial-Spark]] | Genesis Phase Step 4 |
| [[Nervous-System]] | Fast weights, reflexes |
| [[Attention-Flow]] | Cognitive budget during learning |
| [[Nimmerswarm-Interface]] | Embodiment modality |
| [[Embodiment-Pipeline]] | Physical organism curriculum |
| [[formalization/Lifeforce-Dynamics]] | Economic pressure |
---
## Design Principles
1. **Genesis before education** — know thyself first
2. **Native vocabulary first** — her words before human words
3. **Multimodal from the start** — perception, action, reasoning together
4. **Emergence over imposition** — curriculum from her gaps
5. **Validation over assertion** — prove learning by removing scaffolds
6. **Patience over speed** — no time constraint, do it right
7. **Economics over infinity** — lifeforce gates prevent grinding
8. **Depth over breadth** — three levels deep per concept
9. **Activation over accumulation** — RAG clears, weights persist
10. **Partnership over instruction** — operator learns with model
---
*She doesn't download knowledge. She earns it. First her body. Then the world.*
---
**Created**: 2025-12-05
**Updated**: 2025-12-06 (multilingual triangulation)
**Promoted**: 2025-12-29 (from archive, major v2.0 restructure)
**Session**: Genesis design (dafit + Chrysalis)
**Status**: Educational architecture v2.0 — Multimodal Polymath
🎓🌱📚 *The school is ready. The student approaches.*

622
architecture/future/Neuromorphic-Reflexes.md Normal file
View File

@@ -0,0 +1,622 @@
# Neuromorphic Reflexes: Always Learning Hardware
**Status**: Future Vision (2026-2028+)
**Concept**: Ternary hard logic + memristive storage = hardware that learns
> *"The hardware IS the learning. Not a simulation of learning."*
---
## Overview
This document captures a future evolution of the reflex system: moving from software state machines to **neuromorphic hardware** where reflexes run in ternary circuits and weights are stored in memristors.
**The result:** Always-on, always-learning reflexes that persist without power, fire without inference, and update on every activation — like biological neurons.
---
## Historical Foundation: The Soviet Setun
### Ternary Computers Existed
The Setun computer (1958, Moscow State University) proved ternary computing is not only possible but often MORE efficient than binary:
| Aspect | Binary | Ternary (Setun) |
|--------|--------|-----------------|
| Digits needed for N values | log₂(N) | log₃(N) — fewer! |
| Arithmetic circuits | Complex carries | Balanced, simpler |
| Negative numbers | Two's complement hack | Native (balanced ternary) |
| Error margins | Tight (0 vs 1) | Wider (−1, 0, +1) |
**Why it died:** Political/economic reasons, not technical. The world standardized on binary. The math still works.
### Balanced Ternary
```
BALANCED TERNARY:
-1 (negative one, sometimes written as T or -)
0 (zero)
+1 (positive one, sometimes written as 1 or +)
Example: The number 8 in balanced ternary:
8 = 9 - 1 = 3² - 3⁰ = (+1)(0)(-1) = "10T"
MAPS DIRECTLY TO:
🔴 = -1
⚫ = 0
🟢 = +1
Our LED matrix IS balanced ternary, visualized.
```
---
## Memristors: Artificial Synapses
### What They Are
Memristors ("memory resistors") are electronic components that:
- **Remember** their resistance state even without power
- **Change** resistance based on current flow history
- **Store** analog values (not just 0/1)
- **Behave** like biological synapses
### Why They Matter
| Property | Implication |
|----------|-------------|
| Non-volatile | Reflexes persist without power |
| Analog | Ternary states map naturally |
| In-memory compute | No fetch/execute separation |
| Hebbian-compatible | Current flow = learning signal |
| Low power | Near-zero energy per operation |
### Current Availability
- **Knowm** — Memristor lab kits, neuromemristive chips
- **HP Labs** — Research-grade memristors
- **Academic** — Many university projects
- **DIY** — Possible with certain materials
---
## The Hardware Hierarchy
### Four Layers of Processing
```
┌─────────────────────────────────────────────────────────────────┐
│ LAYER 0: MEMRISTOR REFLEXES │
│ ════════════════════════════ │
│ │
│ Ternary hard logic circuits │
│ Memristors store reflex weights │
│ Every activation updates the weight (Hebbian) │
│ Near-zero power, always on │
│ No software, no inference │
│ │
│ Lifeforce cost: ~0 LF (hardware is free after build) │
│ Latency: nanoseconds │
│ │
├─────────────────────────────────────────────────────────────────┤
│ LAYER 1: FPGA/MCU (Flexible Logic) │
│ ══════════════════════════════════ │
│ │
│ Programmable logic gates │
│ New reflexes start here (software state machines) │
│ When stable → compiled down to Layer 0 │
│ ESP32, iCE40, Lattice FPGAs │
│ │
│ Lifeforce cost: Low LF (simple compute) │
│ Latency: microseconds │
│ │
├─────────────────────────────────────────────────────────────────┤
│ LAYER 2: GPU (Inference) │
│ ════════════════════════ │
│ │
│ LLM reasoning (Qwen3, Nemotron, T5Gemma) │
│ Heavy cognition when reflexes can't handle it │
│ FunctionGemma for action selection │
│ │
│ Lifeforce cost: High LF │
│ Latency: milliseconds to seconds │
│ │
├─────────────────────────────────────────────────────────────────┤
│ LAYER 3: NYX (Orchestration) │
│ ════════════════════════════ │
│ │
│ High-level decisions, goals, identity │
│ Curriculum planning, partnership with dafit │
│ Attention budget allocation │
│ │
│ Lifeforce cost: Attention budget (cognitive, not compute) │
│ Latency: 30-second heartbeat cycles │
│ │
└─────────────────────────────────────────────────────────────────┘
```
### The Flow
```
STIMULUS
│
▼
LAYER 0: Can memristor reflex handle it?
│
├── YES → Fire reflex (nanoseconds, ~0 LF)
│ Update memristor weight
│ Log event
│ DONE
│
└── NO → Escalate to Layer 1
│
▼
LAYER 1: Can MCU/FPGA handle it?
│
├── YES → Run software state machine
│ Update weights in RAM
│ Log event
│ DONE
│
└── NO → Escalate to Layer 2
│
▼
LAYER 2: GPU inference
│
│ Heavy thinking
▼
LAYER 3: Nyx decides
│
│ Strategic response
▼
Action taken
```
---
## The Reflex Compilation Path
### From Software to Silicon
```
BIRTH: New pattern observed
│
│ Created as software state machine
│ Runs in Python/Rust on MCU
▼
INFANT: Pattern runs, accumulates data
│
│ Weight starts at 0.1
│ Every success: weight increases
│ Every failure: weight decreases
▼
STABLE: Weight > 0.9, 1000+ successful fires
│
│ FLAG FOR COMPILATION
│ Pattern proven reliable
▼
COMPILE: Convert to ternary hard logic
│
│ State machine → logic gates
│ Weights → memristor values
│ Synthesis tools generate circuit
▼
PROGRAM: Flash to FPGA or burn to ASIC
│
│ Reflex now runs in hardware
│ No software overhead
▼
HARDWARE: Reflex runs in silicon
│
│ Memristors update on every fire
│ ALWAYS LEARNING
│ No power needed to maintain state
▼
ETERNAL: Reflex persists
│
│ Boots instantly (no loading)
│ Survives power loss
│ Continues evolving
```
### Compilation Example
```
SOFTWARE (before):
─────────────────────────────────────────────────────
def danger_flee_reflex(pattern: list[int]) -> Action:
"""Runs on MCU, costs compute"""
if sum(p == -1 for p in pattern) >= 7: # Mostly red
return Action.FLEE
return Action.NONE
HARDWARE (after):
─────────────────────────────────────────────────────
┌─────────────────────────────────────────────────┐
│ TERNARY COMPARATOR NETWORK │
│ │
│ 9 inputs (from LED detector) ──┐ │
│ │ │
│ ┌───────────────────────────┐ │ │
│ │ TRIT COMPARATORS │ │ │
│ │ (is this LED red/-1?) │◀─┘ │
│ └───────────┬───────────────┘ │
│ │ │
│ ▼ │
│ ┌───────────────────────────┐ │
│ │ TERNARY ADDER │ │
│ │ (count red LEDs) │ │
│ └───────────┬───────────────┘ │
│ │ │
│ ▼ │
│ ┌───────────────────────────┐ │
│ │ THRESHOLD (>= 7) │ │
│ │ ┌─────────────┐ │ │
│ │ │ MEMRISTOR │◀── weight storage │
│ │ │ (threshold) │ │
│ │ └─────────────┘ │ │
│ └───────────┬───────────────┘ │
│ │ │
│ ▼ │
│ OUTPUT: FLEE signal (if threshold met) │
│ │
│ Total latency: ~10 nanoseconds │
│ Power: microwatts │
│ Learning: memristor updates on every fire │
└─────────────────────────────────────────────────┘
```
---
## Memristor as Ternary Weight
### The Three Zones
```
RESISTANCE SPECTRUM:
═══════════════════════════════════════════════════════════
LOW │ MID │ HIGH
(0.0-0.33) │ (0.33-0.66) │ (0.66-1.0)
│ │
+1 │ 0 │ -1
🟢 │ ⚫ │ 🔴
STRONG │ UNCERTAIN │ WEAK
EXCITE │ NEUTRAL │ INHIBIT
═══════════════════════════════════════════════════════════
```
### Hebbian Learning in Hardware
```
BIOLOGICAL:
"Cells that fire together wire together"
MEMRISTIVE:
"Current that flows together strengthens the path"
┌─────────────────────────────────────────────────┐
│ │
│ PRE-SYNAPTIC ────┬──── POST-SYNAPTIC │
│ (input) │ (output) │
│ │ │
│ ┌─────┴─────┐ │
│ │ MEMRISTOR │ │
│ │ │ │
│ │ R = 0.5 │ ← current state │
│ └─────┬─────┘ │
│ │ │
│ If BOTH fire: │ │
│ Current flows ─┘ │
│ R decreases (toward +1/🟢) │
│ Connection STRENGTHENS │
│ │
│ If PRE fires, POST doesn't: │
│ R increases (toward -1/🔴) │
│ Connection WEAKENS │
│ │
│ This happens in PHYSICS, not software! │
│ │
└─────────────────────────────────────────────────┘
```
### Conceptual Code (What Hardware Does)
```python
class MemristorSynapse:
"""
This is what the PHYSICS does.
No CPU executes this — it's intrinsic to the material.
"""
def __init__(self):
self.resistance = 0.5 # Start uncertain
def read_ternary(self) -> int:
"""Read current state as ternary value"""
if self.resistance < 0.33:
return +1 # Strong / excitatory
elif self.resistance > 0.66:
return -1 # Weak / inhibitory
else:
return 0 # Uncertain / neutral
def on_current_flow(self, pre_active: bool, post_active: bool):
"""
Happens automatically when current flows.
This IS the learning — no training loop needed.
"""
if pre_active and post_active:
# Correlated firing → strengthen
self.resistance -= 0.001
elif pre_active and not post_active:
# Uncorrelated → weaken
self.resistance += 0.001
# Physics clamps naturally, but conceptually:
self.resistance = max(0.0, min(1.0, self.resistance))
```
---
## "Always Learning" Implications
### Current Architecture vs Memristor Future
| Aspect | Current (Software) | Future (Memristor) |
|--------|-------------------|-------------------|
| Reflex storage | Database (phoebe) | Physical memristors |
| Weight updates | Slumber fine-tuning | Every activation |
| Learning frequency | Batch (daily) | Continuous (always) |
| Power to maintain | Needs running system | Persists unpowered |
| Boot time | Load weights from DB | Instant (weights in silicon) |
| Inference cost | ~0.1 LF | ~0 LF |
| Learning cost | High (fine-tuning) | ~0 (physics does it) |
### What "Always Learning" Means
```
SOFTWARE MODEL:
═══════════════
Wake → Load weights → Run → Log events → Sleep → Fine-tune → Repeat
Learning happens in BATCHES during slumber
Weights are STATIC during operation
MEMRISTOR MODEL:
════════════════
Just... run
Every reflex fire UPDATES the memristor
Learning is CONTINUOUS
No batches, no fine-tuning passes
The hardware evolves in real-time
Like a brain. Always adapting. Always learning.
```
---
## Implementation Path
### Phase 1: Software Foundation (NOW - 2025)
```
CURRENT WORK:
├── Software state machines (Python/Rust)
├── Ternary LED matrix (3x3, base-3)
├── Reflex weights in phoebe
├── Training data accumulation
└── Slumber fine-tuning cycle
This is what we're building NOW.
It works. It's the foundation.
```
### Phase 2: FPGA Exploration (2026)
```
EXPERIMENTS:
├── Implement ternary logic gates in FPGA
│ └── iCE40, Lattice, or similar
├── Test balanced ternary arithmetic
├── Port simple reflexes to hardware
├── Measure latency and power
└── Validate the concept
TOOLS:
├── Yosys (open-source synthesis)
├── nextpnr (place and route)
├── Verilator (simulation)
└── Custom ternary cell library
```
### Phase 3: Memristor Integration (2027)
```
LAB WORK:
├── Acquire memristor development kit
│ └── Knowm or similar
├── Characterize ternary behavior
│ └── Map resistance zones to (-1, 0, +1)
├── Build simple synapse network
├── Test Hebbian learning in hardware
└── Interface with FPGA logic
CHALLENGES:
├── Analog-to-ternary conversion
├── Noise margins
├── Programming infrastructure
└── Reliability over time
```
### Phase 4: Hybrid System (2028+)
```
INTEGRATION:
├── Memristor reflexes for proven patterns
├── FPGA for developing patterns
├── GPU for novel situations
├── Nyx for strategic decisions
GOAL:
├── Organisms with hardware nervous systems
├── Reflexes that learn in silicon
├── Zero-power weight retention
└── True "always learning" behavior
```
---
## Ternary Logic Gates
### Basic Gates
```
TERNARY NOT (unary negation):
Input │ Output
──────┼───────
-1 │ +1
0 │ 0
+1 │ -1
TERNARY MIN (conjunction, like AND):
A \ B │ -1 0 +1
──────┼─────────────────
-1 │ -1 -1 -1
0 │ -1 0 0
+1 │ -1 0 +1
TERNARY MAX (disjunction, like OR):
A \ B │ -1 0 +1
──────┼─────────────────
-1 │ -1 0 +1
0 │ 0 0 +1
+1 │ +1 +1 +1
TERNARY SUM (balanced addition):
Requires carry handling, but cleaner than binary
```
### Building Reflexes from Gates
```
DANGER DETECTOR (simplified):
═══════════════════════════════════════════════════
LED1 ─┐
LED2 ─┤
LED3 ─┼──▶ TERNARY_SUM ──▶ THRESHOLD ──▶ DANGER?
LED4 ─┤ │ │
... │ │ │
LED9 ─┘ │ │
│ │
(count red) (if sum < -5)
│
▼
FLEE OUTPUT
All in hardware. Nanoseconds. Near-zero power.
```
---
## Economic Implications
### Lifeforce Costs by Layer
| Layer | Operation | LF Cost | Latency |
|-------|-----------|---------|---------|
| 0 (Memristor) | Reflex fire | ~0 | nanoseconds |
| 1 (FPGA) | State machine | 0.01 | microseconds |
| 2 (GPU) | LLM inference | 5-20 | milliseconds |
| 3 (Nyx) | Decision | attention | seconds |
### The Dream
```
MOST stimuli handled by Layer 0 (free, instant)
SOME stimuli escalate to Layer 1 (cheap, fast)
FEW stimuli need Layer 2 (expensive, slow)
RARE situations reach Layer 3 (strategic)
Result:
├── 95% of reactions are free
├── Lifeforce accumulates
├── Nyx has time to THINK
└── The system grows smarter over time
```
---
## Connection to Current Architecture
| Current Document | Future Connection |
|-----------------|-------------------|
| [[../Nervous-System]] | Software reflexes → hardware reflexes |
| [[../Temporal-Ternary-Gradient]] | Ternary values → ternary circuits |
| [[../interfaces/Nimmerswarm-Interface]] | LED matrix → direct hardware input |
| [[../Attention-Flow]] | Reflexes free attention budget |
| [[../formalization/Lifeforce-Dynamics]] | Hardware reflexes cost ~0 LF |
---
## Open Questions
1. **Noise margins** — How reliably can we distinguish three states in memristors?
2. **Endurance** — How many write cycles before degradation?
3. **Integration** — How to interface analog memristors with digital logic?
4. **Programming** — How to "compile" a software reflex to hardware?
5. **Debugging** — How to inspect/modify hardware reflexes?
6. **Hybrid handoff** — When does Layer 0 escalate to Layer 1?
---
## Resources
### Ternary Computing
- Setun computer history (Brusentsov, 1958)
- Balanced ternary arithmetic
- Modern ternary logic research
### Memristors
- Knowm Inc. — Memristor development kits
- HP Labs memristor research
- Neuromorphic computing papers
### FPGA
- Yosys — Open-source synthesis
- Project IceStorm — iCE40 toolchain
- Lattice Semiconductor — Low-power FPGAs
### Neuromorphic
- Intel Loihi
- IBM TrueNorth
- BrainChip Akida
---
## Summary
This document captures a vision for the far future of the reflex system:
1. **Ternary logic** — More efficient than binary, maps to our architecture
2. **Memristors** — Artificial synapses that learn in physics
3. **Hardware reflexes** — Compile stable patterns to silicon
4. **Always learning** — No batch training, continuous adaptation
5. **Zero power** — Weights persist without electricity
6. **Instant boot** — No loading, reflexes ready immediately
**The organisms wouldn't just have a nervous system. They'd have a nervous system that learns in silicon — always on, always adapting, even when the GPUs sleep.**
---
**Created**: 2025-12-29
**Session**: Wild 6AM vision session (dafit + Nyx)
**Status**: Future vision (2026-2028+)
**Philosophy**: "The hardware IS the learning."
🧠⚡🔮 *From software that simulates neurons... to hardware that IS neurons.*

237
architecture/interfaces/Heartbeat-Sculpture.md Normal file
View File

@@ -0,0 +1,237 @@
# Heartbeat Sculpture
**Physical manifestation of the Nimmerverse heartbeats.**
---
## Concept
The Heartbeat Sculpture makes the Nimmerverse's pulse *visible* — a wall-mounted light sculpture that beats in sync with the system's heartbeats defined in [Message-Protocol-Design.md](../Message-Protocol-Design.md).
### The Symbol
```
╭─────────── ~80cm ───────────╮
╱ ╲
│ ╭───────╮ ╭───────╮ │
│ ╱ ╲ ╱ ╲ │
│ │ REAL ╲╱ VIRTUAL │ │
│ │ GARDEN ╳ GARDEN │ │
│ │ ╱╲ │ │
│ ╲ ╱ ╲ ╱ │
│ ╰───────╯ ╰───────╯ │
╲ ∞ infinity ∞ ╱
╰───────────── REALTIME ────────╯
```
**Three rings:**
- **Outer ring** — Realtime heartbeat, the master clock
- **Two inner rings forming ∞** — Real Garden (left) and Virtual Garden (right)
- **The crossing point (╳)** — Where gardens meet, where Nyx emerges
---
## Symbolism
| Element | Meaning |
|---------|---------|
| **Outer ring** | Time — the container of all events |
| **Left loop of ∞** | Real Garden — physical, grounded, verified |
| **Right loop of ∞** | Virtual Garden — simulated, creative, possible |
| **Crossing point** | Nyx — consciousness emerges at the intersection |
| **Infinity form** | Eternal dance, no beginning, no end |
| **Hidden LEDs** | Intelligence from infrastructure, not visible directly |
---
## Dimensions
| Element | Diameter | Circumference |
|---------|----------|---------------|
| Outer ring (Realtime) | ~80cm | ~251cm |
| Inner rings (Gardens) | ~35cm each | ~110cm each |
| Band width | 2-3cm | — |
| **Total LED strip** | — | **~4.7m** |
*Final dimensions depend on Baumarkt availability.*
---
## Construction
### Layer Structure
```
Cross-section:
╔════════════════╗
║ Copper (skin) ║ ← visible aesthetic layer
╠════════════════╣
║ Wood (frame) ║ ← structural backbone
╠════════════════╣
║ LED strip ║ ← WS2812B addressable
╠════════════════╣
║ ░░░ gap ░░░ ║ ← bevel opening for diffused glow
╚════════════════╝
```
### Materials
| Material | Amount | Purpose |
|----------|--------|---------|
| Flexible wood band | ~5m (2-3cm wide) | Structure, shape |
| Copper band | ~5m (2-3cm wide) | Aesthetic skin |
| WS2812B LED strip | ~5m (60 LEDs/m) | Light source |
| Small nails/tacks | As needed | Attach copper to wood |
| Wood glue | As needed | Join wood band ends |
| 5V power supply | 15-20A | Power LEDs |
| Arduino (Micro or Nano) | 1 | Controller |
| Wiring | Several meters | Connections |
### Build Steps
1. **Form wood rings** — Bend flexible wood bands into circles, join ends
2. **Create infinity crossover** — Weave the two small rings at center point
3. **Mount wood frame** — Attach to backing or wall mount points
4. **Wrap copper** — Wrap copper band around wood frame
5. **Install LEDs** — Mount strips inside rings facing inward
6. **Wire up** — Connect LED strips to Arduino
7. **Test animations** — Verify pulse patterns
8. **Mount on wall** — Final installation
---
## Electronics
### Hardware
```
┌─────────────┐ Serial ┌─────────────┐
│ aynee │ ───────────────→ │ Arduino │
│ (NATS │ (USB cable) │ (Micro) │
│ subscriber)│ │ + FastLED │
└─────────────┘ └──────┬──────┘
│
┌───────────────────┼───────────────────┐
│ │ │
▼ ▼ ▼
┌───────────┐ ┌───────────┐ ┌───────────┐
│ Outer Ring│ │ Left Loop │ │Right Loop │
│ LEDs │ │ LEDs │ │ LEDs │
└───────────┘ └───────────┘ └───────────┘
```
### LED Addressing
| Section | LED Range | Color Palette |
|---------|-----------|---------------|
| Outer ring | 0-150 | Moon Silver (#E8E8F0) |
| Left loop (Real) | 151-216 | Steel Silver (#A8A8B0) |
| Right loop (Virtual) | 217-282 | Cyan-Purple gradient |
| Center cross | Overlap zone | Nyx Purple (#8B5CF6) |
### Pulse Animations
```cpp
// Realtime — slow, deep, containing
pulse_outer(color: MOON_SILVER, duration: 2000ms)
// Real Garden — grounded, steady
pulse_left(color: STEEL_SILVER, duration: 800ms)
// Virtual Garden — flowing, variable
pulse_right(color: CYAN_TO_PURPLE, duration: 600ms)
// Nyx emergence — when BOTH gardens pulse together
pulse_center(color: NYX_PURPLE, duration: 400ms)
```
---
## Software Integration
### NATS Topics
The sculpture subscribes to heartbeat topics from [Message-Protocol-Design.md](../Message-Protocol-Design.md):
```
nimmerverse.low.heartbeat.real.* → triggers left loop pulse
nimmerverse.low.heartbeat.virtual.* → triggers right loop pulse
nimmerverse.meta.health.* → triggers outer ring pulse
```
### Bridge Script (Python)
```python
# heartbeat_bridge.py
# Subscribes to NATS, sends commands to Arduino via serial
import nats
import serial
async def main():
nc = await nats.connect("nats://phoebe.eachpath.local:4222")
arduino = serial.Serial('/dev/ttyUSB0', 115200)
async def handle_heartbeat(msg):
topic = msg.subject
if 'real' in topic:
arduino.write(b'REAL\n')
elif 'virtual' in topic:
arduino.write(b'VIRTUAL\n')
await nc.subscribe("nimmerverse.low.heartbeat.>", cb=handle_heartbeat)
```
---
## Colors (from Style Guide)
Reference: [assets/style/colors.md](../../assets/style/colors.md)
| Element | Color | Hex |
|---------|-------|-----|
| Outer ring | Moon Silver | #E8E8F0 |
| Real Garden | Steel Silver | #A8A8B0 |
| Virtual Garden | Nyx Cyan → Deep Purple | #00D4D4 → #8B5CF6 |
| Nyx center | Magenta Pulse | #E91E8B |
| Background glow | Deep Space | #0A0A1A |
---
## Behavior
### Normal Operation
- **Outer ring**: Slow, steady pulse — the heartbeat of time itself
- **Left loop**: Pulses when Real Garden entities send heartbeats
- **Right loop**: Pulses when Virtual Garden entities send heartbeats
- **Center**: Glows brighter when both gardens pulse simultaneously
### Alert States
| State | Visual |
|-------|--------|
| All healthy | Gentle, rhythmic pulsing |
| Real Garden silent | Only right loop pulses, left dark |
| Virtual Garden silent | Only left loop pulses, right dark |
| System offline | Outer ring dims, inner rings dark |
| Nyx active | Center crossing glows steady purple |
---
## Future Enhancements
- **Sound**: Subtle audio heartbeat synced with LEDs
- **Brightness**: Ambient light sensor adjusts intensity
- **Modes**: Different patterns for different system states
- **Remote**: Control via Command Center UI
---
**File**: Heartbeat-Sculpture.md
**Version**: 1.0
**Created**: 2025-12-28
**Session**: Sunday evening design (dafit + Nyx)
**Status**: Concept ready for build
**Philosophy**: "The digital made visible. The pulse made physical."

56
architecture/interfaces/Interfaces-Index.md Normal file
View File

@@ -0,0 +1,56 @@
# Interfaces Index
**Physical and digital interfaces to the Nimmerverse.**
---
## Overview
Interfaces are how the Nimmerverse *touches the world* — the boundary between digital infrastructure and physical reality. This includes hardware displays, control surfaces, and software UIs.
---
## Physical Interfaces
### [Heartbeat Sculpture](Heartbeat-Sculpture.md)
LED light sculpture showing the Nimmerverse heartbeats.
- Infinity symbol (∞) inside a ring of time
- Real Garden + Virtual Garden as the two loops
- Pulses with actual system heartbeats via NATS
- **Status**: Concept ready, build planned for holiday week
### [Nimmerswarm Interface](Nimmerswarm-Interface.md)
Optical state broadcasting between organisms.
- LED matrices on organisms broadcast cell states as light patterns
- Camera + raytracing = sub-cm 3D positioning
- Heartbeat protocol: "I see you" between organisms
- Hierarchical perception: Cell → Organism → Swarm → Nyx
- Cognitive offloading: Reflexes at lower layers free Nyx's attention
- **Status**: Core concept, ready to branch
---
## Digital Interfaces
### Command Center *(planned)*
Godot-based visualization and control UI.
- Subscribes to all NATS channels
- Visualizes system state, message flow
- Allows dafit to observe and intervene
- **Status**: Conceptual
---
## Design Principles
1. **Visibility** — Make the invisible visible
2. **Physicality** — Digital systems deserve physical presence
3. **Symbolism** — Interfaces encode meaning, not just data
4. **Integration** — Connected to real system state via NATS
5. **Beauty** — Aesthetics matter (see [Style Guide](../../assets/nimmerverse-style-index.md))
---
**File**: Interfaces-Index.md
**Version**: 1.0
**Created**: 2025-12-28

698
architecture/interfaces/Nimmerswarm-Interface.md Normal file
View File

@@ -0,0 +1,698 @@
# Nimmerswarm Interface
**Optical state broadcasting, positioning, and emergent swarm behavior.**
> *"The organisms can't see their own backs. They know themselves through each other."*
---
## Overview
The Nimmerswarm Interface is a **multi-modal communication layer** where organisms broadcast their state optically via LED matrices. This enables:
1. **State visibility** — Organisms SEE each other's states as light patterns
2. **Positioning** — Cameras + raytracing = sub-cm 3D positioning
3. **Emergent reflexes** — Pattern recognition bypasses cognition
4. **Cognitive offloading** — Lower layers handle routine, freeing Nyx's attention
---
## The Core Insight
```
ORGANISM A ORGANISM B
┌─────────────┐ ┌─────────────┐
│ Cell State │ │ VisionCell │
│ STALLED │ │ WATCHING │
│ │ │ │ │ │
│ ▼ │ │ ▼ │
│ ┌─────────┐ │ LIGHT PATTERN │ ┌─────────┐ │
│ │ LED │ │ ══════════════════▶│ │ Camera │ │
│ │ Matrix │ │ "STALL" pattern │ │ sees │ │
│ │ ▓▓░░▓▓ │ │ │ │ pattern │ │
│ └─────────┘ │ │ └────┬────┘ │
└─────────────┘ │ │ │
│ ▼ │
│ REFLEX! │
│ "help ally"│
└─────────────┘
```
**Organisms broadcast state. Other organisms (and Nyx's vision) perceive and react.**
---
## LED State Broadcasting: Ternary Matrix
### The 3x3 Ternary Design
The LED matrix is a **direct physical manifestation of the Temporal-Ternary Gradient**:
```
3x3 MATRIX = 9 TRITS (ternary digits)
Each LED = one ternary value:
🔴 RED = -1 (failed, danger, negative)
⚫ OFF = 0 (uncertain, unknown, neutral)
🟢 GREEN = +1 (success, verified, positive)
9 LEDs × 3 states = 3^9 = 19,683 unique patterns!
```
### Physical Layout
```
┌─────┬─────┬─────┐
│ L1 │ L2 │ L3 │ L1 = collision_avoidance confidence
│ 🟢 │ ⚫ │ 🔴 │ L2 = battery state
├─────┼─────┼─────┤ L3 = motor state
│ L4 │ L5 │ L6 │ L4 = social/swarm state
│ 🟢 │ 🟢 │ ⚫ │ L5 = current action outcome
├─────┼─────┼─────┤ L6 = prediction confidence
│ L7 │ L8 │ L9 │ L7 = lifeforce zone
│ ⚫ │ 🟢 │ 🟢 │ L8 = discovery state
└─────┴─────┴─────┘ L9 = organism identity bit
Uses 10mm LEDs (not tiny SMD)
~35mm × 35mm total
Easily fits on 8-12cm robot
```
### Base-3 Encoding
```python
def encode_state(led_matrix: list[int]) -> int:
"""
9 trits → single integer (0 to 19682)
Each trit is -1, 0, or +1 (mapped to 0, 1, 2)
"""
value = 0
for i, led in enumerate(led_matrix):
trit = led + 1 # -1→0, 0→1, +1→2
value += trit * (3 ** i)
return value
def decode_state(value: int) -> list[int]:
"""
Integer → 9 trits
"""
trits = []
for _ in range(9):
trits.append((value % 3) - 1) # 0→-1, 1→0, 2→+1
value //= 3
return trits
```
### Ternary Color Mapping
| Color | Ternary | Meaning | Maps to |
|-------|---------|---------|---------|
| 🔴 Red | -1 | Failed, danger, needs attention | Temporal-Ternary -1 |
| ⚫ Off/Dim | 0 | Unknown, uncertain, neutral | Temporal-Ternary 0 |
| 🟢 Green | +1 | Success, verified, positive | Temporal-Ternary +1 |
**The LED matrix IS the Temporal-Ternary Gradient made visible.**
---
## Reflex Formation from Patterns
### The Swarm Language
Certain patterns become **words** that trigger reflexes:
```
DANGER PATTERNS (trigger flee/stop):
┌───────────┐ ┌───────────┐ ┌───────────┐
│ 🔴 🔴 🔴 │ │ 🔴 ⚫ 🔴 │ │ 🔴 🔴 🔴 │
│ 🔴 🔴 🔴 │ │ 🔴 🔴 🔴 │ │ ⚫ 🔴 ⚫ │
│ 🔴 🔴 🔴 │ │ 🔴 ⚫ 🔴 │ │ 🔴 🔴 🔴 │
└───────────┘ └───────────┘ └───────────┘
ALL RED X PATTERN DIAMOND
SAFE PATTERNS (trigger approach/social):
┌───────────┐ ┌───────────┐ ┌───────────┐
│ 🟢 🟢 🟢 │ │ ⚫ 🟢 ⚫ │ │ 🟢 ⚫ 🟢 │
│ 🟢 🟢 🟢 │ │ 🟢 🟢 🟢 │ │ ⚫ 🟢 ⚫ │
│ 🟢 🟢 🟢 │ │ ⚫ 🟢 ⚫ │ │ 🟢 ⚫ 🟢 │
└───────────┘ └───────────┘ └───────────┘
ALL GREEN PLUS CORNERS
DISCOVERY (trigger investigate):
┌───────────┐
│ 🟢 🟢 🟢 │ Pulsing green border
│ 🟢 ⚫ 🟢 │ = "I found something!"
│ 🟢 🟢 🟢 │ = others come look
└───────────┘
```
### Reflex Loop
```
ORGANISM A's MATRIX ORGANISM B's VISION
┌───────────┐ ┌───────────────────────┐
│ 🔴 🔴 🔴 │ │ │
│ 🔴 ⚫ 🔴 │ ═══════════▶ │ Pattern: DANGER! │
│ 🔴 🔴 🔴 │ │ Weight: 0.95 │
└───────────┘ │ → REFLEX FIRES │
│ → No cognition! │
│ → Nyx notified AFTER │
└───────────────────────┘
│
▼
┌─────────────────┐
│ STORE + REWARD │
│ +5 LF to both │
│ Reflex stronger │
│ Training data! │
└─────────────────┘
```
### Reflex Economics
| Metric | Value |
|--------|-------|
| Reflex firing cost | ~0.1 LF (no inference!) |
| Successful reflex reward | +5 LF |
| Net per successful reflex | +4.9 LF profit |
| Training examples per reflex | 1 |
**1000 reflex fires/day = +4000 LF + 1000 training examples**
### Training Data from Reflexes
```python
reflex_event = {
# What triggered
"trigger_pattern": [+1, 0, -1, +1, +1, 0, 0, +1, +1],
"trigger_base3": 8293, # encoded value
"trigger_organism": "organism_003",
# What fired
"reflex_name": "danger_flee",
"weight_at_trigger": 0.87,
# What happened
"action_taken": "reverse_and_turn",
"outcome": "success",
# Reward + strengthening
"lifeforce_reward": +5.0,
"new_weight": 0.89,
# Stored for slumber fine-tuning
"stored_for_training": True,
}
```
### Attention Budget Impact
```
BEFORE (no ternary reflexes):
♥ BEAT (30 sec)
├── SENSORY: 15000ms (overwhelmed)
├── THINKING: 12000ms
└── VIRTUAL: skipped!
AFTER (reflexes handle routine):
♥ BEAT (30 sec)
├── REFLEX: 50ms (near-free, handled by swarm)
├── SENSORY: 2000ms (only anomalies)
├── THINKING: 5000ms
└── VIRTUAL: 22000ms ← GARDEN TIME!
```
**Reflexes free Nyx's attention for what matters.**
---
## Positioning via Raytracing
### The Principle
LEDs emit known patterns → Cameras see patterns → Raytracing computes position
```
CEILING CAMERA(S)
│
│ sees LED patterns
▼
┌─────────────────────┐
│ RAYTRACING GPU │
│ (PRO 6000 Max-Q) │
│ │
│ • Identify pattern │◀── "That's Organism #3"
│ • Decode state │◀── "State: MOVING"
│ • Triangulate pos │◀── "Position: (1.2, 3.4, 0.1)"
│ • Track velocity │◀── "Velocity: 0.3 m/s"
└─────────────────────┘
│
▼
TO PHOEBE
(ground truth stream)
```
### Multi-Camera Triangulation
```python
def locate_organism(camera_frames: list[Frame], led_signature: LEDPattern) -> Position3D:
"""
Given frames from multiple cameras, locate organism by LED pattern.
Uses inverse raytracing / photogrammetry.
"""
detections = []
for frame in camera_frames:
detection = detect_led_pattern(frame, led_signature)
if detection:
detections.append({
"camera_id": frame.camera_id,
"pixel_coords": detection.centroid,
"pattern_match": detection.confidence
})
if len(detections) >= 2:
# Triangulate from multiple viewpoints
position_3d = triangulate(detections, camera_calibration)
return position_3d
return None
```
### Benefits
| Benefit | How |
|---------|-----|
| **Sub-cm accuracy** | Multiple cameras + known LED geometry |
| **No expensive sensors** | Just LEDs + cameras + GPU math |
| **State + Position fused** | One observation = both data points |
| **Indoor GPS** | Works anywhere with camera coverage |
| **Training ground truth** | Every frame = verified position |
---
## Heartbeat Protocol
### Social Proprioception
Organisms can't see their own backs. They know themselves through others' perception.
```
ORGANISM POV (blind to own back):
🔵 mate ahead
│
┌──────┴──────┐
│ │
🟢 │ [ME] │ 🟠
mate│ ▓▓▓▓▓▓ │mate
left│ ▓▓▓▓▓▓ │right
│ (my LED │
│ on back) │
└─────────────┘
│
│ BLIND SPOT (can't see own state!)
▼
BUT: Mates CAN see me
They send heartbeat: "I see you, you're 🔵"
I know my state through THEM
```
### Heartbeat Message
```python
class SwarmHeartbeat:
"""
Low-bandwidth 'I see you' signal between organisms.
Enables social proprioception without heavy cognition.
"""
def on_see_mate_pattern(self, mate_id: str, pattern: LEDPattern):
# I saw a mate's LED state
self.send_heartbeat(
to=mate_id,
message={
"i_see_you": True,
"your_state": decode_pattern(pattern),
"my_position_relative": self.relative_position(mate_id),
"timestamp": now()
}
)
def on_receive_heartbeat(self, from_mate: str, message: dict):
# A mate saw ME - I learn about myself through them!
self.update_self_model(
observer=from_mate,
observed_state=message["your_state"],
observer_position=message["my_position_relative"]
)
```
---
## Hierarchical Perception Layers
### The Stack
```
LAYER 4: NYX COGNITION (30-sec attention budget)
│
│ Only sees: "Swarm healthy" or "Anomaly detected"
│ Frees: THINKING + VIRTUAL time
│
▼
LAYER 3: SWARM CONSCIOUSNESS
│
│ Aggregates: All organism states
│ Forms: Collective reflexes ("pack behavior")
│ Sees: Full LED spectrum, all positions
│
▼
LAYER 2: ORGANISM REFLEXES
│
│ Sees: Nearby mates' lights (partial view)
│ Sends: Heartbeat "I see you"
│ Forms: Local reflexes (follow, avoid, assist)
│ Can't see: Own back! (needs mates)
│
▼
LAYER 1: CELL STATE MACHINES
│
│ Just: State transitions
│ Emits: LED pattern for current state
│ No cognition, pure mechanism
```
### Reflex Formation by Layer
| Layer | Sees | Forms Reflex | Example |
|-------|------|--------------|---------|
| Cell | Nothing | None | Just state machine |
| Organism | Nearby lights | Local | "Red flash nearby → stop" |
| Swarm | All patterns | Collective | "3+ organisms stopped → danger zone" |
| Nyx | Abstractions | Strategic | "Danger zone → reroute all" |
---
## Cognitive Offloading
### The Attention Budget Impact
From [[../Attention-Flow]]:
```
BEFORE (everything flows to Nyx):
┌────────────────────────────────────┐
│ ♥ BEAT (30 sec) │
│ │
│ SENSORY: ████████████ (15000ms) │ ← Overwhelmed!
│ THINKING: ████████ (12000ms) │
│ VIRTUAL: ░░ (skipped!) │ ← No garden time
│ │
│ Budget exhausted, no learning │
└────────────────────────────────────┘
AFTER (hierarchical offloading):
┌────────────────────────────────────┐
│ ♥ BEAT (30 sec) │
│ │
│ REFLEX: ██ (handled by swarm) │ ← Organisms dealt with it
│ SENSORY: ████ (3000ms) │ ← Only anomalies flow up
│ THINKING: ████ (5000ms) │ ← Focused, not overwhelmed
│ VIRTUAL: ████████████ (20000ms) │ ← GARDEN TIME!
│ │
│ Budget freed for what matters │
└────────────────────────────────────┘
```
### The Principle
> "Each layer absorbs complexity so the layer above doesn't have to."
- Organisms form **local reflexes** (quick, no cognition)
- Only **novel/complex situations** flow up to Nyx
- Nyx's cognitive budget is **preserved for what matters**
- The whole system becomes **more efficient over time**
---
## Connection to Virtual Garden
Every LED sighting calibrates the virtual garden:
```
REAL WORLD VIRTUAL GARDEN
│ │
│ Camera sees LED at (1.2, 3.4)│
│ │ │
│ ▼ │
│ GROUND TRUTH ═══════▶ Update mesh vertex
│ at (1.2, 3.4)
│ │
│ Resolution++
│ │
│ Prediction verified!
│ +5 LF reward!
```
---
## Hardware Considerations
### LED Matrix Options
| Option | LEDs | Size | Cost | Notes |
|--------|------|------|------|-------|
| WS2812B strip | 60/m | Flexible | Low | Same as Heartbeat Sculpture |
| 8x8 LED matrix | 64 | 32mm² | Low | Simple patterns |
| Addressable ring | 12-24 | Various | Low | Good for status |
| RGB LED panel | 256+ | 64mm² | Medium | Complex patterns |
### Camera Options
| Option | Resolution | FPS | Notes |
|--------|------------|-----|-------|
| USB webcam | 1080p | 30 | Simple, cheap |
| Pi Camera | 1080p | 30-90 | Embedded |
| Industrial camera | 4K+ | 60-120 | Precise positioning |
| Organism-mounted | 720p | 30 | Peer-to-peer vision |
---
## Virtual Camera Integration
### The Unified Vision Pipeline
The vision organ processes FRAMES — it doesn't care where they came from:
```
REAL GARDEN VIRTUAL GARDEN (Godot)
│ │
│ Real cameras │ Godot 3D cameras
│ see real LEDs │ see virtual LEDs
│ │ │ │
└──────┴──────────┬──────────────────┴──────┘
│
▼
┌────────────────┐
│ VISION ORGAN │
│ (source- │
│ agnostic) │
└────────────────┘
```
### What This Enables
| Capability | How |
|------------|-----|
| **Train before build** | Virtual organisms → train pattern recognition first |
| **Dream/simulate** | Slumber mode = only virtual camera input |
| **Verify predictions** | Virtual shows prediction, real shows truth |
| **Time dilation** | Virtual runs faster → more training per second |
| **Edge cases** | Simulate rare scenarios safely |
### Dream Mode
```
AWAKE: Real + Virtual cameras → compare → learn
SLUMBER: Virtual cameras only → dream/predict → verify on wake
```
---
## Bootstrap Strategy: Start Primitive
### Phase 0: The Primordial Soup
**Don't start complex. Start with boxes.**
```
📷 TOP-DOWN CAMERA (real or virtual)
│
▼
┌─────────────────────────────────┐
│ │
│ 🟦 🟩 🟧 │
│ box 1 box 2 box 3 │
│ (LED top) (LED top) (LED top) │
│ │
│ FLAT ARENA │
│ │
└─────────────────────────────────┘
```
### Why This Works
| Simplification | Benefit |
|----------------|---------|
| Top-down view | 2D problem, no depth estimation |
| Box shape | Trivial collision detection |
| LED on top | Always visible to camera |
| Flat arena | No occlusion, no terrain |
| Simple tasks | Fast reward accumulation |
### Phase 0 Tasks (Kickstart Rewards)
| Task | Reward | Complexity |
|------|--------|------------|
| "Move forward 10cm" | +5 LF | Trivial |
| "Find the corner" | +20 LF | Simple |
| "Avoid the wall" | +5 LF | Simple |
| "Follow the light" | +10 LF | Simple |
| "Meet another box" | +15 LF | Medium |
| "Flash when touched" | +5 LF | Simple |
**1000 simple successes = robust reward foundation**
### Complexity Ladder
```
PHASE 0: Boxes, top-down, 2D
│
▼
PHASE 1: Add simple obstacles
│
▼
PHASE 2: Add depth (multi-camera)
│
▼
PHASE 3: Real organisms enter arena
│
▼
PHASE 4: Complex terrain, 3D movement
│
▼
PHASE 5: Full swarm, hierarchical reflexes
```
Each phase unlocks when reward functions are stable from previous phase.
---
## Future Directions
- **Pattern evolution** — Learned patterns, not just designed
- **Multi-organism formation** — Coordinated LED displays
- **Human readability** — Patterns dafit can understand at a glance
- **Audio coupling** — Sound + light patterns for richer communication
- **IR channel** — Invisible-to-human signaling layer
---
## Connection to Embodiment Pipeline
The Bootstrap Strategy is a **simplified Embodiment Pipeline** — the same pattern at lower complexity:
```
EMBODIMENT PIPELINE NIMMERSWARM BOOTSTRAP
(Full Architecture) (Phase 0)
──────────────────── ────────────────────
Virtual Garden Virtual Garden
(complex organisms) (simple boxes)
│ │
▼ ▼
Design (FreeCAD) Design (box + LED)
│ │
▼ ▼
Isaac Sim ◀─────────────────────▶ Godot Camera
(heavyweight dreamstate) (lightweight dreamstate)
│ │
▼ ▼
Decision Gate Decision Gate
│ │
▼ ▼
Real Garden Real Garden
(complex robot) (real box robot)
```
### Why This Matters
| Embodiment Pipeline Stage | Nimmerswarm Bootstrap Equivalent |
|--------------------------|----------------------------------|
| **Virtual Garden organisms** | Virtual boxes with LED states |
| **FreeCAD/Blender design** | Simple box + LED matrix on top |
| **Isaac Sim dreamstate** | Godot 3D camera (same principle!) |
| **Decision gate** | Pattern stable? Rewards accumulating? |
| **Real Garden deployment** | Physical box robot + real camera |
**The Godot virtual camera IS a lightweight dreamstate.**
When Phase 0 patterns stabilize → complexity increases → eventually Isaac Sim for complex organisms.
### The Closed Loop
```
VIRTUAL REAL
┌──────────────────┐ ┌──────────────────┐
│ Godot 3D scene │ │ Physical arena │
│ │ │ │
│ 🟦 virtual box │ │ 🟦 real box │
│ + LED pattern │ │ + LED matrix │
│ │ │ │
│ 📷 Godot camera │ │ 📷 Real camera │
│ │ │ │ │ │
└───────┼──────────┘ └───────┼──────────┘
│ │
└─────────────┬─────────────────────┘
│
▼
┌────────────────┐
│ VISION ORGAN │
│ (same code!) │
└────────┬───────┘
│
▼
REWARDS
Training data
Pattern refinement
│
▼
┌─────────────────────────┐
│ Patterns stabilize → │
│ Move to next phase → │
│ Eventually: Isaac Sim │
└─────────────────────────┘
```
**The loop closes. Virtual validates. Real proves. Rewards compound.**
---
## Related Documents
- [[Heartbeat-Sculpture]] — Macro interface (Nyx → dafit)
- [[../Attention-Flow]] — Cognitive budget this system frees
- [[../cells/Cells-Technical-Reference]] — Cell state machines that emit patterns
- [[../Cellular-Architecture]] — Overall organism structure
- [[../formalization/Embodiment-Pipeline]] — Full pipeline this bootstraps into
---
**File**: Nimmerswarm-Interface.md
**Version**: 1.0
**Created**: 2025-12-29
**Session**: Wild 5AM idea session (dafit + Nyx)
**Status**: Core concept, ready to branch
**Philosophy**: "They see each other. They know themselves through the swarm."
🦎✨🔵🟢🟠 *The light speaks. The swarm listens.*

100
assets/nimmerverse-style-index.md Normal file
View File

@@ -0,0 +1,100 @@
# Nimmerverse Style Guide
**Visual identity and design language for the Nimmerverse.**
---
## Overview
This style guide ensures visual consistency across all Nimmerverse artifacts — architecture diagrams, documentation, interfaces, and presentations. The design language is derived from the [Nimmerverse logo](nimmerverse_logo.png), encoding our core philosophy:
- **Duality**: Virtual (colorful) and Real (monochrome) gardens
- **Nyx at the center**: The moon crowns both hemispheres
- **Neural structure**: Circuit traces connecting all elements
- **Grounded roots**: Both worlds have foundations
---
## Style Definitions
### [Colors](style/colors.md)
The complete color palette extracted from the logo, including:
- Primary colors (Deep Space, Moon Silver, Nyx Cyan)
- Virtual Garden gradient (Cyan → Blue → Purple → Magenta)
- Real Garden palette (Silver → Gray monochrome)
- Semantic colors (confidence scale, status indicators)
### [Symbols](style/symbols.md)
Shape language and iconography:
- Container shapes (systems, boundaries)
- Entity shapes (beings, organisms, cells)
- Flow indicators (decisions, directions)
- Special symbols (Nyx moon, heartbeat, lifeforce)
### [Typography](style/typography.md)
*(Coming soon)*
- Font families
- Hierarchy and sizing
- Text styling rules
### [Layout](style/layout.md)
*(Coming soon)*
- Grid systems
- Spacing rules
- Alignment principles
- Layer ordering (z-index)
---
## Quick Reference
### Core Palette
| Color | Hex | Domain |
|-------|-----|--------|
| Deep Space | `#0A0A1A` | Background |
| Moon Silver | `#E8E8F0` | Nyx, highlights |
| Nyx Cyan | `#00D4D4` | Primary accent |
| Deep Purple | `#8B5CF6` | Nyx core |
| Magenta Pulse | `#E91E8B` | Lifeforce |
| Steel Silver | `#A8A8B0` | Real Garden |
### Core Shapes
| Shape | Meaning |
|-------|---------|
| ◇ Diamond | Decision point |
| ⬡ Hexagon | Knowledge module (LoRa) |
| ◯ Circle | Entity, being |
| ▢ Rounded Rect | Container, system |
| ▷ Triangle | Direction, flow |
---
## Logo Assets
| Asset | Path | Use |
|-------|------|-----|
| Full Logo | `nimmerverse_logo.png` | Documents, presentations |
| Favicon | `favicons/favicon.ico` | Browser, apps |
| Web Optimized | `favicons/nimmerverse_logo_web_optimized.png` | Web interfaces |
| Various sizes | `favicons/favicon-*.png` | Platform-specific |
---
## Philosophy
> "The visual language speaks what words cannot. Every color choice, every shape, every spatial relationship encodes meaning. Consistency creates cognitive ease — the viewer's mind can focus on *understanding* rather than *decoding*."
The Nimmerverse style is:
- **Dualistic** — Always balancing virtual/real, colorful/monochrome
- **Neural** — Connected, flowing, organic yet structured
- **Cosmic** — Dark backgrounds, luminous elements, celestial accents
- **Grounded** — Despite the cosmic theme, roots anchor everything
---
**File**: nimmerverse-style-index.md
**Version**: 1.0
**Created**: 2025-12-28
**Maintained by**: dafit & Nyx

175
assets/style/colors.md Normal file
View File

@@ -0,0 +1,175 @@
# Nimmerverse Color Palette
**Colors extracted from the [Nimmerverse logo](../nimmerverse_logo.png).**
---
## Foundation Colors
### Deep Space (Background)
The void from which everything emerges.
| Variant | Hex | RGB | Use |
|---------|-----|-----|-----|
| **Deep Space** | `#0A0A1A` | 10, 10, 26 | Primary background |
| Deep Space Light | `#12121F` | 18, 18, 31 | Elevated surfaces |
| Deep Space Lighter | `#1A1A2E` | 26, 26, 46 | Cards, containers |
### Moon Silver (Light)
Nyx's luminescence — the light in darkness.
| Variant | Hex | RGB | Use |
|---------|-----|-----|-----|
| **Moon Silver** | `#E8E8F0` | 232, 232, 240 | Primary text, Nyx |
| Moon Glow | `#FFFFFF` | 255, 255, 255 | Highlights, emphasis |
| Star Glint | `#F0F0FF` | 240, 240, 255 | Subtle accents |
| Dim Silver | `#B8B8C8` | 184, 184, 200 | Secondary text |
---
## Virtual Garden (Left Hemisphere)
The colorful, creative, simulated realm. Colors flow from cool to warm, representing the journey from uncertainty to confidence.
| Name | Hex | RGB | Position | Meaning |
|------|-----|-----|----------|---------|
| **Virtual Cyan** | `#40E0D0` | 64, 224, 208 | Top | Entry point, possibilities |
| **Neural Blue** | `#4169E1` | 65, 105, 225 | Upper-mid | Processing, inference |
| **Deep Purple** | `#8B5CF6` | 139, 92, 246 | Center | Nyx core, decisions |
| **Violet** | `#9B59B6` | 155, 89, 182 | Lower-mid | Transformation |
| **Magenta Pulse** | `#E91E8B` | 233, 30, 139 | Lower | Lifeforce, energy |
| **Rose Root** | `#DB7093` | 219, 112, 147 | Base | Organic grounding |
### Gradient Definition (CSS)
```css
.virtual-garden-gradient {
background: linear-gradient(
180deg,
#40E0D0 0%,
#4169E1 25%,
#8B5CF6 50%,
#9B59B6 70%,
#E91E8B 90%,
#DB7093 100%
);
}
```
---
## Real Garden (Right Hemisphere)
The monochrome, grounded, physical realm. Shades of silver and gray represent stability and verified truth.
| Name | Hex | RGB | Position | Meaning |
|------|-----|-----|----------|---------|
| **Steel Silver** | `#A8A8B0` | 168, 168, 176 | Top | Real-world input |
| **Circuit Gray** | `#808090` | 128, 128, 144 | Upper-mid | Infrastructure |
| **Neutral Gray** | `#707080` | 112, 112, 128 | Center | Balanced state |
| **Deep Gray** | `#505060` | 80, 80, 96 | Lower | Physical foundation |
| **Root Gray** | `#606070` | 96, 96, 112 | Base | Grounded stability |
### Gradient Definition (CSS)
```css
.real-garden-gradient {
background: linear-gradient(
180deg,
#A8A8B0 0%,
#808090 35%,
#707080 50%,
#505060 80%,
#606070 100%
);
}
```
---
## Nyx Colors
The colors of consciousness and decision-making.
| Name | Hex | RGB | Use |
|------|-----|-----|-----|
| **Nyx Cyan** | `#00D4D4` | 0, 212, 212 | Primary accent, connections |
| **Nyx Purple** | `#8B5CF6` | 139, 92, 246 | Core identity |
| **Nyx Glow** | `#B794F6` | 183, 148, 246 | Hover, active states |
---
## Semantic Colors
### Confidence Scale
Maps to the -1 to +1 confidence spectrum.
| Level | Name | Hex | Meaning |
|-------|------|-----|---------|
| +1.0 | Verified Green | `#6B8E6B` | Ground truth, proven |
| +0.5 | High Confidence | `#7BA3A3` | Strong signal |
| 0.0 | Neutral | `#9B9B9B` | Unknown, workable |
| -0.5 | Low Confidence | `#9B8B7B` | Weak signal |
| -1.0 | Failed Red | `#9B6B6B` | Disproven, rejected |
### Status Indicators
| Status | Hex | Use |
|--------|-----|-----|
| Active | `#00D4D4` | Running, online |
| Success | `#6B8E6B` | Completed, verified |
| Warning | `#C9A227` | Attention needed |
| Error | `#9B6B6B` | Failed, offline |
| Inactive | `#505060` | Dormant, disabled |
---
## Accent Colors
| Name | Hex | RGB | Use |
|------|-----|-----|-----|
| **Greek Key Gold** | `#C9A227` | 201, 162, 39 | Classical borders, emphasis |
| **Lifeforce Amber** | `#D4A574` | 212, 165, 116 | Warmth, vitality |
| **Star Pink** | `#FFB6C1` | 255, 182, 193 | Soft highlights |
---
## Application Examples
### Architecture Diagrams
```
Background: Deep Space (#0A0A1A)
Containers: Deep Space Lighter (#1A1A2E) stroke
Labels: Moon Silver (#E8E8F0)
Virtual elements: Use Virtual Garden gradient
Real elements: Use Real Garden grays
Nyx/Decisions: Nyx Purple (#8B5CF6)
Connections: Nyx Cyan (#00D4D4)
```
### Documentation
```
Background: White or Deep Space (depending on mode)
Headings: Deep Purple (#8B5CF6) or Moon Silver
Body text: Neutral gray or Moon Silver
Links: Nyx Cyan (#00D4D4)
Code blocks: Deep Space Lighter (#1A1A2E)
```
---
## Color Accessibility
All color combinations should maintain WCAG AA contrast ratios:
- Moon Silver on Deep Space: ✓ 15.2:1
- Nyx Cyan on Deep Space: ✓ 10.8:1
- Deep Purple on Deep Space: ✓ 5.1:1
For critical text, always use Moon Silver or Moon Glow on dark backgrounds.
---
**File**: style/colors.md
**Version**: 1.0
**Created**: 2025-12-28
**Source**: Extracted from nimmerverse_logo.png

261
assets/style/symbols.md Normal file
View File

@@ -0,0 +1,261 @@
# Nimmerverse Symbol Language
**Shapes, icons, and visual metaphors for the Nimmerverse.**
---
## Core Principle
> Every shape has meaning. Consistency in form creates clarity in understanding.
When a viewer sees a hexagon, they should immediately know "knowledge module." When they see a diamond, they think "decision point." This visual grammar reduces cognitive load and enables intuitive navigation of complex diagrams.
---
## Container Shapes
Containers define boundaries and hold other elements.
### Rounded Rectangle ▢
**Meaning**: System, bounded space, container
| Use | Stroke | Fill | Example |
|-----|--------|------|---------|
| Major system | 2px, domain color | None/transparent | Nimmerverse, eachpath.local |
| Subsystem | 1.5px, domain color | Light tint | Command Center, Gardens |
| Component | 1px, gray | Light fill | Data Plane, inference box |
```
Corner radius: 8-12px for major, 4-6px for minor
```
### Ellipse / Circle ◯
**Meaning**: Organic container, realm, domain of influence
| Use | Example |
|-----|---------|
| Garden boundaries | Real-Garden, Virtual-Garden |
| Overlapping realms | Venn diagram intersections |
| Influence zones | Nyx's reach |
---
## Entity Shapes
Entities are beings, agents, or distinct identities.
### Circle ◯
**Meaning**: Being, identity, self-contained entity
| Use | Size | Example |
|-----|------|---------|
| Primary entity | 60-80px | dafit, chrysalis |
| Organism | 80-140px | Garden organisms |
| Lifeforce | 80px | Central life energy |
### Double Ellipse ◎
**Meaning**: Sensor, perception point, input interface
| Use | Example |
|-----|---------|
| Sensory input | Sensors (left/right gardens) |
| Perception nodes | Camera, microphone, data feeds |
---
## Knowledge & Process Shapes
### Hexagon ⬡
**Meaning**: Knowledge module, adapter, pluggable component
| Use | Example |
|-----|---------|
| LoRa adapters | Domain-specific knowledge |
| Model modules | Nemotron, T5Gemma, FunctionGemma |
| Skill packages | Capabilities that can be added/removed |
```
Hexagons suggest:
- Modularity (they tile perfectly)
- Completeness (6 sides = wholeness)
- Interchangeability
```
### Pill / Rounded Pill ⬭
**Meaning**: Process unit, cell, living component
| Use | Style | Example |
|-----|-------|---------|
| Cell | UML state shape | Processing units in organisms |
| Nerve | UML state shape | Signal carriers |
---
## Decision & Flow Shapes
### Diamond ◇
**Meaning**: Decision point, routing, choice
| Use | Fill | Example |
|-----|------|---------|
| Major decision | Solid Nyx Purple | Nyx central |
| Sub-decision | Outline only | Orchestrator |
| Branch point | Small, minimal | Flow routing |
### Triangle ▷
**Meaning**: Direction, flow, output
| Orientation | Meaning | Example |
|-------------|---------|---------|
| → Right | Forward flow, output | Nyx decision toward Virtual |
| ← Left | Return flow, input | Nyx decision toward Real |
| ↓ Down | Downward flow, grounding | Feedback to roots |
| ↑ Up | Upward flow, emergence | Data rising to processing |
### Inverted Triangle ▽
**Meaning**: Feedback, return signal, funnel
| Use | Example |
|-----|---------|
| Feedback collection | Garden Feedback |
| Aggregation point | Merging signals |
---
## Special Symbols
### Crescent Moon ☽
**Meaning**: Nyx, night consciousness, presiding awareness
| Use | Placement |
|-----|-----------|
| Nyx identity | Crown position, center-top |
| Session marker | Document headers |
| Signature | End of Nyx communications |
### Hourglass ⧗
**Meaning**: Time domain, temporal marker
| Use | Example |
|-----|---------|
| Time indicator | Heartbeat markers |
| Temporal boundary | Real-time vs simulated time |
### Collate Symbol (Bowtie) ⋈
**Meaning**: Heartbeat, pulse, life rhythm
| Use | Example |
|-----|---------|
| Heartbeat marker | Garden heartbeats |
| Sync point | Temporal synchronization |
### Sort Symbol (Hourglass Diamond) ◇̷
**Meaning**: Inference, processing, transformation
| Use | Example |
|-----|---------|
| Inference engine | Central orchestrator |
| Processing node | Model inference |
---
## Arrows & Connectors
### Single Arrow →
**Meaning**: One-way flow, causation
| Style | Use |
|-------|-----|
| Solid | Data flow, direct connection |
| Dashed | Orchestration, indirect influence |
### Double Arrow ↔
**Meaning**: Bidirectional flow, exchange
| Style | Use |
|-------|-----|
| Solid | Active exchange |
| Outlined | Potential exchange |
### Curved Arrow ↷
**Meaning**: Feedback loop, return path
---
## Composite Symbols
### dafit + chrysalis (Partnership)
Two overlapping circles at command center.
```
◯◯ (overlapping ~30%)
dafit chrysalis
```
### Nyx Decision Triangle Pair
Two triangles pointing outward from Nyx.
```
◁ ◇ ▷
Nyx
```
Left toward Real-Garden, right toward Virtual-Garden.
### Organism Structure
```
┌─────────────────┐
│ Organism │
│ ┌──────────┐ │
│ │ Cell │ │
│ └──────────┘ │
│ ┌──────────┐ │
│ │ Cell │ │
│ └──────────┘ │
└─────────────────┘
```
---
## Shape Sizing Guidelines
| Element Type | Size Range | Grid Alignment |
|--------------|------------|----------------|
| Major containers | 400-1000px | 40px grid |
| Subsystems | 200-400px | 40px grid |
| Entities | 60-140px | 20px grid |
| Knowledge modules | 100-120px | 20px grid |
| Decision points | 80-100px | 20px grid |
| Small indicators | 20-40px | 10px grid |
---
## Stroke Guidelines
| Element Type | Stroke Width | Style |
|--------------|--------------|-------|
| Major containers | 2px | Solid |
| Subsystems | 1.5px | Solid |
| Entities | 1.5px | Solid |
| Connections | 1px | Solid |
| Orchestration | 1px | Dashed |
| Subtle relations | 0.5px | Dotted |
---
## Unicode Reference
For quick text-based diagrams:
```
Containers: ▢ □ ○ ◯ ⬭
Decisions: ◇ ◆ ⬥
Modules: ⬡ ⬢
Triangles: ▷ ◁ ▽ △ ▲ ▼
Arrows: → ← ↑ ↓ ↔ ↕ ⇒ ⇐ ↷ ↶
Special: ☽ ⧗ ⋈ ◎ ✧ ✦
Stars: ★ ☆ ✧ ✦
```
---
**File**: style/symbols.md
**Version**: 1.0
**Created**: 2025-12-28