A few months back, while playing around with , I came across something that completely derailed my plans. Strange attractors - fancy math that creates beautiful patterns. At first I thought I'd just render one and move on, but then soon I realized that this is too much fun. When complexity emerges from three simple equations, when you see something chaotic emerge into beautiful, it's hard not to waste some time. I've spent countless hours, maybe more than I'd care to admit, watching these patterns form. I realized there's something deeply satisfying about seeing order emerge from randomness. Let me show you what kept me hooked.

The Basics: Dynamical Systems and Chaos Theory

Dynamical Systems are a mathematical way to understand how things change over time. Imagine you have a system, which could be anything from the movement of planets to the growth of a population. In this system, there are rules that determine how it evolves from one moment to the next. These rules tell you what will happen next based on what is happening now. Some examples are, a pendulum, the weather patterns, a flock of birds, the spread of a virus in a population (we are all too familiar with this one), and stock market.

There are two primary things to understand about this system:

• Phase Space: This is like a big collection of all the possible states the system can be in. Each state is like a snapshot of the system at a specific time. This is also called the state space or the world state.
• Dynamics: These are the rules that takes one state of the system and moves it to the next state. It can be represented as a function that transforms the system from now to later.

For instance, when studying population growth, a phase-space (world-state) might consist of the current population size and the rate of growth or decline at a specific time. The dynamics would then be derived from models of population dynamics, which, considering factors like birth rates, death rates, and carrying capacity of the environment, dictate the changes in population size over time.

Another way of saying this is that the dynamical systems describe how things change over time, in a space of possibilities, governed by a set of rules. Numerous fields such as biology, physics, economics, and applied mathematics, study systems like these, focusing on the specific rules that dictate their evolution. These rules are grounded in relevant theories, such as Newtonian mechanics, fluid dynamics, and mathematics of economics, among others.

Chaos Theory

There are different ways of classifying dynamical systems, and one of the most interesting is the classification into chaotic and non-chaotic systems. The change over time in non-chaotic systems is more deterministic as compared to chaotic systems which exhibit randomness and unpredictability.

Chaos Theory is the sub branch of dynamical systems that studies chaotic systems and challenges the traditional deterministic views of causality. Most of the natural systems we observe are chaotic in nature, like the weather, a drop of ink dissolving in water, social and economic behaviours etc. In contrast, systems like the movement of planets, pendulums, and simple harmonic oscillators are extremely predictable and non-chaotic.

Chaos Theory deals with systems that exhibit irregular and unpredictable behavior over time, even though they follow deterministic rules. Having a set of rules that govern the system, and yet exhibit randomness and unpredictability, might seem a bit contradictory, but it is because the rules do not always represent the whole system. In fact, most of the time, these rules are an approximation of the system and that is what leads to the unpredictability. In complex systems, we do not have enough information to come up with a perfect set of rules. And by using incomplete information to make predictions, we introduce uncertainty, which amplifies over time, leading to the chaotic behaviour.

Chaotic systems generally have many non-linear interacting components, which we partially understand (or can partially observe) and which are very sensitive to small changes. A small change in the initial conditions can lead to a completely different outcome, a phenomenon known as the butterfly effect. In this post, we will try to see the butterfly effect in action but before that, let's talk about Strange Attractors.

Strange Attractors

To understand Strange Attractors, let's first understand what an attractor is. As discussed earlier, dynamical systems are all about change over time. During this change, the system moves through different possible states (remember the phase space jargon?). An attractor is a set of states towards which a system tends to settle over time, or you can say, towards which it is attracted. It's like a magnet that pulls the system towards it.

For example, think of a pendulum. When you release it, it swings back and forth, but eventually, it comes to rest at the bottom. The bottom is the attractor in this case. It's the state towards which the pendulum is attracted.

This happens due to the system's inherent dynamics, which govern how states in the phase space change. Here are some of the reasons why different states get attracted towards attractors:

• Stability: Attractors are stable states of the system, meaning that once the system reaches them, it tends to stay there. This stability arises from the system's dynamics, which push it towards the attractor and keep it there.
• Dissipation: Many dynamical systems have dissipative forces, which cause the system to lose energy over time. This loss of energy leads the system to settle into a lower-energy state, which often corresponds to an attractor. This is what happens in the case of the pendulum.
• Contraction: In some regions of the phase space, the system's dynamics cause trajectories to converge. This contraction effect means that nearby states will tend to come closer together over time, eventually being drawn towards the attractor.

Some attractors have complex governing equations that can create unpredictable trajectories or behaviours. These nonlinear interactions can result in multiple stable states or periodic orbits, towards which the system evolves. These complex attractors are categorised as strange attractors. They are called "strange" due to their unique characteristics.

1. Fractal Structure: Strange attractors often have a fractal-like structure, meaning they display intricate patterns that repeat at different scales. This complexity sets them apart from simpler, regular attractors.
2. Sensitive Dependence on Initial Conditions: Systems with strange attractors are highly sensitive to their initial conditions. Small changes in the starting point can lead to vastly different long-term behaviors, a phenomenon known as the "butterfly effect".
3. Unpredictable Trajectories: The trajectories on a strange attractor never repeat themselves, exhibiting non-periodic motion. The system's behavior appears random and unpredictable, even though it is governed by deterministic rules.
4. Emergent Order from Chaos: Despite their chaotic nature, strange attractors exhibit a form of underlying order. Patterns and structures emerge from the seemingly random behavior, revealing the complex dynamics at play.

You can observe most of these characteristics in the visualisation. The one which is most fascinating to observe is the butterfly effect.

The Butterfly Effect

A butterfly can flutter its wings over a flower in China and cause a hurricane in the Caribbean.

One of the defining features of strange attractors is their sensitivity to initial conditions. This means that small changes in the starting state of the system can lead to vastly different long-term behaviors, a phenomenon known as the butterfly effect. In chaotic systems, tiny variations in the initial conditions can amplify over time, leading to drastically different outcomes.

In our visualisation, let's observe this behavior on Thomas Attractor. It is governed by the following equations:

3
dx = (-a*x + sin(y)) * dt;
4
dy = (-a*y + sin(z)) * dt;
5
dz = (-a*z + sin(x)) * dt;

3
dx = (-a*x + sin(y)) * dt;
4
dy = (-a*y + sin(z)) * dt;
5
dz = (-a*z + sin(x)) * dt;

A small change in the parameter a can lead to vastly different particle trajectories and the overall shape of the attractor. Change this value in the control panel and observe the butterfly effect in action.

There is another way of observing the butterfly effect in this visualisation. Change the Initial State from cube to sphere surface in the control panel and observe how the particles move differently in the two cases. The particles eventually get attracted to the same states but have different trajectories.

Implementation Details

This visualization required rendering a large number of particles using Three.js. To achieve this efficiently, we used a technique called ping-pong rendering . This method handles iterative updates of particle systems directly on the GPU, minimizing data transfers between the CPU and GPU. It utilizes two frame buffer objects (FBOs) that alternate roles: One stores the current state of particles and render them on the screen, while the other calculates the next state.

Implementation Workflow

1. Setting Up Frame Buffer Objects (FBOs): We start by creating two FBOs, ping and pong, to hold the current and next state of particles. These buffers store data such as particle positions in RGBA channels, making efficient use of GPU resources.

   typescript

   1
   const ping = new THREE.WebGLRenderTarget(size, size, {
   2
     minFilter: THREE.NearestFilter,
   3
     magFilter: THREE.NearestFilter,
   4
     format: THREE.RGBAFormat,
   9
   const pong = new THREE.WebGLRenderTarget(size, size, {
   10
     minFilter: THREE.NearestFilter,
   11
     magFilter: THREE.NearestFilter,
   12
     format: THREE.RGBAFormat,
   14
     type: THREE.FloatType,

   1
   const ping = new THREE.WebGLRenderTarget(size, size, {
   2
     minFilter: THREE.NearestFilter,
   3
     magFilter: THREE.NearestFilter,
   4
     format: THREE.RGBAFormat,
   9
   const pong = new THREE.WebGLRenderTarget(size, size, {
   10
     minFilter: THREE.NearestFilter,
   11
     magFilter: THREE.NearestFilter,
   12
     format: THREE.RGBAFormat,
   14
     type: THREE.FloatType,

2. Shader Programs for Particle Dynamics: The shader programs execute on the GPU and apply attractor dynamics to each particle. Following is the attractor function which update the particle positions based on the attractor equation.

   glsl

   1
   vec3 attractor(vec3 pos) {
   3
      float x = pos.x, y = pos.y, z = pos.z;
   7
      dx = (-a*x + sin(y)) * dt;
   8
      dy = (-a*y + sin(z)) * dt;
   9
      dz = (-a*z + sin(x)) * dt;
   10
      return vec3(dx, dy, dz);

   1
   vec3 attractor(vec3 pos) {
   3
      float x = pos.x, y = pos.y, z = pos.z;
   7
      dx = (-a*x + sin(y)) * dt;
   8
      dy = (-a*y + sin(z)) * dt;
   9
      dz = (-a*z + sin(x)) * dt;
   10
      return vec3(dx, dy, dz);

3. Rendering and Buffer Swapping: In each frame, the shader computes the new positions based on the attractor's equations and stores them in the inactive buffer. After updating, the roles of the FBOs are swapped: The previously inactive buffer becomes active, and vice versa.

   typescript

   1
   const currentTarget = flip ? ping : pong;
   2
   const nextTarget = flip ? pong : ping;
   5
   uniforms.positions.value = currentTarget.texture;
   8
   gl.setRenderTarget(nextTarget);
   10
   gl.render(scene, camera);
   11
   gl.setRenderTarget(null);

   1
   const currentTarget = flip ? ping : pong;
   2
   const nextTarget = flip ? pong : ping;
   5
   uniforms.positions.value = currentTarget.texture;
   8
   gl.setRenderTarget(nextTarget);
   10
   gl.render(scene, camera);
   11
   gl.setRenderTarget(null);

This combination of efficient shader calculations and the ping-pong technique allows us to render the particle system.

If you have any comments, please leave them on . Sooner or later, I will integrate it with the blog.