💻 computer science

Neural Particle Automata: Learning Self-Organizing Particle Dynamics

This paper introduces Neural Particle Automata (NPA), a learnable, particle-based generalization of Neural Cellular Automata that utilizes differentiable Smoothed Particle Hydrodynamics operators to enable scalable, self-organizing dynamics for tasks like morphogenesis and texture synthesis.

Original authors: Hyunsoo Kim, Ehsan Pajouheshgar, Sabine Süsstrunk, Wenzel Jakob, Jinah Park

Published 2026-06-25

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Hyunsoo Kim, Ehsan Pajouheshgar, Sabine Süsstrunk, Wenzel Jakob, Jinah Park

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine a flock of birds or a school of fish. Each individual bird or fish is simple; it doesn't have a master plan or a map of the whole ocean. Instead, it just follows a few basic rules based on what its immediate neighbors are doing: "If the bird to my left moves up, I move up too." Yet, when you look at the whole group, they form complex, beautiful, and coordinated shapes that seem to have a life of their own.

This paper introduces a new computer model called Neural Particle Automata (NPA) that teaches computers to do exactly this, but with digital "particles" instead of birds.

Here is a simple breakdown of how it works and what it can do:

1. The Old Way vs. The New Way

The Old Way (Neural Cellular Automata): Imagine a grid of pixels on a screen, like a chessboard. In the old models, every square on the board is fixed. Even if a square is empty and nothing is happening there, the computer still checks it every second. It's like checking every single house in a city to see if anyone is home, even if you know 90% of the houses are empty. This wastes energy and limits how the shapes can move.
The New Way (NPA): Instead of a fixed grid, imagine a bag of marbles floating in space. These marbles can move anywhere. Each marble has a tiny "brain" (a neural network) that looks only at the marbles immediately around it. If a marble moves, it takes its brain with it. This is much more efficient because the computer only pays attention to where the marbles actually are.

2. How the Marbles "See" Each Other

Since the marbles aren't stuck in a grid, they can't just look "left" or "right." To solve this, the authors gave the marbles a special sense called SPH (Smoothed Particle Hydrodynamics).

Think of SPH like a "social radius." Each marble has an invisible bubble around it. Inside that bubble, it can feel the presence of other marbles. It can sense:

Density: "Are there a lot of marbles crowding me?"
Gradients: "Is the crowd getting thicker or thinner in a specific direction?"
Neighbors: "What are the colors or states of the marbles touching my bubble?"

The computer uses these feelings to decide how to move or change the marble's color.

3. What the Computer Learned to Do

The researchers taught these digital marbles to learn rules by trial and error (using a neural network). They showed the system a goal, and the marbles had to figure out how to rearrange themselves to match it. They demonstrated three main tricks:

Growing Shapes (Morphogenesis): They started with a messy, egg-shaped cloud of marbles. The computer learned a rule that made the marbles dance and rearrange themselves until they formed specific shapes, like emojis (a smiley face, a heart) or 3D objects (like a vase or a dinosaur). The marbles didn't just sit there; they actively flowed into place.
Painting Textures: They asked the marbles to create complex patterns, like wood grain or fabric. The marbles moved around to match the colors and density of a target picture, essentially "painting" the image by organizing themselves into the right spots.
Classifying Digits: They turned numbers (like the digit "7") into a cloud of dots. The dots talked to their neighbors, passing information back and forth. Eventually, every single dot in the cloud "agreed" on what number it was looking at, without any central boss telling them the answer.

4. Why This is Cool (The "Superpowers")

The paper highlights a few special features of this system:

Self-Healing: If you take a hammer and smash a chunk of the shape (or erase some marbles), the system doesn't crash. The remaining marbles keep following their rules, and the shape slowly repairs itself, filling in the hole.
No Central Boss: There is no single computer telling the marbles where to go. Every marble makes its own decision based on local rules, yet the whole group acts as one.
Flexible Size: The system works whether you have 1,000 marbles or 100,000. It doesn't matter if the resolution changes; the rules stay the same.

5. The "Secret Sauce"

To make this run fast on a computer, the authors built special software (using something called CUDA kernels) that acts like a super-efficient librarian. Instead of checking every marble against every other marble (which would be too slow), the librarian quickly groups marbles that are close together and only checks those groups. This allows the simulation to run in real-time, even with thousands of moving parts.

In summary: The paper presents a new way to teach computers to simulate self-organizing systems. Instead of using a rigid grid, they use moving particles that talk to their neighbors. This allows for shapes that can grow, heal, and adapt, much like living organisms, but entirely driven by learned mathematical rules.

Technical Summary: Neural Particle Automata (NPA)

Problem Statement

Existing Neural Cellular Automata (NCA) models, while successful in learning self-organizing dynamics for tasks like texture synthesis and morphogenesis, are structurally limited by their reliance on fixed Eulerian lattices (static grids). In these systems, cells are pinned to pixels or voxels with static neighborhood relations. This leads to computational inefficiency in inactive regions and struggles to model heterogeneous dynamics where cells must act as individual entities with continuous positions. Conversely, existing particle-based self-organizing systems (e.g., Particle Life, Clusters) operate on dynamic particles but rely on hand-crafted, non-learnable interaction rules. There is a lack of a framework that combines the robustness and expressivity of learned NCA rules with the flexibility and sparsity of dynamic particle systems.

Methodology

The authors introduce Neural Particle Automata (NPA), a Lagrangian generalization of NCA that transitions from static lattices to dynamic particle systems. In NPA, each cell is represented as a particle with a continuous position $\mathbf{x}_i$ and an internal state $\mathbf{S}_i$ , both updated by a shared, learnable neural rule.

Core Components

Differentiable SPH Perception: To replace grid-based convolutions with mesh-free perception, the authors employ Smoothed Particle Hydrodynamics (SPH) operators. These operators estimate local neighborhood features (density, gradients, smoothing) via kernel-weighted sums over nearby particles within a support radius $\epsilon$ .
- Operators: The framework utilizes Poly6 kernels for smoothing and Spiky kernels for gradients. Key operators include density estimation ( $\rho_i$ ), state smoothing ( $\tilde{\mathbf{S}}_i$ ), density gradients ( $\nabla \rho_i$ ), and state gradients ( $\nabla \mathbf{S}_i$ ).
- Differentiability: The authors analytically derive backward formulations for all SPH operators to enable end-to-end training. To ensure stability, they use a first-order gradient correction for the forward pass but detach the moment matrix inversion during backpropagation.
- Implementation: To handle the quadratic scaling of naive particle interactions, the authors implement memory-efficient, CUDA-accelerated kernels using hash-grid acceleration. They offer two strategies: a particle-centric approach using Morton hashing and a grid-centric approach utilizing shared memory for cooperative neighbor loading.
Neural Update Rule:
- At each step, every particle constructs a perception vector $\mathbf{Z}_i$ comprising its own state, smoothed state, state gradients, and density gradients.
- A shared Multi-Layer Perceptron (MLP) $f_\theta$ maps $\mathbf{Z}_i$ to an update increment $\Delta \mathbf{y}_i$ .
- For dynamic particles, the update includes both position ( $\Delta \mathbf{x}_i$ ) and state ( $\Delta \mathbf{S}_i$ ) changes.
- Updates are applied additively using a stochastic update mask (Bernoulli distribution) to reduce reliance on global synchronization, mimicking biological asynchronous updates.
Training Stability and Equivariance:
- Normalization: Particle masses are normalized to maintain constant total mass, ensuring invariance to particle count changes.
- Scaling: The system is designed to be equivariant to spatial scaling by normalizing inputs and scaling displacement vectors relative to the support radius.
- Stabilization: To prevent training divergence caused by large vector magnitudes, the authors apply a logarithmic scaling to vector-valued perception terms. Gradients with respect to particle positions are stopped during the perception phase to improve convergence.

Key Contributions

Framework Definition: The proposal of NPA as a compact neural model for learning self-organizing particle dynamics, bridging the gap between NCA and particle systems.
SPH Integration: The novel application of differentiable SPH operators as a mesh-free perception mechanism within an NCA architecture, allowing for local interaction on unstructured, dynamic data.
Scalable Implementation: The development of custom CUDA kernels that avoid naive all-pairs interactions, enabling scalable training and inference for large particle sets.
Demonstrated Capabilities: The validation of NPA across three distinct tasks:
1. Morphogenesis: Self-organizing from "egg-like" seeds into target 2D and 3D shapes (e.g., emojis, NeRF objects) via dynamic particle rearrangement.
2. Texture Synthesis: Generating complex RGBA textures from uniform seeds where particles self-organize to match target density and color distributions.
3. Distributed Classification: Achieving global consensus on point cloud classification (PointMNIST) through purely local particle interactions, reaching 98.42% accuracy.

Results and Properties

The paper demonstrates that NPA retains key NCA behaviors such as robustness and regeneration.

Robustness: The models generalize across different particle counts ( $N$ ) and support radii ( $\epsilon$ ) at inference time without retraining.
Regeneration: NPA can recover from perturbations such as state erasure, "cut-like" disruptions, or particle clumping, continuously repairing the target structure through the learned local rule.
Emergent Behaviors: The models exhibit persistent internal flows (vortex-like trajectories) even after target shapes are reached, suggesting a distributed memory mechanism. Furthermore, independently trained NPA "species" can interact within the same simulation, exhibiting cooperation or disruption.
Efficiency: While NPA training is slower per iteration than grid-based GrowingNCA due to the complexity of SPH perception, it is significantly more memory-efficient (using ~6.2 GB vs. 11.4 GB for comparable detail levels in 2D morphogenesis).

Significance and Claims

The authors position NPA as a significant step toward real-time, interactive graphics applications and distributed system modeling. By decoupling the learnable update rule from the spatial perception operator, NPA offers a framework that is:

Hardware-friendly: Due to localized processing and lack of global synchronization.
Resolution and Topology Agnostic: Capable of generalizing across different particle counts and spatial scales.
Self-Correcting: Capable of recovering from errors over time without global intervention.

The paper concludes that NPA provides a "compact neural model" for learning self-organizing systems, offering a path toward applications in fluid simulation optimization, point-cloud denoising, texture synthesis on manifolds, and the control of distributed dynamic systems like drone swarms. The authors acknowledge limitations, including the inability to merge or split particles (fixed particle count) and sensitivity to hyperparameters, suggesting future work in learning particle topology changes and rotation-invariant architectures.