SVG Swarm

100%

✓ Published0🌍 Public

Last edited Feb 9, 2016

Created on May 9, 2012

Five hundred steel-blue circles drift in a simulated swarm, their velocities and positions updated each frame with a simple particle model. D3.js v3 binds the data to SVG circle elements, translating each via the `transform` attribute and scaling its radius based on velocity. A `d3.timer` callback drives the animation, while a live FPS counter in the page header reports the update rate. The visualization compares SVG rendering performance against a canvas-based alternative, using D3's linear scales to map the particle coordinates to pixel space.

AI-generated description

Compare to Canvas Swarm.

A response to Trevor Bedford's post, Comparing performance of Processing.js and D3.js.

gpl-3.0 Licensed

Similar vizzes

Loading thumbnail…

Canvas Swarm

A swarm of 500 points drifts and bounces across a canvas, each point’s velocity and position evolving through a simple physics model with random impulses and damping. The animation runs at a target frame rate, with a live FPS counter displayed. The visualization uses D3’s `d3.range`, `d3.scale.linear`, and `d3.timer` APIs, and renders via Canvas `getContext("2d")`, drawing each point as an arc with `beginPath` and `fill`/`stroke`. The data is procedurally generated—no external dataset—and the canvas is cleared each frame with `clearRect`.

Mmbostock

81% match

Loading thumbnail…

Swarmalator

A swarm of colored circles self-organizes into dynamic patterns, with each particle's hue representing its internal phase. The simulation uses `d3.forceSimulation` to integrate pairwise interactions that combine spatial attraction with phase coupling, controlled by adjustable parameters J and K. Colors transition smoothly via an HSL mapping, while an optional temperature mode recolorings particles based on their kinetic energy using an Inferno colormap. The visualization runs on a Canvas element, rendered in real time as the swarm evolves and responds to mouse interaction.

FFrissAnalytics

80% match

Loading thumbnail…

Circles

A field of 1,000 small circles drifts randomly across an SVG canvas, wrapping around the edges when they exit the viewport. A text label in the corner displays a live frames-per-second counter. The animation uses `d3.timer` to update each circle's `cx` and `cy` attributes every frame, with positions stored in a data array generated from `d3.range(1000)` and `Math.random`. The code runs on D3 v3 and renders purely with SVG elements.

Mmbostock

79% match

Loading thumbnail…

Fork of D3 Selection Exploration

This example demonstrates D3 selections and data joins through an animated swarm of circles whose count, position, and size shift continuously over time. It uses `d3.select`, `d3.range`, and `data().join()` to bind an array of simulated points to SVG circle elements, updating their `cx`, `cy`, and `r` attributes in a 60fps `setInterval` loop. The animation responds to a sine-based time variable, creating smooth, organic motion. Rendering happens entirely in SVG within a full-window viewport.

Mmegan-grannan

77% match

Loading thumbnail…

Untitled

A tiny SVG viewport shows 1,000 randomly placed circles bouncing and wrapping around its edges, with a live frames-per-second counter in the corner. The animation runs through `d3.timer`, updating each circle’s `cx` and `cy` attributes based on randomized velocity values. All rendering uses SVG elements and D3’s data join, with positions recalculated on every tick to keep the motion continuous.

KKanishk Mamgain

77% match

Loading thumbnail…

D3-Arrays

Fifteen black circles undulate in a vertical sine-wave pattern across a full-screen SVG. Each circle updates its vertical position based on a time-incremented angular offset, creating a smooth, animated wave. The example uses D3 v7's `select`, `range`, and `symbol` APIs, with a JavaScript `setInterval` driving the animation loop. Data is generated on the fly as an array of position objects, bound to circle elements via D3's data join, while SVG attributes are updated each tick.

Gg1g10

77% match

Loading thumbnail…

SVG Fundamentals

A field of fifteen circles drifts side to side in a smooth wave-like pattern. Built with D3.js, the animation uses `setInterval` to update positions every frame, calculating each circle's `cx` and `cy` from sine and cosine functions. The SVG canvas is created via `d3.select('body').append('svg')`, and circles are joined to the data with a streaming `join('circle')` operation.

GGT-GillesTeuwen

76% match

Loading thumbnail…

Fork of D3 selections

A dynamic swarm of circles fills the screen, with each circle's position and size oscillating smoothly over time based on a sine wave. The visualization demonstrates D3's data join pattern using `selectAll`, `data`, and `join` to efficiently update the SVG elements every millisecond. Built with React, it uses D3's `range` and custom `makeData` and `vizData` functions to generate coordinates and radii from the current time step. The animation runs continuously via `setInterval`, rendering synchronized, wave-like patterns across the viewport.

Bbjfmbeck

76% match