A high-performance, real-time implementation of Lenia - a fascinating continuous cellular automaton that creates complex, lifelike patterns. Built with Blazor WebAssembly and MudBlazor for a modern, interactive web experience.

• 60 FPS Target: Optimized for smooth real-time simulation
• Adaptive Quality: Automatically adjusts processing quality to maintain performance
• Multi-threaded Processing: Utilizes all CPU cores for maximum speed
• Scalable Grid: Dynamic grid sizing from 24×24 to 128×128
• Memory Optimized: Efficient algorithms with minimal allocations

• Dark Theme: Professional dark interface with custom purple accent
• Real-time Metrics: Live FPS, update time, and render time monitoring
• Responsive Design: Works beautifully on desktop and mobile
• Material Design: Clean, intuitive interface using MudBlazor components
• Interactive Controls: Sliders, buttons, and toggles for all parameters

• Authentic Lenia Mathematics: Implements the original Lenia formulas
• Configurable Physics: Adjust radius (R), time step (Δt), growth parameters (μ, σ)
• Pattern Presets: Pre-configured Orbium and Geminium patterns
• Custom Initialization: Circle patterns and random seeding

Try the live demo: Lenia Simulation

• .NET 9.0 - Modern, cross-platform framework
• Blazor WebAssembly - Client-side web UI with C#
• MudBlazor - Material Design component library
• JavaScript Interop - High-performance canvas rendering

• .NET 9.0 SDK
• A modern web browser (Chrome, Firefox, Safari, Edge)

1. Clone the repository

   git clone https://github.com/phmatray/lenia.git cd lenia

2. Restore dependencies

   dotnet restore

3. Run the application

   cd Lenia/Lenia dotnet run

4. Open your browser Navigate to https://localhost:5001 or http://localhost:5000

• Play/Pause: Click the play button in the top bar or main controls
• Reset: Clear the grid and start fresh
• Patterns: Choose from Circle, Orbium, or Geminium presets

• Radius (R): Neighborhood size for cell interactions (2.0 - 10.0)
• Time Step (Δt): Simulation speed multiplier (0.01 - 0.5)
• Growth μ: Peak of the growth function (0.0 - 0.5)
• Growth σ: Width of the growth function (0.001 - 0.1)

• Grid Size: Adjust from 24×24 to 128×128 cells
• Target FPS: Set desired frame rate (10-120 FPS)
• Adaptive Quality: Auto-adjust processing quality for consistent performance

Lenia is a continuous cellular automaton discovered by Bert Wang-Chak Chan. Unlike traditional cellular automata (like Conway's Game of Life), Lenia uses:

• Continuous values instead of binary states
• Smooth kernels for neighborhood calculations
• Differential equations for state updates
• Real-valued time for fluid evolution

This creates remarkably lifelike behaviors including:

• Self-organization and emergence
• Glider-like moving patterns
• Complex interactions and collisions
• Adaptive and evolutionary dynamics

Update Rule: A^(t+Δt)(x) = clip(A^t(x) + Δt × G(U^t(x)), 0, 1) Where: - A^t(x): Cell state at time t and position x - U^t(x): Local neighborhood potential - G(u): Growth function G(u; μ, σ) = 2×exp(-((u-μ)/σ)²/2) - 1 - Δt: Time step size 

For more details, see the original paper.

├── Lenia/ # Server-side Blazor Web App │ ├── Components/ │ │ └── App.razor # Main application shell │ ├── Program.cs # Server configuration │ └── Lenia.csproj # Server project file │ ├── Lenia.Client/ # Client-side Blazor WebAssembly │ ├── Components/ │ │ └── LeniaCanvas.razor # Canvas rendering component │ ├── Pages/ │ │ └── Home.razor # Main simulation page │ ├── Layout/ │ │ └── MainLayout.razor # App layout with dark theme │ ├── wwwroot/ │ │ └── leniaCanvas.js # High-performance canvas rendering │ ├── LeniaScalable.cs # Optimized simulation engine │ ├── Program.cs # Client configuration │ └── Lenia.Client.csproj # Client project file │ └── README.md # This file 

• Float Precision: Uses float instead of double for 2× memory bandwidth
• Pre-computed Kernels: Kernel weights calculated once and cached
• Parallel Processing: Multi-threaded updates using Parallel.For
• Chunked Processing: Large grids processed across multiple frames
• Adaptive Quality: Dynamic reduction of processed cells when needed

• JavaScript Interop: Direct canvas manipulation for maximum speed
• ImageData Optimization: Efficient pixel buffer updates
• Hardware Scaling: GPU-accelerated canvas scaling
• Minimal Allocations: Reused buffers and optimized memory access

Contributions are welcome! Here's how to get started:

1. Fork the repository
2. Create a feature branch: git checkout -b feature/amazing-feature
3. Make your changes: Follow the existing code style
4. Add tests: Ensure your changes don't break existing functionality
5. Commit your changes: git commit -m 'Add amazing feature'
6. Push to the branch: git push origin feature/amazing-feature
7. Open a Pull Request: Describe your changes and why they're awesome

• Follow C# coding conventions
• Use MudBlazor components for UI consistency
• Maintain 60 FPS performance target
• Add XML documentation for public APIs
• Include unit tests for new features

This project is licensed under the MIT License - see the LICENSE file for details.

• Bert Wang-Chak Chan - Original Lenia research and discovery
• MudBlazor Team - Excellent Blazor component library
• Microsoft - .NET and Blazor frameworks
• Blazor Community - Inspiration and best practices

• Lenia - Biology of Artificial Life - Original paper
• Lenia and Expanded Universe - Extended research
• Bert Chan's YouTube Channel - Lenia demonstrations
• MudBlazor Documentation - UI component reference

• Bug Reports: GitHub Issues
• Feature Requests: GitHub Discussions
• Documentation: Wiki