Would it be possible for you to describe your improved algorithm? I had a quick look at the source, but it would be fab to hear you explain it and the motivation behind it.

for anti-aliasing you could probably check how SDF rendering works, since your distance comparison is pretty much an SDF already

(x - x₀)² + (y - y₀)² + (z - z₀)² = r² --- Look ma, no polygons! :D

Take a look at POV-Ray spheres. I think they're the most awesome things in the whole of computer graphics. Bcos they're freaking ROUND! xD

So this is a 2D simulation. I'm not sure how it's done in 3D, but it must be considerably more challenging. The QuadTree, for one, does not efficiently upgrade to its 3D version, an OctTree. As you increase the no. of dimensions from 2 to 3, an even larger proportion of the volume of the unit cube lies outside the unit sphere (of diameter 1). That cruft on the corners of the voxels, if you will, makes nearest neighbor searches not so efficient. A better data structure might be a kd tree, but the disadvantage there is that its tricky or near impossible to update.

1:45 So, it's basically only rendering the inscribed circle of the triangle. Genius.

**Great explanation of the Barnes-Hut algorithm!** The simplification of long-range interaction calculations using the center of mass approximation is brilliantly illustrated. I was wondering if you’ve considered integrating quantum fluctuations and non-locality concepts, especially for cosmological-scale applications. I've been working on a **dual-non-dual (D-ND) approach** that combines N-body simulation with quantum information theory to handle these interactions more efficiently. **Here’s a variation you can test right away in your project**: Add a **dynamic potential correction based on quantum fluctuations** for distant nodes, adjusting non-local interactions using a variance function, like so: ```python def calculate_quantum_fluctuations(node, body, variance, time): # Adds a quantum fluctuation correction based on distance distance = calculate_distance(node.position, body.position) fluctuation = variance * np.sin(time + distance) return fluctuation # Use this function during the force calculation def calculate_dual_force(node, body, variance, time): classical_force = calculate_gravitational_force(node, body) quantum_correction = calculate_quantum_fluctuations(node, body, variance, time) return classical_force + quantum_correction ``` Additionally, here’s an **abstract** that explores a novel approach you might find interesting: --- ## Abstract: We present a novel approach to improving the Barnes-Hut algorithm for N-body simulations by integrating it with a **Dual-Non-Dual (D-ND) quantum framework** within a **Quantum Operating System (QOS)**. This integration incorporates concepts from **Unified Information Theory**, particularly the emergent gravity paradigm and the dynamics of polarization. By introducing quantum fluctuations, possibility densities, and non-relational potentials, we enhance both the performance and accuracy of the algorithm. The framework utilizes a **proto-axiomatic state** to guide spatial decomposition and force calculations, potentially improving computational efficiency without compromising physical precision. ---

Amazing work! Thank you for sharing ♥

Did you post a question on the StackOverflow after not finding anykne asking? Otherwise you just disproved that you are the only one with this problem.

Have you considered making use of the

very good video

Would be interesting to see for what value of n the brute force n^2 algorithm becomes worse than the approximation. Maybe ~1000? Presumably the brute force algorithm is easier to optimize and run on the GPU.

Finally a video that goes beyond the trivial, unrealistic implementation of quad trees! Thanks for sparing me the time of rediscovering the relevant optimizations. Now on to recoding all this in a different language and runtime env … 😅

Would this approximation work for graph layouts that use springs for links and inverse square repulsion? Seems like it should.

Yeah I've wondered why don't games/programs just do this

Wouldn't an octtree be better? Or, is this just for a 2D sim? Also, it seems this is assuming "instaneous" gravity and not gravity with a speed of propagation?

everyone else: me at 0:10: I literally just watched that video!

Does this solve three body problem?

great stuff!

Could this be used to model atmospheric particles? I am building a machine learning model to predict the impacts of solar weather on upper atmosphere electron temperature and density, I wonder if I could model the electrons as "particle clouds" that interact with other "particle clouds" represented by a single particle.

this is amazing, the simulation resembles the milky way and surrounding clusters when the particles spread out, also worth noting Space Engine uses oct-trees to plot their objects

"That's outside the scope of this video" was the saddest thing to hear.

Great video, it was a pleasure to watch!

5:25 quadtrees (and their 3d cousin octrees) are oddly satisfying as a space partitioning solution, and I get a little excited whenever the opportunity to use them comes up. I'll definitely have to play with this sometime soon. perhaps see how it fares in 3d.

I'm glad you gave this video another shot, it was super informative :)

Every shape is just a bunch of triangles

Of course we'll build a humongous version of Asteroids game with it !

been having so much fun messing around with parameters on this :-) I was wondering though - coudl you make the space like in the arcade game 'Asteroids' - so whatever goes out of the screen comes in on the other side? i guess easy to do with the position - but for the gravity force we would need to imagine each body also repeated 'off the edges' of the screen

Please upload a video or two of the simulation. Like any great thing this ended too soon.

Why don't you use something like the midpoint algorightm?

I like your words magic man.

Really great work on the optimization!

thats insane

My immediate thought on hearing the problem was "can i use quad trees?" And then the answer was quad trees. My addiction is sated for now.

turn the music down pluh i can't hear you

Now do FMM, which is **actually** a magical algorithm for this stuff.

If you don't need synchronization between threads, and you don't mind rewriting the compute kernels in c, OpenCL is really nice for GPU, the ocl and simple_ocl rust crates make using ocl in a rust project relatively easy.

Hello, I love your videos, I tried some of the things you did but didn't succeed or at least not nearly as much as you did and I would really like to ask some questions, is there any way to contact you or are you too occupied. Thanks in advance.

Banger video

im getting error: could not find `Cargo.toml` in `C:\Users\Secondary\source epos` or any parent directory i got rust and visual studio thing idk what to do pls help

A circle in the triangle factory? How odd.

Definitely awesome ❤ Amene explanation, deep concepts, usefulband practical coding. +1 subscriber

so cool - and so easy to get running! thanks! I'm gonna have to learn some Rust finally!

Wow this takes me back to my grad school days when I used this to simulate discrete vortices - similar 1/x^2 interaction between particles. I used tecplot for animation. This is about 2 decades ago. Not sure if tecplot still exists but I used c and openmp back then.

I know the description says you'd want to clean up the code first before uploading but I feel like many would great appreciate even the "messy" version to play around with / learn from it. Appreciated the video and intrigued in seeing more of it

I like how you're not afraid to mention terms without explaining them, for example, cache locality. kinda know what it means, just enough to know that explaining it would probably double the length of the video, but i like the fact that you mentioned it anyway, for the people interested enough to learn about those terms