https://www.red3d.com/cwr/boids/
It was a java applet (sigh) and unfortunately I have not been able to find a working version. That version based on his three "steering" mechanisms had very realistic movement. Other versions, including this one, which are good do not have that same kind of quality. They look like simulations whereas the Reynolds version, for whatever reason, seemed much closer to watching an actual flock.
No criticism intended, it would just be nice to understand the why the difference.
Looking briefly at the code, it seems the fitness function is simply how close the boids are?
Very cool!
function update_positions(boids, dt)
local max_speed = 0.5 -- per frame
local max_accel = 20 -- per second
local max_turn_angle = math.pi/6 -- per second
for _,boid in ipairs(boids) do
boid.pos = vadd(boid.pos, boid.velocity)
end
for i,boid in ipairs(boids) do
local accel = {x=0, y=0}
accel = vadd(accel, vscale(avoid_others(boid, boids), 20*dt))
accel = vadd(accel, vscale(seek_others(boid, boids), 10*dt))
accel = vadd(accel, vscale(align_with_others(boid, boids), 10*dt))
accel = vadd(accel, vscale(remain_within_viewport(boid), 40*dt))
local curr_heading = vnorm(boid.velocity) -- could be nil
accel = vclamp2(accel, max_accel*dt, curr_heading, max_turn_angle*dt)
boid.velocity = vadd(boid.velocity, accel)
boid.velocity = vclamp(boid.velocity, max_speed)
end
end
The key is the last 4 lines. My intuition here is that the way muscle mechanics work, there are limits on both how fast you can accelerate and also how much you can turn per unit time. That's what vclamp2 is doing. It separately clamps both magnitude and angle of acceleration.
My rough sense after this experience was:
* Boids is not a simple program the way the Game of Life or Mandelbrot set is. The original paper had tons of nuance that we gloss over in the internet era.
* Every implementation I've found is either extremely sensitive to weights or does weird stuff in the steering. Stuff like subtracting velocity from acceleration when the units are different, and so on. There may be a numeric basis for them, but it's never been explained to my satisfaction. Whereas my vclamp2 idea roughly hangs together for me. And the evidence it's on the right track is that a wide variety of weights (the 10s, 20s and 40s above) result in behavior that looks right to me.
It seems like perhaps the visual inputs are another interesting area. What do I (as a boid) do when I see one boid in front of me go right, one go left, for example. But thanks!!
The original paper, published in 1987, is "Flocks, herds and schools: A distributed behavioral model"[1]. The implementation was done in Lisp on a Symbolics 3600 Lisp Machine.
Edit: One quite interesting paragraph from the paper regarding performance:
The boid software has not been optimized for speed. But this report would be incomplete without a rough estimate of the actual performance of the system. With a flock of 80 boids, using the naive O(N²) algorithm (and so 6400 individual boid-to-boid comparisons), on a single Lisp Machine without any special hardware accelerators, the simulation ran for about 95 seconds per frame. A ten-second (300 frame) motion test took about eight hours of real time to produce.
Once again, amazing how far hardware has advanced.
Beyond this i was trying to add a map which effects their movement. (if you wanna check how it looks - https://x.com/attentionmech/status/1925690991555531143)
https://www.youtube.com/watch?v=86iQiV3-3IA
Boids Demo Reel 1987 — Part B:
https://www.youtube.com/watch?v=xBniZYiyrb4
>Early motion tests of the boids model of flocking and related collective motion (herds, schools, crowds). Recorded on a Symbolics Lisp Machine between 1986 and 1987.
Stanley and Stella in “BREAKING THE ICE” - Original Symbolics Tapes Restored & Remastered, 1080p:
https://www.youtube.com/watch?v=aYEp26g14Wk
Craig Reynolds #SCCS2015:
https://www.youtube.com/watch?v=rqP_c5zm89Q
>Pioneer Craig Reynolds shares his groundbreaking work in artificial life and computer animation. Reynolds describes his lifelong fascination with simulating natural complexity computationally. By modeling flocking birds from the bottom up, based on simple rules for how individual birds move, Reynolds made the astonishing flock emerge. This agent-based approach allowed new insights into collective behavior impossible to gather from nature alone. Reynolds reflects on the significance of his iconic 1987 "Boids" model for animating birds in films like Batman Returns. But its influence extends further - to complexity science and understanding real-world systems like traffic flow and crowd dynamics. According to Reynolds, the beauty of simple models is their emergent properties. By distilling phenomena to basic rules, computer simulation uncovers new truths about the world. Join this fascinating conversation with a legend of artificial life and computer graphics.
Blender Tutorial - Full Guide to Boid Particles:
https://www.youtube.com/watch?v=J3TUPYVsxow
"Concierge" clip from 1968 Mel Brooks' "The Producers":
https://www.youtube.com/watch?v=aL6mTMShVyk
>Doity, disgusting, filthy, lice ridden boids.
Just some ideas/suggestions: - Better colors: maybe genes can influence colors a bit? The random colors aren't that great, they're good though for making all the boids distinct. - Zooming: Scroll the mousewheel to Zoom In/Out, drag to move around - Interactive: Click on a Boid, have it be followed around using zoom! - Time controls: Not just framerate, but a % multiplier on simulation speed. - GPU Refactor: I don't think you're doing any of this yet, so maybe optimizing for a GPU-based speedup would be cool? See if you can reach 10,000 boids! Sebastian Lague's video goes into parallelization, just not in JavaScript: https://youtu.be/bqtqltqcQhw
The entities in the video are running super fast for testing purposes, so usually they'd be going a lot slower. They can produce some really pleasing patterns as they move through each other etc.
On the downside its quite expensive vs Boids, for example the video is from a slightly older version and every agent is looking at the closest 32 neighbours + 32 obstacles to compute its own velocity. At high densities you can drop that to e.g. 4 neighbours without appreciable difference, which allows for running e.g. 32k entities at 120fps.
I'm super intrigued by what you've created, especially to hear about running it in a compute shader! I'd love to talk with you more about it, if you're open to it? I briefly looked for a way to get in touch directly but didn't see any contact info -- my email is in my profile, I'd love to connect! :)
(the coolest examples come at about half a minute into the video)
each boid has a string, when boids come close , they produce a offspring with mixed string + mutation age lets boids die too
nothing fancy, just for sake of sim
EDIT: also pushed some fixes in params (allow offsprings at larger distance, etc), but basically if the boids don't end up closer, they won't reproduce and the population dies so play with that and lmk
https://github.com/attentionmech/genetic-boids/blob/485fe482...
I'm reading the code but I don't know what it actually DOES in practice; my guess is that Boids with opposite genomes (binary strings with default length 6) are slightly attracted to eachother.
Highly recommend, especially his older videos on simulations.