In the tree simulation project, growth emerged from local pixel rules. Each pixel looked at its neighbors and decided whether to grow, thicken, or produce leaves. This worked well because trees naturally grow through branching structures that expand into empty space.

However, when applying the same approach to animal-like organisms, a problem appears.

Animals are not just collections of pixels expanding outward. They have structured body plans: spines, limbs, organs, and symmetry. These structures must develop gradually and proportionally over time.

This realization led to a new direction for the creature simulation.

The Problem: Spine Locking

In the current prototype, the creature grows its entire spine first.

This introduces a structural issue.

Even when the creature is supposed to represent an infant stage, the spine already exists in its final adult position. The rest of the body simply fills in around it.

This locks the organism into an adult layout too early in development.

As a result:

• Infant proportions cannot differ from adult proportions

• Limb placement is fixed too early

• Development becomes a visual scaling problem rather than a biological growth problem

To solve this, we need a different internal representation of the organism.

Two Possible Solutions

Approach 1 — Rendering Scale

One solution is purely visual.

We could render the creature smaller when it is young and scale it up as it grows.

In this case, the organism structure never changes. Only the rendering scale changes.

While simple, this approach does not actually model development. It only simulates growth visually.

Approach 2 — Vector-Based Body Representation

A more interesting approach is to change how the organism itself is represented.

Instead of storing the organism as a pixel map, we represent it as a vector-based structure encoded inside a texture.

In this model, the organism becomes a compact set of control points or joints, similar to a scene graph.

Packing an Organism into a Texture

Imagine we have a small texture.

For example:

4 × 4 texture
RGBA channels

Flattening this gives us 16 slots.

Each slot can store structured data describing part of the organism.

Example encoding:

i = 0  → dx, dy, dz of first spine segment relative to head
i = 1  → dx, dy, dz of second spine relative to first spine
i = 2  → third spine segment
...
i = 9  → left shoulder socket
i = 10 → right shoulder socket
...
i = n  → hip sockets

The head becomes the origin point, and all other body structures are defined relative to it.

Instead of drawing pixels directly, the shader interprets these packed values to reconstruct the body structure.

What This Changes

With this representation:

• The organism is no longer a rigid pixel skeleton.

• The body becomes a parametric structure.

• Development can modify structural relationships over time.

Examples:

• Infant spine spacing can differ from adult spacing

• Limb attachment points can shift during development

• Body proportions can change as the organism matures

This creates true developmental growth, not just visual scaling.

---

Simulation Inside the Shader

The simulation still happens in parallel on the GPU.

Each texel represents a node in the organism structure.

Like the tree simulation, the update process works in discrete frames:

state(t) → state(t+1)

Each node:

1. Reads its own state from the previous frame

2. Reads nearby nodes from the texture

3. Applies its local rules

4. Writes its updated state

This allows the entire organism to update fully in parallel.

Parallel Node Execution

Each node behaves like a cellular automaton unit, but instead of representing a pixel in space, it represents a structural component of the organism.

Nodes may represent:

• spine segments

• limb joints

• sockets

• organs

• internal systems

Each node runs its own logic independently.

node_i(t+1) = F(node_i(t), neighbors_i(t))

Where neighbors are nearby structural nodes.

To keep the system efficient, we can restrict node lookups to a small neighborhood in the texture, such as adjacent indices.

This preserves the key property of the previous simulation:

massive parallelism with no write conflicts.

Beyond Skeletons

Although the structure resembles a skeleton, the goal is broader.

The same texture-packing strategy can encode additional biological systems.

Examples include:

• blood circulation

• lymphatic transport

• respiratory system

• digestive system

• neural signals

Each system can occupy additional channels or slots in the texture, similar to how the tree simulation used multiple layers of environmental data.

The organism becomes a multi-system simulation encoded in compact GPU memory.

Why This Matters

The shift from pixel maps to vector-encoded organisms enables something important.

It allows organisms to develop, rather than simply appear.

Growth becomes a transformation of structure rather than a scaling of graphics.

This makes it possible to simulate:

• body plan formation

• proportional growth

• internal biological systems

• articulated movement

All while keeping the simulation fully parallel and GPU-friendly.

The Goal

The goal is not merely to animate creatures.

The goal is to create a developmental substrate where organisms can grow according to structural rules.

Just as the tree simulation created believable plant growth through local interactions, this system aims to create animal development through structural emergence.

This approach preserves the core philosophy:

complex life emerging from simple rules

But it moves the simulation from pixel space to structural vector space.