How much can you cut off a 3D shape before it can't grow back?
A real axolotl can lose a leg and grow a new one. We trained a tiny program to do the 3D version of that: grow a voxel shape (a 3D shape built from little cubes, like 3D pixels) from a single starting cell, then regrow it after we cut a chunk away. It works for three shapes out of four. A dense fourth shape fails, and thin shapes recover worst once you cut away a lot. That pattern, of when self-repair holds and when it breaks, is the result.
Why you'd care
Many machine learning models are built from the top down. One big network looks at the whole input and produces the whole answer. Living things are built the other way. No cell can see the whole body. Each one follows the same local rules, reacts to its neighbors, and somehow a hand or a leaf takes shape anyway. That bottom-up process is also what lets a salamander regrow a limb: the same local rules that built it can rebuild it.
A neural cellular automaton (NCA) is a small model that copies this bottom-up style. It has been studied a lot in 2D, on flat pixel images, starting with Mordvintsev and colleagues' 2020 Growing Neural Cellular Automata. In 3D, on voxel shapes, it is much less charted. We cared about a harder question than whether it can grow a shape: how reliably it can heal one after damage. So we trained 3D NCA to grow four shapes and regrow them after damage, and we measured how much damage each shape can take before it stops coming back.
What a neural cellular automaton actually is
Picture a 32 by 32 by 32 grid of cells, about 33,000 of them. Each cell holds a short list of numbers: one that says "am I part of the shape or empty," and a handful of hidden numbers the model uses as scratch space.
There is exactly one update rule, a small neural network, and every cell runs that same rule at every step. A cell can only see its immediate neighbors, so the rule takes in the neighborhood and outputs a small change to the cell's own numbers. Run that update on every cell at once, over and over, and a shape grows out from a single starting cell (the seed). Nothing coordinates the cells from above. The global shape is whatever the shared local rule adds up to.
Training means adjusting that one rule so the grown result matches a target shape. We use the standard recipe for this: keep a pool of grown states, and during training, keep re-running the rule on them so it learns to grow the shape and to hold it steady over long runs. That "hold it steady" part is called persistence. Persistence is what makes self-repair possible.
Self-repair mostly comes for free
The first result is that a model trained with no damage still repaired damage. We trained one model with no damage at all during training. It only ever practiced growing a shape and holding it. Then, at test time, we cut a piece off and let it keep running.
It grew the piece back. We score how well a shape matches its target with IoU (intersection over union), the overlap between the grown shape and the target on a 0-to-1 scale. Recovery after damage is the regrown IoU as a fraction of the pre-damage IoU. For this one no-damage-trained model on the creature shape, mean recovery across the damage tests was 0.999, essentially full recovery, and even its worst single test recovered to 0.78. (That is one shape on a lighter set of cuts. Thin shapes under heavy damage do much worse, as the next section shows.)
Why would a model that never saw damage know how to repair? Because holding a shape steady and repairing it are the same skill. The model has learned that a grown shape is a stable resting point, called an attractor. Damage pushes the cells off it. The same rule that holds the shape then pulls them back. Self-repair falls out of persistence training on its own. We did also train with damage. Once we accounted for run-to-run variation, we could not show that damage during training reliably improved recovery. So we do not claim it does. Persistence alone was enough to get repair.
Recovery falls as you cut away more
Repair is not all-or-nothing. Cut off a little and recovery is nearly perfect. Cut off enough and recovery slips. For some shapes it never comes back.
To make this precise, we swept the severity of the damage, meaning the fraction of the shape we removed, from light to heavy. At each level we measured how much of the shape's pre-damage quality came back. Plotting recovery against severity gives a curve per shape, a compact "phase diagram" of when self-repair holds and when it breaks.
Thin and branchy. Recovers well under light damage, then drops sharply to about 0.14. Each point is the average recovery over four damage types at that severity (1.0 means fully recovered to pre-damage quality). Values are measured at nine severities; the line connects them. Thin structures drop sharply; bulky ones degrade gradually.
The curves tell the main story. Each point is the average recovery over four kinds of damage at that severity. Every shape recovers almost fully when the damage is light. As severity climbs, recovery falls. How fast it falls depends on the shape. The tree is thin and branchy. It recovers almost fully under light damage, then drops sharply: once a big fraction of a thin branch is gone, there is not enough structure left to regrow it. Recovery falls to about 0.14 when 90% is removed. The bulkier creature and chair decline gently instead, still reaching about 0.71 and 0.68 recovery even when 90% of the volume is removed. Geometry, not just training, sets how steep that drop is. One caution about the curves: each point averages four kinds of damage, and the kinds spread out under heavy damage. For the tree at 60% removed, recovery ranges from about 0.51 to 0.81 depending on the cut. Read the curves as trends, not exact values.
The shape that grows best heals worst
The shape the model grows most accurately is the one it repairs worst, the reverse of what you might expect.
Grows the most accurately of the four shapes, yet repairs the worst under heavy damage.
Growing well and healing well are different properties. Switch shapes: the tree tops the growth bar and bottoms the repair bar, the creature does the opposite.
The thin tree is the easiest shape to grow. Its grown accuracy is 0.99, the highest of the four, and it holds that shape almost perfectly over long runs (0.98). Yet under heavy damage it repairs the worst: after 90% removal, recovery is only about 0.14. The creature is the reverse: it grows less sharply (0.73) but recovers about 0.71 under that same heavy damage. Growth fidelity and regeneration robustness are not the same property. They can point in opposite directions.
The reason is the same geometry behind the phase-diagram curves. A thin branch is easy to draw and easy to hold, because there is not much of it. But when you cut a thin branch off, you remove almost all the local signal the model would have used to know where to regrow. A bulky shape is harder to grow accurately, but its extra mass helps. Damage removes a smaller share of the surrounding context, so the rule still knows what to rebuild.
What didn't work
Three results we report as negative. Each one marks an edge of where this works.
- The dense torus failed. Of the four shapes, the torus is the densest, filling 8.2% of the grid versus under 3% for the others. On some random seeds it trained and repaired well. On others the whole grid went empty and stayed that way. A fully empty grid is a dead end: with no live cells, the local rule has nothing to act on, so it cannot recover. Dense, thick shapes are where this approach is still unreliable. We report the torus as a failure.
- It took six tries to get stable at all. Our first five 3D recipes all collapsed to that empty-grid state. The fix was a set of anti-collapse choices: start growth from a tiny seed, balance how the model is scored so it does not over-grow or die back, and restart any patch of grid that goes dead during training. 3D NCA are unstable to train. Most of the engineering went into preventing collapse.
- We could not prove damage training helps. Two runs with the exact same settings gave worst-case recovery of 0.72 and 0.81, a spread of about 0.1. The improvement we hoped to attribute to damage-during-training was about 0.03, smaller than that noise. So we dropped the claim. Persistence training already gives you repair. We cannot show damage training adds to it here.
Where this doesn't hold
These numbers are from single training runs at 32 by 32 by 32 resolution, on four shapes. They are an initial characterization, not a benchmarked comparison against other methods. The run-to-run spread is about 0.1 on worst-case recovery. Treat single-shape numbers as approximate. The torus result says the dense regime is unsolved here. Bigger grids, more shapes, and multiple seeds per shape are all needed before any of this generalizes.
Takeaways
- Self-repair can emerge from persistence alone. If you train a local rule to hold a shape as a stable resting point, it will often regrow that shape after damage without ever being trained on damage.
- Regeneration degrades smoothly with damage, and geometry sets the pace. Recovery falls as you remove more. Thin structures drop faster than bulky ones. A single recovery-versus-severity curve captures this per shape.
- Growing well and healing well are different properties. The shape our model grew most accurately was the one it repaired worst. If you care about robustness, measure repair directly. Do not read it off growth quality.
- Report the collapse. The dense shape that failed and the improvement we could not prove are part of the result. They mark the edge of where this works.