← Back to Projects

Gothic Grandma LLC

MUSE Ecosystem

Emergent World Simulation Platform

Founder & Principal Engineer · 2025–Present

C++20 Go Python TypeScript Dart Electron React Flutter CUDA Metal Vulkan PostgreSQL SQLite Supabase
Key Achievement: 100K+ entities · 13.7× real-time compression · Visual design → GPU kernels

MUSE is an emergent world simulation platform—scales to 100k+ entities with biological needs, psychological states, and social relationships running on deterministic, inspectable systems. The primary application is interactive storytelling: narratives emerge from simulation state rather than scripts, with LLMs translating causality into natural language.

The platform spans simulation, internal tooling, and consumer interfaces. Each component solves a specific problem in the design → compile → simulate → experience pipeline. All tools share the same Go/Supabase backend with role-based access.

LLMs are used strictly for input/output translation and narration. All simulation logic, state transitions, and causal systems are deterministic and fully inspectable.

Tool Ecosystem

Internal Workbench

Consumer Layer

Build Infrastructure

GESTALT Alpha

Kernel Generator

Schema → kernel compilation pipeline. Transforms visual system designs into optimized GPU binaries (CUDA/Metal/Vulkan/CPU).

C++20 Code Generation

TESSERA Alpha

Visual Constructor

React Flow node graph editor for building FONT kernel batches. Embedded as an iframe panel within GLYPH.

React TypeScript React Flow

SIBYL Alpha

Architecture Analyzer

Python-based codebase analysis parsing C++, Go, Python, TypeScript, Dart, and SQL. Dependency mapping, API extraction, health metrics. Feeds into Architecture Explorer panel.

Python Static Analysis

PYNAX Alpha

Registry Builder

Scans C++ and Go APIs to populate the master command registry. Extracts endpoints, permissions, and contract signatures needed for runtime command dispatch.

Python API Scanning Code Parsing

Platform Architecture

Emergence at Scale
Like Conway's Game of Life demonstrates emergence from simple rules applied to pixels, MUSE scales emergent behavior to 100,000+ entities—where societies, economies, and narratives emerge from distributed systems coordinating through shared state.

Visual → Compiled Pipeline

Visual Modeling
Database Schema
Code Generation
GPU/CPU Kernels
Runtime Execution
Declarative configuration → Optimized compilation → Deterministic execution

Communication Layers

Go Control Plane (port 8766)
REST API · JWT/OAuth auth · Multi-workbench routing · Fibonacci backoff sync
Electron IPC Bridge
Workbench↔backend communication · Preload scripts · Secure context isolation
FONT Server (port 7777)
WebSocket · Simulation control · World state streaming · Command dispatch
Supabase Realtime
Multi-user sync · Database change broadcasts · Live collaboration updates

Core Architecture

FONT Simulation Engine
100k+ entities · Biological timing kernels · Schema→kernel code generation · Sub-100ms updates
Cross-Platform GPU
CUDA/Metal/Vulkan kernel generation · GPU-first batch processing · Parallel entity updates
PostgreSQL (Supabase)
Row-Level Security · Multi-schema architecture · Local SQLite backup queue
Role-Based Workbenches
Shared infrastructure · Tools differ by permissions and workflow · OAuth + RLS policies
Designed for scale: On-demand execution processes 100,000+ concurrent entities in millisecond bursts. Burst computation when needed, idle otherwise—efficient resource usage by design.

What Makes MUSE Different

Deterministic Simulation, Not Generation

  • Real causality — consequences emerge from biological and psychological systems, not scripts
  • Persistent state — worlds remember everything through database-backed memory, no LLM context limits
  • Inspectable logic — trace any behavior back to root cause through explicit data flow
  • No hallucination risk — simulation truth is ground truth; LLMs only translate at boundaries

On-Demand Execution

  • Burst computation on prompts — processes 100,000+ entities in milliseconds when user acts
  • Efficient by design — idle when paused, no wasted cycles on continuous rendering
  • Scales independently — simulation complexity grows with world richness, not interaction frequency
  • Central state management — shared database backend, resource-aware scheduling

Visual Design → Compiled Code

  • Design visually — build systems in GLYPH's Constructor panel using node graphs, no hand-written simulation code
  • Automatic compilation — visual designs compile to optimized GPU/CPU kernels via GESTALT
  • Database as source of truth — all system definitions live in the schema; code generates from it
  • Full traceability — every behavior traces back to its visual definition

Unified Platform, Role-Based Access

  • One workbench, all roles — engineers, researchers, and creators all work from GLYPH; saved layout presets expose the right panels for each workflow
  • Shared infrastructure — same Go backend, same database schemas, same panel system; roles differ by layout and permissions, not implementation
  • Real-time collaboration — multiple users can build the same systems simultaneously from different locations via Supabase Realtime

What Problem MUSE Solves

Problem: Modern interactive fiction, educational software, and AI-driven storytelling systems are built on static scripts or probabilistic text generation. They can be immersive, but they do not simulate causality. Their characters do not truly perceive, decide, or change in response to integrated biological, psychological, and social forces.

Solution: MUSE enables embodied, scientifically grounded simulation where:

  • Perception, decision-making, learning, and relationships arise from real models of biology and psychology
  • Long-term change emerges from cause-and-effect, not narrative branching
  • Users can probe systems like scientists—not just consume a story
  • Worlds persist, evolve, and surprise without relying on LLM memory or hallucinated state

The result is a new medium: interactive worlds where people don't just read about perspectives—they inhabit them.

Who It's For

  • Readers — experience Living Worlds through GRIM, interacting via natural language
  • Researchers — run experiments on FONT, probe simulation state, and export data without touching code, via GLYPH's research panels
  • Creative directors — author worlds through GLYPH's content panels — characters, environments, relationships — using semantics and description
  • System engineers — design and profile the perceptual, behavioral, and physical systems that power everything via GLYPH's kernel engineering and dev panels

How does this connect? MUSE is where I study architecture → processing → behavior most directly, with full control over system design. Read about the throughline →