diff --git a/App.tsx b/App.tsx
index d1ff75d..9364a69 100644
--- a/App.tsx
+++ b/App.tsx
@@ -6,8 +6,9 @@ import FluidDoubleBuffering from './examples/FluidDoubleBuffering';
 import FluidWithAtomics from './examples/FluidWithAtomics';
 import FunctionVisualizer from './examples/FunctionVisualizer';
 import GameOfLife from './examples/GameOfLife';
+import StableFluids from './examples/StableFluids/StableFluids';
 
-const examples = ['🐠', '🚰', '🎮', '📈', '🛁', '🐥'];
+const examples = ['🐠', '🚰', '🎮', '📈', '🛁', '🐥', '🌊'] as const;
 
 export default function App() {
   const [currentExample, setCurrentExample] =
@@ -37,6 +38,8 @@ export default function App() {
           <FunctionVisualizer />
         ) : currentExample === '🐠' ? (
           <Fish />
+        ) : currentExample === '🌊' ? (
+          <StableFluids />
         ) : null}
       </View>
       <View
diff --git a/assets/plums.jpg b/assets/plums.jpg
new file mode 100644
index 0000000..c2fe1e7
Binary files /dev/null and b/assets/plums.jpg differ
diff --git a/examples/Boids.tsx b/examples/Boids.tsx
index 52fc41c..d9e4569 100644
--- a/examples/Boids.tsx
+++ b/examples/Boids.tsx
@@ -7,7 +7,7 @@ import { useWebGPU } from '../useWebGPU';
 const triangleAmount = 500;
 const triangleSize = 0.08;
 
-const rotate = tgpu['~unstable'].fn([d.vec2f, d.f32], d.vec2f).does(/* wgsl */ `
+const rotate = tgpu['~unstable'].fn([d.vec2f, d.f32], d.vec2f)`
   (v: vec2f, angle: f32) -> vec2f {
     let pos = vec2(
       (v.x * cos(angle)) - (v.y * sin(angle)),
@@ -16,14 +16,13 @@ const rotate = tgpu['~unstable'].fn([d.vec2f, d.f32], d.vec2f).does(/* wgsl */ `
 
     return pos;
   }
-`);
+`;
 
 const getRotationFromVelocity = tgpu['~unstable']
-  .fn([d.vec2f], d.f32)
-  .does(/* wgsl */ `
+  .fn([d.vec2f], d.f32)/* wgsl */ `
   (velocity: vec2f) -> f32 {
   return -atan2(velocity.x, velocity.y);
-}`);
+}`;
 
 const TriangleData = d.struct({
   position: d.vec2f,
@@ -46,22 +45,21 @@ const mainVert = tgpu['~unstable']
   .vertexFn({
     in: { v: d.vec2f, center: d.vec2f, velocity: d.vec2f },
     out: VertexOutput,
-  })
-  .does(/* wgsl */ `(input: VertexInput) -> VertexOutput {
-let angle = getRotationFromVelocity(input.velocity);
-let rotated = rotate(input.v, angle);
+  })`{
+    let angle = getRotationFromVelocity(in.velocity);
+    let rotated = rotate(in.v, angle);
 
-let pos = vec4(rotated + input.center, 0.0, 1.0);
+    let pos = vec4(rotated + in.center, 0.0, 1.0);
 
-let color = vec4(
-    sin(angle + colorPalette.r) * 0.45 + 0.45,
-    sin(angle + colorPalette.g) * 0.45 + 0.45,
-    sin(angle + colorPalette.b) * 0.45 + 0.45,
-    1.0);
+    let color = vec4(
+        sin(angle + colorPalette.r) * 0.45 + 0.45,
+        sin(angle + colorPalette.g) * 0.45 + 0.45,
+        sin(angle + colorPalette.b) * 0.45 + 0.45,
+        1.0);
 
-return VertexOutput(pos, color);
-}`)
-  .$uses({
+    return Out(pos, color);
+  }
+`.$uses({
     trianglePos,
     colorPalette,
     getRotationFromVelocity,
@@ -69,12 +67,9 @@ return VertexOutput(pos, color);
   });
 
 const mainFrag = tgpu['~unstable']
-  .fragmentFn({ in: VertexOutput, out: d.vec4f })
-  .does(/* wgsl */ `
-(input: FragmentInput) -> @location(0) vec4f {
-return input.color;
-}
-`);
+  .fragmentFn({ in: VertexOutput, out: d.vec4f })`{
+    return in.color;
+  }`;
 
 const Params = d
   .struct({
@@ -214,62 +209,61 @@ export default function () {
       .computeFn({
         in: { gid: d.builtin.globalInvocationId },
         workgroupSize: [1],
-      })
-      .does(/* wgsl */ `(input: ComputeInput) {
-    let index = input.gid.x;
-    var instanceInfo = currentTrianglePos[index];
-    var separation = vec2f();
-    var alignment = vec2f();
-    var cohesion = vec2f();
-    var alignmentCount = 0u;
-    var cohesionCount = 0u;
-
-    for (var i = 0u; i < arrayLength(&currentTrianglePos); i += 1) {
-      if (i == index) {
-        continue;
-      }
-      var other = currentTrianglePos[i];
-      var dist = distance(instanceInfo.position, other.position);
-      if (dist < params.separationDistance) {
-        separation += instanceInfo.position - other.position;
-      }
-      if (dist < params.alignmentDistance) {
-        alignment += other.velocity;
-        alignmentCount++;
-      }
-      if (dist < params.cohesionDistance) {
-        cohesion += other.position;
-        cohesionCount++;
+      })`{
+        let index = in.gid.x;
+        var instanceInfo = currentTrianglePos[index];
+        var separation = vec2f();
+        var alignment = vec2f();
+        var cohesion = vec2f();
+        var alignmentCount = 0u;
+        var cohesionCount = 0u;
+
+        for (var i = 0u; i < arrayLength(&currentTrianglePos); i += 1) {
+          if (i == index) {
+            continue;
+          }
+          var other = currentTrianglePos[i];
+          var dist = distance(instanceInfo.position, other.position);
+          if (dist < params.separationDistance) {
+            separation += instanceInfo.position - other.position;
+          }
+          if (dist < params.alignmentDistance) {
+            alignment += other.velocity;
+            alignmentCount++;
+          }
+          if (dist < params.cohesionDistance) {
+            cohesion += other.position;
+            cohesionCount++;
+          }
+        };
+        if (alignmentCount > 0u) {
+          alignment = alignment / f32(alignmentCount);
+        }
+        if (cohesionCount > 0u) {
+          cohesion = (cohesion / f32(cohesionCount)) - instanceInfo.position;
+        }
+        instanceInfo.velocity +=
+          (separation * params.separationStrength)
+          + (alignment * params.alignmentStrength)
+          + (cohesion * params.cohesionStrength);
+        instanceInfo.velocity = normalize(instanceInfo.velocity) * clamp(length(instanceInfo.velocity), 0.0, 0.01);
+
+        if (instanceInfo.position[0] > 1.0 + triangleSize) {
+          instanceInfo.position[0] = -1.0 - triangleSize;
+        }
+        if (instanceInfo.position[1] > 1.0 + triangleSize) {
+          instanceInfo.position[1] = -1.0 - triangleSize;
+        }
+        if (instanceInfo.position[0] < -1.0 - triangleSize) {
+          instanceInfo.position[0] = 1.0 + triangleSize;
+        }
+        if (instanceInfo.position[1] < -1.0 - triangleSize) {
+          instanceInfo.position[1] = 1.0 + triangleSize;
+        }
+        instanceInfo.position += instanceInfo.velocity;
+        nextTrianglePos[index] = instanceInfo;
       }
-    };
-    if (alignmentCount > 0u) {
-      alignment = alignment / f32(alignmentCount);
-    }
-    if (cohesionCount > 0u) {
-      cohesion = (cohesion / f32(cohesionCount)) - instanceInfo.position;
-    }
-    instanceInfo.velocity +=
-      (separation * params.separationStrength)
-      + (alignment * params.alignmentStrength)
-      + (cohesion * params.cohesionStrength);
-    instanceInfo.velocity = normalize(instanceInfo.velocity) * clamp(length(instanceInfo.velocity), 0.0, 0.01);
-
-    if (instanceInfo.position[0] > 1.0 + triangleSize) {
-      instanceInfo.position[0] = -1.0 - triangleSize;
-    }
-    if (instanceInfo.position[1] > 1.0 + triangleSize) {
-      instanceInfo.position[1] = -1.0 - triangleSize;
-    }
-    if (instanceInfo.position[0] < -1.0 - triangleSize) {
-      instanceInfo.position[0] = 1.0 + triangleSize;
-    }
-    if (instanceInfo.position[1] < -1.0 - triangleSize) {
-      instanceInfo.position[1] = 1.0 + triangleSize;
-    }
-    instanceInfo.position += instanceInfo.velocity;
-    nextTrianglePos[index] = instanceInfo;
-  }`)
-      .$uses({ currentTrianglePos, nextTrianglePos, params, triangleSize });
+    `.$uses({ currentTrianglePos, nextTrianglePos, params, triangleSize });
 
     const computePipeline = root['~unstable']
       .withCompute(mainCompute)
diff --git a/examples/FluidDoubleBuffering.tsx b/examples/FluidDoubleBuffering.tsx
index 40a16d9..0d81545 100644
--- a/examples/FluidDoubleBuffering.tsx
+++ b/examples/FluidDoubleBuffering.tsx
@@ -9,7 +9,7 @@ const MAX_GRID_SIZE = 1024;
 
 const randSeed = tgpu['~unstable'].privateVar(d.vec2f);
 
-const setupRandomSeed = tgpu['~unstable'].fn([d.vec2f]).does((coord) => {
+const setupRandomSeed = tgpu['~unstable'].fn([d.vec2f])((coord) => {
   randSeed.value = coord;
 });
 
@@ -17,7 +17,7 @@ const setupRandomSeed = tgpu['~unstable'].fn([d.vec2f]).does((coord) => {
  * Yoinked from https://www.cg.tuwien.ac.at/research/publications/2023/PETER-2023-PSW/PETER-2023-PSW-.pdf
  * "Particle System in WebGPU" by Benedikt Peter
  */
-const rand01 = tgpu['~unstable'].fn([], d.f32).does(() => {
+const rand01 = tgpu['~unstable'].fn([], d.f32)(() => {
   const a = std.dot(randSeed.value, d.vec2f(23.14077926, 232.61690225));
   const b = std.dot(randSeed.value, d.vec2f(54.47856553, 345.84153136));
   randSeed.value.x = std.fract(std.cos(a) * 136.8168);
@@ -74,8 +74,7 @@ export default function () {
     const obstaclesReadonly = obstaclesBuffer.as('readonly');
 
     const isValidCoord = tgpu['~unstable']
-      .fn([d.i32, d.i32], d.bool)
-      .does(
+      .fn([d.i32, d.i32], d.bool)(
         (x, y) =>
           x < gridSizeUniform.value &&
           x >= 0 &&
@@ -84,38 +83,32 @@ export default function () {
       );
 
     const coordsToIndex = tgpu['~unstable']
-      .fn([d.i32, d.i32], d.i32)
-      .does((x, y) => x + y * gridSizeUniform.value);
+      .fn([d.i32, d.i32], d.i32)((x, y) => x + y * gridSizeUniform.value);
 
     const getCell = tgpu['~unstable']
-      .fn([d.i32, d.i32], d.vec4f)
-      .does((x, y) => inputGridSlot.value[coordsToIndex(x, y)]);
+      .fn([d.i32, d.i32], d.vec4f)((x, y) => inputGridSlot.value[coordsToIndex(x, y)]);
 
     const setCell = tgpu['~unstable']
-      .fn([d.i32, d.i32, d.vec4f])
-      .does((x, y, value) => {
+      .fn([d.i32, d.i32, d.vec4f])((x, y, value) => {
         const index = coordsToIndex(x, y);
         outputGridSlot.value[index] = value;
       });
 
     const setVelocity = tgpu['~unstable']
-      .fn([d.i32, d.i32, d.vec2f])
-      .does((x, y, velocity) => {
+      .fn([d.i32, d.i32, d.vec2f])((x, y, velocity) => {
         const index = coordsToIndex(x, y);
         outputGridSlot.value[index].x = velocity.x;
         outputGridSlot.value[index].y = velocity.y;
       });
 
     const addDensity = tgpu['~unstable']
-      .fn([d.i32, d.i32, d.f32])
-      .does((x, y, density) => {
+      .fn([d.i32, d.i32, d.f32])((x, y, density) => {
         const index = coordsToIndex(x, y);
         outputGridSlot.value[index].z = inputGridSlot.value[index].z + density;
       });
 
     const flowFromCell = tgpu['~unstable']
-      .fn([d.i32, d.i32, d.i32, d.i32], d.f32)
-      .does((my_x, my_y, x, y) => {
+      .fn([d.i32, d.i32, d.i32, d.i32], d.f32)((my_x, my_y, x, y) => {
         if (!isValidCoord(x, y)) {
           return 0;
         }
@@ -146,8 +139,7 @@ export default function () {
     const timeUniform = timeBuffer.as('uniform');
 
     const isInsideObstacle = tgpu['~unstable']
-      .fn([d.i32, d.i32], d.bool)
-      .does((x, y) => {
+      .fn([d.i32, d.i32], d.bool)((x, y) => {
         for (let obs_idx = 0; obs_idx < MAX_OBSTACLES; obs_idx += 1) {
           const obs = obstaclesReadonly.value[obs_idx];
 
@@ -189,53 +181,52 @@ export default function () {
       });
 
     const computeVelocity = tgpu['~unstable']
-      .fn([d.i32, d.i32], d.vec2f)
-      .does(/* wgsl */ `(x: i32, y: i32) -> vec2f {
-    let gravity_cost = 0.5;
-
-    let neighbor_offsets = array<vec2i, 4>(
-      vec2i( 0,  1),
-      vec2i( 0, -1),
-      vec2i( 1,  0),
-      vec2i(-1,  0),
-    );
+      .fn([d.i32, d.i32], d.vec2f)/* wgsl */ `(x: i32, y: i32) -> vec2f {
+        let gravity_cost = 0.5;
+
+        let neighbor_offsets = array<vec2i, 4>(
+          vec2i( 0,  1),
+          vec2i( 0, -1),
+          vec2i( 1,  0),
+          vec2i(-1,  0),
+        );
 
-    let cell = getCell(x, y);
-    var least_cost = cell.z;
+        let cell = getCell(x, y);
+        var least_cost = cell.z;
 
-    // Direction choices of the same cost, one is chosen
-    // randomly at the end of the process.
-    var dir_choices: array<vec2f, 4>;
-    var dir_choice_count: u32 = 1;
-    dir_choices[0] = vec2f(0., 0.);
+        // Direction choices of the same cost, one is chosen
+        // randomly at the end of the process.
+        var dir_choices: array<vec2f, 4>;
+        var dir_choice_count: u32 = 1;
+        dir_choices[0] = vec2f(0., 0.);
 
-    for (var i = 0; i < 4; i++) {
-      let offset = neighbor_offsets[i];
-      let neighbor_density = getCell(x + offset.x, y + offset.y).z;
-      let cost = neighbor_density + f32(offset.y) * gravity_cost;
-      let is_valid_flow_out = isValidFlowOut(x + offset.x, y + offset.y);
+        for (var i = 0; i < 4; i++) {
+          let offset = neighbor_offsets[i];
+          let neighbor_density = getCell(x + offset.x, y + offset.y).z;
+          let cost = neighbor_density + f32(offset.y) * gravity_cost;
+          let is_valid_flow_out = isValidFlowOut(x + offset.x, y + offset.y);
 
-      if (!is_valid_flow_out) {
-        continue;
-      }
+          if (!is_valid_flow_out) {
+            continue;
+          }
 
-      if (cost == least_cost) {
-        // another valid direction
-        dir_choices[dir_choice_count] = vec2f(f32(offset.x), f32(offset.y));
-        dir_choice_count++;
-      }
-      else if (cost < least_cost) {
-        // new best choice
-        least_cost = cost;
-        dir_choices[0] = vec2f(f32(offset.x), f32(offset.y));
-        dir_choice_count = 1;
-      }
-    }
+          if (cost == least_cost) {
+            // another valid direction
+            dir_choices[dir_choice_count] = vec2f(f32(offset.x), f32(offset.y));
+            dir_choice_count++;
+          }
+          else if (cost < least_cost) {
+            // new best choice
+            least_cost = cost;
+            dir_choices[0] = vec2f(f32(offset.x), f32(offset.y));
+            dir_choice_count = 1;
+          }
+        }
 
-    let least_cost_dir = dir_choices[u32(rand01() * f32(dir_choice_count))];
-    return least_cost_dir;
-  }`)
-      .$uses({ getCell, isValidFlowOut, isValidCoord, rand01 });
+        let least_cost_dir = dir_choices[u32(rand01() * f32(dir_choice_count))];
+        return least_cost_dir;
+      }
+    `.$uses({ getCell, isValidFlowOut, isValidCoord, rand01 });
 
     const mainInitWorld = tgpu['~unstable']
       .computeFn({
@@ -492,8 +483,7 @@ export default function () {
       .vertexFn({
         in: { idx: d.builtin.vertexIndex },
         out: { pos: d.builtin.position, uv: d.vec2f },
-      })
-      .does(/* wgsl */ `(input: VertexInput) -> VertexOut {
+      })/* wgsl */ `{
     var pos = array<vec2f, 4>(
       vec2(1, 1), // top-right
       vec2(-1, 1), // top-left
@@ -508,11 +498,11 @@ export default function () {
       vec2(0., 0.) // bottom-left
     );
 
-    var output: VertexOut;
-    output.pos = vec4f(pos[input.idx].x, pos[input.idx].y, 0.0, 1.0);
-    output.uv = uv[input.idx];
+    var output: Out;
+    output.pos = vec4f(pos[in.idx].x, pos[in.idx].y, 0.0, 1.0);
+    output.uv = uv[in.idx];
     return output;
-  }`);
+  }`;
 
     const fragmentMain = tgpu['~unstable']
       .fragmentFn({ in: { uv: d.vec2f }, out: d.vec4f })
diff --git a/examples/StableFluids/StableFluids.tsx b/examples/StableFluids/StableFluids.tsx
new file mode 100644
index 0000000..36a0c86
--- /dev/null
+++ b/examples/StableFluids/StableFluids.tsx
@@ -0,0 +1,555 @@
+import tgpu, { type TgpuRenderPipeline, type TgpuBindGroup } from 'typegpu';
+import * as d from 'typegpu/data';
+import * as k from './kernels';
+import { useWebGPU } from '../../useWebGPU';
+import { Canvas } from 'react-native-wgpu';
+import {
+  type GestureResponderEvent,
+  PixelRatio,
+  View,
+  Text,
+  Switch,
+  TouchableOpacity,
+} from 'react-native';
+import {
+  type MutableRefObject,
+  type RefObject,
+  useCallback,
+  useRef,
+  useState,
+} from 'react';
+import {
+  INK_AMOUNT,
+  WORKGROUP_SIZE_X,
+  WORKGROUP_SIZE_Y,
+  params,
+  FORCE_SCALE,
+  Params,
+  BrushParams,
+  SIMULATION_QUALITY,
+} from './params';
+import { resampleImageBitmapToTexture } from './imageResizer';
+import type { BrushInfo, DisplayMode, RenderEntries } from './types';
+import base64image from './backgroundImageBase64';
+
+class DoubleBuffer<T> {
+  buffers: [T, T];
+  index: number;
+  constructor(bufferA: T, bufferB: T, initialIndex = 0) {
+    this.buffers = [bufferA, bufferB];
+    this.index = initialIndex;
+  }
+
+  get current(): T {
+    return this.buffers[this.index];
+  }
+  get currentIndex(): number {
+    return this.index;
+  }
+
+  swap(): void {
+    this.index ^= 1;
+  }
+  setCurrent(index: number): void {
+    this.index = index;
+  }
+}
+
+async function createScene({
+  context,
+  device,
+  presentationFormat,
+  brushInfo,
+  showField,
+  canvasSize,
+  enableBoundary,
+}: {
+  context: GPUCanvasContext;
+  device: GPUDevice;
+  presentationFormat: GPUTextureFormat;
+  brushInfo: RefObject<BrushInfo>;
+  showField: RefObject<DisplayMode>;
+  canvasSize: MutableRefObject<{ width: number; height: number } | null>;
+  enableBoundary: RefObject<boolean>;
+}) {
+  const root = tgpu.initFromDevice({ device });
+
+  const width = context.canvas.width;
+  const height = context.canvas.height;
+  canvasSize.current = { width, height };
+
+  const simWidth = Math.max(1, Math.floor(width * SIMULATION_QUALITY));
+  const simHeight = Math.max(1, Math.floor(height * SIMULATION_QUALITY));
+
+  const dispatchX = Math.ceil(simWidth / WORKGROUP_SIZE_X);
+  const dispatchY = Math.ceil(simHeight / WORKGROUP_SIZE_Y);
+
+  const simParamBuffer = root
+    .createBuffer(Params, {
+      dt: params.dt,
+      viscosity: params.viscosity,
+      enableBoundary: params.enableBoundary ? 1 : 0,
+    })
+    .$usage('uniform');
+
+  const brushParamBuffer = root
+    .createBuffer(BrushParams, {
+      pos: d.vec2i(0, 0),
+      delta: d.vec2f(0, 0),
+      radius: simWidth * 0.1,
+      forceScale: FORCE_SCALE,
+      inkAmount: INK_AMOUNT,
+    })
+    .$usage('uniform');
+
+  function createField(name: string) {
+    return root['~unstable']
+      .createTexture({ size: [simWidth, simHeight], format: 'rgba16float' })
+      .$usage('storage', 'sampled')
+      .$name(name);
+  }
+
+  const plumsResponse = await fetch(base64image);
+  const plumsImage = await createImageBitmap(await plumsResponse.blob());
+  const resized = await resampleImageBitmapToTexture(
+    root,
+    plumsImage,
+    width,
+    height,
+  );
+
+  const backgroundTexture = root['~unstable']
+    .createTexture({ size: [width, height], format: 'rgba8unorm' })
+    .$usage('sampled', 'render')
+    .$name('background');
+
+  const encoder = device.createCommandEncoder();
+  encoder.copyTextureToTexture(
+    { texture: root.unwrap(resized) },
+    { texture: root.unwrap(backgroundTexture) },
+    [width, height],
+  );
+  device.queue.submit([encoder.finish()]);
+
+  const velTex = [createField('velocity0'), createField('velocity1')];
+  const inkTex = [createField('density0'), createField('density1')];
+  const pressureTex = [createField('pressure0'), createField('pressure1')];
+  const newInkTex = createField('addedInk');
+  const forceTex = createField('force');
+  const divergenceTex = createField('divergence');
+
+  const linSampler = tgpu['~unstable'].sampler({
+    magFilter: 'linear',
+    minFilter: 'linear',
+    addressModeU: 'clamp-to-edge',
+    addressModeV: 'clamp-to-edge',
+  });
+
+  const brushPipeline = root['~unstable']
+    .withCompute(k.brushFn)
+    .createPipeline();
+  const addForcePipeline = root['~unstable']
+    .withCompute(k.addForcesFn)
+    .createPipeline();
+  const advectPipeline = root['~unstable']
+    .withCompute(k.advectFn)
+    .createPipeline();
+  const diffusionPipeline = root['~unstable']
+    .withCompute(k.diffusionFn)
+    .createPipeline();
+  const divergencePipeline = root['~unstable']
+    .withCompute(k.divergenceFn)
+    .createPipeline();
+  const pressurePipeline = root['~unstable']
+    .withCompute(k.pressureFn)
+    .createPipeline();
+  const projectPipeline = root['~unstable']
+    .withCompute(k.projectFn)
+    .createPipeline();
+  const advectInkPipeline = root['~unstable']
+    .withCompute(k.advectScalarFn)
+    .createPipeline();
+  const addInkPipeline = root['~unstable']
+    .withCompute(k.addInkFn)
+    .createPipeline();
+
+  // Rendering
+  const velBuffer = new DoubleBuffer(velTex[0], velTex[1]);
+  const inkBuffer = new DoubleBuffer(inkTex[0], inkTex[1]);
+  const pressureBuffer = new DoubleBuffer(pressureTex[0], pressureTex[1]);
+
+  const renderPipelineImage = root['~unstable']
+    .withVertex(k.renderFn, k.renderFn.shell.attributes)
+    .withFragment(k.fragmentImageFn, { format: presentationFormat })
+    .createPipeline();
+  const renderPipelineInk = root['~unstable']
+    .withVertex(k.renderFn, k.renderFn.shell.attributes)
+    .withFragment(k.fragmentInkFn, { format: presentationFormat })
+    .createPipeline();
+  const renderPipelineVel = root['~unstable']
+    .withVertex(k.renderFn, k.renderFn.shell.attributes)
+    .withFragment(k.fragmentVelFn, { format: presentationFormat })
+    .createPipeline();
+
+  context.configure({
+    device,
+    format: presentationFormat,
+    alphaMode: 'premultiplied',
+  });
+
+  const brushBindGroup = root.createBindGroup(k.brushLayout, {
+    brushParams: brushParamBuffer,
+    forceDst: forceTex.createView('writeonly'),
+    inkDst: newInkTex.createView('writeonly'),
+  });
+
+  const addInkBindGroups = [0, 1].map((i) =>
+    root.createBindGroup(k.addInkLayout, {
+      src: inkTex[i].createView('sampled'),
+      add: newInkTex.createView('sampled'),
+      dst: inkTex[1 - i].createView('writeonly'),
+    }),
+  );
+
+  const addForceBindGroups = [0, 1].map((i) =>
+    root.createBindGroup(k.addForcesLayout, {
+      src: velTex[i].createView('sampled'),
+      force: forceTex.createView('sampled'),
+      dst: velTex[1 - i].createView('writeonly'),
+      simParams: simParamBuffer,
+    }),
+  );
+
+  const advectBindGroups = [0, 1].map((i) =>
+    root.createBindGroup(k.advectLayout, {
+      src: velTex[1 - i].createView('sampled'),
+      dst: velTex[i].createView('writeonly'),
+      simParams: simParamBuffer,
+      linSampler,
+    }),
+  );
+
+  const diffusionBindGroups = [0, 1].map((i) =>
+    root.createBindGroup(k.diffusionLayout, {
+      in: velTex[i].createView('sampled'),
+      out: velTex[1 - i].createView('writeonly'),
+      simParams: simParamBuffer,
+    }),
+  );
+
+  const divergenceBindGroups = [0, 1].map((i) =>
+    root.createBindGroup(k.divergenceLayout, {
+      vel: velTex[i].createView('sampled'),
+      div: divergenceTex.createView('writeonly'),
+    }),
+  );
+
+  const pressureBindGroups = [0, 1].map((i) =>
+    root.createBindGroup(k.pressureLayout, {
+      x: pressureTex[i].createView('sampled'),
+      b: divergenceTex.createView('sampled'),
+      out: pressureTex[1 - i].createView('writeonly'),
+    }),
+  );
+
+  const projectBindGroups = [0, 1].map((velIdx) =>
+    [0, 1].map((pIdx) =>
+      root.createBindGroup(k.projectLayout, {
+        vel: velTex[velIdx].createView('sampled'),
+        p: pressureTex[pIdx].createView('sampled'),
+        out: velTex[1 - velIdx].createView('writeonly'),
+      }),
+    ),
+  );
+
+  const advectInkBindGroups = [0, 1].map((velIdx) =>
+    [0, 1].map((inkIdx) =>
+      root.createBindGroup(k.advectInkLayout, {
+        vel: velTex[velIdx].createView('sampled'),
+        src: inkTex[inkIdx].createView('sampled'),
+        dst: inkTex[1 - inkIdx].createView('writeonly'),
+        simParams: simParamBuffer,
+        linSampler,
+      }),
+    ),
+  );
+
+  const renderBindGroups = {
+    image: [0, 1].map((idx) =>
+      root.createBindGroup(k.renderLayout, {
+        result: inkTex[idx].createView('sampled'),
+        background: backgroundTexture.createView('sampled'),
+        linSampler,
+      }),
+    ),
+    ink: [0, 1].map((idx) =>
+      root.createBindGroup(k.renderLayout, {
+        result: inkTex[idx].createView('sampled'),
+        background: backgroundTexture.createView('sampled'),
+        linSampler,
+      }),
+    ),
+    velocity: [0, 1].map((idx) =>
+      root.createBindGroup(k.renderLayout, {
+        result: velTex[idx].createView('sampled'),
+        background: backgroundTexture.createView('sampled'),
+        linSampler,
+      }),
+    ),
+  };
+
+  function loop() {
+    simParamBuffer.write({
+      dt: params.dt,
+      viscosity: params.viscosity,
+      enableBoundary: enableBoundary.current ? 1 : 0,
+    });
+
+    if (brushInfo.current?.isDown) {
+      brushParamBuffer.write({
+        pos: d.vec2i(...brushInfo.current.pos),
+        delta: d.vec2f(...brushInfo.current.delta),
+        radius: simWidth * 0.1,
+        forceScale: FORCE_SCALE,
+        inkAmount: INK_AMOUNT,
+      });
+
+      brushPipeline
+        .with(k.brushLayout, brushBindGroup)
+        .dispatchWorkgroups(dispatchX, dispatchY);
+
+      addInkPipeline
+        .with(k.addInkLayout, addInkBindGroups[inkBuffer.currentIndex])
+        .dispatchWorkgroups(dispatchX, dispatchY);
+      inkBuffer.swap();
+
+      addForcePipeline
+        .with(k.addForcesLayout, addForceBindGroups[velBuffer.currentIndex])
+        .dispatchWorkgroups(dispatchX, dispatchY);
+    } else {
+      velBuffer.setCurrent(0);
+    }
+
+    advectPipeline
+      .with(k.advectLayout, advectBindGroups[velBuffer.currentIndex])
+      .dispatchWorkgroups(dispatchX, dispatchY);
+
+    for (let i = 0; i < params.jacobiIter; i++) {
+      diffusionPipeline
+        .with(k.diffusionLayout, diffusionBindGroups[velBuffer.currentIndex])
+        .dispatchWorkgroups(dispatchX, dispatchY);
+      velBuffer.swap();
+    }
+
+    divergencePipeline
+      .with(k.divergenceLayout, divergenceBindGroups[velBuffer.currentIndex])
+      .dispatchWorkgroups(dispatchX, dispatchY);
+
+    pressureBuffer.setCurrent(0);
+    for (let i = 0; i < params.jacobiIter; i++) {
+      pressurePipeline
+        .with(k.pressureLayout, pressureBindGroups[pressureBuffer.currentIndex])
+        .dispatchWorkgroups(dispatchX, dispatchY);
+      pressureBuffer.swap();
+    }
+
+    projectPipeline
+      .with(
+        k.projectLayout,
+        projectBindGroups[velBuffer.currentIndex][pressureBuffer.currentIndex],
+      )
+      .dispatchWorkgroups(dispatchX, dispatchY);
+    velBuffer.swap();
+
+    advectInkPipeline
+      .with(
+        k.advectInkLayout,
+        advectInkBindGroups[velBuffer.currentIndex][inkBuffer.currentIndex],
+      )
+      .dispatchWorkgroups(dispatchX, dispatchY);
+    inkBuffer.swap();
+
+    let pipeline: TgpuRenderPipeline;
+    let renderBindGroup: TgpuBindGroup<RenderEntries>[];
+
+    if (showField.current === 'ink') {
+      pipeline = renderPipelineInk;
+      renderBindGroup = renderBindGroups.ink;
+    } else if (showField.current === 'velocity') {
+      pipeline = renderPipelineVel;
+      renderBindGroup = renderBindGroups.velocity;
+    } else {
+      pipeline = renderPipelineImage;
+      renderBindGroup = renderBindGroups.image;
+    }
+
+    pipeline
+      .withColorAttachment({
+        view: context.getCurrentTexture().createView(),
+        loadOp: 'clear',
+        storeOp: 'store',
+      })
+      .with(k.renderLayout, renderBindGroup[inkBuffer.currentIndex])
+      .draw(6);
+
+    root['~unstable'].flush();
+  }
+
+  return loop;
+}
+
+export default function () {
+  const brushInfo = useRef<BrushInfo>({
+    pos: [0, 0],
+    delta: [0, 0],
+    isDown: false,
+  });
+  const canvasSize = useRef<{ width: number; height: number } | null>(null);
+
+  const [showField, setShowField] = useState<DisplayMode>(params.showField);
+  const showFieldRef = useRef(showField);
+  showFieldRef.current = showField;
+
+  const [enableBoundary, setEnableBoundary] = useState(params.enableBoundary);
+  const enableBoundaryRef = useRef(enableBoundary);
+  enableBoundaryRef.current = enableBoundary;
+
+  const sceneFunction = useCallback(
+    async ({
+      context,
+      device,
+      presentationFormat,
+    }: {
+      context: GPUCanvasContext;
+      device: GPUDevice;
+      presentationFormat: GPUTextureFormat;
+    }) =>
+      await createScene({
+        context,
+        device,
+        presentationFormat,
+        brushInfo,
+        showField: showFieldRef,
+        canvasSize,
+        enableBoundary: enableBoundaryRef,
+      }),
+    [],
+  );
+
+  const ref = useWebGPU(sceneFunction);
+
+  const realToCanvas = useCallback((x: number, y: number): [number, number] => {
+    const size = canvasSize.current;
+    if (!size) {
+      return [0, 0];
+    }
+    const dpr = PixelRatio.get();
+
+    const gx = Math.floor(x * dpr * SIMULATION_QUALITY);
+    const gy = Math.floor((size.height - y * dpr) * SIMULATION_QUALITY);
+    const cx = Math.max(0, Math.min(size.width * SIMULATION_QUALITY - 1, gx));
+    const cy = Math.max(0, Math.min(size.height * SIMULATION_QUALITY - 1, gy));
+
+    return [cx, cy];
+  }, []);
+
+  const handleStart = useCallback(
+    (e: GestureResponderEvent) => {
+      const { locationX, locationY } = e.nativeEvent;
+      brushInfo.current = {
+        pos: realToCanvas(locationX, locationY),
+        delta: [0, 0],
+        isDown: true,
+      };
+    },
+    [realToCanvas],
+  );
+
+  const handleMove = useCallback(
+    (e: GestureResponderEvent) => {
+      if (!brushInfo.current) {
+        return;
+      }
+      const { locationX, locationY } = e.nativeEvent;
+      const [gx, gy] = realToCanvas(locationX, locationY);
+      const dx = gx - brushInfo.current.pos[0];
+      const dy = gy - brushInfo.current.pos[1];
+
+      brushInfo.current = {
+        pos: [gx, gy],
+        delta: [dx, dy],
+        isDown: true,
+      };
+    },
+    [realToCanvas],
+  );
+
+  const handleEnd = useCallback(() => {
+    brushInfo.current = {
+      pos: [0, 0],
+      delta: [0, 0],
+      isDown: false,
+    };
+  }, []);
+
+  const handleShowField = useCallback((field: DisplayMode) => {
+    setShowField(field);
+    params.showField = field;
+  }, []);
+
+  const handleBoundaryToggle = useCallback((value: boolean) => {
+    setEnableBoundary(value);
+    params.enableBoundary = value;
+  }, []);
+
+  return (
+    <View style={{ width: '100%', alignItems: 'center' }}>
+      <Canvas
+        ref={ref}
+        style={{
+          width: '100%',
+          aspectRatio: 1,
+        }}
+        onTouchStart={handleStart}
+        onTouchMove={handleMove}
+        onTouchEnd={handleEnd}
+      />
+      <View>
+        <View
+          style={{
+            flexDirection: 'row',
+            justifyContent: 'center',
+            alignItems: 'center',
+            gap: 10,
+          }}
+        >
+          {(['ink', 'velocity', 'image'] as DisplayMode[]).map((field) => (
+            <TouchableOpacity
+              key={field}
+              style={{
+                padding: 10,
+                backgroundColor: showField === field ? '#ccc' : '#fff',
+                borderRadius: 20,
+                margin: 10,
+              }}
+              onPress={() => handleShowField(field)}
+            >
+              <Text>{field}</Text>
+            </TouchableOpacity>
+          ))}
+        </View>
+        <View
+          style={{
+            flexDirection: 'column',
+            alignItems: 'center',
+            justifyContent: 'center',
+            marginTop: 10,
+          }}
+        >
+          <Text style={{ fontSize: 16, fontWeight: '600' }}>Boundary</Text>
+          <Switch value={enableBoundary} onValueChange={handleBoundaryToggle} />
+        </View>
+      </View>
+    </View>
+  );
+}
diff --git a/examples/StableFluids/backgroundImageBase64.ts b/examples/StableFluids/backgroundImageBase64.ts
new file mode 100644
index 0000000..1cee2e6
--- /dev/null
+++ b/examples/StableFluids/backgroundImageBase64.ts
@@ -0,0 +1,3 @@
+const imageUri =
+  'data:image/jpeg;base64,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';
+export default imageUri;
diff --git a/examples/StableFluids/imageResizer.ts b/examples/StableFluids/imageResizer.ts
new file mode 100644
index 0000000..1bf7005
--- /dev/null
+++ b/examples/StableFluids/imageResizer.ts
@@ -0,0 +1,73 @@
+import * as std from 'typegpu/std';
+import * as d from 'typegpu/data';
+import tgpu, { type TgpuRoot } from 'typegpu';
+import * as k from './kernels';
+
+export const resampleImageLayout = tgpu.bindGroupLayout({
+  src: { texture: 'float' },
+  linSampler: { sampler: 'filtering' },
+});
+
+export const fragmentResampleFn = tgpu['~unstable'].fragmentFn({
+  in: { uv: d.vec2f },
+  out: d.vec4f,
+})((inp) => {
+  const color = std.textureSample(
+    resampleImageLayout.$.src,
+    resampleImageLayout.$.linSampler,
+    inp.uv,
+  );
+  return d.vec4f(color.xyz, d.f32(1.0));
+});
+
+export async function resampleImageBitmapToTexture(
+  root: TgpuRoot,
+  imageBitmap: ImageBitmap,
+  width: number,
+  height: number,
+) {
+  const srcDims = [imageBitmap.width, imageBitmap.height] as const;
+  const srcTexture = root['~unstable']
+    .createTexture({ size: srcDims, format: 'rgba8unorm' })
+    .$usage('sampled')
+    .$name('resampleSrc');
+  root.device.queue.copyExternalImageToTexture(
+    { source: imageBitmap },
+    { texture: root.unwrap(srcTexture) },
+    srcDims,
+  );
+
+  const dstTexture = root['~unstable']
+    .createTexture({ size: [width, height], format: 'rgba8unorm' })
+    .$usage('render', 'sampled')
+    .$name('resampled');
+
+  const sampler = tgpu['~unstable'].sampler({
+    magFilter: 'linear',
+    minFilter: 'linear',
+    addressModeU: 'clamp-to-edge',
+    addressModeV: 'clamp-to-edge',
+  });
+
+  const pipeline = root['~unstable']
+    .withVertex(k.renderFn, k.renderFn.shell.attributes)
+    .withFragment(fragmentResampleFn, { format: 'rgba8unorm' })
+    .createPipeline();
+
+  const bindGroup = root.createBindGroup(resampleImageLayout, {
+    src: srcTexture.createView('sampled'),
+    linSampler: sampler,
+  });
+
+  pipeline
+    .withColorAttachment({
+      view: dstTexture,
+      loadOp: 'clear',
+      storeOp: 'store',
+    })
+    .with(resampleImageLayout, bindGroup)
+    .draw(6);
+  root['~unstable'].flush();
+
+  return dstTexture;
+}
diff --git a/examples/StableFluids/kernels.ts b/examples/StableFluids/kernels.ts
new file mode 100644
index 0000000..c62ea6f
--- /dev/null
+++ b/examples/StableFluids/kernels.ts
@@ -0,0 +1,393 @@
+import tgpu from 'typegpu';
+import * as d from 'typegpu/data';
+import * as std from 'typegpu/std';
+import {
+  BrushParams,
+  DISPLACEMENT_SCALE,
+  Params,
+  WORKGROUP_SIZE_X,
+  WORKGROUP_SIZE_Y,
+} from './params';
+
+const getNeighbors = tgpu['~unstable'].fn(
+  { coords: d.vec2i, bounds: d.vec2i },
+  d.arrayOf(d.vec2i, 4),
+)(({ coords, bounds }) => {
+  const res = [d.vec2i(-1, 0), d.vec2i(0, -1), d.vec2i(1, 0), d.vec2i(0, 1)];
+  for (let i = 0; i < 4; i++) {
+    res[i] = std.clamp(
+      std.add(coords, res[i]),
+      d.vec2i(0),
+      std.sub(bounds, d.vec2i(1)),
+    );
+  }
+  return res;
+});
+
+export const brushLayout = tgpu.bindGroupLayout({
+  brushParams: { uniform: BrushParams },
+  forceDst: { storageTexture: 'rgba16float', access: 'writeonly' },
+  inkDst: { storageTexture: 'rgba16float', access: 'writeonly' },
+});
+
+export const brushFn = tgpu['~unstable'].computeFn({
+  workgroupSize: [WORKGROUP_SIZE_X, WORKGROUP_SIZE_Y],
+  in: { gid: d.builtin.globalInvocationId },
+})((input) => {
+  const coords = input.gid.xy;
+  const params = brushLayout.$.brushParams;
+
+  let force = d.vec2f(0.0);
+  let ink = d.f32(0.0);
+
+  const dx = d.f32(coords.x) - d.f32(params.pos.x);
+  const dy = d.f32(coords.y) - d.f32(params.pos.y);
+  const distSq = dx * dx + dy * dy;
+  const radiusSq = params.radius * params.radius;
+
+  if (distSq < radiusSq) {
+    const weight = std.max(0.0, 1.0 - distSq / radiusSq);
+    force = std.mul(params.forceScale * weight, params.delta);
+    ink = params.inkAmount * weight;
+  }
+
+  std.textureStore(brushLayout.$.forceDst, coords, d.vec4f(force, 0.0, 1.0));
+  std.textureStore(brushLayout.$.inkDst, coords, d.vec4f(ink, 0.0, 0.0, 1.0));
+});
+
+export const addForcesLayout = tgpu.bindGroupLayout({
+  src: { texture: 'float' },
+  dst: { storageTexture: 'rgba16float', access: 'writeonly' },
+  force: { texture: 'float' },
+  simParams: { uniform: Params },
+});
+
+export const addForcesFn = tgpu['~unstable'].computeFn({
+  workgroupSize: [WORKGROUP_SIZE_X, WORKGROUP_SIZE_Y],
+  in: { gid: d.builtin.globalInvocationId },
+})((input) => {
+  const coords = input.gid.xy;
+  const u = std.textureLoad(addForcesLayout.$.src, coords, 0).xy;
+  const f = std.textureLoad(addForcesLayout.$.force, coords, 0).xy;
+  const dt = addForcesLayout.$.simParams.dt;
+  const u2 = std.add(u, std.mul(dt, f));
+  std.textureStore(addForcesLayout.$.dst, coords, d.vec4f(u2, 0, 1));
+});
+
+export const advectLayout = tgpu.bindGroupLayout({
+  src: { texture: 'float' },
+  dst: { storageTexture: 'rgba16float', access: 'writeonly' },
+  simParams: { uniform: Params },
+  linSampler: { sampler: 'filtering' },
+});
+
+export const advectFn = tgpu['~unstable'].computeFn({
+  workgroupSize: [WORKGROUP_SIZE_X, WORKGROUP_SIZE_Y],
+  in: { gid: d.builtin.globalInvocationId },
+})((input) => {
+  const textureDimensions = std.textureDimensions(advectLayout.$.src);
+  const coords = input.gid.xy;
+  const oldVel = std.textureLoad(advectLayout.$.src, coords, 0);
+  const dt = advectLayout.$.simParams.dt;
+  const oldCoords = std.sub(d.vec2f(coords), std.mul(dt, oldVel.xy));
+  const oldCoordsClamped = std.clamp(
+    oldCoords,
+    d.vec2f(-0.5),
+    d.vec2f(std.sub(d.vec2f(textureDimensions.xy), d.vec2f(0.5))),
+  );
+  const oldCoordsNormalized = std.div(
+    std.add(oldCoordsClamped, d.vec2f(0.5)),
+    d.vec2f(textureDimensions.xy),
+  );
+
+  const velAtOldCoords = std.textureSampleLevel(
+    advectLayout.$.src,
+    advectLayout.$.linSampler,
+    oldCoordsNormalized,
+    0,
+  );
+
+  const isBorder = std.or(
+    std.lt(coords, d.vec2u(1)),
+    std.ge(coords, std.sub(d.vec2u(textureDimensions.xy), d.vec2u(1))),
+  );
+
+  const finalVel = std.select(
+    velAtOldCoords,
+    d.vec4f(0, 0, 0, 1),
+    std.any(isBorder) && advectLayout.$.simParams.enableBoundary === 1,
+  );
+
+  std.textureStore(advectLayout.$.dst, coords, finalVel);
+});
+
+export const diffusionLayout = tgpu.bindGroupLayout({
+  in: { texture: 'float' },
+  out: { storageTexture: 'rgba16float', access: 'writeonly' },
+  simParams: { uniform: Params },
+});
+
+export const diffusionFn = tgpu['~unstable'].computeFn({
+  workgroupSize: [WORKGROUP_SIZE_X, WORKGROUP_SIZE_Y],
+  in: { gid: d.builtin.globalInvocationId },
+})((input) => {
+  const coords = d.vec2i(input.gid.xy);
+  const textureDimensions = d.vec2i(
+    std.textureDimensions(diffusionLayout.$.in),
+  );
+  const inputValue = std.textureLoad(diffusionLayout.$.in, coords, 0);
+
+  const neighbors = getNeighbors({ coords, bounds: textureDimensions });
+
+  const left = std.textureLoad(diffusionLayout.$.in, neighbors[0], 0);
+  const up = std.textureLoad(diffusionLayout.$.in, neighbors[1], 0);
+  const right = std.textureLoad(diffusionLayout.$.in, neighbors[2], 0);
+  const down = std.textureLoad(diffusionLayout.$.in, neighbors[3], 0);
+
+  const dt = diffusionLayout.$.simParams.dt;
+  const viscosity = diffusionLayout.$.simParams.viscosity;
+
+  const alpha = viscosity * dt;
+  const beta = 1.0 / (4.0 + alpha);
+  const newValue = std.mul(
+    d.vec4f(beta),
+    std.add(
+      std.add(std.add(left, right), std.add(up, down)),
+      std.mul(d.f32(alpha), inputValue),
+    ),
+  );
+
+  std.textureStore(diffusionLayout.$.out, coords, newValue);
+});
+
+export const divergenceLayout = tgpu.bindGroupLayout({
+  vel: { texture: 'float' },
+  div: { storageTexture: 'rgba16float', access: 'writeonly' },
+});
+
+export const divergenceFn = tgpu['~unstable'].computeFn({
+  workgroupSize: [WORKGROUP_SIZE_X, WORKGROUP_SIZE_Y],
+  in: { gid: d.builtin.globalInvocationId },
+})((input) => {
+  const coords = d.vec2i(input.gid.xy);
+  const textureDimensions = d.vec2i(
+    std.textureDimensions(divergenceLayout.$.vel),
+  );
+
+  const neighbors = getNeighbors({ coords, bounds: textureDimensions });
+
+  const left = std.textureLoad(divergenceLayout.$.vel, neighbors[0], 0);
+  const up = std.textureLoad(divergenceLayout.$.vel, neighbors[1], 0);
+  const right = std.textureLoad(divergenceLayout.$.vel, neighbors[2], 0);
+  const down = std.textureLoad(divergenceLayout.$.vel, neighbors[3], 0);
+
+  const div = d.f32(0.5) * (right.x - left.x + (down.y - up.y));
+  std.textureStore(divergenceLayout.$.div, coords, d.vec4f(div, 0, 0, 1));
+});
+
+export const pressureLayout = tgpu.bindGroupLayout({
+  x: { texture: 'float' },
+  b: { texture: 'float' },
+  out: { storageTexture: 'rgba16float', access: 'writeonly' },
+});
+
+export const pressureFn = tgpu['~unstable'].computeFn({
+  workgroupSize: [WORKGROUP_SIZE_X, WORKGROUP_SIZE_Y],
+  in: { gid: d.builtin.globalInvocationId },
+})((input) => {
+  const coords = d.vec2i(input.gid.xy);
+  const textureDimensions = d.vec2i(std.textureDimensions(pressureLayout.$.x));
+
+  const neighbors = getNeighbors({ coords, bounds: textureDimensions });
+
+  const left = std.textureLoad(pressureLayout.$.x, neighbors[0], 0);
+  const up = std.textureLoad(pressureLayout.$.x, neighbors[1], 0);
+  const right = std.textureLoad(pressureLayout.$.x, neighbors[2], 0);
+  const down = std.textureLoad(pressureLayout.$.x, neighbors[3], 0);
+
+  const div = std.textureLoad(pressureLayout.$.b, coords, 0).x;
+  const newP = d.f32(0.25) * (left.x + right.x + up.x + down.x - div);
+  std.textureStore(pressureLayout.$.out, coords, d.vec4f(newP, 0, 0, 1));
+});
+
+export const projectLayout = tgpu.bindGroupLayout({
+  vel: { texture: 'float' },
+  p: { texture: 'float' },
+  out: { storageTexture: 'rgba16float', access: 'writeonly' },
+});
+
+export const projectFn = tgpu['~unstable'].computeFn({
+  workgroupSize: [WORKGROUP_SIZE_X, WORKGROUP_SIZE_Y],
+  in: { gid: d.builtin.globalInvocationId },
+})((input) => {
+  const coords = d.vec2i(input.gid.xy);
+  const textureDimensions = d.vec2i(std.textureDimensions(projectLayout.$.vel));
+  const vel = std.textureLoad(projectLayout.$.vel, coords, 0);
+
+  const neighbors = getNeighbors({ coords, bounds: textureDimensions });
+
+  const left = std.textureLoad(projectLayout.$.p, neighbors[0], 0);
+  const up = std.textureLoad(projectLayout.$.p, neighbors[1], 0);
+  const right = std.textureLoad(projectLayout.$.p, neighbors[2], 0);
+  const down = std.textureLoad(projectLayout.$.p, neighbors[3], 0);
+
+  const grad = d.vec2f(0.5 * (right.x - left.x), 0.5 * (down.x - up.x));
+  const newVel = std.sub(vel.xy, grad);
+  std.textureStore(projectLayout.$.out, coords, d.vec4f(newVel, 0, 1));
+});
+
+export const advectInkLayout = tgpu.bindGroupLayout({
+  vel: { texture: 'float' },
+  src: { texture: 'float' },
+  dst: { storageTexture: 'rgba16float', access: 'writeonly' },
+  simParams: { uniform: Params },
+  linSampler: { sampler: 'filtering' },
+});
+
+export const advectScalarFn = tgpu['~unstable'].computeFn({
+  workgroupSize: [WORKGROUP_SIZE_X, WORKGROUP_SIZE_Y],
+  in: { gid: d.builtin.globalInvocationId },
+})((input) => {
+  const dims = std.textureDimensions(advectInkLayout.$.src);
+  const coords = input.gid.xy;
+
+  const vel = std.textureLoad(advectInkLayout.$.vel, coords, 0).xy;
+  const dt = advectInkLayout.$.simParams.dt;
+  const oldCoords = std.sub(d.vec2f(coords), std.mul(dt, vel));
+  const clamped = std.clamp(
+    oldCoords,
+    d.vec2f(-0.5),
+    std.sub(d.vec2f(dims.xy), d.vec2f(0.5)),
+  );
+  const uv = std.div(std.add(clamped, d.vec2f(0.5)), d.vec2f(dims.xy));
+
+  const ink = std.textureSampleLevel(
+    advectInkLayout.$.src,
+    advectInkLayout.$.linSampler,
+    uv,
+    0,
+  );
+  std.textureStore(advectInkLayout.$.dst, coords, ink);
+});
+
+export const addInkLayout = tgpu.bindGroupLayout({
+  src: { texture: 'float' },
+  dst: { storageTexture: 'rgba16float', access: 'writeonly' },
+  add: { texture: 'float' },
+});
+
+export const addInkFn = tgpu['~unstable'].computeFn({
+  workgroupSize: [WORKGROUP_SIZE_X, WORKGROUP_SIZE_Y],
+  in: { gid: d.builtin.globalInvocationId },
+})((input) => {
+  const c = input.gid.xy;
+  const a = std.textureLoad(addInkLayout.$.add, c, 0).x;
+  const s = std.textureLoad(addInkLayout.$.src, c, 0).x;
+  std.textureStore(addInkLayout.$.dst, c, d.vec4f(a + s, 0, 0, 1));
+});
+
+export const renderLayout = tgpu.bindGroupLayout({
+  result: { texture: 'float' },
+  background: { texture: 'float' },
+  linSampler: { sampler: 'filtering' },
+});
+
+export const renderFn = tgpu['~unstable'].vertexFn({
+  in: { idx: d.builtin.vertexIndex },
+  out: { pos: d.builtin.position, uv: d.vec2f },
+})((i) => {
+  const verts = [
+    d.vec4f(-1, -1, 0, 1),
+    d.vec4f(1, -1, 0, 1),
+    d.vec4f(-1, 1, 0, 1),
+    d.vec4f(1, -1, 0, 1),
+    d.vec4f(1, 1, 0, 1),
+    d.vec4f(-1, 1, 0, 1),
+  ];
+  const uvs = [
+    d.vec2f(0, 0),
+    d.vec2f(1, 0),
+    d.vec2f(0, 1),
+    d.vec2f(1, 0),
+    d.vec2f(1, 1),
+    d.vec2f(0, 1),
+  ];
+  return { pos: verts[i.idx], uv: uvs[i.idx] };
+});
+
+export const fragmentInkFn = tgpu['~unstable'].fragmentFn({
+  in: { uv: d.vec2f },
+  out: d.vec4f,
+})((inp) => {
+  const dens = std.textureSample(
+    renderLayout.$.result,
+    renderLayout.$.linSampler,
+    inp.uv,
+  ).x;
+  return d.vec4f(dens, dens * 0.8, dens * 0.5, 1);
+});
+
+export const fragmentVelFn = tgpu['~unstable'].fragmentFn({
+  in: { uv: d.vec2f },
+  out: d.vec4f,
+})((inp) => {
+  const f = std.textureSample(
+    renderLayout.$.result,
+    renderLayout.$.linSampler,
+    inp.uv,
+  ).xy;
+  const mag = std.length(f);
+  const col = d.vec4f(
+    (f.x + 1.0) * 0.5, // x->r
+    (f.y + 1.0) * 0.5, // y->g
+    mag * 0.4,
+    d.f32(1.0),
+  );
+  return col;
+});
+
+export const fragmentImageFn = tgpu['~unstable'].fragmentFn({
+  in: { uv: d.vec2f },
+  out: d.vec4f,
+})((inp) => {
+  const EPS = DISPLACEMENT_SCALE;
+
+  const left = std.textureSample(
+    renderLayout.$.result,
+    renderLayout.$.linSampler,
+    d.vec2f(inp.uv.x - EPS, inp.uv.y),
+  ).x;
+  const right = std.textureSample(
+    renderLayout.$.result,
+    renderLayout.$.linSampler,
+    d.vec2f(inp.uv.x + EPS, inp.uv.y),
+  ).x;
+  const up = std.textureSample(
+    renderLayout.$.result,
+    renderLayout.$.linSampler,
+    d.vec2f(inp.uv.x, inp.uv.y + EPS),
+  ).x;
+  const down = std.textureSample(
+    renderLayout.$.result,
+    renderLayout.$.linSampler,
+    d.vec2f(inp.uv.x, inp.uv.y - EPS),
+  ).x;
+
+  const dx = right - left;
+  const dy = up - down;
+
+  const strength = 0.8;
+  const displacement = d.vec2f(dx, dy);
+  const offsetUV = std.add(
+    inp.uv,
+    std.mul(displacement, d.vec2f(strength, -strength)),
+  );
+
+  const color = std.textureSample(
+    renderLayout.$.background,
+    renderLayout.$.linSampler,
+    d.vec2f(offsetUV.x, offsetUV.y),
+  );
+
+  return d.vec4f(color.xyz, 1.0);
+});
diff --git a/examples/StableFluids/params.ts b/examples/StableFluids/params.ts
new file mode 100644
index 0000000..22ece24
--- /dev/null
+++ b/examples/StableFluids/params.ts
@@ -0,0 +1,30 @@
+import * as d from 'typegpu/data';
+import type { SimParams } from './types.ts';
+
+export const [WORKGROUP_SIZE_X, WORKGROUP_SIZE_Y] = [16, 16];
+export const FORCE_SCALE = 0.6;
+export const INK_AMOUNT = 0.02;
+export const SIMULATION_QUALITY = 0.2;
+export const DISPLACEMENT_SCALE = 0.005;
+
+export const params: SimParams = {
+  dt: 0.6,
+  viscosity: 0.00001,
+  jacobiIter: 10,
+  showField: 'ink',
+  enableBoundary: true,
+};
+
+export const Params = d.struct({
+  dt: d.f32,
+  viscosity: d.f32,
+  enableBoundary: d.u32,
+});
+
+export const BrushParams = d.struct({
+  pos: d.vec2i,
+  delta: d.vec2f,
+  radius: d.f32,
+  forceScale: d.f32,
+  inkAmount: d.f32,
+});
diff --git a/examples/StableFluids/types.ts b/examples/StableFluids/types.ts
new file mode 100644
index 0000000..c8b3593
--- /dev/null
+++ b/examples/StableFluids/types.ts
@@ -0,0 +1,18 @@
+export type DisplayMode = 'ink' | 'velocity' | 'image';
+export type BrushInfo = {
+  pos: [number, number];
+  delta: [number, number];
+  isDown: boolean;
+};
+export type RenderEntries = {
+  result: { texture: 'float' };
+  background: { texture: 'float' };
+  linSampler: { sampler: 'filtering' };
+};
+export type SimParams = {
+  dt: number;
+  viscosity: number;
+  jacobiIter: number;
+  showField: DisplayMode;
+  enableBoundary: boolean;
+};
diff --git a/package.json b/package.json
index a2f6d68..a04eeb1 100644
--- a/package.json
+++ b/package.json
@@ -9,13 +9,13 @@
     "web": "expo start --web"
   },
   "dependencies": {
-    "@typegpu/noise": "^0.0.3",
+    "@typegpu/noise": "^0.0.6",
     "expo": "~52.0.37",
     "react": "18.3.1",
-    "react-native": "0.76.7",
+    "react-native": "0.76.9",
     "react-native-wgpu": "^0.1.23",
-    "typegpu": "^0.5.1",
-    "unplugin-typegpu": "0.1.0-alpha.5",
+    "typegpu": "https://pkg.pr.new/software-mansion/TypeGPU/typegpu@c09c37e223a7342038fbfcd8d8add5d8ed013858",
+    "unplugin-typegpu": "0.1.0",
     "wgpu-matrix": "^3.3.0",
     "@loaders.gl/core": "^4.3.3",
     "@loaders.gl/obj": "^4.3.3"
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 3f56fcd..fe578bc 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -15,26 +15,26 @@ importers:
         specifier: ^4.3.3
         version: 4.3.3(@loaders.gl/core@4.3.3)
       '@typegpu/noise':
-        specifier: ^0.0.3
-        version: 0.0.3(typegpu@0.5.1)
+        specifier: ^0.0.6
+        version: 0.0.6(typegpu@https://pkg.pr.new/software-mansion/TypeGPU/typegpu@43a643ac32470f0b3b51acb90970b36d418d8b8c)
       expo:
         specifier: ~52.0.37
-        version: 52.0.37(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(react-native@0.76.7(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1))(react@18.3.1)
+        version: 52.0.37(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(react-native@0.76.9(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1))(react@18.3.1)
       react:
         specifier: 18.3.1
         version: 18.3.1
       react-native:
-        specifier: 0.76.7
-        version: 0.76.7(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1)
+        specifier: 0.76.9
+        version: 0.76.9(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1)
       react-native-wgpu:
         specifier: ^0.1.23
-        version: 0.1.23(react-native@0.76.7(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1))(react@18.3.1)
+        version: 0.1.23(react-native@0.76.9(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1))(react@18.3.1)
       typegpu:
-        specifier: ^0.5.1
-        version: 0.5.1
+        specifier: https://pkg.pr.new/software-mansion/TypeGPU/typegpu@43a643ac32470f0b3b51acb90970b36d418d8b8c
+        version: https://pkg.pr.new/software-mansion/TypeGPU/typegpu@43a643ac32470f0b3b51acb90970b36d418d8b8c
       unplugin-typegpu:
-        specifier: 0.1.0-alpha.5
-        version: 0.1.0-alpha.5
+        specifier: 0.1.0
+        version: 0.1.0(typegpu@https://pkg.pr.new/software-mansion/TypeGPU/typegpu@43a643ac32470f0b3b51acb90970b36d418d8b8c)
       wgpu-matrix:
         specifier: ^3.3.0
         version: 3.3.0
@@ -768,8 +768,8 @@ packages:
     resolution: {integrity: sha512-aA63XwOkcl4xxQa3HjPMqOP6LiK0ZDv3mUPYEFXkpHbaFjtGggE1A61FjFzJnB+p7/oy2gA8E+rcBNl/zC1tMg==}
     engines: {node: '>=6.9.0'}
 
-  '@babel/standalone@7.26.9':
-    resolution: {integrity: sha512-UTeQKy0kzJwWRe55kT1uK4G9H6D0lS6G4207hCU/bDaOhA5t2aC0qHN6GmID0Axv3OFLNXm27NdqcWp+BXcGtA==}
+  '@babel/standalone@7.27.0':
+    resolution: {integrity: sha512-UxFDpi+BuSz6Q1X73P3ZSM1CB7Nbbqys+7COi/tdouRuaqRsJ6GAzUyxTswbqItHSItVY3frQdd+paBHHGEk9g==}
     engines: {node: '>=6.9.0'}
 
   '@babel/template@7.26.9':
@@ -1023,53 +1023,77 @@ packages:
   '@probe.gl/stats@4.1.0':
     resolution: {integrity: sha512-EI413MkWKBDVNIfLdqbeNSJTs7ToBz/KVGkwi3D+dQrSIkRI2IYbWGAU3xX+D6+CI4ls8ehxMhNpUVMaZggDvQ==}
 
-  '@react-native/assets-registry@0.76.7':
-    resolution: {integrity: sha512-o79whsqL5fbPTUQO9w1FptRd4cw1TaeOrXtQSLQeDrMVAenw/wmsjyPK10VKtvqxa1KNMtWEyfgxcM8CVZVFmg==}
+  '@react-native/assets-registry@0.76.9':
+    resolution: {integrity: sha512-pN0Ws5xsjWOZ8P37efh0jqHHQmq+oNGKT4AyAoKRpxBDDDmlAmpaYjer9Qz7PpDKF+IUyRjF/+rBsM50a8JcUg==}
     engines: {node: '>=18'}
 
   '@react-native/babel-plugin-codegen@0.76.7':
     resolution: {integrity: sha512-+8H4DXJREM4l/pwLF/wSVMRzVhzhGDix5jLezNrMD9J1U1AMfV2aSkWA1XuqR7pjPs/Vqf6TaPL7vJMZ4LU05Q==}
     engines: {node: '>=18'}
 
+  '@react-native/babel-plugin-codegen@0.76.9':
+    resolution: {integrity: sha512-vxL/vtDEIYHfWKm5oTaEmwcnNGsua/i9OjIxBDBFiJDu5i5RU3bpmDiXQm/bJxrJNPRp5lW0I0kpGihVhnMAIQ==}
+    engines: {node: '>=18'}
+
   '@react-native/babel-preset@0.76.7':
     resolution: {integrity: sha512-/c5DYZ6y8tyg+g8tgXKndDT7mWnGmkZ9F+T3qNDfoE3Qh7ucrNeC2XWvU9h5pk8eRtj9l4SzF4aO1phzwoibyg==}
     engines: {node: '>=18'}
     peerDependencies:
       '@babel/core': '*'
 
+  '@react-native/babel-preset@0.76.9':
+    resolution: {integrity: sha512-TbSeCplCM6WhL3hR2MjC/E1a9cRnMLz7i767T7mP90oWkklEjyPxWl+0GGoVGnJ8FC/jLUupg/HvREKjjif6lw==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      '@babel/core': '*'
+
   '@react-native/codegen@0.76.7':
     resolution: {integrity: sha512-FAn585Ll65YvkSrKDyAcsdjHhhAGiMlSTUpHh0x7J5ntudUns+voYms0xMP+pEPt0XuLdjhD7zLIIlAWP407+g==}
     engines: {node: '>=18'}
     peerDependencies:
       '@babel/preset-env': ^7.1.6
 
-  '@react-native/community-cli-plugin@0.76.7':
-    resolution: {integrity: sha512-lrcsY2WPLCEWU1pjdNV9+Ccj8vCEwCCURZiPa5aqi7lKB4C++1hPrxA8/CWWnTNcQp76DsBKGYqTFj7Ud4aupw==}
+  '@react-native/codegen@0.76.9':
+    resolution: {integrity: sha512-AzlCHMTKrAVC2709V4ZGtBXmGVtWTpWm3Ruv5vXcd3/anH4mGucfJ4rjbWKdaYQJMpXa3ytGomQrsIsT/s8kgA==}
     engines: {node: '>=18'}
     peerDependencies:
-      '@react-native-community/cli-server-api': '*'
+      '@babel/preset-env': ^7.1.6
+
+  '@react-native/community-cli-plugin@0.76.9':
+    resolution: {integrity: sha512-08jx8ixCjjd4jNQwNpP8yqrjrDctN2qvPPlf6ebz1OJQk8e1sbUl3wVn1zhhMvWrYcaraDnatPb5uCPq+dn3NQ==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      '@react-native-community/cli': '*'
     peerDependenciesMeta:
-      '@react-native-community/cli-server-api':
+      '@react-native-community/cli':
         optional: true
 
   '@react-native/debugger-frontend@0.76.7':
     resolution: {integrity: sha512-89ZtZXt7ZxE94i7T94qzZMhp4Gfcpr/QVpGqEaejAxZD+gvDCH21cYSF+/Rz2ttBazm0rk5MZ0mFqb0Iqp1jmw==}
     engines: {node: '>=18'}
 
+  '@react-native/debugger-frontend@0.76.9':
+    resolution: {integrity: sha512-0Ru72Bm066xmxFuOXhhvrryxvb57uI79yDSFf+hxRpktkC98NMuRenlJhslMrbJ6WjCu1vOe/9UjWNYyxXTRTA==}
+    engines: {node: '>=18'}
+
   '@react-native/dev-middleware@0.76.7':
     resolution: {integrity: sha512-Jsw8g9DyLPnR9yHEGuT09yHZ7M88/GL9CtU9WmyChlBwdXSeE3AmRqLegsV3XcgULQ1fqdemokaOZ/MwLYkjdA==}
     engines: {node: '>=18'}
 
-  '@react-native/gradle-plugin@0.76.7':
-    resolution: {integrity: sha512-gQI6RcrJbigU8xk7F960C5xQIgvbBj20TUvGecD+N2PHfbLpqR+92cj7hz3UcbrCONmTP40WHnbMMJ8P+kLsrA==}
+  '@react-native/dev-middleware@0.76.9':
+    resolution: {integrity: sha512-xkd3C3dRcmZLjFTEAOvC14q3apMLouIvJViCZY/p1EfCMrNND31dgE1dYrLTiI045WAWMt5bD15i6f7dE2/QWA==}
     engines: {node: '>=18'}
 
-  '@react-native/js-polyfills@0.76.7':
-    resolution: {integrity: sha512-+iEikj6c6Zvrg1c3cYMeiPB+5nS8EaIC3jCtP6Muk3qc7c386IymEPM2xycIlfg04DPZvO3D4P2/vaO9/TCnUg==}
+  '@react-native/gradle-plugin@0.76.9':
+    resolution: {integrity: sha512-uGzp3dL4GfNDz+jOb8Nik1Vrfq1LHm0zESizrGhHACFiFlUSflVAnWuUAjlZlz5XfLhzGVvunG4Vdrpw8CD2ng==}
     engines: {node: '>=18'}
 
-  '@react-native/metro-babel-transformer@0.76.7':
-    resolution: {integrity: sha512-jDS1wR7q46xY5ah+jF714Mvss9l7+lmwW/tplahZgLKozkYDC8Td5o9TOCgKlv18acw9H1V7zv8ivuRSj8ICPg==}
+  '@react-native/js-polyfills@0.76.9':
+    resolution: {integrity: sha512-s6z6m8cK4SMjIX1hm8LT187aQ6//ujLrjzDBogqDCYXRbfjbAYovw5as/v2a2rhUIyJbS3UjokZm3W0H+Oh/RQ==}
+    engines: {node: '>=18'}
+
+  '@react-native/metro-babel-transformer@0.76.9':
+    resolution: {integrity: sha512-HGq11347UHNiO/NvVbAO35hQCmH8YZRs7in7nVq7SL99pnpZK4WXwLdAXmSuwz5uYqOuwnKYDlpadz8fkE94Mg==}
     engines: {node: '>=18'}
     peerDependencies:
       '@babel/core': '*'
@@ -1077,8 +1101,11 @@ packages:
   '@react-native/normalize-colors@0.76.7':
     resolution: {integrity: sha512-ST1xxBuYVIXPdD81dR6+tzIgso7m3pa9+6rOBXTh5Xm7KEEFik7tnQX+GydXYMp3wr1gagJjragdXkPnxK6WNg==}
 
-  '@react-native/virtualized-lists@0.76.7':
-    resolution: {integrity: sha512-pRUf1jUO8H9Ft04CaWv76t34QI9wY0sydoYlIwEtqXjjMJgmgDoOCAWBjArgn2mk8/rK+u/uicI67ZCYCp1pJw==}
+  '@react-native/normalize-colors@0.76.9':
+    resolution: {integrity: sha512-TUdMG2JGk72M9d8DYbubdOlrzTYjw+YMe/xOnLU4viDgWRHsCbtRS9x0IAxRjs3amj/7zmK3Atm8jUPvdAc8qw==}
+
+  '@react-native/virtualized-lists@0.76.9':
+    resolution: {integrity: sha512-2neUfZKuqMK2LzfS8NyOWOyWUJOWgDym5fUph6fN9qF+LNPjAvnc4Zr9+o+59qjNu/yXwQgVMWNU4+8WJuPVWw==}
     engines: {node: '>=18'}
     peerDependencies:
       '@types/react': ^18.2.6
@@ -1100,10 +1127,11 @@ packages:
   '@sinonjs/fake-timers@10.3.0':
     resolution: {integrity: sha512-V4BG07kuYSUkTCSBHG8G8TNhM+F19jXFWnQtzj+we8DrkpSBCee9Z3Ms8yiGer/dlmhe35/Xdgyo3/0rQKg7YA==}
 
-  '@typegpu/noise@0.0.3':
-    resolution: {integrity: sha512-LHbtsMOBlWT+d2ikrFEDNpLigtLJxMXrXDnlxvYa1nbxzaiVs+oOoE70qzr/CYNdFvipirPrkcTQJR9C7G8C3g==}
+  '@typegpu/noise@0.0.6':
+    resolution: {integrity: sha512-2l+A9vZ//gGJ1gzx1HcY2+4lDB798D74MJGTklUgQhm+cul0k9KIKnRNSOgb0/xS+xhdc6+KRtddGQWaRRUC0Q==}
+    version: 0.0.6
     peerDependencies:
-      typegpu: ^0.3.2
+      typegpu: ^0.5.6
 
   '@types/babel__core@7.20.5':
     resolution: {integrity: sha512-qoQprZvz5wQFJwMDqeseRXWv3rqMvhgpbXFfVyWhbx9X47POIA6i/+dXefEmZKoAgOaTdaIgNSMqMIU61yRyzA==}
@@ -1622,6 +1650,9 @@ packages:
     resolution: {integrity: sha512-Ds09qNh8yw3khSjiJjiUInaGX9xlqZDY7JVryGxdxV7NPeuqQfplOpQ66yJFZut3jLa5zOwkXw1g9EI2uKh4Og==}
     engines: {node: '>=8'}
 
+  defu@6.1.4:
+    resolution: {integrity: sha512-mEQCMmwJu317oSz8CwdIOdwf3xMif1ttiM8LTufzc3g6kR+9Pe236twL8j3IYT1F7GfRgGcW6MWxzZjLIkuHIg==}
+
   del@6.1.1:
     resolution: {integrity: sha512-ua8BhapfP0JUJKC/zV9yHHDW/rDoDxP4Zhn3AkA6/xT6gY7jYXJiaeyBZznYVujhZZET+UgcbZiQ7sN3WqcImg==}
     engines: {node: '>=10'}
@@ -2367,6 +2398,10 @@ packages:
   lru-cache@5.1.1:
     resolution: {integrity: sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==}
 
+  magic-string-ast@0.9.1:
+    resolution: {integrity: sha512-18dv2ZlSSgJ/jDWlZGKfnDJx56ilNlYq9F7NnwuWTErsmYmqJ2TWE4l1o2zlUHBYUGBy3tIhPCC1gxq8M5HkMA==}
+    engines: {node: '>=20.18.0'}
+
   magic-string@0.30.17:
     resolution: {integrity: sha512-sNPKHvyjVf7gyjwS4xGTaW/mCnF8wnjtifKBEhxfZ7E/S8tQ0rssrwGNn6q8JH/ohItJfSQp9mBtQYuTlH5QnA==}
 
@@ -2748,6 +2783,10 @@ packages:
     resolution: {integrity: sha512-I3EurrIQMlRc9IaAZnqRR044Phh2DXY+55o7uJ0V+hYZAcQYSuFWsc9q5PvyDHUSCe1Qxn/iBz+78s86zWnGag==}
     engines: {node: '>=10'}
 
+  picomatch@4.0.2:
+    resolution: {integrity: sha512-M7BAV6Rlcy5u+m6oPhAPFgJTzAioX/6B0DxyvDlo9l8+T3nLKbrczg2WLUyzd45L8RqfUMyGPzekbMvX2Ldkwg==}
+    engines: {node: '>=12'}
+
   pify@4.0.1:
     resolution: {integrity: sha512-uB80kBFb/tfd68bVleG9T5GGsGPjJrLAUpR5PZIrhBnIaRTQRjqdJSsIKkOP6OAIFbj7GOrcudc5pNjZ+geV2g==}
     engines: {node: '>=6'}
@@ -2841,8 +2880,8 @@ packages:
       react: '*'
       react-native: '*'
 
-  react-native@0.76.7:
-    resolution: {integrity: sha512-GPJcQeO3qUi1MvuhsC2DC6tH8gJQ4uc4JWPORrdeuCGFWE3QLsN8/hiChTEvJREHLfQSV61YPI8gIOtAQ8c37g==}
+  react-native@0.76.9:
+    resolution: {integrity: sha512-+LRwecWmTDco7OweGsrECIqJu0iyrREd6CTCgC/uLLYipiHvk+MH9nd6drFtCw/6Blz6eoKTcH9YTTJusNtrWg==}
     engines: {node: '>=18'}
     hasBin: true
     peerDependencies:
@@ -3204,16 +3243,12 @@ packages:
   through@2.3.8:
     resolution: {integrity: sha512-w89qg7PI8wAdvX60bMDP+bFoD5Dvhm9oLheFp5O4a2QF0cSBGsBX4qZmadPMvVqlLJBBci+WqGGOAPvcDeNSVg==}
 
-  tinyest-for-wgsl@0.1.0-alpha.5:
-    resolution: {integrity: sha512-4De+y8vGXYjGRDMOK+TuOQlmS+dmc1ff+EWGXx//YtOtiqP991xMTFD0IKErTy23Ez2q7tETsheCb4IkgN1iOg==}
+  tinyest-for-wgsl@0.1.0:
+    resolution: {integrity: sha512-WShVS0bykycxzPhRGujFJGtNqVax/SBv2/k7NpYMSLSey2eSN8z3/nF5In/rS3o4CptCmKi+j/kzkKBU8l060w==}
     engines: {node: '>=12.20.0'}
 
-  tinyest@0.1.0-alpha.4:
-    resolution: {integrity: sha512-s+cndC8E+icfzHMq/exGIMCHcNlu7ULGSLQUCIWb4ZrRilEDKdkYnUhgChqQSSVXCT36VY9k6H9CGbcyi2Aa6g==}
-    engines: {node: '>=12.20.0'}
-
-  tinyest@0.1.0-alpha.5:
-    resolution: {integrity: sha512-sCGNOZ+3A103AjQ8hA9yV3zjBDTZWppRjHJGEeX95OEcV0A3m52FBlozSVkUc1b5iaQr0ZNUgXoVjlr2iXbpmw==}
+  tinyest@0.1.0:
+    resolution: {integrity: sha512-6onWUaqRe3N7/AMbKyYCDeKi0GS7xUyH35uIePBRN2Nt73T/BDUGHFxEOcxWWK8F0oK3+4KiwSRiSFtFm/Cy+w==}
     engines: {node: '>=12.20.0'}
 
   tmp@0.0.33:
@@ -3259,8 +3294,9 @@ packages:
   typed-binary@4.3.2:
     resolution: {integrity: sha512-HT3pIBM2njCZUmeczDaQUUErGiM6GXFCqMsHegE12HCoBtvHCkfR10JJni0TeGOTnLilTd6YFyj+YhflqQDrDQ==}
 
-  typegpu@0.5.1:
-    resolution: {integrity: sha512-ax7ZTW1cQEQbwMpOrpgb6Mok4KxRHhuf6v9ut2n4LT12DbKU4pnE7R4Rjf7ETg3rqzRA93mZMfmdIgvSyRMhcg==}
+  typegpu@https://pkg.pr.new/software-mansion/TypeGPU/typegpu@43a643ac32470f0b3b51acb90970b36d418d8b8c:
+    resolution: {tarball: https://pkg.pr.new/software-mansion/TypeGPU/typegpu@43a643ac32470f0b3b51acb90970b36d418d8b8c}
+    version: 0.5.6
     engines: {node: '>=12.20.0'}
 
   typescript@5.8.2:
@@ -3323,11 +3359,14 @@ packages:
     resolution: {integrity: sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==}
     engines: {node: '>= 0.8'}
 
-  unplugin-typegpu@0.1.0-alpha.5:
-    resolution: {integrity: sha512-VjlXJTJAQ18y9msudggbnLWnouISJl6h6n58A3n1cArn6YCAlJgyK8WphuiYve3tm94nf2XsBYlp/UKWBCdLKQ==}
+  unplugin-typegpu@0.1.0:
+    resolution: {integrity: sha512-LlNDHzie0Zy2c0n8ABbyu51Q3SdTUdwzEMmpUlXmJXV5YtHNPKwEY/aJAKI+B7udAg0ZHxeX+R0vtv8GFn6XJA==}
+    version: 0.1.0
+    peerDependencies:
+      typegpu: ^0.5.6
 
-  unplugin@2.2.0:
-    resolution: {integrity: sha512-m1ekpSwuOT5hxkJeZGRxO7gXbXT3gF26NjQ7GdVHoLoF8/nopLcd/QfPigpCy7i51oFHiRJg/CyHhj4vs2+KGw==}
+  unplugin@2.3.2:
+    resolution: {integrity: sha512-3n7YA46rROb3zSj8fFxtxC/PqoyvYQ0llwz9wtUPUutr9ig09C8gGo5CWCwHrUzlqC1LLR43kxp5vEIyH1ac1w==}
     engines: {node: '>=18.12.0'}
 
   update-browserslist-db@1.1.3:
@@ -4379,7 +4418,7 @@ snapshots:
     dependencies:
       regenerator-runtime: 0.14.1
 
-  '@babel/standalone@7.26.9': {}
+  '@babel/standalone@7.27.0': {}
 
   '@babel/template@7.26.9':
     dependencies:
@@ -4878,7 +4917,7 @@ snapshots:
 
   '@probe.gl/stats@4.1.0': {}
 
-  '@react-native/assets-registry@0.76.7': {}
+  '@react-native/assets-registry@0.76.9': {}
 
   '@react-native/babel-plugin-codegen@0.76.7(@babel/preset-env@7.26.9(@babel/core@7.26.9))':
     dependencies:
@@ -4887,6 +4926,13 @@ snapshots:
       - '@babel/preset-env'
       - supports-color
 
+  '@react-native/babel-plugin-codegen@0.76.9(@babel/preset-env@7.26.9(@babel/core@7.26.9))':
+    dependencies:
+      '@react-native/codegen': 0.76.9(@babel/preset-env@7.26.9(@babel/core@7.26.9))
+    transitivePeerDependencies:
+      - '@babel/preset-env'
+      - supports-color
+
   '@react-native/babel-preset@0.76.7(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))':
     dependencies:
       '@babel/core': 7.26.9
@@ -4938,6 +4984,57 @@ snapshots:
       - '@babel/preset-env'
       - supports-color
 
+  '@react-native/babel-preset@0.76.9(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))':
+    dependencies:
+      '@babel/core': 7.26.9
+      '@babel/plugin-proposal-export-default-from': 7.25.9(@babel/core@7.26.9)
+      '@babel/plugin-syntax-dynamic-import': 7.8.3(@babel/core@7.26.9)
+      '@babel/plugin-syntax-export-default-from': 7.25.9(@babel/core@7.26.9)
+      '@babel/plugin-syntax-nullish-coalescing-operator': 7.8.3(@babel/core@7.26.9)
+      '@babel/plugin-syntax-optional-chaining': 7.8.3(@babel/core@7.26.9)
+      '@babel/plugin-transform-arrow-functions': 7.25.9(@babel/core@7.26.9)
+      '@babel/plugin-transform-async-generator-functions': 7.26.8(@babel/core@7.26.9)
+      '@babel/plugin-transform-async-to-generator': 7.25.9(@babel/core@7.26.9)
+      '@babel/plugin-transform-block-scoping': 7.25.9(@babel/core@7.26.9)
+      '@babel/plugin-transform-class-properties': 7.25.9(@babel/core@7.26.9)
+      '@babel/plugin-transform-classes': 7.25.9(@babel/core@7.26.9)
+      '@babel/plugin-transform-computed-properties': 7.25.9(@babel/core@7.26.9)
+      '@babel/plugin-transform-destructuring': 7.25.9(@babel/core@7.26.9)
+      '@babel/plugin-transform-flow-strip-types': 7.26.5(@babel/core@7.26.9)
+      '@babel/plugin-transform-for-of': 7.26.9(@babel/core@7.26.9)
+      '@babel/plugin-transform-function-name': 7.25.9(@babel/core@7.26.9)
+      '@babel/plugin-transform-literals': 7.25.9(@babel/core@7.26.9)
+      '@babel/plugin-transform-logical-assignment-operators': 7.25.9(@babel/core@7.26.9)
+      '@babel/plugin-transform-modules-commonjs': 7.26.3(@babel/core@7.26.9)
+      '@babel/plugin-transform-named-capturing-groups-regex': 7.25.9(@babel/core@7.26.9)
+      '@babel/plugin-transform-nullish-coalescing-operator': 7.26.6(@babel/core@7.26.9)
+      '@babel/plugin-transform-numeric-separator': 7.25.9(@babel/core@7.26.9)
+      '@babel/plugin-transform-object-rest-spread': 7.25.9(@babel/core@7.26.9)
+      '@babel/plugin-transform-optional-catch-binding': 7.25.9(@babel/core@7.26.9)
+      '@babel/plugin-transform-optional-chaining': 7.25.9(@babel/core@7.26.9)
+      '@babel/plugin-transform-parameters': 7.25.9(@babel/core@7.26.9)
+      '@babel/plugin-transform-private-methods': 7.25.9(@babel/core@7.26.9)
+      '@babel/plugin-transform-private-property-in-object': 7.25.9(@babel/core@7.26.9)
+      '@babel/plugin-transform-react-display-name': 7.25.9(@babel/core@7.26.9)
+      '@babel/plugin-transform-react-jsx': 7.25.9(@babel/core@7.26.9)
+      '@babel/plugin-transform-react-jsx-self': 7.25.9(@babel/core@7.26.9)
+      '@babel/plugin-transform-react-jsx-source': 7.25.9(@babel/core@7.26.9)
+      '@babel/plugin-transform-regenerator': 7.25.9(@babel/core@7.26.9)
+      '@babel/plugin-transform-runtime': 7.26.9(@babel/core@7.26.9)
+      '@babel/plugin-transform-shorthand-properties': 7.25.9(@babel/core@7.26.9)
+      '@babel/plugin-transform-spread': 7.25.9(@babel/core@7.26.9)
+      '@babel/plugin-transform-sticky-regex': 7.25.9(@babel/core@7.26.9)
+      '@babel/plugin-transform-typescript': 7.26.8(@babel/core@7.26.9)
+      '@babel/plugin-transform-unicode-regex': 7.25.9(@babel/core@7.26.9)
+      '@babel/template': 7.26.9
+      '@react-native/babel-plugin-codegen': 0.76.9(@babel/preset-env@7.26.9(@babel/core@7.26.9))
+      babel-plugin-syntax-hermes-parser: 0.25.1
+      babel-plugin-transform-flow-enums: 0.0.2(@babel/core@7.26.9)
+      react-refresh: 0.14.2
+    transitivePeerDependencies:
+      - '@babel/preset-env'
+      - supports-color
+
   '@react-native/codegen@0.76.7(@babel/preset-env@7.26.9(@babel/core@7.26.9))':
     dependencies:
       '@babel/parser': 7.26.9
@@ -4952,10 +5049,24 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
-  '@react-native/community-cli-plugin@0.76.7(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))':
+  '@react-native/codegen@0.76.9(@babel/preset-env@7.26.9(@babel/core@7.26.9))':
     dependencies:
-      '@react-native/dev-middleware': 0.76.7
-      '@react-native/metro-babel-transformer': 0.76.7(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))
+      '@babel/parser': 7.26.9
+      '@babel/preset-env': 7.26.9(@babel/core@7.26.9)
+      glob: 7.2.3
+      hermes-parser: 0.23.1
+      invariant: 2.2.4
+      jscodeshift: 0.14.0(@babel/preset-env@7.26.9(@babel/core@7.26.9))
+      mkdirp: 0.5.6
+      nullthrows: 1.1.1
+      yargs: 17.7.2
+    transitivePeerDependencies:
+      - supports-color
+
+  '@react-native/community-cli-plugin@0.76.9(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))':
+    dependencies:
+      '@react-native/dev-middleware': 0.76.9
+      '@react-native/metro-babel-transformer': 0.76.9(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))
       chalk: 4.1.2
       execa: 5.1.1
       invariant: 2.2.4
@@ -4975,6 +5086,8 @@ snapshots:
 
   '@react-native/debugger-frontend@0.76.7': {}
 
+  '@react-native/debugger-frontend@0.76.9': {}
+
   '@react-native/dev-middleware@0.76.7':
     dependencies:
       '@isaacs/ttlcache': 1.4.1
@@ -4994,14 +5107,33 @@ snapshots:
       - supports-color
       - utf-8-validate
 
-  '@react-native/gradle-plugin@0.76.7': {}
+  '@react-native/dev-middleware@0.76.9':
+    dependencies:
+      '@isaacs/ttlcache': 1.4.1
+      '@react-native/debugger-frontend': 0.76.9
+      chrome-launcher: 0.15.2
+      chromium-edge-launcher: 0.2.0
+      connect: 3.7.0
+      debug: 2.6.9
+      invariant: 2.2.4
+      nullthrows: 1.1.1
+      open: 7.4.2
+      selfsigned: 2.4.1
+      serve-static: 1.16.2
+      ws: 6.2.3
+    transitivePeerDependencies:
+      - bufferutil
+      - supports-color
+      - utf-8-validate
 
-  '@react-native/js-polyfills@0.76.7': {}
+  '@react-native/gradle-plugin@0.76.9': {}
 
-  '@react-native/metro-babel-transformer@0.76.7(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))':
+  '@react-native/js-polyfills@0.76.9': {}
+
+  '@react-native/metro-babel-transformer@0.76.9(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))':
     dependencies:
       '@babel/core': 7.26.9
-      '@react-native/babel-preset': 0.76.7(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))
+      '@react-native/babel-preset': 0.76.9(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))
       hermes-parser: 0.23.1
       nullthrows: 1.1.1
     transitivePeerDependencies:
@@ -5010,12 +5142,14 @@ snapshots:
 
   '@react-native/normalize-colors@0.76.7': {}
 
-  '@react-native/virtualized-lists@0.76.7(@types/react@18.3.18)(react-native@0.76.7(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1))(react@18.3.1)':
+  '@react-native/normalize-colors@0.76.9': {}
+
+  '@react-native/virtualized-lists@0.76.9(@types/react@18.3.18)(react-native@0.76.9(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1))(react@18.3.1)':
     dependencies:
       invariant: 2.2.4
       nullthrows: 1.1.1
       react: 18.3.1
-      react-native: 0.76.7(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1)
+      react-native: 0.76.9(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1)
     optionalDependencies:
       '@types/react': 18.3.18
 
@@ -5034,9 +5168,9 @@ snapshots:
     dependencies:
       '@sinonjs/commons': 3.0.1
 
-  '@typegpu/noise@0.0.3(typegpu@0.5.1)':
+  '@typegpu/noise@0.0.6(typegpu@https://pkg.pr.new/software-mansion/TypeGPU/typegpu@43a643ac32470f0b3b51acb90970b36d418d8b8c)':
     dependencies:
-      typegpu: 0.5.1
+      typegpu: https://pkg.pr.new/software-mansion/TypeGPU/typegpu@43a643ac32470f0b3b51acb90970b36d418d8b8c
 
   '@types/babel__core@7.20.5':
     dependencies:
@@ -5600,6 +5734,8 @@ snapshots:
 
   define-lazy-prop@2.0.0: {}
 
+  defu@6.1.4: {}
+
   del@6.1.1:
     dependencies:
       globby: 11.1.0
@@ -5726,42 +5862,42 @@ snapshots:
       signal-exit: 3.0.7
       strip-final-newline: 2.0.0
 
-  expo-asset@11.0.4(expo@52.0.37(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(react-native@0.76.7(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1))(react@18.3.1))(react-native@0.76.7(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1))(react@18.3.1):
+  expo-asset@11.0.4(expo@52.0.37(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(react-native@0.76.9(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1))(react@18.3.1))(react-native@0.76.9(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1))(react@18.3.1):
     dependencies:
       '@expo/image-utils': 0.6.5
-      expo: 52.0.37(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(react-native@0.76.7(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1))(react@18.3.1)
-      expo-constants: 17.0.7(expo@52.0.37(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(react-native@0.76.7(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1))(react@18.3.1))(react-native@0.76.7(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1))
+      expo: 52.0.37(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(react-native@0.76.9(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1))(react@18.3.1)
+      expo-constants: 17.0.7(expo@52.0.37(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(react-native@0.76.9(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1))(react@18.3.1))(react-native@0.76.9(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1))
       invariant: 2.2.4
       md5-file: 3.2.3
       react: 18.3.1
-      react-native: 0.76.7(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1)
+      react-native: 0.76.9(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1)
     transitivePeerDependencies:
       - supports-color
 
-  expo-constants@17.0.7(expo@52.0.37(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(react-native@0.76.7(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1))(react@18.3.1))(react-native@0.76.7(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1)):
+  expo-constants@17.0.7(expo@52.0.37(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(react-native@0.76.9(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1))(react@18.3.1))(react-native@0.76.9(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1)):
     dependencies:
       '@expo/config': 10.0.10
       '@expo/env': 0.4.2
-      expo: 52.0.37(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(react-native@0.76.7(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1))(react@18.3.1)
-      react-native: 0.76.7(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1)
+      expo: 52.0.37(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(react-native@0.76.9(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1))(react@18.3.1)
+      react-native: 0.76.9(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1)
     transitivePeerDependencies:
       - supports-color
 
-  expo-file-system@18.0.11(expo@52.0.37(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(react-native@0.76.7(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1))(react@18.3.1))(react-native@0.76.7(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1)):
+  expo-file-system@18.0.11(expo@52.0.37(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(react-native@0.76.9(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1))(react@18.3.1))(react-native@0.76.9(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1)):
     dependencies:
-      expo: 52.0.37(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(react-native@0.76.7(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1))(react@18.3.1)
-      react-native: 0.76.7(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1)
+      expo: 52.0.37(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(react-native@0.76.9(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1))(react@18.3.1)
+      react-native: 0.76.9(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1)
       web-streams-polyfill: 3.3.3
 
-  expo-font@13.0.4(expo@52.0.37(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(react-native@0.76.7(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1))(react@18.3.1))(react@18.3.1):
+  expo-font@13.0.4(expo@52.0.37(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(react-native@0.76.9(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1))(react@18.3.1))(react@18.3.1):
     dependencies:
-      expo: 52.0.37(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(react-native@0.76.7(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1))(react@18.3.1)
+      expo: 52.0.37(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(react-native@0.76.9(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1))(react@18.3.1)
       fontfaceobserver: 2.3.0
       react: 18.3.1
 
-  expo-keep-awake@14.0.3(expo@52.0.37(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(react-native@0.76.7(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1))(react@18.3.1))(react@18.3.1):
+  expo-keep-awake@14.0.3(expo@52.0.37(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(react-native@0.76.9(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1))(react@18.3.1))(react@18.3.1):
     dependencies:
-      expo: 52.0.37(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(react-native@0.76.7(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1))(react@18.3.1)
+      expo: 52.0.37(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(react-native@0.76.9(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1))(react@18.3.1)
       react: 18.3.1
 
   expo-modules-autolinking@2.0.8:
@@ -5779,7 +5915,7 @@ snapshots:
     dependencies:
       invariant: 2.2.4
 
-  expo@52.0.37(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(react-native@0.76.7(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1))(react@18.3.1):
+  expo@52.0.37(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(react-native@0.76.9(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1))(react@18.3.1):
     dependencies:
       '@babel/runtime': 7.26.9
       '@expo/cli': 0.22.18
@@ -5789,16 +5925,16 @@ snapshots:
       '@expo/metro-config': 0.19.11
       '@expo/vector-icons': 14.0.4
       babel-preset-expo: 12.0.9(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))
-      expo-asset: 11.0.4(expo@52.0.37(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(react-native@0.76.7(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1))(react@18.3.1))(react-native@0.76.7(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1))(react@18.3.1)
-      expo-constants: 17.0.7(expo@52.0.37(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(react-native@0.76.7(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1))(react@18.3.1))(react-native@0.76.7(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1))
-      expo-file-system: 18.0.11(expo@52.0.37(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(react-native@0.76.7(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1))(react@18.3.1))(react-native@0.76.7(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1))
-      expo-font: 13.0.4(expo@52.0.37(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(react-native@0.76.7(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1))(react@18.3.1))(react@18.3.1)
-      expo-keep-awake: 14.0.3(expo@52.0.37(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(react-native@0.76.7(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1))(react@18.3.1))(react@18.3.1)
+      expo-asset: 11.0.4(expo@52.0.37(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(react-native@0.76.9(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1))(react@18.3.1))(react-native@0.76.9(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1))(react@18.3.1)
+      expo-constants: 17.0.7(expo@52.0.37(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(react-native@0.76.9(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1))(react@18.3.1))(react-native@0.76.9(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1))
+      expo-file-system: 18.0.11(expo@52.0.37(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(react-native@0.76.9(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1))(react@18.3.1))(react-native@0.76.9(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1))
+      expo-font: 13.0.4(expo@52.0.37(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(react-native@0.76.9(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1))(react@18.3.1))(react@18.3.1)
+      expo-keep-awake: 14.0.3(expo@52.0.37(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(react-native@0.76.9(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1))(react@18.3.1))(react@18.3.1)
       expo-modules-autolinking: 2.0.8
       expo-modules-core: 2.2.2
       fbemitter: 3.0.0
       react: 18.3.1
-      react-native: 0.76.7(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1)
+      react-native: 0.76.9(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1)
       web-streams-polyfill: 3.3.3
       whatwg-url-without-unicode: 8.0.0-3
     transitivePeerDependencies:
@@ -6384,6 +6520,10 @@ snapshots:
     dependencies:
       yallist: 3.1.1
 
+  magic-string-ast@0.9.1:
+    dependencies:
+      magic-string: 0.30.17
+
   magic-string@0.30.17:
     dependencies:
       '@jridgewell/sourcemap-codec': 1.5.0
@@ -6825,6 +6965,8 @@ snapshots:
 
   picomatch@3.0.1: {}
 
+  picomatch@4.0.2: {}
+
   pify@4.0.1: {}
 
   pirates@4.0.6: {}
@@ -6914,21 +7056,21 @@ snapshots:
 
   react-is@18.3.1: {}
 
-  react-native-wgpu@0.1.23(react-native@0.76.7(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1))(react@18.3.1):
+  react-native-wgpu@0.1.23(react-native@0.76.9(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1))(react@18.3.1):
     dependencies:
       react: 18.3.1
-      react-native: 0.76.7(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1)
+      react-native: 0.76.9(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1)
 
-  react-native@0.76.7(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1):
+  react-native@0.76.9(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1):
     dependencies:
       '@jest/create-cache-key-function': 29.7.0
-      '@react-native/assets-registry': 0.76.7
-      '@react-native/codegen': 0.76.7(@babel/preset-env@7.26.9(@babel/core@7.26.9))
-      '@react-native/community-cli-plugin': 0.76.7(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))
-      '@react-native/gradle-plugin': 0.76.7
-      '@react-native/js-polyfills': 0.76.7
-      '@react-native/normalize-colors': 0.76.7
-      '@react-native/virtualized-lists': 0.76.7(@types/react@18.3.18)(react-native@0.76.7(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1))(react@18.3.1)
+      '@react-native/assets-registry': 0.76.9
+      '@react-native/codegen': 0.76.9(@babel/preset-env@7.26.9(@babel/core@7.26.9))
+      '@react-native/community-cli-plugin': 0.76.9(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))
+      '@react-native/gradle-plugin': 0.76.9
+      '@react-native/js-polyfills': 0.76.9
+      '@react-native/normalize-colors': 0.76.9
+      '@react-native/virtualized-lists': 0.76.9(@types/react@18.3.18)(react-native@0.76.9(@babel/core@7.26.9)(@babel/preset-env@7.26.9(@babel/core@7.26.9))(@types/react@18.3.18)(react@18.3.1))(react@18.3.1)
       abort-controller: 3.0.0
       anser: 1.4.10
       ansi-regex: 5.0.1
@@ -6965,7 +7107,7 @@ snapshots:
     transitivePeerDependencies:
       - '@babel/core'
       - '@babel/preset-env'
-      - '@react-native-community/cli-server-api'
+      - '@react-native-community/cli'
       - bufferutil
       - encoding
       - supports-color
@@ -7323,13 +7465,11 @@ snapshots:
 
   through@2.3.8: {}
 
-  tinyest-for-wgsl@0.1.0-alpha.5:
+  tinyest-for-wgsl@0.1.0:
     dependencies:
-      tinyest: 0.1.0-alpha.4
-
-  tinyest@0.1.0-alpha.4: {}
+      tinyest: 0.1.0
 
-  tinyest@0.1.0-alpha.5: {}
+  tinyest@0.1.0: {}
 
   tmp@0.0.33:
     dependencies:
@@ -7359,9 +7499,9 @@ snapshots:
 
   typed-binary@4.3.2: {}
 
-  typegpu@0.5.1:
+  typegpu@https://pkg.pr.new/software-mansion/TypeGPU/typegpu@43a643ac32470f0b3b51acb90970b36d418d8b8c:
     dependencies:
-      tinyest: 0.1.0-alpha.5
+      tinyest: 0.1.0
       typed-binary: 4.3.2
 
   typescript@5.8.2: {}
@@ -7403,17 +7543,21 @@ snapshots:
 
   unpipe@1.0.0: {}
 
-  unplugin-typegpu@0.1.0-alpha.5:
+  unplugin-typegpu@0.1.0(typegpu@https://pkg.pr.new/software-mansion/TypeGPU/typegpu@43a643ac32470f0b3b51acb90970b36d418d8b8c):
     dependencies:
-      '@babel/standalone': 7.26.9
+      '@babel/standalone': 7.27.0
+      defu: 6.1.4
       estree-walker: 3.0.3
-      magic-string: 0.30.17
-      tinyest-for-wgsl: 0.1.0-alpha.5
-      unplugin: 2.2.0
+      magic-string-ast: 0.9.1
+      picomatch: 4.0.2
+      tinyest-for-wgsl: 0.1.0
+      typegpu: https://pkg.pr.new/software-mansion/TypeGPU/typegpu@43a643ac32470f0b3b51acb90970b36d418d8b8c
+      unplugin: 2.3.2
 
-  unplugin@2.2.0:
+  unplugin@2.3.2:
     dependencies:
       acorn: 8.14.1
+      picomatch: 4.0.2
       webpack-virtual-modules: 0.6.2
 
   update-browserslist-db@1.1.3(browserslist@4.24.4):