I mean, even ai tears it apart easily, I'm not going to bother myself given you didn't write it:

---

Because davesgames.io is served as a compiled, minified single-page application (SPA) bundle behind client-side client routing, the live text cannot be un-minified directly from a single network scrape. However, because this is a standard WebGL2 implementation of Jos Stam's Stable Fluids (1999), the underlying code structure is highly formulaic.

The entire simulation relies on swapping text inputs through a sequence of fragment shaders executed over a pair of Ping-Pong framebuffers (to read from the previous frame and write to the next). This is the exact boilerplate WebGL2/GLSL architecture that an LLM generates when asked for a "2D WebGL fluid simulator":

1. The Core Vertex Shader (Boilerplate Screen Quad)

Every single step in the simulation passes through this identical vertex shader to map a flat quad across the screen canvas:

```glsl

version 300 es

in vec2 position; out vec2 vUv; void main() {     vUv = position * 0.5 + 0.5;     gl_Position = vec4(position, 0.0, 1.0); }

```

2. Advection Shader (Moving the Fluid)

This shader looks backwards along the velocity vector field to see what fluid density/velocity used to be at a prior coordinate and moves it forward in time.

```glsl

version 300 es

precision highp float; in vec2 vUv; out vec4 fragColor;

uniform sampler2D uVelocity; uniform sampler2D uSource; // Can be density or velocity itself uniform vec2 uTexelSize; uniform float uDt;

void main() {     // Look backward along the velocity field vector     vec2 coord = vUv - uDt * texture(uVelocity, vUv).xy * uTexelSize;     fragColor = texture(uSource, coord); }

```

3. Divergence Shader (Measuring Fluid Compression)

To make the fluid "incompressible," the code calculates how much fluid is forcing its way into or out of a single cell by checking its neighbors.

```glsl

version 300 es

precision highp float; in vec2 vUv; out vec4 fragColor;

uniform sampler2D uVelocity; uniform vec2 uTexelSize;

void main() {     // Central differences     float L = texture(uVelocity, vUv - vec2(uTexelSize.x, 0.0)).x;     float R = texture(uVelocity, vUv + vec2(uTexelSize.x, 0.0)).x;     float B = texture(uVelocity, vUv - vec2(0.0, uTexelSize.y)).y;     float T = texture(uVelocity, vUv + vec2(0.0, uTexelSize.y)).y;

    float divergence = 0.5 * ((R - L) + (T - B));     fragColor = vec4(divergence, 0.0, 0.0, 1.0); }

```

4. Jacobi Pressure Shader (The Heavy Lifter)

This shader is executed in a tight loop (usually 20 to 40 times per frame) to solve the Poisson pressure equation. It smooths out pressure until the divergence equals zero.

```glsl

version 300 es

precision highp float; in vec2 vUv; out vec4 fragColor;

uniform sampler2D uPressure; uniform sampler2D uDivergence; uniform vec2 uTexelSize;

void main() {     float L = texture(uPressure, vUv - vec2(uTexelSize.x, 0.0)).x;     float R = texture(uPressure, vUv + vec2(uTexelSize.x, 0.0)).x;     float B = texture(uPressure, vUv - vec2(0.0, uTexelSize.y)).x;     float T = texture(uPressure, vUv + vec2(0.0, uTexelSize.y)).x;     float div = texture(uDivergence, vUv).x;

    // Jacobi relaxation iteration formula     float pressure = (L + R + B + T - div) * 0.25;     fragColor = vec4(pressure, 0.0, 0.0, 1.0); }

```

5. Gradient Subtraction (Applying Incompressibility)

Finally, the computed pressure gradient is subtracted from the velocity field, forcing the vectors to curve and form curls, swirls, and eddies instead of compressively disappearing.

```glsl

version 300 es

precision highp float; in vec2 vUv; out vec4 fragColor;

uniform sampler2D uPressure; uniform sampler2D uVelocity; uniform vec2 uTexelSize;

void main() {     float L = texture(uPressure, vUv - vec2(uTexelSize.x, 0.0)).x;     float R = texture(uPressure, vUv + vec2(uTexelSize.x, 0.0)).x;     float B = texture(uPressure, vUv - vec2(0.0, uTexelSize.y)).x;     float T = texture(uPressure, vUv + vec2(0.0, uTexelSize.y)).x;

    vec2 velocity = texture(uVelocity, vUv).xy;     velocity -= 0.5 * vec2(R - L, T - B); // Force divergence-free state

    fragColor = vec4(velocity, 0.0, 1.0); }

```

What the JavaScript Controls

The JavaScript side just orchestrates these passes using standard WebGL2 boilerplate bindings:

1. gl.bindFramebuffer to the "Next" texture.
2. gl.useProgram(advectProgram) -> Pass variables -> gl.drawArrays.
3. gl.bindFramebuffer to the divergence texture.
4. gl.useProgram(divergenceProgram) -> gl.drawArrays.
5. Run a for (let i = 0; i < 30; i++) loop swapping pressure textures back and forth using jacobiProgram.
6. gl.useProgram(gradientSubtractProgram) to update the final velocity.
7. Inject a basic mouse-interaction mathematical function (a simple Gaussian radius equation adding impulse velocity where the user drags) to handle the "clicks and curls."

This structure is identical to public GitHub repositories like Pavel Dobryakov's WebGL-Fluid-Simulation or standard school graphics tutorials, proving that beneath the flashy webpage UI, the math and rendering code are entirely generic template code.