← All tools

Complex Systems Interactive tool

Flocking Bird Sandbox

Explore emergent flocking. Lead a flock with your cursor and tune separation, alignment and cohesion to see collective motion emerge from simple local rules.

1.48
0.78
0.42

Getting started

This sandbox demonstrates emergent collective motion using a flock of simple autonomous agents. Each bird only responds to nearby birds and the position of your cursor, yet the group can organise into coherent, fluid motion without any bird knowing the shape or direction of the flock as a whole.

When the page first loads, the birds sit irregularly along the bottom of the sandbox. Move your cursor into the black area to disturb them: they take off and begin following it.

  1. Move the cursor slowly through the sandbox and watch the flock reorganise around the moving target.
  2. Increase Separation to make nearby birds repel one another more strongly. The flock becomes more dispersed and collisions are avoided more aggressively.
  3. Increase Alignment to make each bird match the direction of its neighbours more strongly. The flock tends to form smoother, more coordinated streams.
  4. Increase Cohesion to make birds steer more strongly towards the local centre of nearby birds. The flock contracts into tighter groups.
  5. Try reducing one term almost to zero. The characteristic behaviour of the flock changes dramatically even though the other rules remain unchanged.

The interesting behaviour comes from the interaction between the three rules rather than any one rule in isolation.

The mathematics

The model is based on the classic boids idea: each bird is an agent with a position xi\mathbf{x}_i and velocity vi\mathbf{v}_i. At each update it examines neighbouring birds within a perception radius and constructs three steering terms.

For bird ii, let Ni\mathcal{N}_i denote the set of nearby birds.

Separation

Separation pushes the bird away from neighbours that are too close:

Si=−∑j∈Niws(rij)xj−xi∥xj−xi∥,\mathbf{S}_i = -\sum_{j\in\mathcal{N}_i} w_s(r_{ij}) \frac{\mathbf{x}_j-\mathbf{x}_i} {\|\mathbf{x}_j-\mathbf{x}_i\|},

where

rij=∥xj−xi∥.r_{ij}=\|\mathbf{x}_j-\mathbf{x}_i\|.

The repulsion smoothly fades to zero at the separation radius rather than switching off abruptly.

Alignment

Alignment makes the bird turn towards the local average velocity:

Ai=vdesired−vi,\mathbf{A}_i = \mathbf{v}_{\mathrm{desired}} - \mathbf{v}_i,

with

vdesired=vmax⁡∑j∈Niwijvj∥∑j∈Niwijvj∥.\mathbf{v}_{\mathrm{desired}} = v_{\max} \frac{ \sum_{j\in\mathcal{N}_i} w_{ij}\mathbf{v}_j }{ \left\| \sum_{j\in\mathcal{N}_i} w_{ij}\mathbf{v}_j \right\| }.

Nearby birds contribute more strongly than birds near the edge of the perception radius.

Cohesion

Cohesion first calculates the weighted local centre of the flock,

xc,i=∑j∈Niwijxj∑j∈Niwij,\mathbf{x}_{c,i} = \frac{ \sum_{j\in\mathcal{N}_i}w_{ij}\mathbf{x}_j }{ \sum_{j\in\mathcal{N}_i}w_{ij} },

then steers bird ii towards xc,i\mathbf{x}_{c,i}.

The neighbour weighting used by the sandbox is approximately

wij=(1−rij2R2)2,rij<R,w_{ij} = \left( 1-\frac{r_{ij}^2}{R^2} \right)^2, \qquad r_{ij}<R,

where RR is the perception radius.

The three flocking terms are combined with steering towards the cursor:

ai=ksSi+kaAi+kcCi+kpPi+aedge+aorbit.\mathbf{a}_i = k_s\mathbf{S}_i + k_a\mathbf{A}_i + k_c\mathbf{C}_i + k_p\mathbf{P}_i + \mathbf{a}_{\mathrm{edge}} + \mathbf{a}_{\mathrm{orbit}}.

Here ksk_s, kak_a and kck_c are the Separation, Alignment and Cohesion slider values. They are dimensionless steering weights, not physical constants.

Pi\mathbf{P}_i steers the flock towards the cursor. A small tangential term, aorbit\mathbf{a}_{\mathrm{orbit}}, encourages birds to flow around the target rather than collapsing onto a single point. Soft edge steering keeps birds inside the sandbox.

The model is inspired by Craig Reynolds’ original distributed flocking model: Boids.

How it is computed

The sandbox normally contains roughly 120–215 birds, with the exact population depending on canvas area. Each bird stores its two-dimensional position, velocity, steering acceleration, heading and wing-animation phase.

A naive flocking model would compare every bird with every other bird, requiring approximately N2N^2 neighbour checks. Instead, the sandbox divides the canvas into a spatial hash grid. Birds are inserted into cells with a width equal to the perception radius, and each bird only checks its own cell and the eight surrounding cells.

The main neighbourhood radius is approximately 76 px, while the stronger close-range separation rule acts inside approximately 27 px.

The simulation uses a fixed physics timestep of

Δt=1144 s\Delta t = \frac{1}{144}\ \mathrm{s}

on standard displays. Fixed-step integration prevents changes in browser frame rate from directly altering the flock dynamics. If reduced-motion mode is enabled, the simulation uses a lower update rate and fewer birds.

Steering acceleration is low-pass filtered before it changes velocity:

a~n+1=a~n+α(an−a~n),\tilde{\mathbf{a}}_{n+1} = \tilde{\mathbf{a}}_n + \alpha \left( \mathbf{a}_n-\tilde{\mathbf{a}}_n \right),

where

α=1−e−γΔt.\alpha = 1-e^{-\gamma\Delta t}.

This removes high-frequency steering jitter while preserving a responsive flock. The direction of each bird is also limited to a maximum turn rate, so an agent cannot instantaneously reverse direction.

Bird speed is constrained to approximately 82–205 px/s. Rendering is extrapolated slightly beyond the latest physics state and the displayed heading is smoothed independently, which helps the motion remain visually continuous on high-refresh-rate screens.

Before the first interaction, the physics loop is effectively dormant and the birds are placed irregularly along the lower edge. Entering the sandbox launches them with slightly different initial upward velocities. From that point onwards, the cursor becomes a moving target for the flock.

The flapping wings are purely visual. Their phase differs between birds and their frequency increases slightly with flight speed; the wing animation does not feed back into the flocking equations.

What the model assumes

This is an agent-based behavioural model, not an aerodynamic simulation of bird flight.

Each bird is treated as a point-like agent moving in two dimensions. There is no lift, drag, gravity, body mass, energy expenditure, wake interaction or wing-generated aerodynamics. Birds do not explicitly collide; separation simply makes close approaches increasingly unlikely.

Neighbour awareness is isotropic: a bird can respond to agents around it rather than having a biologically realistic field of view. There are no obstacles, predators, leaders or communication delays. The cursor acts as an artificial moving attractor added to the standard flocking rules.

The slider values control the relative strengths of behavioural rules. They should therefore be interpreted as model parameters, not measurable properties of a real flock.

Most importantly, the global structure is never prescribed. No bird is told to form an arc, stream, cluster or rotating group. Those patterns arise from repeated local interactions between neighbouring agents.

← Explore more tools