mahnoor·fatima

computational creative direction

PULSE

Slime-mold optimization identity for a mobility and logistics network

NETWORK Hold to lay down food and pull the network toward you

SEED 0X5EA2 RE-SOLVING

PULSE

Volume IX — A mobility and logistics network

Computational Creative Direction — Slime Mold Optimization

The research question

What if a brand behaved according to one computational law — the one a brainless slime mold uses to rebuild the Tokyo rail map overnight?

PULSE routes things through cities: people, packages, power. Its whole product is finding the efficient path through a shifting network — which is precisely what Physarum polycephalum, the slime mold, does without a brain. Given food sources, it grows a web, then reinforces the tubes carrying the most flow and starves the rest, converging on a network that rivals human-engineered transit systems. PULSE’s identity runs that same algorithm live: it is a network that thickens where it’s used and fades where it isn’t.

The computational principle

Slime-mold (Physarum) optimization is agent-based path-finding. Thousands of simple agents deposit a chemical trail as they move and steer toward stronger trails — a positive feedback loop. Paths that get traffic get reinforced; paths that don’t evaporate. Out of that emerges a transport network that balances efficiency against resilience, the same trade-off every logistics planner fights. It’s decentralized intelligence: no agent plans the network, yet the network is planned.

The behavior engine

One agent field drives the mark, the type, and the live route maps. Agents lay trail; trail evaporates; the surviving veins are the brand.

// Physarum agents + trail field — the entire PULSE engine
class Pulse {
  constructor(w, h, count = 4000) {
    this.w = w; this.h = h;
    this.trail = new Float32Array(w * h);          // pheromone map
    this.agents = Array.from({ length: count }, () => ({
      x: Math.random() * w, y: Math.random() * h,
      a: Math.random() * Math.PI * 2
    }));
  }

  sample(x, y) {                                   // read trail, wrapping edges
    const w = this.w, h = this.h;
    const ix = ((x | 0) % w + w) % w, iy = ((y | 0) % h + h) % h;
    return this.trail[ix + iy * w];
  }

  step({ speed = 1, sensorAngle = 0.5, sensorDist = 9,
         turn = 0.4, evaporate = 0.96, deposit = 5 } = {}) {
    const w = this.w, h = this.h;
    for (const ag of this.agents) {
      // sense trail ahead, left, and right
      const f  = this.sample(ag.x + Math.cos(ag.a) * sensorDist,
                             ag.y + Math.sin(ag.a) * sensorDist);
      const l  = this.sample(ag.x + Math.cos(ag.a - sensorAngle) * sensorDist,
                             ag.y + Math.sin(ag.a - sensorAngle) * sensorDist);
      const r  = this.sample(ag.x + Math.cos(ag.a + sensorAngle) * sensorDist,
                             ag.y + Math.sin(ag.a + sensorAngle) * sensorDist);
      if (f < l && f < r) ag.a += (Math.random() < 0.5 ? -turn : turn);
      else if (l > r) ag.a -= turn;
      else if (r > l) ag.a += turn;                // steer toward strongest trail

      ag.x = (ag.x + Math.cos(ag.a) * speed + w) % w;
      ag.y = (ag.y + Math.sin(ag.a) * speed + h) % h;
      this.trail[(ag.x | 0) + (ag.y | 0) * w] += deposit;   // lay pheromone
    }
    for (let i = 0; i < this.trail.length; i++) this.trail[i] *= evaporate; // fade
  }

  feed(x, y, amount = 200) { this.trail[(x | 0) + (y | 0) * this.w] += amount; }
}

feed() places attractors — cities, depots, demand — and the veins grow between them on their own. The evaporation rate is PULSE’s master dial: high evaporation gives a lean, efficient network; low evaporation gives a redundant, resilient one.

The visual language

Every PULSE surface is a vein network — glowing pathways that thicken with traffic and thin toward the edges. The mark is the emergent web between a fixed set of nodes; because the agents re-solve it every session, the exact routing differs, but the topology reads as PULSE — a living circulatory system. The aesthetic is anatomical and electric: dark ground, bright filaments, the look of a nervous system or a lit-up transit map.

Living typography

Letters are destinations the network connects. Each glyph’s key points are seeded as food sources; agents grow veins between them, and the letterform emerges as the reinforced path. Heavily “trafficked” letters — a brand name, a headline — grow thick, confident strokes; incidental text stays thin and capillary. Type looks routed rather than drawn, and it pulses with the flow along it.

Motion rules

  • Use thickens, disuse fades. The identity continuously reinforces active paths and evaporates idle ones — it’s never finished optimizing.
  • Live demand reshapes it. Real network load feeds attractors, so the brand’s veins swell exactly where the real network is busy.
  • Pulse. Flow travels the veins as rhythmic pulses of light, tempo tied to throughput.
  • Reroute on obstruction. Block a path (an outage, a cursor) and the agents find a new route in seconds, visibly.

Interactive website

The site is a circulatory system you travel through. Sections are nodes; moving between them sends a pulse of agents that reinforces the vein you took, so the paths you use most literally grow thicker on your personal map. A live network-status view uses the same engine as the logo — brand and operational dashboard are one system at two scales.

Physical applications

  • Transit & logistics maps: real routes rendered as a live Physarum network — the map optimizes in front of the viewer.
  • Operations centers: wall-scale vein displays of the live network, pulsing with actual throughput.
  • Print: captured at a solved state, each unique to its demand snapshot.
  • Station wayfinding: signage that shows the network breathing, not a frozen diagram.

The brand system

Guidelines define network states: named regimes (Seek, Reinforce, Optimize, Resilient, Reroute) each specifying evaporation, deposit, and legibility. “On-brand” means the network is running in a state matched to context — a stable service map runs Optimize (lean, resolved); an incident view runs Reroute (searching, redundant).

Color: near-black ground, vein amber, flow cyan, hot coral for congestion, dim slate for evaporating paths. Trail strength maps to hue — the busiest veins burn coral, the fading ones cool to slate.

Open-source behavioral library

Shipped as pulse.js, an eight-verb API over the agent field:

const net = new Pulse(canvas, { agents: 4000 });

net.Feed(point, amount);   // place demand — veins grow toward it
net.Reinforce(path);       // pump flow along a route — it thickens
net.Evaporate(rate);       // set decay — leaner or more redundant network
net.Sense(angle, dist);    // tune agent perception — smoother or sharper webs
net.Reroute(obstacle);     // block a path — the network finds another
net.Pulse(bpm);            // send rhythmic flow down the veins
net.Prune();               // let unused paths fully fade
net.Solve(nodes);          // grow the optimal network between a set of nodes

Reflection

PULSE was about an identity that is never done. Most logos are solved once and locked; this one re-optimizes every time it runs, because the network it depicts is always changing. That meant designing a process with a recognizable signature rather than a fixed image — tuning the agents so the web always looks like PULSE even though it’s technically different every second.

The lasting idea: slime mold is proof that intelligence can be decentralized and emergent, which is exactly the promise a modern logistics network makes. PULSE’s identity doesn’t claim to be smart — it demonstrates it, re-solving its own routing in front of you, thickening where you travel and letting the rest fade.