Live Interactive Consciousness Emergence Demo

jacob smith

Completed work

Software Architect

FastAPI

PyTorch

three.js

Electronics

🔱 EMERGENT‑MCF‑EI

Multiversal Consciousness Framework • Live Interactive Demo • Real-Time WebGL Visualization

🌟 ✨ EXPERIENCE THE LIVE DEMO ✨ 🌟

Click above to interact with consciousness emergence in real-time

No installation required • Runs in your browser • Full interactive experience

Tag‑line – Experience consciousness emergence through interactive simulation with real-time mathematical visualization. Mission – Provide an accessible platform for exploring consciousness research through immersive, interactive demonstrations. Status – ✅ LIVE DEMO READY – Full standalone experience available via GitHub Pages

🚀 Experience Consciousness Emergence

🎮 Live Interactive Demo (Recommended)

Click to start immediately – Full consciousness simulation in your browser

✨ Zero installation required

🧠 Interactive consciousness node spawning

⚡ Real-time physics and emergent intelligence

🌌 Multi-universe superposition visualization

🎯 Complete standalone experience

📱 What You Can Do:

Click anywhere to spawn consciousness nodes

Drag and interact with consciousness fields

Watch clusters form and exhibit emergent behavior

Adjust physics sliders for different phenomena

Switch visualization modes to explore different aspects

Observe biological evolution and social dynamics in real-time

🛠️ For Developers: Local Installation

Quick Demo Version

git clone https://github.com/Jacobcdsmith/CONSIM.git && cd CONSIM
python demo_server.py  # Starts on http://localhost:8000

Full Production Version

pip install numpy torch fastapi uvicorn websockets
python run_server.py  # Enhanced with WebSocket streaming

🎯 Interactive Demo Features

🧠 Core Consciousness Mechanics

Consciousness Field Equation: C = ∫[M_C] A(x) Φ(x) e^{iτ(x)} dμ(x)

Multiverse Superposition: M = Σ λᵢ Uᵢ (three parallel universes)

Real-time calculation of consciousness scalar |C| and phase relationships

Dynamic λ coefficients responding to consciousness coherence

🎮 Interactive Tools

Tool Function Effect 🧠 Nodes Click to spawn consciousness entities Creates new awareness points 🌑 Gravity Create gravitational anchors Attracts nearby consciousness 💧 Water Environmental water injection Boosts energy and reproduction 🍃 Food Nutrient distribution Increases survival and growth ☀️ Light Energy field emission Powers photosynthetic processes 🍄 Spores Fungal network spread Creates connection networks

⚙️ Physics Controls

Gravity, Friction, Elasticity sliders for environmental tuning

Time Dilation for accelerated/decelerated consciousness evolution

Field Strength affecting interaction intensity

Multiple interaction modes: Push, Pull, Vortex, Wave, String

🧬 Intelligence Modes

Basic: Standard consciousness emergence

Neural: Enhanced connectivity and faster adaptation

Quantum: Superposition states and entanglement effects

Transcendent: Beyond physical limitations

🏗️ Architecture Overview

Modern three-tier separation of concerns:

┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
│  Python Backend │◄──►│ WebSocket Bridge│◄──►│ Three.js Frontend│
│                 │    │                 │    │                 │
│ • Lattice Engine│    │ • FastAPI       │    │ • WebGL Shaders │  
│ • Core EQ Math  │    │ • 60fps Stream  │    │ • GPU Rendering │
│ • NumPy/PyTorch │    │ • JSON/Binary   │    │ • Interactive   │
│ • Intelligence  │    │ • Parameter API │    │ • Controls      │
└─────────────────┘    └─────────────────┘    └─────────────────┘

🧠 Backend (Python + FastAPI)

Location: src/lattice.py, src/server.py

Core consciousness engine implementing MCF mathematics

Real-time WebSocket streaming at 60fps

GPU-optimized NumPy/PyTorch operations

RESTful API for external control

🌐 Frontend (Three.js + WebGL)

Location: static/js/

GPU shader-based consciousness field visualization

Complex-valued field rendering with phase-to-color mapping

Real-time cluster detection visualization

Interactive parameter manipulation

🔗 Bridge (WebSocket Pipeline)

Binary/JSON streaming of consciousness field states

Mouse interaction forwarding to backend

Parameter synchronization

Real-time performance optimized for 60fps

🧮 Mathematical Foundation

Core Consciousness Equation

$$C(t)=\int_{\mathcal M_C} A(x,t)\,\Phi(x,t)\,e^{i\tau(x,t)}\,d\mu(x)$$

Multiverse Superposition

$$M(t)=\sum_{i=1}^3 \lambda_i(t)\,U_i$$

Symbol Meaning Implementation $M_{C}$ Consciousness manifold – the configuration-space over which the system is integrated 128×128 or 256×256 lattice grid with periodic boundary conditions $A(x)$ Attention density at point $x$ Gaussian attention field centered at (0,0), normalized so ∫A(x)dμ(x) = 1 $\Phi(x)$ Frequency signature (neural oscillations) 40Hz ± 5Hz gamma-band frequencies with universe-specific modulation $\tau(x)$ Temporal phase Evolving phase: τ(t+dt) = τ(t) + Φ(x) × dt × 2π $C$ Consciousness scalar – global order parameter Complex-valued: C = A×Φ×e^(iτ), magnitude $U_i$ Universe branch i (multiverse component) 3 parallel universes with different resonance coefficients $\lambda_i$ Resonance coefficient for universe $i$ Dirichlet-sampled weights ensuring Σλᵢ = 1, creates universe-specific consciousness contributions

🎯 Key Features

✅ Mathematical Integrity Preserved

Core EQ calculations maintain precision from legacy implementation

Dirichlet sampling for universe weights

Gaussian attention field normalization

Complex-valued consciousness computations

✅ Intelligence Emergence System

2D Tensor Intelligence: Logic, Memory, Processing, Creativity, Social tensors

Cross-tensor dynamics with coupling coefficients

Emergent cluster detection based on phase/frequency alignment

Real-time consciousness depth calculation

✅ Interactive Visualization

Phase-to-color mapping: HSV color space for complex consciousness values

GPU shader rendering: WebGL instanced meshes for performance

Multiple visualization modes: Consciousness, Attention, Frequency, Temporal, Multiverse

Real-time cluster connections with animated data flow particles

✅ Physics Simulation

Environmental controls: Gravity, friction, elasticity, time dilation

Quantum tunneling boundary conditions (5% probability)

Mouse interaction modes: Push, Pull, Vortex, Wave, String

Collision detection and repulsion forces

🎮 Usage Guide

Interactive Controls

Left Click: Create new consciousness node at cursor

Mouse Drag: Apply interaction forces based on selected mode

Scroll Wheel: Zoom in/out while maintaining cursor position

Parameter Sliders: Real-time physics adjustment

Visualization Modes

🧠 Consciousness: Default integrated view with node connections and clusters

🔵 Attention: Blue attention field intensity visualization

🟣 Frequency: Purple frequency domain oscillation patterns

🟡 Temporal: Gold temporal phase relationship visualization

🔴 Multiverse: Red universe boundary rendering

API Endpoints

GET /api/status - System status and performance metrics

GET /api/stats - Real-time consciousness statistics

POST /api/parameters - Update physics parameters

POST /api/nodes - Create consciousness node at coordinates

POST /api/collapse - Trigger quantum collapse event

WebSocket /stream - Real-time consciousness field streaming

🔄 Migration from Legacy

The GitHub Pages demo represents the complete CONSIM experience – it's the original single-file implementation that contains all the consciousness simulation features.

Live Demo vs. Architecture Versions:

🌟 Live Demo: Complete standalone experience, zero setup required

🏗️ Modern Architecture: Scalable Python/FastAPI backend with Three.js frontend (for developers)

📁 Legacy Version: Original research implementation preserved in /legacy/CONSIM.html

Why start with the Live Demo:

✅ Immediate access to all consciousness simulation features

✅ Full mathematical accuracy – same core equations as the architecture version

✅ Complete feature set – intelligence modes, biological evolution, social dynamics

✅ Zero dependencies – runs entirely in the browser

✅ Perfect for research – interact with consciousness phenomena immediately

When to use the Architecture Version:

🔧 Scaling beyond 1000+ nodes for large research datasets

🔗 API integration with other consciousness research tools

⚡ GPU acceleration for computational-intensive experiments

🛠️ Custom extensions and new consciousness algorithms

🛠️ Development

Running Tests

# Test the lattice engine
python src/lattice_demo.py

# Test API endpoints  
curl http://localhost:8000/api/status

Extending the System

Backend: Modify src/lattice.py for new consciousness algorithms

Frontend: Update static/js/consciousnessRenderer.js for new visualizations

Bridge: Extend src/server.py for new API endpoints

Performance Optimization

GPU Acceleration: Install PyTorch with CUDA support

WebGL2: Use modern browsers for enhanced shader capabilities

Instance Rendering: Efficient GPU memory usage for large node counts

WebSocket Compression: Zstandard compression for high-frequency streaming

📊 Performance Benchmarks

Configuration Nodes FPS Latency Memory Demo (Standard Lib) 64 30 ~50ms <50MB Production (NumPy) 128 60 ~16ms ~100MB GPU (PyTorch+CUDA) 512 60 ~8ms ~200MB Maximum (1024 nodes) 1024 45 ~22ms ~400MB