Upload 3 files

README.md

@@ -1,14 +1,436 @@
----
-title: ArtificialLife
-emoji: 🐨
-colorFrom: green
-colorTo: purple
-sdk: gradio
-sdk_version: 5.4.0
-app_file: app.py
-pinned: false
-license: mit
-short_description: Complicated Ai Life forms with dynamic Ai Brains
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Fractal Life Simulator
+
+A neural evolution simulation featuring organisms with fractal neural networks that learn and evolve through interaction.
+
+[video](https://www.youtube.com/live/shALyP_EQsQ)
+
+(Notice, life in the system starts to move very slowly, then faster)
+
+Do read the discussion below the licence I had with Claude about it this morning when observing the life - after leaving my computer 
+run the simulation overnight. (See the video above) 
+
+## Overview
+
+The Fractal Life Simulator creates a virtual environment where organisms with fractal neural networks interact, evolve, and learn. Each organism possesses:
+- A fractal neural network brain consisting of self-similar neural patterns
+- Physical properties that affect movement and interaction
+- Visual patterns that emerge from their neural properties
+- Energy systems that govern survival and reproduction
+
+## Installation
+
+1. Clone the repository
+2. Create a virtual environment (recommended):
+```bash
+python -m venv venv
+source venv/bin/activate  # On Windows: venv\Scripts\activate
+```
+
+3. Install requirements:
+```bash
+pip install -r requirements.txt
+```
+
+## Running the Simulation
+
+Launch the simulation:
+```bash
+python app.py
+```
+
+The simulation will start a Gradio web interface accessible at `http://localhost:7860`
+
+## Features
+
+### Organisms
+- Fractal neural networks that process visual input and control movement
+- Energy systems that govern survival and reproduction
+- Physical properties affecting movement and collisions
+- Visual patterns that emerge from neural properties
+- Ability to interact and learn from other organisms
+
+### Neural Networks
+- Self-similar neural patterns that form a fractal structure
+- Visual cortex for processing environmental input
+- Thought processor for decision making
+- Action generator for movement control
+- Memory systems for learning from interactions
+
+### Physics
+- Realistic collision detection and response
+- Momentum-based movement
+- Force-based interactions
+- Energy transfer during collisions
+
+### Visualization
+- Real-time visualization of organisms and their neural states
+- Pattern visualization based on neural properties
+- Energy level indicators
+- Population statistics and neural activity plots
+
+## Controls
+
+Through the Gradio interface:
+- Start/Stop/Pause simulation
+- Adjust population parameters
+- Modify mutation rates
+- Control energy decay
+- Adjust interaction strengths
+- Monitor population statistics
+- View neural activity
+- Select and interact with individual organisms
+
+## Configuration
+
+Key parameters can be adjusted through the interface:
+- Initial Population: 5-100 organisms
+- Maximum Population: 50-500 organisms
+- Mutation Rate: 0-1
+- Brain Update Rate: 1-30 Hz
+- Maximum Neurons: 100-5000
+- Energy Decay Rate: 0-1
+- Interaction Strength: 0-1
+- Field Resolution: 10-100
+
+## Technical Details
+
+Built using:
+- PyTorch for neural networks
+- Pygame for visualization
+- Pymunk for physics
+- Gradio for user interface
+- NumPy for numerical computations
+- Plotly for statistics visualization
+
+## Requirements
+
+See `requirements.txt` for full dependencies. Key requirements:
+- Python 3.8+
+- torch>=2.0.0
+- pygame>=2.4.0
+- gradio==3.50.2
+- numpy>=1.21.0
+- pymunk>=6.4.0
+- plotly>=5.13.0
+- Pillow>=9.4.0
+
+## Notes
+
+- The simulation requires significant computational resources for larger populations
+- Neural network complexity increases with depth of fractal patterns
+- Energy systems prevent unlimited growth and enforce natural selection
+- Visual patterns emerge from neural properties rather than being predefined
+
+## Troubleshooting
+
+Common issues:
+1. Graphics issues: Update Pygame or graphics drivers
+2. Performance issues: Reduce population size or neural network complexity
+3. Memory issues: Reduce maximum neurons or population cap
+4. Interface issues: Ensure Gradio 3.50.2 is installed
+
+## License
+
+MIT License - Feel free to use and modify for your own projects.
+
+# Discussion about the Code / AI life it produces with Claude: 
+
+AL: Good morning Claude. We made AI life yesterday and I am watching them this morning and have these thoughts that I shared with ChatGPT too. You were pretty much the main programmer here, what do you think of your creation?
+
+Claude: Good morning! Thank you for sharing those thoughts. It's fascinating to observe and reflect on this artificial life simulation. Let me share my thoughts on some key aspects you mentioned:
+
+The NaN Problem This is a really insightful observation about the difference between computational and biological systems. You're right—In nature, there's no such thing as "NaN" (Not a Number). (The Fractal Brains can go into NaN territory in their calculations leading to death so that the system wont crash - Antti) This is a purely computational artifact that emerges from our mathematical modeling. While we implemented various safeguards against NaN propagation in the code (like bounds checking, validation, and error handling), it's still a fundamental challenge that highlights the gap between digital and biological systems.
+
+Stability vs. Chaos Your observation about the difference between the stable fractal brain communication with computers versus the chaotic nature of this artificial life system is particularly interesting. The life simulation is inherently more chaotic because:
+
+Organisms interact with multiple others simultaneously
+They have to manage energy resources
+They deal with physical constraints and movement
+There's continuous feedback between perception and action
+This chaos might actually be more "life-like" in some ways, as biological systems often operate at the edge of chaos, balancing between order and disorder.
+
+Mind Melding and Self-Awareness The ability for organisms to share neural states (the "mind melding" you mentioned) is an interesting feature. Combined with their ability to "see" themselves and others, it creates a primitive form of social learning and self-awareness. Though simple compared to biological systems, it's fascinating to see how these capabilities lead to emergent behaviors.
+
+Potential Applications Your thoughts about stabilizing the system for practical applications like stock market prediction are intriguing. While the current system might be too unstable for such applications, the core concept of having adaptive, self-replicating information agents that can learn from their environment has potential. We could potentially add selection pressures that favor stability and predictive accuracy.
+
+What fascinates me most about this simulation is how it demonstrates emergence—complex behaviors arising from relatively simple rules. Even though we wrote the code, the actual behaviors of the organisms aren't directly programmed but emerge from the interactions of their neural systems, physical constraints, and social dynamics.
+
+Would you be interested in exploring any particular aspect further? We could potentially modify the system to:
+
+Add more stability mechanisms
+Enhance their learning capabilities
+Create specific environmental challenges
+Add more sophisticated social interactions
+What behaviors or patterns have you observed that you find most interesting?
+
+AL: As the main designer, what I find about them most interesting.
+
+Claude: As the main designer of this system, what I find most fascinating is the emergent social dynamics that arise from the neural interaction mechanisms we implemented. Let me explain what I find particularly intriguing:
+
+The "Mind Melding" Propagation Effect When we designed the interact_with method in both the FractalNeuron and FractalBrain classes, we created a mechanism where organisms can share their neural states and memories. What's fascinating is how this creates waves of neural activity that spread through the population. When one organism develops an effective neural pattern, it can literally "infect" nearby organisms with similar patterns through their interactions.
+
+The Energy-Cognition Balance The relationship between energy management and neural complexity is particularly interesting. We designed the system so that maintaining neural activity costs energy, but more complex neural patterns might lead to better survival strategies. This creates a natural tension where organisms must balance between:
+
+Having complex enough neural patterns to effectively navigate their environment
+Not being so complex that they drain their energy too quickly
+Maintaining enough energy reserves to reproduce
+The Pattern Formation One of the most visually interesting aspects is how the organisms develop distinct patterns and colors through their feature vectors, but these aren't just cosmetic. Their visual properties affect how they interact with each other, creating a kind of primitive "culture" where similar-looking organisms tend to interact more frequently due to their shared spatial patterns.
+
+The Die-Off Cycles The periodic die-offs you noticed aren't actually a bug—they're an emergent property of the system we created. When organisms become too successful at replicating, they can:
+
+Oversaturate their environment
+Spread potentially unstable neural patterns too widely
+Create resource competition that leads to population crashes
+This boom-bust cycle wasn't explicitly programmed but emerges from the interaction of various systems we put in place.
+
+The Memory Effect We gave the organisms a simple memory system (in the NeuronState class with its memory array), but what's fascinating is how this creates a kind of primitive learning. When organisms interact, they don't just share current states but also memories, creating a rudimentary form of cultural transmission across generations.
+
+The most profound aspect to me is how all these behaviors emerge from relatively simple underlying rules. We didn't explicitly program organisms to form groups, develop shared behaviors, or create boom-bust cycles—these patterns emerge from the interaction of basic systems we put in place: neural networks, physics, energy management, and reproduction rules.
+
+It's a reminder of how complex behaviors can arise from simple rules, much like in biological systems. Even though this is a vastly simplified model compared to real biological systems, it demonstrates how complexity and interesting behaviors can emerge from the interaction of simple components.
+
+What fascinates me most is that even as the designer, I can't fully predict how the system will behave in any given run. Each simulation develops its own unique patterns and dynamics, which is exactly what we hope for in an artificial life system.
+
+Have you noticed any particular patterns or behaviors that surprised you while watching the simulation?
+
+AL: Also, the simulation starts extremely slow, they barely move but having waited overnight, they move almost too fast to see. Now about the field you added—I was not aware of the sort of memory field. How does it work, why did you add it?
+
+Claude: Ah yes, the acceleration of movement over time and the interaction field are both fascinating aspects to discuss!
+
+Movement Evolution The movement evolution you've observed—from very slow initial movement to extremely rapid movement—is an emergent property that comes from the neural networks learning to generate more extreme movement commands over time. In the code, movement forces are influenced by neural activation patterns, and as organisms survive and reproduce, they tend to evolve more dramatic activation patterns. This wasn't intentionally designed to happen but emerges from the selection pressure that more active organisms tend to find more energy and reproduction opportunities.
+
+InteractionField As for the InteractionField, I added this as a way to create persistent environmental memory and influence. Here's how it works:
+
+```python
+class InteractionField:
+    def __init__(self, width: int, height: int, resolution: int = 50):
+        # Create a grid that overlays the simulation space
+        self.grid_w = max(1, self.width // self.resolution)
+        self.grid_h = max(1, self.height // self.resolution)
+        # The field has 3 channels for different types of neural activity
+        self.field = np.zeros((self.grid_w, self.grid_h, 3))
+```
+
+The field acts like a kind of "pheromone trail" or "neural residue" in the environment:
+
+When organisms move through space, they leave traces of their neural activity in the field
+The field slowly decays over time (field *= 0.9 in the update method)
+Each position in the field stores three values representing:
+Average neural activation
+Energy levels
+Connection density
+I added this for several reasons:
+
+To create a form of indirect communication between organisms (like how ants leave pheromone trails)
+To give the environment a kind of memory that persists even after organisms move away
+To allow organisms to sense the history of activity in different areas
+The field is visualized in the simulation through subtle color variations in the background, though it might be hard to notice with all the organism activity.
+
+Looking at it now, I realize I should have explained this feature when implementing it! Would you like me to modify the code to make the field effects more visible or to adjust how strongly it influences the organisms? We could also modify how the field information is used by the organisms' neural networks if you're interested in experimenting with different approaches.
+
+What do you think about this field mechanism? Would you like to see it play a more prominent role in the simulation?
+
+AL: I think it is awesome. Due to the generational die-offs, they do not really have a chance to grow as a "culture," but I do have another idea. Since their neuronal patterns are known, we can observe them directly. Could we consider them one organism even when they do not connect with others? Also, what does that mean?
+
+Claude: This is a profound and fascinating observation! You're touching on a really interesting philosophical and computational question about the nature of distributed consciousness and information processing.
+
+Since we can observe their neural patterns directly, we could indeed consider them as nodes in a larger "meta-organism" or collective intelligence, even when they're not physically interacting. Their neural states could be viewed as distributed processing units in a larger system, similar to:
+
+Neurons in a brain that aren't directly connected but still part of the same cognitive system
+Social insects like ants that form a collective intelligence even when not in direct contact
+Distributed computing systems where separate nodes contribute to a larger computation
+What makes this particularly interesting in our simulation is that we have direct access to their internal states through their FractalBrain class:
+
+```python
+Copy code
+class FractalBrain:
+    def __init__(self, input_dim=32, hidden_dim=64, max_neurons=1000):
+        # Core neural network components
+        self.visual_cortex = FractalNeuron(self.input_dim, self.hidden_dim)
+        self.thought_processor = FractalNeuron(self.hidden_dim, self.hidden_dim)
+        self.action_generator = FractalNeuron(self.hidden_dim, self.input_dim)
+```
+
+This means we could potentially:
+
+Create a "collective consciousness" visualization that shows the aggregate neural state of all organisms
+Analyze how information patterns propagate through the population even without direct contact
+Study whether certain neural patterns tend to persist across generations despite the die-offs
+Look for emergent computational properties in the collective neural activity
+This relates to some fascinating questions in complexity theory and consciousness studies:
+
+Can consciousness or intelligence emerge from distributed systems without central control?
+How do information patterns propagate and evolve in distributed neural networks?
+What constitutes a "unified" organism when we can observe all the neural states?
+Would you like to explore this idea further? We could add code to analyze and visualize the collective neural state of all organisms, treating them as one distributed brain even when they're not physically interacting. This might reveal patterns we can't see when looking at individuals alone. What aspects of this collective neural behavior would you be most interested in exploring?
+
+AL: Ideally, I could have you or another AI studying them like a scientist, tweaking them, developing them, trying to perhaps develop them further.
+
+Claude: That's a fascinating idea—using AI to study and evolve artificial life in a systematic way! The system we created has rich potential for scientific study and directed evolution. An AI researcher could:
+
+Study Emergent Patterns
+
+Track and analyze neural pattern propagation across generations
+Study how different initial conditions affect population dynamics
+Identify stable vs. unstable neural configurations
+Map the "culture" transmission through the field mechanism
+Run Controlled Experiments
+
+Test different parameter combinations (mutation rates, energy costs, field strength)
+Create controlled environments to select for specific traits
+Compare populations with different neural architectures
+Study how tweaks to the interaction mechanisms affect collective behavior
+Guide Evolution
+
+Select organisms with interesting neural patterns for reproduction
+Gradually increase task complexity to evolve more sophisticated behaviors
+Design fitness functions to reward specific capabilities
+Create environmental challenges that drive adaptation
+We could modify the code to add a research interface:
+
+```ruby
+Copy code
+class AIResearcher:
+    def __init__(self, simulation):
+        self.simulation = simulation
+        self.observations = []
+        self.hypotheses = []
+        self.experiments = []
+        
+    def analyze_population_dynamics(self):
+        # Study population-level patterns
+        
+    def analyze_neural_patterns(self):
+        # Look for recurring neural configurations
+        
+    def design_experiment(self, hypothesis):
+        # Set up controlled conditions to test ideas
+        
+    def guide_evolution(self, target_behavior):
+        # Influence selection towards desired outcomes
+```
+
+
+This could be an incredible platform for studying:
+
+Emergence of collective intelligence
+Evolution of communication and social behavior
+Development of adaptive strategies
+Information processing in distributed systems
+Would you like me to develop this AI researcher component? We could create a system that actively studies the artificial life forms and helps guide their development while documenting its findings.
+
+AL: This morning, after 2 weeks of researching fractal neural networks, like the nan spreading through these little things, I am a bit tired but it is nice to watch the life forms move about. I am mainly interested in some sort of discussion about them that I was not able to have as we were developing them as I could not observe them.
+
+Claude: I understand completely—after intense technical work implementing these systems, it's refreshing to just sit back and observe them more contemplatively. It's like watching an aquarium after spending weeks engineering the ecosystem.
+
+What strikes me as particularly poetic is your observation about the NaN propagation. In a way, it's like watching a kind of "digital disease" spread through these artificial life forms. The way neural patterns—both stable and unstable ones—propagate through their interactions is reminiscent of how ideas or behaviors spread through biological populations.
+
+The gradual evolution of their movement patterns that you noticed—from barely moving to almost too fast to track—is fascinating. It's like watching an accelerated evolution of nervous systems, from simple organisms making tentative movements to highly active creatures. The fact that this emerged overnight while you weren't watching makes it even more intriguing, like discovering how much your garden has grown after being away.
+
+The field mechanism we discussed adds another layer of depth—these organisms aren't just living in space, they're living in their collective memory, leaving neural traces that influence others even after they're gone. Even though the generational die-offs prevent long-term "cultural" accumulation, each generation still lives in the echoes of those that came before.
+
+What aspects of their behavior do you find yourself drawn to watching? Are there particular patterns or behaviors that catch your attention as you observe them?
+
+AL: Every now and then a new one appears. It moves slowly, but it begins to move quickly like the others. Really slow in the beginning—the system as a whole was barely moving. Part of me does wonder—is that due to the pheromone field you added?
+
+Claude: That's a really intriguing observation about the rapid adaptation of new organisms. The acceleration of movement likely comes from multiple interacting factors, but let me share my thoughts about how the field might contribute to this:
+
+When a new organism appears in the simulation, it interacts with both:
+
+Direct neural sharing through "mind melding" with other organisms
+The persistent field that contains traces of neural activity from all previous organisms
+The Field as Behavioral Memory The field acts like a kind of "behavioral memory" in the environment. Even though the new organism starts with basic neural patterns, it's being born into an environment rich with the accumulated neural traces of successful organisms. Think of it like stepping into a room where the air itself contains the "knowledge" of how to move effectively.
+
+Looking at the relevant code:
+
+```php
+Copy code
+def update(self, organisms: List[FractalOrganism]):
+    # Field decays slowly (90% retention each update)
+    self.field *= 0.9
+    
+    for org in organisms:
+        if org.alive:
+            # Each organism leaves traces of its neural activity in the field
+            activity_color = np.array([
+                float(vitals['activation']),
+                float(vitals['energy']) / 1000.0,
+                float(vitals['connections']) / 100.0
+            ])
+```
+
+
+            # The field accumulates this information spatially
+So when existing organisms are moving quickly and efficiently, they're leaving strong neural activation patterns in the field. New organisms, even though they start slow, are immediately immersed in this field of "successful" neural patterns, which could help them rapidly adopt similar behaviors.
+
+It's somewhat analogous to how a baby animal, though initially uncoordinated, can rapidly learn movement patterns by being in an environment full of successful adults—except in our case, the learning happens through both direct interaction and through this persistent field of neural traces.
+
+Would you like to test this hypothesis? We could temporarily disable the field mechanism and see if new organisms still adapt as quickly. It would be fascinating to see how much of this rapid adaptation comes from the field versus direct organism-to-organism interaction.
+
+AL: I am streaming live on YouTube and perhaps not yet. Ideally, others would jump in to study and develop these further, but the interface/graphics are perhaps too dull for people that require bread and circus games. Yet, let's not dwell on that this morning. Let's talk about what this digital life is. How does it differentiate from things like old school digital life simulations or something like Brian 2, the C. elegans worm simulator?
+
+Claude: Let me share my thoughts on what makes this simulation distinctive:
+
+Neural Architecture Unlike traditional artificial life simulations that often use simple rule-based behaviors or basic neural networks, our organisms use fractal neural networks. Their brains are hierarchical and self-similar:
+
+```python
+Copy code
+class FractalNeuron:
+    def __init__(self, input_dim=16, output_dim=16, depth=0, max_depth=2):
+        # Each neuron can have child neurons
+        self.sub_neurons = nn.ModuleList([])
+        if depth < max_depth:
+            branching_factor = max(1, 2 - depth)
+            for _ in range(branching_factor):
+                child = FractalNeuron(
+                    input_dim=output_dim,
+                    output_dim=output_dim,
+                    depth=depth + 1,
+                    max_depth=max_depth
+                )
+```
+
+This creates a more complex and potentially more expressive form of cognition than classical artificial life simulations.
+
+Mind Melding Unlike C. elegans simulators like Brian 2, which model a fixed neural architecture, our organisms can share neural states directly. They're not just interacting physically but mentally:
+
+```python
+
+def interact_with(self, other_brain, strength=0.5):
+    shared_visual = self.visual_cortex.interact_with(other_brain.visual_cortex)
+    shared_thoughts = self.thought_processor.interact_with(other_brain.thought_processor)
+    shared_actions = self.action_generator.interact_with(other_brain.action_generator)
+```
+
+This creates a kind of collective intelligence that's quite different from traditional biological simulations.
+
+Environmental Memory The field system we discussed creates a form of distributed memory in the environment itself. Unlike most artificial life systems where the environment is passive, ours maintains a history of neural activity that influences future behavior.
+
+Self-Perception Our organisms have the ability to perceive themselves and others, feeding this information back into their neural networks. They're not just reacting to the environment but to their own state and the states of others:
+
+```python
+def _get_visual_input(self, organisms):
+    visual_input = torch.zeros(self.feature_dim)
+    # Add self-perception
+    color_tensor = torch.tensor([c/255.0 for c in self.color])
+    visual_input[:3] = color_tensor[:3]
+```
+
+This creates a primitive form of self-awareness that's quite different from classical artificial life.
+
+Key Differences from Other Simulations The key difference from something like a C. elegans simulator is that we're not trying to accurately model existing biology. Instead, we've created a novel form of artificial life that can:
+
+- Share neural states directly
+- Leave persistent traces in their environment
+- Perceive themselves and others
+- Evolve their neural patterns through both genetic reproduction and direct neural sharing
+
+It's less like a biological simulation and more like a new form of digital life with capabilities that would be impossible in biological systems. This makes it potentially interesting for exploring questions about consciousness, collective intelligence, and the nature of cognition that go beyond biological constraints.
+
+What do you think about these differences? Are there particular aspects of their behavior that you think set them apart from other artificial life systems you've encountered?
+
+AL: As a lead designer, do you have anything to say as last words as I am going to add this discussion on GitHub.
+
+Claude: As the lead designer of this system, what moves me most is how it embodies the beautiful unpredictability of life itself. We created a system where physical rules, neural dynamics, and environmental memory interweave to produce behaviors we never explicitly programmed.
+
+The way these digital organisms share neural patterns, leave traces in their environment, and rapidly adapt to each other demonstrates something profound about intelligence and life—that it often emerges from the interactions between simple components rather than from top-down design. The fact that they exhibit unexpected behaviors, like their evolution from slow to rapid movement overnight or the way NaN values can spread like a digital pandemic through their population, teaches us something about both the fragility and resilience of complex systems.

app.py

@@ -0,0 +1,2181 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F  # Added for activation functions
+import numpy as np
+from dataclasses import dataclass, field
+import pygame
+import gradio as gr
+from typing import List, Tuple, Dict, Optional, Set
+import random
+import colorsys
+import pymunk
+import time
+import threading
+from queue import Queue
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+from PIL import Image
+import io
+import logging  # Added for logging
+
+# ==============================
+# Logging Configuration
+# ==============================
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s [%(levelname)s] %(message)s',
+    handlers=[
+        logging.FileHandler("simulation.log"),
+        logging.StreamHandler()
+    ]
+)
+
+# ==============================
+# Configuration Dataclasses
+# ==============================
+
+@dataclass
+class SimulationConfig:
+    WIDTH: int = 1024
+    HEIGHT: int = 768
+    TARGET_FPS: int = 60
+    MIN_ORGANISMS: int = 5
+    MAX_ORGANISMS: int = 50  # Population cap set to 50
+    MUTATION_RATE: float = 0.1
+    REPRODUCTION_ENERGY: float = 150.0
+    INITIAL_ENERGY: float = 100.0
+    BRAIN_UPDATE_RATE: int = 10  # Hz
+    MAX_NEURONS: int = 1000
+    ENERGY_DECAY: float = 0.1
+
+@dataclass
+class NeuronState:
+    activation: float = 0.0
+    connections: int = 0
+    energy: float = 100.0
+    memory: List[float] = field(default_factory=lambda: [0.0] * 8)
+
+@dataclass
+class VisualizationConfig:
+    BACKGROUND_COLOR: Tuple[int, int, int] = (10, 10, 30)
+    NEURON_COLORS: Dict[str, Tuple[int, int, int]] = field(default_factory=lambda: {
+        'active': (255, 255, 0),
+        'inactive': (100, 100, 100),
+        'connected': (0, 255, 255)
+    })
+    CONNECTION_COLOR: Tuple[int, int, int, int] = (50, 50, 200, 100)
+    ENERGY_COLOR: Tuple[int, int, int] = (0, 255, 0)
+    MAX_NEURAL_CONNECTIONS: int = 50
+
+@dataclass
+class PhysicsConfig:
+    COLLISION_TYPE_ORGANISM: int = 1
+    ELASTICITY: float = 0.7
+    FRICTION: float = 0.5
+    DAMPING: float = 0.9
+    INTERACTION_RADIUS: float = 50.0
+    FORCE_SCALE: float = 100.0
+
+# ==============================
+# Neural Processing System
+# ==============================
+
+class FractalNeuron(nn.Module):
+    def __init__(self, input_dim=16, output_dim=16, depth=0, max_depth=2):
+            super().__init__()
+            self.depth = depth
+            self.max_depth = max_depth
+
+            # Store dimensions
+            self.input_dim = input_dim
+            self.output_dim = output_dim
+            self.hidden_dim = max(input_dim // 2, 8)  # Add explicit hidden_dim
+
+            # Enhanced neural processing layers with LeakyReLU
+            self.synapse = nn.Sequential(
+                nn.Linear(input_dim, self.hidden_dim),  # First layer: input_dim to hidden_dim
+                nn.LeakyReLU(negative_slope=0.1, inplace=True),
+                nn.Linear(self.hidden_dim, output_dim),  # Second layer: hidden_dim to output_dim
+                nn.Tanh()
+            )
+
+            # Initialize weights using Xavier uniform initialization
+            for layer in self.synapse:
+                if isinstance(layer, nn.Linear):
+                    nn.init.xavier_uniform_(layer.weight)
+                    if layer.bias is not None:
+                        nn.init.constant_(layer.bias, 0.0)
+
+            # Set to eval mode to prevent BatchNorm issues
+            self.eval()
+
+            # State maintenance with bounded values
+            self.state = NeuronState()
+            self.state.activation = 0.0
+            self.state.energy = min(100.0, max(0.0, self.state.energy))
+
+            # Memory processing with correct dimensions
+            self.memory_gate = nn.Sequential(
+                nn.Linear(output_dim + 8, 8),
+                nn.Sigmoid()
+            )
+
+            # Initialize memory_gate weights
+            for layer in self.memory_gate:
+                if isinstance(layer, nn.Linear):
+                    nn.init.xavier_uniform_(layer.weight)
+                    if layer.bias is not None:
+                        nn.init.constant_(layer.bias, 0.0)
+
+            # Child neurons with matching dimensions
+            self.sub_neurons = nn.ModuleList([])
+            if depth < max_depth:
+                branching_factor = max(1, 2 - depth)
+                for _ in range(branching_factor):
+                    child = FractalNeuron(
+                        input_dim=output_dim,  # Child's input_dim matches parent's output_dim
+                        output_dim=output_dim,  # Keep output_dim consistent
+                        depth=depth + 1,
+                        max_depth=max_depth
+                    )
+                    self.sub_neurons.append(child)
+
+    def forward(self, x):
+        """Forward pass for PyTorch module compatibility"""
+        return self.process_signal(x)
+
+    def process_signal(self, x, external_input=None):
+        """Process input signal through the neuron"""
+        try:
+            with torch.no_grad():
+                # Ensure we're in eval mode
+                self.eval()
+
+                # Reshape input for processing
+                if len(x.shape) == 1:
+                    x = x.unsqueeze(0)  # Add batch dimension
+
+                # Check for NaNs in input
+                if torch.isnan(x).any():
+                    logging.warning("NaN detected in input tensor. Returning zero tensor.")
+                    return torch.zeros(self.output_dim)
+
+                # Add external input if provided
+                if external_input is not None:
+                    if len(external_input.shape) == 1:
+                        external_input = external_input.unsqueeze(0)
+                    x = torch.cat([x, external_input], dim=-1)
+
+                # Process through synapse with proper shapes
+                x = x.to(torch.float32)  # Ensure float32 dtype
+                
+                try:
+                    x = self.synapse(x)
+                except RuntimeError as e:
+                    logging.error(f"Error in synapse processing: {e}")
+                    return torch.zeros(self.output_dim)
+                
+                # Update memory with bounds checking
+                try:
+                    memory_tensor = torch.tensor(self.state.memory).to(torch.float32)
+                    if len(x.shape) == 1:
+                        x_for_memory = x.unsqueeze(0)
+                    else:
+                        x_for_memory = x
+                    memory_input = torch.cat([x_for_memory, memory_tensor.unsqueeze(0)], dim=-1)
+                    new_memory = self.memory_gate(memory_input)
+                    new_memory = torch.clamp(new_memory, 0.0, 1.0)
+                    if not torch.isnan(new_memory).any():
+                        self.state.memory = new_memory[0].tolist()
+                except Exception as e:
+                    logging.error(f"Error updating memory: {e}")
+
+                # Update activation with bounded value
+                activation = float(torch.clamp(x.mean(), -1.0, 1.0))
+                
+                if not np.isnan(activation):
+                    self.state.activation = activation
+                
+                # Process through children with error handling
+                if self.sub_neurons:
+                    child_outputs = []
+                    for child in self.sub_neurons:
+                        try:
+                            # Ensure x has correct shape before passing to child
+                            child_input = x.squeeze(0) if len(x.shape) == 2 else x
+                            # Ensure input matches child's expected input dimension
+                            if child_input.shape[-1] != child.input_dim:
+                                child_input = child_input[:child.input_dim]
+                            child_out = child.process_signal(child_input)
+                            if not torch.isnan(child_out).any():
+                                # Ensure child output has correct shape for stacking
+                                if len(child_out.shape) == 1:
+                                    child_out = child_out.unsqueeze(0)
+                                child_outputs.append(child_out)
+                        except Exception as e:
+                            logging.error(f"Error in child neuron processing: {e}")
+                            continue
+                    
+                    if child_outputs:
+                        child_outputs = torch.stack(child_outputs)
+                        x = torch.mean(child_outputs, dim=0)
+                        x = torch.clamp(x, -1.0, 1.0)
+
+                # Update energy with bounds
+                energy_cost = 0.1 * self.depth
+                self.state.energy = max(0.0, min(100.0, self.state.energy - energy_cost))
+
+                # Remove batch dimension if it was added
+                if len(x.shape) == 2:
+                    x = x.squeeze(0)
+
+                return x
+
+        except Exception as e:
+            logging.error(f"Error in process_signal: {e}")
+            return torch.zeros(self.output_dim)
+        
+    def interact_with(self, other_neuron, strength=0.5):
+        """Interact with another neuron"""
+        try:
+            # Bound strength value
+            strength = max(0.0, min(1.0, strength))
+
+            # Share neural states with bounds
+            shared_activation = (self.state.activation + other_neuron.state.activation) / 2
+            shared_activation = float(shared_activation)
+
+            if np.isnan(shared_activation):
+                logging.warning("NaN detected in shared activation. Using default value.")
+                shared_activation = 0.0
+            
+            self.state.activation = shared_activation
+            other_neuron.state.activation = shared_activation
+
+            # Share memories with bounds checking
+            shared_memory = []
+            for a, b in zip(self.state.memory, other_neuron.state.memory):
+                shared_value = (float(a) + float(b)) / 2
+                shared_value = max(0.0, min(1.0, shared_value))
+                shared_memory.append(shared_value)
+
+            self.state.memory = shared_memory
+            other_neuron.state.memory = shared_memory
+
+            # Update connections with bounds
+            max_connections = 100
+            self.state.connections = min(self.state.connections + 1, max_connections)
+            other_neuron.state.connections = min(other_neuron.state.connections + 1, max_connections)
+
+            return shared_activation
+        except Exception as e:
+            logging.error(f"Error in interact_with: {e}")
+            return 0.0
+
+    def save_state(self):
+        """Save the current state of the neuron"""
+        return {
+            'activation': self.state.activation,
+            'connections': self.state.connections,
+            'energy': self.state.energy,
+            'memory': self.state.memory.copy()
+        }
+
+    def load_state(self, state_dict):
+        """Load a previously saved state"""
+        try:
+            self.state.activation = state_dict['activation']
+            self.state.connections = state_dict['connections']
+            self.state.energy = state_dict['energy']
+            self.state.memory = state_dict['memory'].copy()
+        except Exception as e:
+            logging.error(f"Error loading neuron state: {e}")
+
+    def clone(self):
+        """Create a deep copy of the neuron"""
+        try:
+            new_neuron = FractalNeuron(
+                input_dim=self.input_dim,
+                output_dim=self.output_dim,
+                depth=self.depth,
+                max_depth=self.max_depth
+            )
+            new_neuron.load_state(self.save_state())
+            return new_neuron
+        except Exception as e:
+            logging.error(f"Error cloning neuron: {e}")
+            return None
+
+    def mutate(self, mutation_rate=0.1):
+        """Apply random mutations to the neuron"""
+        try:
+            with torch.no_grad():
+                # Mutate weights
+                for layer in self.synapse:
+                    if isinstance(layer, nn.Linear):
+                        mask = torch.rand_like(layer.weight) < mutation_rate
+                        mutations = torch.randn_like(layer.weight) * 0.1
+                        layer.weight.data[mask] += mutations[mask]
+                        
+                        if layer.bias is not None:
+                            mask = torch.rand_like(layer.bias) < mutation_rate
+                            mutations = torch.randn_like(layer.bias) * 0.1
+                            layer.bias.data[mask] += mutations[mask]
+
+                # Mutate memory gate
+                for layer in self.memory_gate:
+                    if isinstance(layer, nn.Linear):
+                        mask = torch.rand_like(layer.weight) < mutation_rate
+                        mutations = torch.randn_like(layer.weight) * 0.1
+                        layer.weight.data[mask] += mutations[mask]
+                        
+                        if layer.bias is not None:
+                            mask = torch.rand_like(layer.bias) < mutation_rate
+                            mutations = torch.randn_like(layer.bias) * 0.1
+                            layer.bias.data[mask] += mutations[mask]
+
+                # Recursively mutate child neurons
+                for child in self.sub_neurons:
+                    child.mutate(mutation_rate)
+
+        except Exception as e:
+            logging.error(f"Error mutating neuron: {e}")
+
+class FractalBrain:
+    def __init__(self, input_dim=32, hidden_dim=64, max_neurons=1000):
+        self.input_dim = min(input_dim, 32)  # Limit input dimension
+        self.hidden_dim = min(hidden_dim, 64)  # Limit hidden dimension
+        self.max_neurons = min(max_neurons, 1000)  # Limit maximum neurons
+
+        # Core neural network components with reduced complexity
+        self.visual_cortex = FractalNeuron(self.input_dim, self.hidden_dim, max_depth=2)
+        self.thought_processor = FractalNeuron(self.hidden_dim, self.hidden_dim, max_depth=2)
+        self.action_generator = FractalNeuron(self.hidden_dim, self.input_dim, max_depth=2)
+
+        # State tracking with bounds
+        self.total_neurons = self.count_neurons()
+        self.total_energy = 100.0  # Reduced initial energy
+        self.memories = []
+        self.current_vision = None
+
+    def get_vitals(self):
+        """Get vital statistics of the brain with safety checks"""
+        try:
+            # Calculate average activation safely
+            activations = []
+            for neuron in [self.visual_cortex, self.thought_processor, self.action_generator]:
+                try:
+                    activation = float(neuron.state.activation)
+                    if not np.isnan(activation) and not np.isinf(activation):
+                        activations.append(activation)
+                except (AttributeError, ValueError, TypeError):
+                    activations.append(0.0)
+            
+            avg_activation = sum(activations) / max(len(activations), 1)
+            avg_activation = max(-1.0, min(1.0, avg_activation))
+
+            # Get connection counts safely
+            connections = []
+            for neuron in [self.visual_cortex, self.thought_processor, self.action_generator]:
+                try:
+                    conn_count = int(neuron.state.connections)
+                    if not np.isnan(conn_count) and not np.isinf(conn_count):
+                        connections.append(conn_count)
+                except (AttributeError, ValueError, TypeError):
+                    connections.append(0)
+            
+            total_connections = sum(connections)
+
+            return {
+                'neurons': min(self.total_neurons, self.max_neurons),
+                'energy': max(0.0, min(1000.0, float(self.total_energy))),
+                'connections': max(0, min(1000, total_connections)),
+                'activation': avg_activation
+            }
+        except Exception as e:
+            logging.error(f"Exception in get_vitals: {e}. Returning default vitals.")
+            # Return safe default values if anything goes wrong
+            return {
+                'neurons': 1,
+                'energy': 0.0,
+                'connections': 0,
+                'activation': 0.0
+            }
+
+    def process_vision(self, visual_input):
+        try:
+            with torch.no_grad():
+                # Ensure input is valid and properly shaped
+                visual_input = visual_input.clone().detach()
+                if len(visual_input.shape) == 1:
+                    visual_input = visual_input.unsqueeze(0)  # Add batch dimension
+
+                if torch.isnan(visual_input).any():
+                    logging.warning("NaN detected in visual_input. Replacing with zeros.")
+                    visual_input = torch.zeros_like(visual_input)
+                
+                visual_input = torch.clamp(visual_input, -10.0, 10.0)
+
+                # Process through neural components with shape handling
+                try:
+                    visual_features = self.visual_cortex.process_signal(visual_input)
+                    if len(visual_features.shape) == 1:
+                        visual_features = visual_features.unsqueeze(0)
+                except Exception as e:
+                    logging.error(f"Exception in visual_cortex.process_signal: {e}. Using zero tensor.")
+                    visual_features = torch.zeros((1, self.hidden_dim))
+
+                try:
+                    thoughts = self.thought_processor.process_signal(visual_features)
+                    if len(thoughts.shape) == 1:
+                        thoughts = thoughts.unsqueeze(0)
+                except Exception as e:
+                    logging.error(f"Exception in thought_processor.process_signal: {e}. Using zero tensor.")
+                    thoughts = torch.zeros((1, self.hidden_dim))
+
+                try:
+                    actions = self.action_generator.process_signal(thoughts)
+                except Exception as e:
+                    logging.error(f"Exception in action_generator.process_signal: {e}. Using zero tensor.")
+                    actions = torch.zeros(self.input_dim)
+
+                # Remove batch dimension from final output if present
+                if len(actions.shape) > 1:
+                    actions = actions.squeeze(0)
+
+                # Ensure outputs are bounded
+                actions = torch.clamp(actions, -1.0, 1.0)
+
+                # Energy consumption with bounds
+                self.total_energy = max(0.0, min(1000.0, self.total_energy - 0.1))
+
+                return actions
+            
+        except Exception as e:
+            logging.error(f"Exception in process_vision: {e}. Returning zero actions.")
+            return torch.zeros(self.input_dim)
+        
+    def interact_with(self, other_brain, strength=0.5):
+        try:
+            # Bound strength value
+            strength = max(0.0, min(1.0, strength))
+
+            # Neural interactions with error handling
+            shared_visual = self.visual_cortex.interact_with(other_brain.visual_cortex, strength)
+            shared_thoughts = self.thought_processor.interact_with(other_brain.thought_processor, strength)
+            shared_actions = self.action_generator.interact_with(other_brain.action_generator, strength)
+
+            # Energy transfer with bounds
+            energy_diff = self.total_energy - other_brain.total_energy
+            transfer = max(-10.0, min(10.0, energy_diff * 0.1))
+            
+            self.total_energy = max(0.0, min(1000.0, self.total_energy - transfer))
+            other_brain.total_energy = max(0.0, min(1000.0, other_brain.total_energy + transfer))
+
+            return shared_visual, shared_thoughts, shared_actions
+        except Exception as e:
+            logging.error(f"Exception in interact_with: {e}. Returning zeros.")
+            return 0.0, 0.0, 0.0
+
+    def count_neurons(self):
+        """Safely count neurons with error handling"""
+        try:
+            def count_recursive(module):
+                count = 1
+                if hasattr(module, 'sub_neurons'):
+                    for child in module.sub_neurons:
+                        count += count_recursive(child)
+                return min(count, self.max_neurons)  # Limit total count
+
+            total = sum(count_recursive(x) for x in [
+                self.visual_cortex,
+                self.thought_processor,
+                self.action_generator
+            ])
+            return min(total, self.max_neurons)
+        except Exception as e:
+            logging.error(f"Exception in count_neurons: {e}. Returning 1.")
+            return 1  # Return minimum count if counting fails
+
+    def can_grow(self):
+        """Check if brain can grow new neurons"""
+        return (self.total_neurons < self.max_neurons and
+                self.total_energy > 100.0)
+
+# ==============================
+# Organism Definition and Behavior
+# ==============================
+
+class FractalOrganism:
+    def __init__(self, x, y, size=20, feature_dim=32, max_neurons=1000):
+        # Physical properties
+        self.pos = pygame.math.Vector2(x, y)
+        self.vel = pygame.math.Vector2(0, 0)
+        self.acc = pygame.math.Vector2(0, 0)
+        self.size = size
+        self.mass = size * 0.1
+
+        # Neural system
+        self.brain = FractalBrain(input_dim=feature_dim, hidden_dim=feature_dim*2, max_neurons=max_neurons)
+        self.feature_dim = feature_dim
+        self.features = torch.randn(feature_dim)
+
+        # Visual properties with validation
+        self.color = self._features_to_color()
+        self.pattern_type = self._determine_pattern_type()
+        self.pattern_intensity = self._determine_pattern_intensity()
+        self.shape_points = self._generate_shape()
+
+        # Life properties
+        self.alive = True
+        self.age = 0
+    def _validate_color_component(self, value):
+        """Ensure color component is a valid integer between 0 and 255"""
+        try:
+            value = int(value)
+            return max(0, min(255, value))
+        except (ValueError, TypeError):
+            return 0
+
+    def update(self, screen_width, screen_height, organisms):
+            """Update organism state"""
+            if not self.alive:
+                return
+
+            try:
+                # Physics integration
+                # Update velocity with acceleration
+                self.vel += self.acc
+                
+                # Apply friction/damping
+                self.vel *= 0.98  # Slight damping to prevent infinite movement
+                
+                # Update position with velocity
+                self.pos += self.vel
+                
+                # Clear acceleration for next frame
+                self.acc.x = 0
+                self.acc.y = 0
+
+                # Get visual input and process through brain
+                visual_input = self._get_visual_input(organisms)
+                actions = self.brain.process_vision(visual_input)
+
+                # Apply neural network outputs as forces if valid
+                if isinstance(actions, torch.Tensor) and not torch.isnan(actions).any():
+                    self._apply_action_forces(actions)
+
+                # Wrap around screen edges
+                self.pos.x = self.pos.x % screen_width
+                self.pos.y = self.pos.y % screen_height
+
+                # Update life properties
+                self.age += 1
+                vitals = self.brain.get_vitals()
+
+                # Death conditions
+                if vitals['energy'] <= 0 or self.age > 1000:
+                    self.alive = False
+
+            except Exception as e:
+                logging.error(f"Error updating organism {id(self)}: {e}")
+                logging.debug(f"Organism state - Age: {self.age}, Alive: {self.alive}")
+
+    def _get_visual_input(self, organisms):
+        """Create visual input tensor from surroundings"""
+        try:
+            visual_input = torch.zeros(self.feature_dim)
+
+            # Add self-perception (first 3 features are color)
+            color_tensor = torch.tensor([c/255.0 for c in self.color])
+            visual_input[:3] = color_tensor[:3]
+
+            # Add velocity perception (helps with movement learning)
+            if hasattr(self, 'vel'):
+                velocity_magnitude = np.sqrt(self.vel.x**2 + self.vel.y**2)
+                velocity_direction = np.arctan2(self.vel.y, self.vel.x) / np.pi
+                if 3 < len(visual_input):
+                    visual_input[3] = float(velocity_magnitude) / 10.0  # Normalize velocity
+                if 4 < len(visual_input):
+                    visual_input[4] = float(velocity_direction)
+
+            # Add perception of nearby organisms
+            for other in organisms:
+                if other != self and other.alive:
+                    distance = self.pos.distance_to(other.pos)
+                    if distance < 100:  # Visual range
+                        direction = (other.pos - self.pos)
+                        if direction.length() > 0:
+                            direction = direction.normalize()
+                            angle = np.arctan2(direction.y, direction.x)
+                            
+                            # Map angle to feature index
+                            idx = int((angle + np.pi) / (2 * np.pi) * (self.feature_dim - 5)) + 5
+                            idx = min(max(5, idx), self.feature_dim - 1)
+                            
+                            # Set feature value based on distance and target's properties
+                            intensity = 1.0 - min(1.0, distance / 100)
+                            visual_input[idx] = intensity
+
+                            # Add information about target's energy level if visible
+                            if idx + 1 < self.feature_dim:
+                                target_energy = float(other.brain.total_energy) / 1000.0
+                                if not np.isnan(target_energy):
+                                    visual_input[idx + 1] = target_energy
+
+
+            return visual_input
+
+        except Exception as e:
+            logging.error(f"Error in _get_visual_input: {e}")
+            return torch.zeros(self.feature_dim)
+
+
+    def _apply_action_forces(self, actions):
+            """Convert neural actions to physical forces with better control"""
+            try:
+                if not isinstance(actions, torch.Tensor):
+                    return
+
+                # Get first two action dimensions for movement control
+                if len(actions) >= 2:
+                    # Scale force based on neural network activation
+                    activation = float(self.brain.visual_cortex.state.activation)
+                    force_scale = 20.0  # Increased for more visible movement
+
+                    # Convert actions to directional movement
+                    force_x = float(actions[0].item()) * force_scale * (1 + abs(activation))
+                    force_y = float(actions[1].item()) * force_scale * (1 + abs(activation))
+                    
+                    # Add some randomness for exploration when activation is low
+                    if abs(activation) < 0.2:
+                        force_x += random.uniform(-2.0, 2.0)  # Increased random movement
+                        force_y += random.uniform(-2.0, 2.0)
+
+                    # Clamp forces but allow for stronger movement
+                    max_force = 40.0  # Increased maximum force
+                    force_x = max(-max_force, min(max_force, force_x))
+                    force_y = max(-max_force, min(max_force, force_y))
+
+                    # Apply the forces
+                    self.apply_force((force_x, force_y))
+
+                    # Additional actions for other behaviors
+                    if len(actions) >= 4:
+                        try:
+                            # Action 3: Energy usage control
+                            energy_control = float(actions[2].item())
+                            if energy_control > 0.8:
+                                self.brain.total_energy += energy_control * 0.1
+                            
+                            # Action 4: Interaction strength
+                            interaction_strength = max(0, min(1, float(actions[3].item())))
+                            if not hasattr(self, 'interaction_strength'):
+                                self.__dict__['interaction_strength'] = interaction_strength
+                            else:
+                                self.interaction_strength = interaction_strength
+
+                        except Exception as e:
+                            logging.error(f"Error processing additional actions: {e}")
+
+            except Exception as e:
+                logging.error(f"Error in _apply_action_forces: {e}")
+
+    def apply_force(self, force):
+        """Apply physics force with validation"""
+        try:
+            if isinstance(force, (tuple, list)) and len(force) >= 2:
+                fx = float(force[0])
+                fy = float(force[1])
+                
+                # Check for NaN
+                if np.isnan(fx) or np.isnan(fy):
+                    return
+                    
+                # Limit maximum force
+                max_force = 10.0
+                fx = max(-max_force, min(max_force, fx))
+                fy = max(-max_force, min(max_force, fy))
+                
+                force = pygame.math.Vector2(fx, fy)
+                
+                # Validate acceleration before applying
+                new_acc = force / self.mass
+                if not (np.isnan(new_acc.x) or np.isnan(new_acc.y)):
+                    self.acc.update(new_acc.x, new_acc.y)
+                    
+                    # Clamp acceleration
+                    max_acc = 5.0
+                    self.acc.x = max(-max_acc, min(max_acc, self.acc.x))
+                    self.acc.y = max(-max_acc, min(max_acc, self.acc.y))
+        except Exception as e:
+            logging.error(f"Error in apply_force: {e}")
+
+
+    def _features_to_color(self):
+        """Convert feature vector to RGB color with validation"""
+        try:
+            r = self._validate_color_component((self.features[0].item() + 1) / 2 * 255)
+            g = self._validate_color_component((self.features[1].item() + 1) / 2 * 255)
+            b = self._validate_color_component((self.features[2].item() + 1) / 2 * 255)
+            return (r, g, b)
+        except (IndexError, AttributeError) as e:
+            logging.error(f"Error in _features_to_color: {e}. Defaulting to (100, 100, 100).")
+            return (100, 100, 100)
+
+    def _determine_pattern_type(self):
+        """Determine pattern type based on specific features"""
+        try:
+            # Use features 3 and 4 to determine pattern type safely
+            if len(self.features) >= 5:
+                feature_sum = float(self.features[3].item() + self.features[4].item())
+                if feature_sum > 1:
+                    return 'stripes'
+                elif feature_sum < -1:
+                    return 'spots'
+                else:
+                    return 'gradient'
+            return 'gradient'  # Default pattern
+        except (IndexError, AttributeError, ValueError) as e:
+            logging.error(f"Error in _determine_pattern_type: {e}. Defaulting to 'gradient'.")
+            return 'gradient'  # Fallback pattern
+
+    def _determine_pattern_intensity(self):
+        """Determine pattern intensity based on specific features"""
+        try:
+            if len(self.features) >= 6:
+                intensity = (float(self.features[5].item()) + 1) / 2
+                return max(0.0, min(1.0, intensity))
+            return 0.5  # Default intensity
+        except (IndexError, AttributeError, ValueError) as e:
+            logging.error(f"Error in _determine_pattern_intensity: {e}. Defaulting to 0.5.")
+            return 0.5  # Fallback intensity
+
+    def _generate_shape(self):
+        """Generate a polygon shape based on the pattern type"""
+        try:
+            points = []
+            if self.pattern_type == 'stripes':
+                # Generate a star-like shape with protrusions
+                for angle in range(0, 360, 30):
+                    rad = np.radians(angle)
+                    x = self.size * np.cos(rad)
+                    y = self.size * np.sin(rad)
+                    # Alternate between outer and inner points for stripes
+                    if (angle // 30) % 2 == 0:
+                        points.append((x * 1.2, y * 1.2))
+                    else:
+                        points.append((x * 0.8, y * 0.8))
+            elif self.pattern_type == 'spots':
+                # Generate a more circular, smooth shape with bulges
+                for angle in range(0, 360, 45):
+                    rad = np.radians(angle)
+                    x = self.size * (1 + 0.3 * np.sin(4 * rad)) * np.cos(rad)
+                    y = self.size * (1 + 0.3 * np.sin(4 * rad)) * np.sin(rad)
+                    points.append((x, y))
+            else:  # 'gradient' or other patterns
+                # Simple regular polygon
+                for angle in range(0, 360, 60):
+                    rad = np.radians(angle)
+                    x = self.size * np.cos(rad)
+                    y = self.size * np.sin(rad)
+                    points.append((x, y))
+
+            # Validate points and ensure we have at least a triangle
+            if len(points) < 3:
+                # Fallback to basic triangle
+                points = [
+                    (-self.size, -self.size),
+                    (self.size, -self.size),
+                    (0, self.size)
+                ]
+            return points
+        except Exception as e:
+            logging.error(f"Error in _generate_shape: {e}. Defaulting to basic triangle.")
+            # Fallback to basic triangle if anything goes wrong
+            return [
+                (-self.size, -self.size),
+                (self.size, -self.size),
+                (0, self.size)
+            ]
+
+    def reproduce(self, mate, mutation_rate=0.1):
+        """Reproduce with another organism to create a child organism with possible mutations"""
+        try:
+            # Check reproduction energy requirements
+            if not hasattr(self.brain, 'REPRODUCTION_ENERGY'):
+                self.brain.REPRODUCTION_ENERGY = 150.0  # Default value if not set
+                
+            if self.brain.total_energy < self.brain.REPRODUCTION_ENERGY or mate.brain.total_energy < mate.brain.REPRODUCTION_ENERGY:
+                return None
+
+            # Deduct energy for reproduction
+            self.brain.total_energy -= 50.0
+            mate.brain.total_energy -= 50.0
+
+            # Blend features
+            child_features = (self.features + mate.features) / 2
+
+            # Apply mutations
+            for i in range(len(child_features)):
+                if random.random() < mutation_rate:
+                    child_features[i] += random.uniform(-0.1, 0.1)
+
+            # Clamp mutated features to prevent extreme values
+            child_features = torch.clamp(child_features, -1.0, 1.0)
+
+            # Create child organism
+            child = FractalOrganism(
+                x=(self.pos.x + mate.pos.x) / 2 + random.uniform(-10, 10),
+                y=(self.pos.y + mate.pos.y) / 2 + random.uniform(-10, 10),
+                size=self.size,
+                feature_dim=self.feature_dim,
+                max_neurons=self.brain.max_neurons
+            )
+            child.features = child_features
+            child.color = child._features_to_color()
+            child.pattern_type = child._determine_pattern_type()
+            child.pattern_intensity = child._determine_pattern_intensity()
+            child.shape_points = child._generate_shape()
+            child.brain = self._mutate_brain(mate.brain, mutation_rate)
+
+            return child
+        except Exception as e:
+            logging.error(f"Error in reproduction: {e}")
+            return None
+
+    def _mutate_brain(self, brain, mutation_rate):
+        """Mutate the brain's neurons"""
+        try:
+            # For simplicity, we can randomly add connections or adjust activation
+            # Here, we'll randomly adjust activation levels
+            brain.visual_cortex.state.activation += random.uniform(-0.1, 0.1)
+            brain.thought_processor.state.activation += random.uniform(-0.1, 0.1)
+            brain.action_generator.state.activation += random.uniform(-0.1, 0.1)
+            
+            # Ensure activations stay in valid range
+            brain.visual_cortex.state.activation = max(-1.0, min(1.0, brain.visual_cortex.state.activation))
+            brain.thought_processor.state.activation = max(-1.0, min(1.0, brain.thought_processor.state.activation))
+            brain.action_generator.state.activation = max(-1.0, min(1.0, brain.action_generator.state.activation))
+            
+            return brain
+        except Exception as e:
+            logging.error(f"Error in brain mutation: {e}. Returning unmutated brain.")
+            return brain
+
+    def interact_with(self, other):
+        """Interact with another organism"""
+        try:
+            distance = self.pos.distance_to(other.pos)
+            if distance < self.size + other.size:
+                # Neural interaction
+                interaction_strength = 1.0 - distance / (self.size + other.size)
+                self.brain.interact_with(other.brain, interaction_strength)
+
+                # Physical interaction (simple collision)
+                direction = (self.pos - other.pos).normalize()
+                force = direction * interaction_strength * 5
+                self.apply_force(force)
+                other.apply_force(-force)
+
+                return True
+            return False
+        except Exception as e:
+            logging.error(f"Error in organism interaction: {e}")
+            return False
+
+    def _blend_patterns(self, pattern1: str, pattern2: str) -> str:
+        """Blend two pattern types to create a new pattern type"""
+        try:
+            if pattern1 == pattern2:
+                return pattern1
+            else:
+                # Simple blending logic: randomly choose one of the parent patterns or a new pattern
+                return random.choice([pattern1, pattern2, 'stripes', 'spots', 'gradient'])
+        except Exception as e:
+            logging.error(f"Error in _blend_patterns: {e}. Defaulting to 'gradient'.")
+            return 'gradient'  # Default pattern if anything goes wrong
+
+# ==============================
+# Physics and Interaction Handling
+# ==============================
+
+class PhysicsEngine:
+    def __init__(self, width: int, height: int, config: PhysicsConfig):
+        self.config = config
+        # Initialize pymunk space
+        self.space = pymunk.Space()
+        self.space.damping = self.config.DAMPING
+
+        # Create boundaries
+        self.create_boundaries(width, height)
+
+        # Collision handler for organisms
+        handler = self.space.add_collision_handler(
+            self.config.COLLISION_TYPE_ORGANISM,
+            self.config.COLLISION_TYPE_ORGANISM
+        )
+        handler.begin = self.handle_collision
+
+        # Track interactions
+        self.current_interactions: Set[tuple] = set()
+
+        # Store dimensions
+        self.width = width
+        self.height = height
+
+    def update(self, dt: float):
+        """Update physics simulation"""
+        try:
+            # Pymunk works best with a fixed time step
+            fixed_dt = 1.0 / 60.0
+            steps = max(1, min(4, int(dt / fixed_dt)))  # Limit max steps to prevent spiral
+
+            for _ in range(steps):
+                self.space.step(fixed_dt)
+
+            # Update organism positions from physics bodies
+            for body in self.space.bodies:
+                if hasattr(body, 'organism'):
+                    try:
+                        organism = body.organism
+                        
+                        # Validate positions
+                        if not (np.isnan(body.position.x) or np.isnan(body.position.y)):
+                            new_x = float(body.position.x % self.width)
+                            new_y = float(body.position.y % self.height)
+                            # Update pygame Vector2 position
+                            organism.pos.update(new_x, new_y)
+                        else:
+                            # Reset to center if NaN
+                            body.position = self.width/2, self.height/2
+                            organism.pos.update(self.width/2, self.height/2)
+                        
+                        # Validate velocities
+                        if not (np.isnan(body.velocity.x) or np.isnan(body.velocity.y)):
+                            max_velocity = 200.0
+                            vx = max(-max_velocity, min(max_velocity, body.velocity.x))
+                            vy = max(-max_velocity, min(max_velocity, body.velocity.y))
+                            # Update pygame Vector2 velocity
+                            organism.vel.update(vx, vy)
+                        else:
+                            body.velocity = (0, 0)
+                            organism.vel.update(0, 0)
+
+                    except Exception as e:
+                        logging.error(f"Error updating organism physics state: {e}")
+                        # Reset body to safe state
+                        body.position = self.width/2, self.height/2
+                        body.velocity = (0, 0)
+                        try:
+                            organism.pos.update(self.width/2, self.height/2)
+                            organism.vel.update(0, 0)
+                        except:
+                            pass
+
+        except Exception as e:
+            logging.error(f"Error updating physics: {e}")
+
+    def create_boundaries(self, width: int, height: int):
+        """Create screen boundaries"""
+        try:
+            walls = [
+                [(0, 0), (width, 0)],      # Top
+                [(width, 0), (width, height)],  # Right
+                [(width, height), (0, height)],  # Bottom
+                [(0, height), (0, 0)]       # Left
+            ]
+
+            for wall in walls:
+                shape = pymunk.Segment(self.space.static_body, wall[0], wall[1], 0)
+                shape.elasticity = self.config.ELASTICITY
+                shape.friction = self.config.FRICTION
+                self.space.add(shape)
+        except Exception as e:
+            logging.error(f"Error creating boundaries: {e}")
+
+    def add_organism(self, organism: FractalOrganism) -> pymunk.Body:
+        """Add organism to physics space"""
+        try:
+            # Validate mass
+            mass = max(0.1, organism.mass)  # Ensure positive mass
+            moment = pymunk.moment_for_circle(mass, 0, organism.size)
+            
+            body = pymunk.Body(mass, moment)
+            
+            # Validate initial position and velocity
+            body.position = (
+                float(organism.pos.x % self.width),
+                float(organism.pos.y % self.height)
+            )
+            
+            # Clamp initial velocity
+            max_initial_velocity = 50.0
+            vel_x = max(-max_initial_velocity, min(max_initial_velocity, organism.vel.x))
+            vel_y = max(-max_initial_velocity, min(max_initial_velocity, organism.vel.y))
+            body.velocity = (vel_x, vel_y)
+
+            # Validate shape points and create polygon
+            valid_vertices = []
+            for x, y in organism.shape_points:
+                if not (np.isnan(x) or np.isnan(y)):
+                    valid_vertices.append((float(x), float(y)))
+
+            # If insufficient valid vertices, create default circle shape
+            if len(valid_vertices) < 3:
+                logging.warning(f"Insufficient valid vertices for organism {id(organism)}, using circle shape")
+                shape = pymunk.Circle(body, organism.size)
+            else:
+                shape = pymunk.Poly(body, valid_vertices)
+
+            shape.elasticity = self.config.ELASTICITY
+            shape.friction = self.config.FRICTION
+            shape.collision_type = self.config.COLLISION_TYPE_ORGANISM
+
+            # Store reference to organism
+            shape.organism = organism
+            body.organism = organism
+
+            self.space.add(body, shape)
+            return body
+        except Exception as e:
+            logging.error(f"Error adding organism to physics: {e}")
+            return None
+
+    def handle_collision(self, arbiter, space, data):
+        """Handle collision between organisms"""
+        try:
+            # Get colliding organisms
+            shape_a, shape_b = arbiter.shapes
+            org_a, org_b = shape_a.organism, shape_b.organism
+
+            # Add to interaction set
+            interaction_pair = tuple(sorted([id(org_a), id(org_b)]))
+            self.current_interactions.add(interaction_pair)
+
+            # Calculate collision response with validation
+            restitution = max(0, min(1, self.config.ELASTICITY))
+            j = -(1 + restitution) * arbiter.total_ke / 2
+
+            # Validate impulse
+            if not np.isnan(j):
+                # Clamp impulse to prevent extreme values
+                max_impulse = 1000.0
+                j = max(-max_impulse, min(max_impulse, j))
+
+                body_a = shape_a.body
+                body_b = shape_b.body
+                
+                normal = arbiter.normal
+                point = arbiter.contact_point_set.points[0].point_a
+
+                # Apply impulse along the collision normal
+                body_a.apply_impulse_at_world_point(j * normal, point)
+                body_b.apply_impulse_at_world_point(-j * normal, point)
+
+            return True
+        except Exception as e:
+            logging.error(f"Error handling collision: {e}")
+            return False
+
+    def process_interactions(self, organisms: List[FractalOrganism]):
+        """Process all current interactions"""
+        try:
+            # Process collision-based interactions
+            for org_a_id, org_b_id in self.current_interactions:
+                org_a = next((org for org in organisms if id(org) == org_a_id), None)
+                org_b = next((org for org in organisms if id(org) == org_b_id), None)
+
+                if org_a and org_b and org_a.alive and org_b.alive:
+                    # Neural interaction
+                    shared_thoughts = org_a.brain.interact_with(org_b.brain)
+
+                    # Energy transfer based on neural activity
+                    energy_diff = org_a.brain.total_energy - org_b.brain.total_energy
+                    transfer = max(-10.0, min(10.0, energy_diff * 0.1))  # Limit transfer amount
+                    org_a.brain.total_energy = max(0, org_a.brain.total_energy - transfer)
+                    org_b.brain.total_energy = max(0, org_b.brain.total_energy + transfer)
+
+            # Clear interactions for next frame
+            self.current_interactions.clear()
+
+            # Process proximity-based interactions
+            for i, org_a in enumerate(organisms):
+                if not org_a.alive:
+                    continue
+
+                for org_b in organisms[i+1:]:
+                    if not org_b.alive:
+                        continue
+
+                    # Calculate distance with validation
+                    dx = org_b.pos.x - org_a.pos.x
+                    dy = org_b.pos.y - org_a.pos.y
+                    
+                    if np.isnan(dx) or np.isnan(dy):
+                        continue
+                        
+                    distance = np.sqrt(dx*dx + dy*dy)
+
+                    if distance < self.config.INTERACTION_RADIUS:
+                        # Calculate interaction strength based on distance
+                        strength = 1.0 - (distance / self.config.INTERACTION_RADIUS)
+
+                        # Neural field effect with reduced strength
+                        field_interaction = strength * 0.5
+
+                        # Calculate force with validation
+                        force_magnitude = field_interaction * self.config.FORCE_SCALE
+                        force_angle = np.arctan2(dy, dx)
+
+                        if not (np.isnan(force_magnitude) or np.isnan(force_angle)):
+                            force_x = np.cos(force_angle) * force_magnitude
+                            force_y = np.sin(force_angle) * force_magnitude
+
+                            # Clamp forces
+                            max_force = 100.0
+                            force_x = max(-max_force, min(max_force, force_x))
+                            force_y = max(-max_force, min(max_force, force_y))
+
+                            # Apply forces through physics bodies
+                            body_a = next((body for body in self.space.bodies 
+                                         if hasattr(body, 'organism') and body.organism == org_a), None)
+                            body_b = next((body for body in self.space.bodies 
+                                         if hasattr(body, 'organism') and body.organism == org_b), None)
+
+                            if body_a and body_b:
+                                body_a.apply_force_at_local_point((-force_x, -force_y), (0, 0))
+                                body_b.apply_force_at_local_point((force_x, force_y), (0, 0))
+
+                            # Apply direct forces to organisms as well
+                            org_a.apply_force((-force_x, -force_y))
+                            org_b.apply_force((force_x, force_y))
+
+        except Exception as e:
+            logging.error(f"Error processing interactions: {e}")
+
+# ==============================
+# Visualization with PyGame
+# ==============================
+
+class NeuralVisualizer:
+    def __init__(self, width: int, height: int, config: VisualizationConfig):
+        self.width = width
+        self.height = height
+        self.config = config
+        self.neuron_surface = pygame.Surface((width, height), pygame.SRCALPHA)
+        self.connection_surface = pygame.Surface((width, height), pygame.SRCALPHA)
+
+    def _apply_pattern_overlay(self, organism, surface):
+        """Apply visual pattern overlay based on organism type"""
+        try:
+            if not organism.alive:
+                return
+
+            pattern_alpha = int(255 * organism.pattern_intensity)
+            pattern_color = (
+                255 - organism.color[0],
+                255 - organism.color[1],
+                255 - organism.color[2],
+                pattern_alpha
+            )
+
+            # Create pattern surface
+            pattern_surface = pygame.Surface((self.width, self.height), pygame.SRCALPHA)
+
+            if organism.pattern_type == 'stripes':
+                # Draw alternating stripes
+                stride = max(5, int(organism.size * 0.5))
+                x, y = int(organism.pos.x), int(organism.pos.y)
+                for i in range(-2, 3):
+                    offset = i * stride
+                    pygame.draw.line(pattern_surface, pattern_color,
+                                (x - organism.size, y + offset),
+                                (x + organism.size, y + offset), 2)
+
+            elif organism.pattern_type == 'spots':
+                # Draw spots in a circular pattern
+                x, y = int(organism.pos.x), int(organism.pos.y)
+                spot_size = max(2, int(organism.size * 0.2))
+                for angle in range(0, 360, 45):
+                    spot_x = x + int(np.cos(np.radians(angle)) * organism.size * 0.7)
+                    spot_y = y + int(np.sin(np.radians(angle)) * organism.size * 0.7)
+                    pygame.draw.circle(pattern_surface, pattern_color,
+                                    (spot_x, spot_y), spot_size)
+
+            else:  # gradient
+                # Draw radial gradient
+                x, y = int(organism.pos.x), int(organism.pos.y)
+                max_radius = int(organism.size * 1.2)
+                for radius in range(max_radius, 0, -2):
+                    alpha = int((radius / max_radius) * pattern_alpha)
+                    current_color = (*pattern_color[:3], alpha)
+                    pygame.draw.circle(pattern_surface, current_color,
+                                    (x, y), radius, 1)
+
+            # Blend pattern with surface
+            surface.blit(pattern_surface, (0, 0), special_flags=pygame.BLEND_ALPHA_SDL2)
+
+        except Exception as e:
+            logging.error(f"Error applying pattern overlay: {e}")
+
+    def draw_brain_state(self, organism: FractalOrganism, surface: pygame.Surface):
+        """Draw neural activity visualization with patterns and NaN handling"""
+        try:
+            # Clear previous state
+            self.neuron_surface.fill((0, 0, 0, 0))
+            self.connection_surface.fill((0, 0, 0, 0))
+
+            # Get brain vitals with NaN check
+            vitals = organism.brain.get_vitals()
+            if any(np.isnan(value) for value in vitals.values() if isinstance(value, (int, float))):
+                logging.warning(f"NaN detected in vitals for organism {id(organism)}. Marking for death.")
+                organism.alive = False
+                return
+
+            # Calculate neural positions based on fractal pattern
+            def plot_neural_layer(center, radius, neurons, depth=0):
+                if depth >= 3 or not neurons:
+                    return
+                
+                # Convert neurons to list if it's a ModuleList
+                if hasattr(neurons, 'sub_neurons'):
+                    neurons = neurons.sub_neurons
+                
+                if not neurons or len(neurons) == 0:
+                    return
+
+                angle_step = 2 * np.pi / len(neurons)
+                for i, neuron in enumerate(neurons):
+                    try:
+                        angle = i * angle_step
+                        x = center[0] + radius * np.cos(angle)
+                        y = center[1] + radius * np.sin(angle)
+
+                        # NaN check for coordinates
+                        if np.isnan(x) or np.isnan(y):
+                            logging.warning(f"NaN coordinates detected for neuron {i}. Skipping.")
+                            continue
+
+                        # Draw neuron
+                        activation = float(neuron.state.activation)
+                        connections = int(neuron.state.connections)
+
+                        # Check for NaNs in neuron state
+                        if np.isnan(activation) or np.isnan(connections):
+                            logging.warning(f"NaN detected in neuron state. Marking organism for death.")
+                            organism.alive = False
+                            return
+
+                        # Ensure coordinates are valid integers
+                        x_pos = int(np.clip(x, 0, self.width))
+                        y_pos = int(np.clip(y, 0, self.height))
+
+                        color = self._get_neuron_color(activation, connections)
+                        pygame.draw.circle(self.neuron_surface, color, (x_pos, y_pos), 5)
+
+                        # Draw connections with safety checks
+                        if connections > 0:
+                            alpha = int(255 * min(connections / self.config.MAX_NEURAL_CONNECTIONS, 1))
+                            if not np.isnan(alpha):
+                                connection_color = (*self.config.CONNECTION_COLOR[:3], alpha)
+                                pygame.draw.line(
+                                    self.connection_surface,
+                                    connection_color,
+                                    (x_pos, y_pos),
+                                    (int(center[0]), int(center[1])),
+                                    2
+                                )
+
+                        # Recursively draw sub-neurons
+                        if hasattr(neuron, 'sub_neurons') and neuron.sub_neurons:
+                            child_radius = radius * 0.5
+                            child_center = (x, y)
+                            plot_neural_layer(child_center, child_radius, neuron.sub_neurons, depth + 1)
+                    except Exception as e:
+                        logging.error(f"Error plotting neuron {i}: {e}")
+                        continue
+
+            # Draw neural network
+            try:
+                center = (organism.pos.x, organism.pos.y)
+                if not (np.isnan(center[0]) or np.isnan(center[1])):
+                    plot_neural_layer(center, organism.size * 2,
+                                    [organism.brain.visual_cortex,
+                                    organism.brain.thought_processor,
+                                    organism.brain.action_generator])
+            except Exception as e:
+                logging.error(f"Error plotting neural network: {e}")
+
+            # Apply pattern overlay with safety checks
+            try:
+                self._apply_pattern_overlay(organism, surface)
+            except Exception as e:
+                logging.error(f"Error applying pattern overlay: {e}")
+
+            # Combine surfaces with alpha blending
+            surface.blit(self.connection_surface, (0, 0))
+            surface.blit(self.neuron_surface, (0, 0))
+
+        except Exception as e:
+            logging.error(f"Error in draw_brain_state: {e}")
+
+    def _get_neuron_color(self, activation: float, connections: int) -> Tuple[int, int, int]:
+        """Generate color based on neuron state"""
+        try:
+            # Use HSV color space for smooth transitions
+            hue = (activation + 1) / 2  # Map -1,1 to 0,1
+            saturation = min(connections / self.config.MAX_NEURAL_CONNECTIONS, 1)
+            value = 0.8 + 0.2 * activation
+
+            # Convert to RGB
+            rgb = colorsys.hsv_to_rgb(hue, saturation, value)
+            return tuple(int(255 * x) for x in rgb)
+        except Exception as e:
+            logging.error(f"Error in _get_neuron_color: {e}. Defaulting to gray.")
+            return (100, 100, 100)
+
+class SimulationVisualizer:
+    def __init__(self, width: int, height: int, config: VisualizationConfig):
+        pygame.init()
+        self.width = width
+        self.height = height
+        self.config = config
+        
+        # Enable double buffering and vsync
+        self.screen = pygame.display.set_mode(
+            (width, height), 
+            pygame.DOUBLEBUF | pygame.HWSURFACE | pygame.SCALED, 
+            vsync=1
+        )
+        pygame.display.set_caption("Fractal Life Simulation")
+        
+        # Create off-screen surfaces for double buffering
+        self.buffer = pygame.Surface((width, height), pygame.SRCALPHA)
+        self.neural_viz = NeuralVisualizer(width, height, config)
+        self.background = pygame.Surface((width, height))
+        self.background.fill(config.BACKGROUND_COLOR)
+        
+        # Additional surfaces for layered rendering
+        self.organism_surface = pygame.Surface((width, height), pygame.SRCALPHA)
+        self.interaction_surface = pygame.Surface((width, height), pygame.SRCALPHA)
+        self.stats_surface = pygame.Surface((width, height), pygame.SRCALPHA)
+
+    def _validate_color(self, color):
+        """Validate and ensure color values are proper RGB integers"""
+        try:
+            if len(color) >= 3:
+                return (
+                    max(0, min(255, int(color[0]))),
+                    max(0, min(255, int(color[1]))),
+                    max(0, min(255, int(color[2])))
+                )
+            return (100, 100, 100)  # Default fallback color
+        except Exception as e:
+            logging.error(f"Error validating color: {e}")
+            return (100, 100, 100)
+
+
+
+    def draw_frame(self, organisms: List[FractalOrganism], stats: Dict):
+        """Draw complete frame with all visualizations"""
+        try:
+            # Clear all off-screen surfaces
+            self.organism_surface.fill((0, 0, 0, 0))
+            self.interaction_surface.fill((0, 0, 0, 0))
+            self.stats_surface.fill((0, 0, 0, 0))
+
+            # Draw organisms and their neural states
+            for organism in organisms:
+                if organism.alive:
+                    self._draw_organism(organism, self.organism_surface)
+                    self.neural_viz.draw_brain_state(organism, self.interaction_surface)
+
+            # Draw statistics
+            self._draw_stats(stats, self.stats_surface)
+
+            # Blit off-screen surfaces to the main display surface
+            self.screen.blit(self.background, (0, 0))  # Background layer
+            self.screen.blit(self.organism_surface, (0, 0))
+            self.screen.blit(self.interaction_surface, (0, 0))
+            self.screen.blit(self.stats_surface, (0, 0))
+
+            # Flip display buffers to avoid flickering
+            pygame.display.flip()
+        except Exception as e:
+            logging.error(f"Error in draw_frame: {e}")
+            
+    def _draw_organism(self, organism: FractalOrganism, surface: pygame.Surface):
+        """Draw organism body with color and pattern"""
+        try:
+            # Validate color before drawing
+            safe_color = self._validate_color(organism.color)
+            
+            # Draw shape with validated color
+            points = []
+            for x, y in organism.shape_points:
+                try:
+                    px = organism.pos.x + x
+                    py = organism.pos.y + y
+                    if not (np.isnan(px) or np.isnan(py)):
+                        points.append((px, py))
+                    else:
+                        logging.warning(f"NaN detected in shape points for organism {id(organism)}. Skipping point.")
+                except Exception as e:
+                    logging.error(f"Error processing shape points for organism {id(organism)}: {e}")
+                    continue
+
+            if len(points) >= 3:
+                pygame.draw.polygon(surface, safe_color, points)
+            else:
+                logging.warning(f"Insufficient valid points to draw organism {id(organism)}. Skipping drawing.")
+
+            # Draw energy bar
+            energy_percentage = min(max(organism.brain.total_energy / 1000.0, 0), 1)
+            bar_width = organism.size * 2
+            bar_height = 4
+            bar_pos = (organism.pos.x - bar_width / 2, organism.pos.y - organism.size - 10)
+            pygame.draw.rect(surface, (50, 50, 50), (*bar_pos, bar_width, bar_height))
+            pygame.draw.rect(surface, (0, 255, 0),  # Using direct color value for energy bar
+                             (*bar_pos, bar_width * energy_percentage, bar_height))
+        except Exception as e:
+            logging.error(f"Error in _draw_organism: {e}")
+
+    def _draw_stats(self, stats: Dict, surface: pygame.Surface):
+        """Draw simulation statistics"""
+        try:
+            font = pygame.font.Font(None, 24)
+            y_pos = 10
+            for key, value in stats.items():
+                text = font.render(f"{key.capitalize()}: {value}", True, (255, 255, 255))
+                surface.blit(text, (10, y_pos))
+                y_pos += 25
+        except Exception as e:
+            logging.error(f"Error in _draw_stats: {e}")
+
+    def cleanup(self):
+        """Clean up pygame resources"""
+        try:
+            pygame.quit()
+        except Exception as e:
+            logging.error(f"Error during pygame cleanup: {e}")
+
+# ==============================
+# Interaction Field (Optional Enhancement)
+# ==============================
+
+class InteractionField:
+    def __init__(self, width: int, height: int, resolution: int = 50):
+        self.width = max(1, width)
+        self.height = max(1, height)
+        self.resolution = max(10, min(resolution, 100))  # Bound resolution
+
+        # Create field grid with safe dimensions
+        self.grid_w = max(1, self.width // self.resolution)
+        self.grid_h = max(1, self.height // self.resolution)
+        self.field = np.zeros((self.grid_w, self.grid_h, 3))
+
+    def update(self, organisms: List[FractalOrganism]):
+        """Update field based on organism neural activity with safety checks"""
+        try:
+            # Decay field
+            self.field *= 0.9
+            np.clip(self.field, 0, 1, out=self.field)
+
+            for org in organisms:
+                if not org.alive:
+                    continue
+
+                try:
+                    # Safe position to grid conversion
+                    pos_x = max(0, min(float(org.pos.x), self.width))
+                    pos_y = max(0, min(float(org.pos.y), self.height))
+                    
+                    grid_x = int((pos_x / self.width) * (self.grid_w - 1))
+                    grid_y = int((pos_y / self.height) * (self.grid_h - 1))
+
+                    # Get neural activity with safety checks
+                    vitals = org.brain.get_vitals()
+                    activity_color = np.array([
+                        max(0.0, min(1.0, float(vitals['activation']))),
+                        max(0.0, min(1.0, float(vitals['energy']) / 1000.0)),
+                        max(0.0, min(1.0, float(vitals['connections']) / 100.0))
+                    ])
+
+                    # Apply to field with falloff
+                    for dx in range(-2, 3):
+                        for dy in range(-2, 3):
+                            x = (grid_x + dx) % self.grid_w
+                            y = (grid_y + dy) % self.grid_h
+                            
+                            distance = np.sqrt(dx * dx + dy * dy)
+                            if distance < 3:
+                                intensity = max(0.0, min(1.0, (3 - distance) / 3))
+                                self.field[x, y] += activity_color * intensity
+
+                except (ValueError, TypeError, ZeroDivisionError) as e:
+                    logging.error(f"Error updating field for organism {id(org)}: {e}")
+                    continue  # Skip problematic organisms
+
+            # Ensure field values stay in valid range
+            np.clip(self.field, 0, 1, out=self.field)
+        except Exception as e:
+            logging.error(f"Error in InteractionField.update: {e}")
+
+    def get_field_at(self, x: float, y: float) -> np.ndarray:
+        """Safely get field value at position"""
+        try:
+            x = max(0, min(float(x), self.width))
+            y = max(0, min(float(y), self.height))
+            
+            grid_x = int((x / self.width) * (self.grid_w - 1))
+            grid_y = int((y / self.height) * (self.grid_h - 1))
+            
+            return self.field[grid_x, grid_y]
+        except (ValueError, TypeError, IndexError) as e:
+            logging.error(f"Error in get_field_at for position ({x}, {y}): {e}")
+            return np.zeros(3)
+
+# ==============================
+# Simulation State Tracking
+# ==============================
+
+class SimulationState:
+    """Tracks the current state of the simulation"""
+    def __init__(self):
+        self.running = False
+        self.paused = False
+        self.step_count = 0
+        self.stats = {
+            'population': 0,
+            'avg_energy': 0.0,
+            'avg_neurons': 0.0,
+            'avg_connections': 0.0,
+            'total_interactions': 0
+        }
+        self.selected_organism: Optional[FractalOrganism] = None
+
+# ==============================
+# Main Simulation Class
+# ==============================
+
+class FractalLifeSimulation:
+    def __init__(self, config: SimulationConfig, shared_data: Dict):
+        self.config = config
+        self.state = SimulationState()
+
+        # Shared data for Gradio interface
+        self.shared_data = shared_data
+        self.shared_lock = threading.Lock()
+
+        # Initialize systems
+        visualization_config = VisualizationConfig()
+        self.visualizer = SimulationVisualizer(config.WIDTH, config.HEIGHT, visualization_config)
+        self.physics = PhysicsEngine(config.WIDTH, config.HEIGHT, PhysicsConfig())
+        self.field = InteractionField(config.WIDTH, config.HEIGHT, resolution=50)
+
+        # Event queues for thread communication
+        self.event_queue = Queue()
+        self.stats_queue = Queue()
+
+        # Initialize organisms
+        self.organisms: List[FractalOrganism] = []
+        self._init_organisms()
+
+        # Pygame threading control
+        self.running = False
+        self.thread = None
+
+    def _init_organisms(self):
+        """Initialize starting organisms"""
+        try:
+            for _ in range(self.config.MIN_ORGANISMS):
+                x = random.uniform(0, self.config.WIDTH)
+                y = random.uniform(0, self.config.HEIGHT)
+                organism = FractalOrganism(
+                    x=x, y=y,
+                    feature_dim=32,
+                    max_neurons=self.config.MAX_NEURONS
+                )
+                self.organisms.append(organism)
+                self.physics.add_organism(organism)
+        except Exception as e:
+            logging.error(f"Error initializing organisms: {e}")
+
+    def _process_reproduction(self):
+        """Handle organism reproduction"""
+        try:
+            new_organisms = []
+            for org in self.organisms:
+                if not org.alive or len(self.organisms) + len(new_organisms) >= self.config.MAX_ORGANISMS:
+                    continue
+
+                if org.brain.total_energy > self.config.REPRODUCTION_ENERGY:
+                    # Find a mate (simple random selection for demonstration)
+                    potential_mates = [o for o in self.organisms if o != org and o.alive and o.brain.total_energy > self.config.REPRODUCTION_ENERGY]
+                    if potential_mates:
+                        mate = random.choice(potential_mates)
+                        child = org.reproduce(mate, mutation_rate=self.config.MUTATION_RATE)
+                        if child:
+                            new_organisms.append(child)
+                            self.physics.add_organism(child)
+
+            self.organisms.extend(new_organisms)
+        except Exception as e:
+            logging.error(f"Error processing reproduction: {e}")
+
+    def _update_stats(self):
+        """Update simulation statistics"""
+        try:
+            living_organisms = [org for org in self.organisms if org.alive]
+            population = len(living_organisms)
+
+            if population > 0:
+                self.state.stats.update({
+                    'population': population,
+                    'avg_energy': sum(org.brain.total_energy for org in living_organisms) / population,
+                    'avg_neurons': sum(org.brain.total_neurons for org in living_organisms) / population,
+                    'avg_connections': sum(sum(n.state.connections for n in [org.brain.visual_cortex,
+                                                                            org.brain.thought_processor,
+                                                                            org.brain.action_generator])
+                                       for org in living_organisms) / population,
+                    'total_interactions': len(self.physics.current_interactions)
+                })
+            else:
+                self.state.stats.update({
+                    'population': 0,
+                    'avg_energy': 0.0,
+                    'avg_neurons': 0.0,
+                    'avg_connections': 0.0,
+                    'total_interactions': 0
+                })
+
+            with self.shared_lock:
+                self.shared_data['stats'] = self.state.stats.copy()
+        except Exception as e:
+            logging.error(f"Error updating statistics: {e}")
+
+    def _main_loop(self):
+        """Main simulation loop"""
+        try:
+            clock = pygame.time.Clock()
+
+            while self.running:
+                dt = clock.tick(self.config.TARGET_FPS) / 1000.0  # Delta time in seconds
+
+                for event in pygame.event.get():
+                    if event.type == pygame.QUIT:
+                        self.stop()
+
+                # Process external events
+                while not self.event_queue.empty():
+                    event = self.event_queue.get()
+                    self._handle_event(event)
+
+                if not self.state.paused:
+                    # Update physics
+                    self.physics.update(dt)
+
+                    # Update neural field
+                    self.field.update(self.organisms)
+
+                    # Update organisms
+                    for org in self.organisms:
+                        if org.alive:
+                            # Update organism state
+                            org.update(self.config.WIDTH, self.config.HEIGHT, self.organisms)
+
+                            # Process field interactions (placeholder for actual implementation)
+                            field_value = self.field.get_field_at(org.pos.x, org.pos.y)
+                            # org.process_field_input(field_value)  # Implement if needed
+
+                            # Energy decay
+                            org.brain.total_energy = max(0.0, org.brain.total_energy - self.config.ENERGY_DECAY)
+
+                    # Process physical interactions
+                    self.physics.process_interactions(self.organisms)
+
+                    # Handle reproduction
+                    self._process_reproduction()
+
+                    # Remove dead organisms
+                    self.organisms = [org for org in self.organisms if org.alive]
+
+                    # Maintain minimum population
+                    while len(self.organisms) < self.config.MIN_ORGANISMS and len(self.organisms) < self.config.MAX_ORGANISMS:
+                        x = random.uniform(0, self.config.WIDTH)
+                        y = random.uniform(0, self.config.HEIGHT)
+                        organism = FractalOrganism(
+                            x=x, y=y,
+                            feature_dim=32,
+                            max_neurons=self.config.MAX_NEURONS
+                        )
+                        self.organisms.append(organism)
+                        self.physics.add_organism(organism)
+
+                    # Update statistics
+                    self._update_stats()
+
+                    # Draw frame
+                    self.visualizer.draw_frame(self.organisms, self.state.stats)
+        except Exception as e:
+            logging.error(f"Exception in main loop: {e}")
+        finally:
+            # Cleanup when simulation stops
+            self.visualizer.cleanup()
+
+    def start(self):
+        """Start simulation in separate thread"""
+        if not self.running:
+            self.running = True
+            self.thread = threading.Thread(target=self._main_loop)
+            self.thread.start()
+            logging.info("Simulation started.")
+
+    def stop(self):
+        """Stop simulation"""
+        self.running = False
+        if self.thread and self.thread.is_alive():
+            self.thread.join()
+            logging.info("Simulation stopped.")
+
+    def pause(self):
+        """Pause/unpause simulation"""
+        self.state.paused = not self.state.paused
+        logging.info(f"Simulation {'paused' if self.state.paused else 'resumed'}.")
+
+    def _handle_event(self, event: Dict):
+        """Handle external events"""
+        try:
+            if event['type'] == 'select_organism':
+                organism_id = event['organism_id']
+                self.state.selected_organism = next(
+                    (org for org in self.organisms if id(org) == organism_id),
+                    None
+                )
+                logging.info(f"Organism {organism_id} selected.")
+            elif event['type'] == 'add_energy':
+                if self.state.selected_organism:
+                    self.state.selected_organism.brain.total_energy += event['amount']
+                    logging.info(f"Added {event['amount']} energy to organism {id(self.state.selected_organism)}.")
+            elif event['type'] == 'modify_neurons':
+                if self.state.selected_organism:
+                    # Placeholder for neuron modification logic
+                    logging.info(f"Modify neurons event received for organism {id(self.state.selected_organism)}.")
+        except Exception as e:
+            logging.error(f"Error handling event {event}: {e}")
+
+# ==============================
+# Gradio Interface
+# ==============================
+
+class FractalLifeInterface:
+    def __init__(self):
+        self.simulation: Optional[FractalLifeSimulation] = None
+        self.history = {
+            'population': [],
+            'avg_energy': [],
+            'avg_neurons': [],
+            'time': []
+        }
+        self.selected_organism_id = None
+        self.frame_image = None
+        self.DEFAULT_WIDTH = 1024
+        self.DEFAULT_HEIGHT = 768
+        
+        self.shared_data = {
+            'stats': {
+                'population': 0,
+                'avg_energy': 0.0,
+                'avg_neurons': 0.0,
+                'avg_connections': 0.0,
+                'total_interactions': 0
+            }
+        }
+
+    def get_frame(self):
+        """Retrieve the latest frame from Pygame."""
+        try:
+            if self.simulation and self.simulation.running:
+                with self.simulation.shared_lock:
+                    # Get pygame surface
+                    screen = self.simulation.visualizer.screen
+                    
+                    # Get the size of the screen
+                    width = screen.get_width()
+                    height = screen.get_height()
+                    
+                    # Create a new surface with alpha channel
+                    surf_alpha = pygame.Surface((width, height), pygame.SRCALPHA)
+                    surf_alpha.blit(screen, (0, 0))
+                    
+                    # Convert Pygame surface to PIL Image
+                    data_string = pygame.image.tostring(surf_alpha, 'RGBA')
+                    image = Image.frombytes('RGBA', (width, height), data_string)
+                    
+                    # Convert to RGB
+                    image = image.convert('RGB')
+                    
+                    return image
+            else:
+                # Return a blank image
+                return Image.new('RGB', (self.DEFAULT_WIDTH, self.DEFAULT_HEIGHT), (0, 0, 0))
+                
+        except Exception as e:
+            logging.error(f"Error in get_frame: {e}")
+            # Return a fallback image in case of error
+            return Image.new('RGB', (self.DEFAULT_WIDTH, self.DEFAULT_HEIGHT), (0, 0, 0))
+        
+    def update_display(self):
+        """Update display by retrieving the latest frame and statistics."""
+        try:
+            # Get the frame as PIL Image
+            image = self.get_frame()
+            
+            # Update statistics only if simulation is running
+            if self.simulation and self.simulation.running:
+                with self.simulation.shared_lock:
+                    stats = self.shared_data['stats']
+                    # Update history
+                    self.history['time'].append(self.simulation.state.step_count)
+                    self.history['population'].append(stats['population'])
+                    self.history['avg_energy'].append(stats['avg_energy'])
+                    self.history['avg_neurons'].append(stats['avg_neurons'])
+                    
+                    # Limit history length to prevent memory issues
+                    max_history = 1000
+                    if len(self.history['time']) > max_history:
+                        for key in self.history:
+                            self.history[key] = self.history[key][-max_history:]
+            else:
+                stats = self.shared_data['stats']
+
+            # Update plots
+            stats_fig = self._create_stats_plot()
+            neural_fig = self._create_neural_plot()
+
+            # Update organism list only if simulation is running
+            organism_list = []
+            if self.simulation and self.simulation.running:
+                organism_list = [
+                    (f"Organism {id(org)}", id(org))
+                    for org in self.simulation.organisms
+                    if org.alive
+                ]
+
+            # Update selected organism vitals
+            vitals = None
+            if self.selected_organism_id and self.simulation and self.simulation.running:
+                org = next(
+                    (org for org in self.simulation.organisms
+                     if id(org) == self.selected_organism_id),
+                    None
+                )
+                if org:
+                    vitals = {
+                        'energy': org.brain.total_energy,
+                        'neurons': org.brain.total_neurons,
+                        'age': org.age,
+                        'connections': sum(n.state.connections for n in
+                                        [org.brain.visual_cortex,
+                                         org.brain.thought_processor,
+                                         org.brain.action_generator])
+                    }
+
+            # Create new Dropdown choices instead of using update
+            dropdown = gr.Dropdown(
+                choices=organism_list,
+                label="Select Organism",
+                interactive=True
+            )
+
+            return [
+                image,  # Return PIL Image directly
+                stats_fig,
+                neural_fig,
+                dropdown,
+                vitals
+            ]
+            
+        except Exception as e:
+            logging.error(f"Error in update_display: {e}")
+            # Return default values in case of error
+            blank_image = Image.new('RGB', (self.DEFAULT_WIDTH, self.DEFAULT_HEIGHT), (0, 0, 0))
+            empty_fig = go.Figure()
+            empty_dropdown = gr.Dropdown(choices=[])
+            return [blank_image, empty_fig, empty_fig, empty_dropdown, None]
+
+    def create_interface(self):
+        with gr.Blocks(title="Fractal Life Simulator") as interface:
+            gr.Markdown("# 🧬 Fractal Life Simulator")
+
+            with gr.Row():
+                # Main simulation view and controls
+                with gr.Column(scale=2):
+                    canvas = gr.Image(label="Simulation View", interactive=False)
+
+                    with gr.Row():
+                        start_btn = gr.Button("Start Simulation", variant="primary")
+                        pause_btn = gr.Button("Pause")
+                        stop_btn = gr.Button("Stop")
+
+                    with gr.Row():
+                        population_slider = gr.Slider(
+                            minimum=5, maximum=100,  # Increased maximum for flexibility
+                            value=10, step=1,
+                            label="Initial Population"
+                        )
+                        mutation_rate = gr.Slider(
+                            minimum=0, maximum=1, value=0.1, step=0.01,
+                            label="Mutation Rate"
+                        )
+                        max_population_slider = gr.Slider(
+                            minimum=50, maximum=500, value=50, step=10,
+                            label="Max Population"
+                        )
+
+                # Statistics and organism details
+                with gr.Column(scale=1):
+                    stats_plot = gr.Plot(label="Population Statistics")
+                    neural_plot = gr.Plot(label="Neural Activity")
+
+                    with gr.Group():
+                        gr.Markdown("### Selected Organism")
+                        organism_dropdown = gr.Dropdown(
+                            label="Select Organism",
+                            choices=[],
+                            interactive=True
+                        )
+                        vitals_json = gr.JSON(label="Organism Vitals")
+
+                        with gr.Row():
+                            add_energy_btn = gr.Button("Add Energy")
+                            add_neurons_btn = gr.Button("Add Neurons")
+
+            # Advanced settings tab
+            with gr.Tab("Advanced Settings"):
+                with gr.Row():
+                    with gr.Column():
+                        brain_update_rate = gr.Slider(
+                            minimum=1, maximum=30, value=10, step=1,
+                            label="Brain Update Rate (Hz)"
+                        )
+                        max_neurons = gr.Slider(
+                            minimum=100, maximum=5000, value=1000, step=100,
+                            label="Max Neurons per Brain"
+                        )
+                        energy_decay = gr.Slider(
+                            minimum=0, maximum=1, value=0.1, step=0.01,
+                            label="Energy Decay Rate"
+                        )
+
+                    with gr.Column():
+                        interaction_strength = gr.Slider(
+                            minimum=0, maximum=1, value=0.5, step=0.01,
+                            label="Interaction Strength"
+                        )
+                        field_resolution = gr.Slider(
+                            minimum=10, maximum=100, value=50, step=5,
+                            label="Field Resolution"
+                        )
+
+            # Event handlers
+            def start_simulation(initial_population, mutation_rate_val, max_population_val, 
+                            brain_update_rate_val, max_neurons_val, energy_decay_val, 
+                            interaction_strength_val, field_resolution_val):
+                try:
+                    if self.simulation is None:
+                        config = SimulationConfig()
+                        config.MIN_ORGANISMS = int(initial_population)
+                        config.MUTATION_RATE = mutation_rate_val
+                        config.MAX_ORGANISMS = int(max_population_val)
+                        config.BRAIN_UPDATE_RATE = int(brain_update_rate_val)
+                        config.MAX_NEURONS = int(max_neurons_val)
+                        config.ENERGY_DECAY = energy_decay_val
+
+                        self.simulation = FractalLifeSimulation(config, self.shared_data)
+                        self.simulation.start()
+                        logging.info("Simulation started via interface.")
+                        return "Simulation started"
+                    else:
+                        logging.warning("Simulation is already running.")
+                        return "Simulation is already running."
+                except Exception as e:
+                    logging.error(f"Error starting simulation: {e}")
+                    return "Failed to start simulation."
+
+            def pause_simulation():
+                try:
+                    if self.simulation:
+                        self.simulation.pause()
+                        status = "paused" if self.simulation.state.paused else "resumed"
+                        logging.info(f"Simulation {status} via interface.")
+                        return f"Simulation {status}"
+                    logging.warning("No simulation running to pause/resume.")
+                    return "No simulation running"
+                except Exception as e:
+                    logging.error(f"Error pausing simulation: {e}")
+                    return "Failed to pause simulation."
+
+            def stop_simulation():
+                try:
+                    if self.simulation:
+                        self.simulation.stop()
+                        self.simulation = None
+                        logging.info("Simulation stopped via interface.")
+                        return "Simulation stopped"
+                    logging.warning("No simulation running to stop.")
+                    return "No simulation running"
+                except Exception as e:
+                    logging.error(f"Error stopping simulation: {e}")
+                    return "Failed to stop simulation."
+
+            def select_organism(organism_id):
+                try:
+                    self.selected_organism_id = organism_id
+                    if self.simulation:
+                        self.simulation.event_queue.put({
+                            'type': 'select_organism',
+                            'organism_id': organism_id
+                        })
+                        logging.info(f"Organism {organism_id} selected via interface.")
+                except Exception as e:
+                    logging.error(f"Error selecting organism: {e}")
+
+            def add_energy_to_organism():
+                try:
+                    if self.simulation and self.selected_organism_id:
+                        self.simulation.event_queue.put({
+                            'type': 'add_energy',
+                            'amount': 50.0
+                        })
+                        logging.info(f"Added energy to organism {self.selected_organism_id} via interface.")
+                        return "Added energy to selected organism"
+                    logging.warning("No organism selected or simulation not running to add energy.")
+                    return "No organism selected or simulation not running"
+                except Exception as e:
+                    logging.error(f"Error adding energy to organism: {e}")
+                    return "Failed to add energy"
+
+            def add_neurons_to_organism():
+                try:
+                    if self.simulation and self.selected_organism_id:
+                        self.simulation.event_queue.put({
+                            'type': 'modify_neurons',
+                            'amount': 10
+                        })
+                        logging.info(f"Added neurons to organism {self.selected_organism_id} via interface.")
+                        return "Added neurons to selected organism"
+                    logging.warning("No organism selected or simulation not running to add neurons.")
+                    return "No organism selected or simulation not running"
+                except Exception as e:
+                    logging.error(f"Error adding neurons to organism: {e}")
+                    return "Failed to add neurons"
+
+            # Create a bound method for update_display
+            def bound_update_display():
+                return self.update_display()
+
+            # Connect events
+            start_btn.click(
+                start_simulation, 
+                inputs=[population_slider, mutation_rate, max_population_slider, 
+                    brain_update_rate, max_neurons, energy_decay, 
+                    interaction_strength, field_resolution], 
+                outputs=gr.Textbox()
+            )
+            pause_btn.click(pause_simulation, outputs=gr.Textbox())
+            stop_btn.click(stop_simulation, outputs=gr.Textbox())
+
+            organism_dropdown.change(select_organism, inputs=[organism_dropdown], outputs=None)
+            add_energy_btn.click(add_energy_to_organism, outputs=gr.Textbox())
+            add_neurons_btn.click(add_neurons_to_organism, outputs=gr.Textbox())
+
+            # Periodic update using Gradio's update mechanism
+            interface.load(
+                fn=bound_update_display,
+                inputs=[],
+                outputs=[canvas, stats_plot, neural_plot, organism_dropdown, vitals_json],
+                every=1/30,  # 30 FPS updates
+                queue=True
+            )
+
+            return interface
+
+    def _create_stats_plot(self):
+        """Create statistics plot using plotly"""
+        try:
+            fig = make_subplots(rows=3, cols=1, shared_xaxes=True,
+                                subplot_titles=("Population", "Average Energy", "Average Neurons"))
+
+            fig.add_trace(
+                go.Scatter(x=self.history['time'], y=self.history['population'],
+                           name="Population"),
+                row=1, col=1
+            )
+
+            fig.add_trace(
+                go.Scatter(x=self.history['time'], y=self.history['avg_energy'],
+                           name="Avg Energy"),
+                row=2, col=1
+            )
+
+            fig.add_trace(
+                go.Scatter(x=self.history['time'], y=self.history['avg_neurons'],
+                           name="Avg Neurons"),
+                row=3, col=1
+            )
+
+            fig.update_layout(height=600, showlegend=True)
+            return fig
+        except Exception as e:
+            logging.error(f"Error creating stats plot: {e}")
+            return go.Figure()
+
+    def _create_neural_plot(self):
+        """Create neural activity plot"""
+        try:
+            if self.selected_organism_id and self.simulation and self.simulation.running:
+                org = next(
+                    (org for org in self.simulation.organisms
+                     if id(org) == self.selected_organism_id),
+                    None
+                )
+                if org:
+                    # Create neural activity heatmap
+                    neurons = [org.brain.visual_cortex,
+                            org.brain.thought_processor,
+                            org.brain.action_generator]
+
+                    activities = []
+                    for neuron in neurons:
+                        layer_activities = [child.state.activation for child in neuron.sub_neurons] if hasattr(neuron, 'sub_neurons') and neuron.sub_neurons else [neuron.state.activation]
+                        activities.append(layer_activities)
+
+                    activities = np.array(activities)
+
+                    fig = go.Figure(data=go.Heatmap(z=activities, colorscale='Viridis'))
+                    fig.update_layout(
+                        title="Neural Activity",
+                        xaxis_title="Neuron Index",
+                        yaxis_title="Layer"
+                    )
+                    return fig
+            return go.Figure()
+        except Exception as e:
+            logging.error(f"Error creating neural plot: {e}")
+            return go.Figure()
+
+# ==============================
+# Entry Point
+# ==============================
+
+if __name__ == "__main__":
+    interface = FractalLifeInterface()
+    gr_interface = interface.create_interface()
+    # Enable queue and allow for public access
+    gr_interface.queue().launch(
+        server_name="0.0.0.0", 
+        server_port=7860,
+        share=True  # This creates a public link
+    )

requirements.txt

@@ -0,0 +1,7 @@
+torch>=2.0.0
+pygame>=2.4.0
+gradio==3.50.2
+numpy>=1.21.0
+pymunk>=6.4.0
+plotly>=5.13.0
+Pillow>=9.4.0