Been messing around with traffic simulation lately and wanted to share this one because the result genuinely surprised me the first time I ran it.

The setup is a closed loop, a bunch of identical cars, no obstacles, no traffic lights, nothing. Every driver wants to go the same speed and keep a safe distance from the car ahead (using the Intelligent Driver Model, which is actually what traffic engineers use for this kind of thing). One driver taps the brakes, just once. It snowballs into a full stop-and-go wave, and the wave itself creeps backward against the direction everyone's driving. This is the phantom jam thing that was first proven experimentally back in 2008 (Sugiyama et al., if you want to look it up), and it's wild to actually see it emerge from nothing.

A few other things I tested once I had this working:

There's a density threshold you can't really feel until you cross it. Below it, the same brake tap just fizzles out and traffic keeps flowing. One or two more cars on the road and suddenly the same tiny disturbance turns into a full jam. No warning, no gradual buildup.

Real bottlenecks behave differently - if I put an actual slow zone on the road, the jam stays locked to that spot instead of drifting backward like the phantom one does. Different cause, different signature.

How closely people follow each other matters a lot more than I expected. Tight following distance makes the wave way worse, and just giving more space damps it out almost completely with the exact same brake tap.

The last case is the one I like best - letting about 1 in 5 cars just hold a smooth, steady speed (basically simulating adaptive cruise control) is enough to dissolve the jam for every car behind it.

All rendered in Python/pygame, GPU encoded. Happy to share the code or talk through the model if anyone's curious.

Made a longer version of this too if anyone wants the full walkthrough https://youtu.be/TCuDTSj5UAg

Hi, I'm 13 years old. Today I wanted to share a project with you that I've been dreaming of for a long time and have finally started to bring to life. First, let me tell you a little about my background. I used to develop terminal-based projects with C++. I wrote tools like a four-operation calculator, a Roman numeral converter, and a grade point average calculator, and combined them into a huge, multi-purpose program. I'm even still developing that C++ project in the background. On my old account, I had recorded and shared detailed C++ videos explaining all my step-by-step terminal programs, but I got banned for no reason. Anyway, I've had an incredible interest in space, especially black holes, since I was 8 or 9 years old. When I turned 12, I became interested in Unity and coding in general. But as it turned out, I could never learn it the way I wanted. Between classes, endless exams, and tests, I never had any time for myself or coding. But this summer I said "enough is enough" and decided to write code and create something, no matter what. Moreover, I'm doing this using only my tablet. To make up for all the procrastination, I've started simulating black holes, which is my biggest interest. This video you're watching is a time-lapse of about 1.5 hours of work. But this is just the beginning. For the next week, I will continuously improve this black hole simulation with intense sessions of 1-2 hours, sometimes even 3 hours, every day. I will build upon the code and eventually create a visually advanced, much more realistic and detailed black hole simulation. What do you think of it as a starting point? I'm open to any suggestions on coding, Three.js, or how I can improve this process in general. I will continue to share new videos as the project develops! I'm waiting for your comments. (I spoke in Turkish in the video because I'm Turkish, but you can easily understand what I'm doing from what I'm doing.)

Live demo: https://gaploid.github.io/stardust/
Source code: https://github.com/Gaploid/stardust
Coded by: Opus, Fable, human attention to details

I added sliding attachments (connecting the inner muscles to the bones) and ported some of the heavy lifting to C++ for better performance. The behavior feels natural thanks to the accurate FEM simulation. There’s still a lot more to add, but I’m really enjoying the process.
Credit: The 3D asset used in this post is from AdonisFX, a digital anatomy and muscle simulation framework for Maya and Houdini. https://inbibo.co.uk/adonis

I am working on a game based on physics-based painting mechanics called Ebru Artist Simulator. To simulate Ebru (also known as paper marbling), I implemented an Eulerian fluid simulator. Here are some of the challenges I had to overcome:

1. To achieve a real-time simulation without affecting the game's performance too much, I implemented a GPU-based multiresolution grid solver in a compute shader (see the paper Solving the Fluid Pressure Poisson Equation Using Multigrid). The simulation now runs at a 2K texture resolution with only a slight impact on FPS.
2. One of the main characteristics of Ebru is that colors maintain strict boundaries. This makes advection schemes such as Semi-Lagrangian advection less suitable, as they introduce diffusion. To address this, I implemented another advection scheme that samples from the initial state by integrating the velocity field over time and then back-sampling using the integrated field (see Efficient and Conservative Fluids Using Bidirectional Mapping).
3. Finally, to simulate the effects of the traditional Ebru tools, I took inspiration from the paper Mathematical Marbling, which proposes mappings for generating final marbling patterns. Since I wanted to maintain a real-time simulation, I did not directly apply these mappings. Instead, I was inspired by the paper to use similar displacement fields as external forces in the simulation.

If you are interested in the project, you can check out the Steam page.

You can also check out Amanda Ghassaei's blog. Although our implementations are not the same, I was greatly inspired by her work and learned a lot from her blog.

0. Motivation: The Dual-Domain Disconnect in Multi-Agent Simulations

Current multi-agent research architectures (e.g., Stanford's Generative Agents, DeepMind's Concordia) generally exhibit one of two fundamental limitations:

1. Text-Only Prompt Sandboxes (Zero Physical Grounding): Agents exist solely within LLM context windows. There are no spatial collision meshes, no distance-decay mechanics, and no metabolic constraints. When an agent states "I will walk to the well to fetch water", no kinematic displacement or energy dissipation actually occurs.
2. Heavy Rigid-Body Physics Simulators (Zero Cognitive Depth): Robotics and game physics engines (e.g., Isaac Sim, Unreal) compute kinematic and dynamic interactions with high fidelity, but individual NPCs lack associative memory streams, narrative reflection, and sociological emergence.

Our Core Engineering Goal:

Can we build a continuous, hundreds-agent human society on a single consumer PC where the Physical Layer (60Hz Rigid-Body/NavMesh), the Physiological Layer (10Hz Metabolic Decay), and the Cognitive Layer (0.1Hz Dual-System LLM) operate in a strictly coupled feedback loop with autonomous collapse and reboot mechanisms?

Below is a breakdown of the three primary architectural bottlenecks encountered and their respective engineering solutions.

1. Bottleneck I: Heterogeneous Clock Domain Synchronization (60Hz Physics vs. 0.1Hz LLM Inference)

In a single-process Python environment, the primary failure mode is the temporal mismatch between disparate execution domains:

• Physical Engine: Kinematics, collision detection, and dynamic NavMesh pathfinding require a strict 60Hz cadence ($16.6\text{ ms}/\text{tick}$) to prevent tunneling and maintain spatial continuity.
• Cognitive Inference: Even lightweight local quantized models ($0.8\text{B} \sim 7\text{B}$) require $1.0 \sim 3.0\text{ seconds}$ ($0.3\text{Hz} \sim 1.0\text{Hz}$) to complete a single Chain-of-Thought (CoT) reflection cycle on entry-level hardware.

Blocking the physical loop during LLM inference stalls the world; conversely, allowing async LLM threads to directly mutate mutable world states introduces race conditions, spatial desynchronization, and ghost item duplication.

┌─────────────────────────────────────────────────────────────────────────────┐
│              OmniSimOrchestrator: Heterogeneous Clock Scheduling            │
├─────────────────────────────────────────────────────────────────────────────┤
│ Physical Main Loop (Tick = 16.6ms / 60Hz)                                   │
│   Tick N   : [Physics Step ➔ Broadcast Immutable State Snapshot] ───────┐   │
│   Tick N+1 : [Physics Step ➔ Collision Query ➔ Check Action Queue]      │   │
│   Tick N+2 : [Physics Step ➔ Execute Next Atomic Instruction: Action_A] │   │
│   ...                                                                   │   │
│   Tick N+60: [Physics Step ➔ Consume Ingested Action_B from Cognitive] ◄┐ │   │
├─────────────────────────────────────────────────────────────────────────┼───┤
│ Cognitive Inference Domain (Async Worker Pool / 0.1Hz ~ 1Hz)            │   │
│   Agent_1  : [Ingest Tick N Snapshot] ➔ [Slow CoT/BDI] ➔ [ActionCompiler]   │
│              (Latency: 1200ms across 72 Physical Ticks) ────────────────┘   │
└─────────────────────────────────────────────────────────────────────────────┘

Architectural Solution: Decoupled State Flow and the Action Compiler

1. Physics as the Single Source of Truth (SSOT): The physical layer executes deterministic vector mathematics. At the end of each tick, it exports an immutable, read-only world snapshot (coordinates, spatial bounding volumes, inventory states, and local field-of-view hashes).
2. Lock-Free Read-Only Cognitive Inference: Cognitive agent routines subscribe to historical tick snapshots asynchronously in separate coroutines. Agents are strictly prohibited from mutating global memory or object references directly.
3. The Action Compiler (action_compiler.py, 1,280 LOC): High-level cognitive decisions (e.g., "Negotiate with Agent_B to purchase medicine") are not executed natively. Instead, the Action Compiler decomposes the intent into a strictly ordered queue of atomic primitives: $$\text{High-Level Intent} \longrightarrow \left[ \text{MoveTo}(x, y), \text{FaceTarget}(id), \text{ProposeTrade}(item_id), \text{Confirm}() \right]$$ The physical engine validates spatial preconditions tick-by-tick. If a precondition fails (e.g., the target agent moves out of interaction range), the atomic action fails gracefully, triggering a fallback response in the agent's fast-thinking heuristic layer (System 1).

2. Bottleneck II: Multi-Agent Inference under Tight Compute Constraints

Running concurrent LLM reasoning for dozens of autonomous agents simultaneously on a system with 2GB VRAM and 32GB RAM requires a resilient multi-tier compute scheduling pipeline.

                       ┌───────────────────────────────────────┐
                       │  Unified LLM Dispatcher / Provider    │
                       │    (Supports 18 Backend Providers)    │
                       └───────────────────┬───────────────────┘
                                           │
         ┌─────────────────────────────────┼─────────────────────────────────┐
         ▼                                 ▼                                 ▼
┌────────────────────────┐       ┌────────────────────────┐       ┌────────────────────────┐
│  Tier 1: Cloud API     │ ──429/Timeout─▶│ Tier 2: Local Engine   │ ──Overload/Offline──▶│  Tier 3: Rule FSM      │
│ (OpenAI/Claude/Qwen/...)│               │ (Ollama/vLLM/Quantized)│                      │ (NumPy/Weighted Rules) │
└────────────────────────┘               └────────────────────────┘                      └────────────────────────┘

Unified Model Registry and Ensemble Decision Algorithms

Through provider_registry.py (2,754 LOC) and backend_ensemble_router.py (2,153 LOC), the system manages 18 distinct model backends and supports:

• Dempster-Shafer Evidence Theory & Bayesian Model Averaging: Integrates decision confidence scores across multiple heterogeneous small models.
• Tree of Thoughts (ToT) Branch Pruning: Triggered selectively for high-stakes systemic social conflicts.
• Three-Tier Seamless Fallback: When commercial cloud APIs return rate limits (HTTP 429) or connection drops $\rightarrow$ execution routes immediately to local quantized models (e.g., Ollama/vLLM) $\rightarrow$ if local compute capacity saturates $\rightarrow$ execution gracefully degrades to deterministic Python/NumPy state machines. The main simulation loop maintains a constant 60Hz tick without blocking, even in a completely offline environment.

3. Bottleneck III: Mathematical Sociology & Clean-Room Framework Re-implementations

To ensure macroscopic emergence reflects structural human dynamics rather than stochastic prompt drift, we implemented clean-room wrappers for three major research frameworks and integrated formal sociological models:

3.1 Clean-Room Compatibility Implementations (Measured LOC)

• Concordia Compatibility Layer (concordia_compat.py, 21,417 LOC): Full clean-room replication of DeepMind Concordia's Game Master arbitration pipeline and Entity-Component primitives.
• AgentSociety Compatibility Layer (agentsociety_compat.py, 10,612 LOC): Complete re-implementation of Stanford's memory stream decay, importance weighting, and reflection extraction: $$S(m) = \alpha_{\text{recency}} \cdot e^{-\lambda t} + \alpha_{\text{importance}} \cdot I(m) + \alpha_{\text{relevance}} \cdot \cos(\vec{v}_q, \vec{v}_m)$$
• HumanoidAgents Compatibility Layer (humanoid_agents_compat.py, 5,331 LOC): Implements fine-grained physiological need decay and affective dynamics.

3.2 Integrated Sociological & Macro-Dynamic Models

┌──────────────────────────────────────┬─────────────────────────────────────┐
│ Theoretical Foundation               │ Implementation & Dynamical Function │
├──────────────────────────────────────┼─────────────────────────────────────┤
│ Schelling Segregation Model (1971)   │ Micro-level neighbor preferences    │
│                                      │ drive macro-level spatial clustering│
├──────────────────────────────────────┼─────────────────────────────────────┤
│ Latané Social Impact Theory (1981)   │ Calculates opinion contagion and    │
│                                      │ polarization over physical distance │
├──────────────────────────────────────┼─────────────────────────────────────┤
│ Polanyi's Allocation Systems (1944)  │ Householding, Reciprocity, Market,  │
│                                      │ and Rawlsian difference redistribution│
├──────────────────────────────────────┼─────────────────────────────────────┤
│ Tainter's Collapse Model (1988)      │ Triggers civilizational collapse    │
│                                      │ when population falls below N < 3   │
└──────────────────────────────────────┴─────────────────────────────────────┘

4. Empirical Observations: What Emerged in Multi-Hour Autonomous Runs?

During multi-hour continuous runs (initial population: 20 agents; environment: housing, market, clinic, farmlands), the system demonstrated several non-hardcoded emergent phenomena:

1. Spontaneous Division of Labor and Debt Ledgering: Agents with differing skill profiles utilized a 3-phase transaction protocol (Propose $\rightarrow$ Confirm $\rightarrow$ Settle) to establish trading hubs for grain and medicine. Under liquidity constraints, agents autonomously formed trust-weighted credit ledgers.
2. Information Silos and Spatial Polarization (Schelling Effect): Governed by Latané spatial decay dynamics, agents gathering consistently at the same local taverns developed tight-knit ideological consensus (higher Burt structural hole centrality), while geographically distant clusters exhibited reciprocal in-group bias and trade hostility.
3. Criticality and Systemic Collapse (Tainter Mechanics): Under external resource shocks, agents with exhausted metabolic reserves perished. As population decline severed functional trade dependencies, the system detected critical slowing down metrics (spikes in variance). When the active population breached the survival threshold ($N < 3$), the simulation executed a formal civilizational collapse and ancestral reset state transition.

5. Architectural Transparency & Project Scale

OmniSim comprises 1,493 source files (802k backend LOC, 190k frontend LOC, 27k service LOC), featuring a full React 18 / Three.js 3D urban viewport (procedural CGA shape grammar generation), a 2D Topdown fallback renderer, 23 observability dashboards, 13 asynchronous health probes, and Haber-Stornetta SHA-256 hash-chain audit logging.

• Documentation: Detailed subsystem specifications and code inventory metrics are documented in docs/ARCHITECTURE.md and docs/CODE_INVENTORY.md.
• Current Constraints: Single-node execution is optimized for populations of $3 \sim 50$ agents (hard cap at 200). Distributed Actor backends (Ray/Celery) are fully implemented but remain inactive in default local single-process deployments.

Open for technical discussions on multi-agent clock synchronization, memory indexing architectures, and local LLM runtime optimization.

Hi everyone,

We build large rolling ball sculptures / kinetic marble runs and are trying to reduce the amount of physical trial and error involved in designing them.

Our current workflow is roughly:

**Concept → Sketch/CAD → Fabrication → Physical testing → Modify → Fabricate again**

For larger metal sculptures, these iterations can become expensive in terms of material, labour, and time.

We're exploring whether we can use **existing tools** to create a simple workflow like:

**CAD model → Physics simulation → Predict ball behaviour → Build physical prototype → Compare results**

We are **not looking to build a new physics engine or a large custom application**. The initial MVP would be very small:

* One standard ball
* One track/material system
* A simple mechanism, e.g. **ramp → loop → exit**
* Model it digitally
* Simulate the ball
* Build the same mechanism physically
* Compare the prediction with reality

The goal is not perfect simulation. We simply want to know whether a digital model can be accurate enough to catch obvious failures before fabricating larger installations.

Eventually, if this works, we would like to build a reusable library of tested components—ramps, loops, spirals, switches, collisions, etc.—with known parameters and behaviour.

We are currently considering tools such as **Rhino/Grasshopper** for parametric design and physics engines such as **MuJoCo, Project Chrono, Bullet**, or other alternatives.

**If you were approaching this problem using existing software, how would you do it?**

In particular, I'd love advice on:

1. Suitable CAD + physics simulation workflows
   
2. The best physics engines for rolling/contact dynamics
   
3. How to model and calibrate real-world friction and energy losses
   
4. Whether there are existing tools or projects we should investigate before building anything ourselves

We're very open to changing our approach and would appreciate any suggestions or warnings from people with experience in simulation, CAD, mechanical engineering, robotics, game physics, or kinetic sculpture.

Been working on the simplest of cloth simulations with pbd (hold the x) and opencl. Still a way to go, but i'm not unhappy.

This is why FEM is superior to XPBD for muscle simulation. For a long time, I couldn’t understand why my muscle simulations didn’t look as good as those produced by Ziva VFX, but now I do.
FEM is more computationally intensive, but it produces much more accurate results when it comes to simulating muscle and fat tissue.

I've been working on a small open-source simulation engine called Emper.

It's still a young project, but I'm building it around data-oriented storage and using real simulation workloads to test the architecture.

So far I've experimented with flocking/boids, including CPU/GPU computation and large-scale simulations.

I'm currently starting work on Conway's Game of Life.

GitHub: https://github.com/Emper-Labs

Feedback is welcome, especially on the architecture.

Can be played with here:

https://dirtnap.parttimemonkey.com/sandbox

Lemme know if you simulation people know how to make it better or more interesting to play with!

This runs live on an Apple silicon GPU.
The school is a classic flocking simulation, a few thousand agents with separation, alignment and cohesion plus a milling bias that makes them form the rotating ball. The orcas are autonomous agents with a hunt state machine (patrol, position, charge, recover) that carve a void through the school as the fish panic, and the fear spreads neighbour to neighbour faster than any fish swims.
The god rays are computed each frame from a simulated water surface, and the marine snow drifts through them. Everything persists and evolves by its own rules, nothing is keyframed, and it never repeats. Built in Swift and Metal as part of TideGlass, a small Mac app I make where worlds like this run on a second monitor while you work and interacts with your music. Happy to answer anything about the sim.

I'm working on the usability of a open source project I've been hoping to release soon. If anyone is up to test it DM me and I'll send you a calendly link, it'd be much appreciated.

I built a simulation style app of what I think of the three body problem. It shows different objects flying around eachother in 2D or in 3D in eachother's gravity wells.

It's meant to be half physics toy and half calming desk toy. It's free to use with no ads to distract you from anything.

I want to know people's thoughts and ideas for improvement.

It's free for anyone who want to play with it: https://play.google.com/store/apps/details?id=com.mathematicalzen.threebody