5.2.1 Boids — Flocking from Three Rules

Overview

A starling murmuration looks like one organism, but each bird is following three rules and looking at maybe seven neighbours. Craig Reynolds published that observation in 1987 as the boids algorithm — short for bird-oid objects — and it became the canonical demonstration of emergent behaviour, the way that complex global patterns arise from agents that share no global view [1]. In this lesson you will implement separation, alignment, and cohesion, render 30 boids into a 400×400 GIF, and feel the moment when the system tips from random drift into coordinated motion. The same three-rule recipe ran the bat swarm in Batman Returns (1992) and the wildebeest stampede in The Lion King (1994); it has not aged a day.

Learning objectives

1. Articulate what “emergent behaviour” means — and why local rules are sufficient to produce global coordination.
2. Implement the three boids rules: separation (avoid crowding), alignment (match heading), and cohesion (stay together).
3. Use a perception radius to give each boid a local neighbourhood — and recognise that radius as the algorithm’s only knob with units.
4. Tune rule weights to dial the flock from “diffuse cloud” to “tight ball” to “parallel stream”.

Quick start — see the flock in action

The simplest possible flock — cohesion only, no neighbours, just everyone steering toward the centre of mass.

import numpy as np
from PIL import Image, ImageDraw
import imageio.v2 as imageio

positions = np.random.rand(30, 2) * 400
velocities = (np.random.rand(30, 2) - 0.5) * 4

frames = []
for _ in range(150):
    img = Image.new('RGB', (400, 400), (20, 20, 30))
    draw = ImageDraw.Draw(img)
    for x, y in positions:
        draw.ellipse([x - 3, y - 3, x + 3, y + 3], fill=(0, 200, 200))
    frames.append(np.array(img))

    centre = positions.mean(axis=0)
    positions += (centre - positions) * 0.01 + velocities * 0.5
    positions %= 400  # wrap at edges

imageio.mimsave('simple_flock.gif', frames, fps=20)

Core concepts

Concept 1 — Emergence from local rules

Each boid sees only the neighbours inside its perception radius — typically 50 pixels in a 400×400 canvas. It applies three steering rules to those neighbours, sums the resulting forces, and updates its velocity. That is the entire algorithm. No boid knows where the flock is going, what shape it is, or how big it is. The flock is not represented anywhere in the program — it is what you see from the outside [2].

This is self-organisation in the technical sense: the global pattern is not designed, planned, or coordinated. It is a side-effect of local interactions [3]. The same dynamic shows up in slime moulds, ant colonies, traffic jams, and applause synchronising in a concert hall.

Concept 2 — The three rules

Separation — steer away from neighbours that are too close. Without it the flock collapses to a point.

if distance < personal_space:
    away = my_position - neighbour_position
    separation_force += away / distance     # 1/d weighting

Alignment — match the average velocity of nearby neighbours. Without it the flock has no direction.

average_velocity = neighbour_velocities.mean(axis=0)
alignment_force = average_velocity - my_velocity

Cohesion — steer toward the centre of mass of nearby neighbours. Without it the flock falls apart.

centre_of_mass = neighbour_positions.mean(axis=0)
cohesion_force = centre_of_mass - my_position

Concept 3 — Rule weights as flock personality

The same three rules with different weights produce flocks with completely different temperaments. There is no “correct” set of weights — the choice is aesthetic.

Push separation high and the flock spreads into a nervous cloud. Push cohesion high and it balls up and bounces around its own centre. Push alignment high and it streams in parallel lanes like a school of fish.

Exercises

Three exercises in Execute → Modify → Create order: run the canonical simulation, retune its weights, then add a fourth rule of your own.

CREATE III.

Add a fourth rule — obstacle avoidance

Use boids_starter.py, which contains the three rules already wired up and an unimplemented obstacle_avoidance(positions) function. Add a circular obstacle at the centre of the canvas and make boids steer around it.

boids_starter.py — Exercise 3 scaffold

Requirements

• Boids within 1.5 * OBSTACLE_RADIUS of the obstacle centre should steer away.
• The avoidance force should be stronger when the boid is closer.
• The force should point directly away from the obstacle centre.

Hint 1 — distance to obstacle

obstacle_centre = np.array([OBSTACLE_X, OBSTACLE_Y])
direction = positions[i] - obstacle_centre
distance = np.sqrt((direction ** 2).sum())

direction is the vector from the obstacle to the boid. Its length is the distance.

Hint 2 — falloff with distance

if 0 < distance < OBSTACLE_RADIUS * 1.5:
    unit = direction / distance
    strength = (OBSTACLE_RADIUS * 1.5 - distance) / distance
    steering[i] = unit * strength

strength is large when distance is small and falls to zero at the perception edge. The pattern mirrors separation — both rules are “push away, harder when closer”.

Complete solution

def obstacle_avoidance(positions):
    steering = np.zeros_like(positions)
    obstacle_centre = np.array([OBSTACLE_X, OBSTACLE_Y])
    for i in range(len(positions)):
        direction = positions[i] - obstacle_centre
        distance = np.sqrt((direction ** 2).sum())
        if 0 < distance < OBSTACLE_RADIUS * 1.5:
            unit = direction / distance
            strength = (OBSTACLE_RADIUS * 1.5 - distance) / distance
            steering[i] = unit * strength
    return steering

Add OBSTACLE_WEIGHT * obstacle_avoidance(positions) to the velocity update with OBSTACLE_WEIGHT ≈ 2.5 so it dominates other rules when active.

Make it your own

• Add a predator that moves toward the nearest boid. All boids within a large “fear radius” steer directly away. The flock will fragment and re-form behind the predator.
• Replace the wrap-at-edges rule with bounded edges that apply a soft repulsive force at the canvas border — more biological than the toroidal wrap.
• Colour each boid by the magnitude of its current velocity. The flock now visualises its own energy field.

Downloads

Summary

Common pitfalls to avoid

• Forgetting to clip the maximum force magnitude. Two boids inside each other’s personal space can teleport on the next frame.
• Iterating for i in range(n): for j in range(n) for the neighbour search. Vectorise with cdist or a KD-tree for n > 200.
• Dividing by distance without a distance > 0 guard. A boid eventually overlaps with itself or a duplicate and the simulation explodes.
• Tuning weights without re-randomising the seed each run. You will mistake one lucky initial condition for the algorithm’s behaviour.
• Edge-wrapping in pixel space without also wrapping in the neighbour search. Boids on opposite sides of the canvas should see each other if the world is toroidal.

References