diff --git a/apps/typegpu-docs/tests/individual-example-tests/3d-fish.test.ts b/apps/typegpu-docs/tests/individual-example-tests/3d-fish.test.ts
index 6d0eb3e5d4..076d3bfd8b 100644
--- a/apps/typegpu-docs/tests/individual-example-tests/3d-fish.test.ts
+++ b/apps/typegpu-docs/tests/individual-example-tests/3d-fish.test.ts
@@ -63,11 +63,11 @@ describe('3d fish example', () => {
         return ((x << k) | (x >> (32u - k)));
       }
 
-      var<private> seed: vec2f;
+      var<private> seed_1: vec2f;
 
       fn seed2(value: vec2f) {
         let scrambled = scrambleSeed2(value);
-        seed = ((vec2f(u32To01F32(hash((scrambled.x ^ scrambled.y))), u32To01F32(hash((rotl(scrambled.x, 16u) ^ scrambled.y)))) * 2f) - 1f);
+        seed_1 = ((vec2f(u32To01F32(hash((scrambled.x ^ scrambled.y))), u32To01F32(hash((rotl(scrambled.x, 16u) ^ scrambled.y)))) * 2f) - 1f);
       }
 
       fn randSeed2(seed: vec2f) {
@@ -75,11 +75,11 @@ describe('3d fish example', () => {
       }
 
       fn sample() -> f32 {
-        let a = dot(seed, vec2f(23.140779495239258, 232.6168975830078));
-        let b = dot(seed, vec2f(54.47856521606445, 345.8415222167969));
-        seed.x = fract((cos(a) * 136.8168f));
-        seed.y = fract((cos(b) * 534.7645f));
-        return seed.y;
+        let a = dot(seed_1, vec2f(23.140779495239258, 232.6168975830078));
+        let b = dot(seed_1, vec2f(54.47856521606445, 345.8415222167969));
+        seed_1.x = fract((cos(a) * 136.8168f));
+        seed_1.y = fract((cos(b) * 534.7645f));
+        return seed_1.y;
       }
 
       fn randFloat01() -> f32 {
diff --git a/apps/typegpu-docs/tests/individual-example-tests/caustics.test.ts b/apps/typegpu-docs/tests/individual-example-tests/caustics.test.ts
index 1af3ef3c87..bfd5a29cb1 100644
--- a/apps/typegpu-docs/tests/individual-example-tests/caustics.test.ts
+++ b/apps/typegpu-docs/tests/individual-example-tests/caustics.test.ts
@@ -71,11 +71,11 @@ describe('caustics example', () => {
         return (f - 1f);
       }
 
-      var<private> seed: vec2f;
+      var<private> seed_1: vec2f;
 
       fn seed3(value: vec3f) {
         let scrambled = scrambleSeed3(value);
-        seed = ((vec2f(u32To01F32(hash((scrambled.x ^ rotl(scrambled.z, 16u)))), u32To01F32(hash((rotl(scrambled.y, 16u) ^ scrambled.z)))) * 2f) - 1f);
+        seed_1 = ((vec2f(u32To01F32(hash((scrambled.x ^ rotl(scrambled.z, 16u)))), u32To01F32(hash((rotl(scrambled.y, 16u) ^ scrambled.z)))) * 2f) - 1f);
       }
 
       fn randSeed3(seed: vec3f) {
@@ -83,11 +83,11 @@ describe('caustics example', () => {
       }
 
       fn sample_1() -> f32 {
-        let a = dot(seed, vec2f(23.140779495239258, 232.6168975830078));
-        let b = dot(seed, vec2f(54.47856521606445, 345.8415222167969));
-        seed.x = fract((cos(a) * 136.8168f));
-        seed.y = fract((cos(b) * 534.7645f));
-        return seed.y;
+        let a = dot(seed_1, vec2f(23.140779495239258, 232.6168975830078));
+        let b = dot(seed_1, vec2f(54.47856521606445, 345.8415222167969));
+        seed_1.x = fract((cos(a) * 136.8168f));
+        seed_1.y = fract((cos(b) * 534.7645f));
+        return seed_1.y;
       }
 
       fn randOnUnitSphere() -> vec3f {
diff --git a/apps/typegpu-docs/tests/individual-example-tests/clouds.test.ts b/apps/typegpu-docs/tests/individual-example-tests/clouds.test.ts
index 1dd14503f8..d370effc76 100644
--- a/apps/typegpu-docs/tests/individual-example-tests/clouds.test.ts
+++ b/apps/typegpu-docs/tests/individual-example-tests/clouds.test.ts
@@ -71,11 +71,11 @@ describe('clouds example', () => {
         return ((x << k) | (x >> (32u - k)));
       }
 
-      var<private> seed: vec2f;
+      var<private> seed_1: vec2f;
 
       fn seed2(value: vec2f) {
         let scrambled = scrambleSeed2(value);
-        seed = ((vec2f(u32To01F32(hash((scrambled.x ^ scrambled.y))), u32To01F32(hash((rotl(scrambled.x, 16u) ^ scrambled.y)))) * 2f) - 1f);
+        seed_1 = ((vec2f(u32To01F32(hash((scrambled.x ^ scrambled.y))), u32To01F32(hash((rotl(scrambled.x, 16u) ^ scrambled.y)))) * 2f) - 1f);
       }
 
       fn randSeed2(seed: vec2f) {
@@ -85,11 +85,11 @@ describe('clouds example', () => {
       @group(0) @binding(0) var<uniform> resolutionUniform: vec2f;
 
       fn sample() -> f32 {
-        let a = dot(seed, vec2f(23.140779495239258, 232.6168975830078));
-        let b = dot(seed, vec2f(54.47856521606445, 345.8415222167969));
-        seed.x = fract((cos(a) * 136.8168f));
-        seed.y = fract((cos(b) * 534.7645f));
-        return seed.y;
+        let a = dot(seed_1, vec2f(23.140779495239258, 232.6168975830078));
+        let b = dot(seed_1, vec2f(54.47856521606445, 345.8415222167969));
+        seed_1.x = fract((cos(a) * 136.8168f));
+        seed_1.y = fract((cos(b) * 534.7645f));
+        return seed_1.y;
       }
 
       fn randFloat01() -> f32 {
diff --git a/apps/typegpu-docs/tests/individual-example-tests/fluid-double-buffering.test.ts b/apps/typegpu-docs/tests/individual-example-tests/fluid-double-buffering.test.ts
index c613c28924..143ca3741a 100644
--- a/apps/typegpu-docs/tests/individual-example-tests/fluid-double-buffering.test.ts
+++ b/apps/typegpu-docs/tests/individual-example-tests/fluid-double-buffering.test.ts
@@ -130,11 +130,11 @@ describe('fluid double buffering example', () => {
         return ((x << k) | (x >> (32u - k)));
       }
 
-      var<private> seed: vec2f;
+      var<private> seed_1: vec2f;
 
       fn seed2(value: vec2f) {
         let scrambled = scrambleSeed2(value);
-        seed = ((vec2f(u32To01F32(hash((scrambled.x ^ scrambled.y))), u32To01F32(hash((rotl(scrambled.x, 16u) ^ scrambled.y)))) * 2f) - 1f);
+        seed_1 = ((vec2f(u32To01F32(hash((scrambled.x ^ scrambled.y))), u32To01F32(hash((rotl(scrambled.x, 16u) ^ scrambled.y)))) * 2f) - 1f);
       }
 
       fn randSeed2(seed: vec2f) {
@@ -189,11 +189,11 @@ describe('fluid double buffering example', () => {
       }
 
       fn sample() -> f32 {
-        let a = dot(seed, vec2f(23.140779495239258, 232.6168975830078));
-        let b = dot(seed, vec2f(54.47856521606445, 345.8415222167969));
-        seed.x = fract((cos(a) * 136.8168f));
-        seed.y = fract((cos(b) * 534.7645f));
-        return seed.y;
+        let a = dot(seed_1, vec2f(23.140779495239258, 232.6168975830078));
+        let b = dot(seed_1, vec2f(54.47856521606445, 345.8415222167969));
+        seed_1.x = fract((cos(a) * 136.8168f));
+        seed_1.y = fract((cos(b) * 534.7645f));
+        return seed_1.y;
       }
 
       fn randFloat01() -> f32 {
@@ -387,11 +387,11 @@ describe('fluid double buffering example', () => {
         return ((x << k) | (x >> (32u - k)));
       }
 
-      var<private> seed: vec2f;
+      var<private> seed_1: vec2f;
 
       fn seed2(value: vec2f) {
         let scrambled = scrambleSeed2(value);
-        seed = ((vec2f(u32To01F32(hash((scrambled.x ^ scrambled.y))), u32To01F32(hash((rotl(scrambled.x, 16u) ^ scrambled.y)))) * 2f) - 1f);
+        seed_1 = ((vec2f(u32To01F32(hash((scrambled.x ^ scrambled.y))), u32To01F32(hash((rotl(scrambled.x, 16u) ^ scrambled.y)))) * 2f) - 1f);
       }
 
       fn randSeed2(seed: vec2f) {
@@ -446,11 +446,11 @@ describe('fluid double buffering example', () => {
       }
 
       fn sample() -> f32 {
-        let a = dot(seed, vec2f(23.140779495239258, 232.6168975830078));
-        let b = dot(seed, vec2f(54.47856521606445, 345.8415222167969));
-        seed.x = fract((cos(a) * 136.8168f));
-        seed.y = fract((cos(b) * 534.7645f));
-        return seed.y;
+        let a = dot(seed_1, vec2f(23.140779495239258, 232.6168975830078));
+        let b = dot(seed_1, vec2f(54.47856521606445, 345.8415222167969));
+        seed_1.x = fract((cos(a) * 136.8168f));
+        seed_1.y = fract((cos(b) * 534.7645f));
+        return seed_1.y;
       }
 
       fn randFloat01() -> f32 {
diff --git a/apps/typegpu-docs/tests/individual-example-tests/game-of-life.test.ts b/apps/typegpu-docs/tests/individual-example-tests/game-of-life.test.ts
index edcf8524ef..54db279d0e 100644
--- a/apps/typegpu-docs/tests/individual-example-tests/game-of-life.test.ts
+++ b/apps/typegpu-docs/tests/individual-example-tests/game-of-life.test.ts
@@ -56,11 +56,11 @@ describe('game of life example', () => {
         return ((x << k) | (x >> (32u - k)));
       }
 
-      var<private> seed: vec2f;
+      var<private> seed_1: vec2f;
 
       fn seed2(value: vec2f) {
         let scrambled = scrambleSeed2(value);
-        seed = ((vec2f(u32To01F32(hash((scrambled.x ^ scrambled.y))), u32To01F32(hash((rotl(scrambled.x, 16u) ^ scrambled.y)))) * 2f) - 1f);
+        seed_1 = ((vec2f(u32To01F32(hash((scrambled.x ^ scrambled.y))), u32To01F32(hash((rotl(scrambled.x, 16u) ^ scrambled.y)))) * 2f) - 1f);
       }
 
       fn randSeed2(seed: vec2f) {
@@ -68,11 +68,11 @@ describe('game of life example', () => {
       }
 
       fn sample() -> f32 {
-        let a = dot(seed, vec2f(23.140779495239258, 232.6168975830078));
-        let b = dot(seed, vec2f(54.47856521606445, 345.8415222167969));
-        seed.x = fract((cos(a) * 136.8168f));
-        seed.y = fract((cos(b) * 534.7645f));
-        return seed.y;
+        let a = dot(seed_1, vec2f(23.140779495239258, 232.6168975830078));
+        let b = dot(seed_1, vec2f(54.47856521606445, 345.8415222167969));
+        seed_1.x = fract((cos(a) * 136.8168f));
+        seed_1.y = fract((cos(b) * 534.7645f));
+        return seed_1.y;
       }
 
       fn randFloat01() -> f32 {
diff --git a/apps/typegpu-docs/tests/individual-example-tests/jelly-slider.test.ts b/apps/typegpu-docs/tests/individual-example-tests/jelly-slider.test.ts
index 096f979ae4..daf7fcf697 100644
--- a/apps/typegpu-docs/tests/individual-example-tests/jelly-slider.test.ts
+++ b/apps/typegpu-docs/tests/individual-example-tests/jelly-slider.test.ts
@@ -109,11 +109,11 @@ describe('jelly-slider example', () => {
         return ((x << k) | (x >> (32u - k)));
       }
 
-      var<private> seed: vec2f;
+      var<private> seed_1: vec2f;
 
       fn seed2(value: vec2f) {
         let scrambled = scrambleSeed2(value);
-        seed = ((vec2f(u32To01F32(hash((scrambled.x ^ scrambled.y))), u32To01F32(hash((rotl(scrambled.x, 16u) ^ scrambled.y)))) * 2f) - 1f);
+        seed_1 = ((vec2f(u32To01F32(hash((scrambled.x ^ scrambled.y))), u32To01F32(hash((rotl(scrambled.x, 16u) ^ scrambled.y)))) * 2f) - 1f);
       }
 
       fn randSeed2(seed: vec2f) {
@@ -200,11 +200,11 @@ describe('jelly-slider example', () => {
       @group(1) @binding(1) var bezierTexture: texture_2d<f32>;
 
       fn sample() -> f32 {
-        let a = dot(seed, vec2f(23.140779495239258, 232.6168975830078));
-        let b = dot(seed, vec2f(54.47856521606445, 345.8415222167969));
-        seed.x = fract((cos(a) * 136.8168f));
-        seed.y = fract((cos(b) * 534.7645f));
-        return seed.y;
+        let a = dot(seed_1, vec2f(23.140779495239258, 232.6168975830078));
+        let b = dot(seed_1, vec2f(54.47856521606445, 345.8415222167969));
+        seed_1.x = fract((cos(a) * 136.8168f));
+        seed_1.y = fract((cos(b) * 534.7645f));
+        return seed_1.y;
       }
 
       fn randFloat01() -> f32 {
diff --git a/apps/typegpu-docs/tests/individual-example-tests/jelly-switch.test.ts b/apps/typegpu-docs/tests/individual-example-tests/jelly-switch.test.ts
index 3e55f69bb8..8ba5c3146f 100644
--- a/apps/typegpu-docs/tests/individual-example-tests/jelly-switch.test.ts
+++ b/apps/typegpu-docs/tests/individual-example-tests/jelly-switch.test.ts
@@ -68,11 +68,11 @@ describe('jelly switch example', () => {
         return ((x << k) | (x >> (32u - k)));
       }
 
-      var<private> seed: vec2f;
+      var<private> seed_1: vec2f;
 
       fn seed2(value: vec2f) {
         let scrambled = scrambleSeed2(value);
-        seed = ((vec2f(u32To01F32(hash((scrambled.x ^ scrambled.y))), u32To01F32(hash((rotl(scrambled.x, 16u) ^ scrambled.y)))) * 2f) - 1f);
+        seed_1 = ((vec2f(u32To01F32(hash((scrambled.x ^ scrambled.y))), u32To01F32(hash((rotl(scrambled.x, 16u) ^ scrambled.y)))) * 2f) - 1f);
       }
 
       fn randSeed2(seed: vec2f) {
diff --git a/apps/typegpu-docs/tests/individual-example-tests/jump-flood-voronoi.test.ts b/apps/typegpu-docs/tests/individual-example-tests/jump-flood-voronoi.test.ts
index dcdd564c3e..4b0400d959 100644
--- a/apps/typegpu-docs/tests/individual-example-tests/jump-flood-voronoi.test.ts
+++ b/apps/typegpu-docs/tests/individual-example-tests/jump-flood-voronoi.test.ts
@@ -57,11 +57,11 @@ describe('jump flood (voronoi) example', () => {
         return ((x << k) | (x >> (32u - k)));
       }
 
-      var<private> seed: vec2f;
+      var<private> seed_1: vec2f;
 
       fn seed2(value: vec2f) {
         let scrambled = scrambleSeed2(value);
-        seed = ((vec2f(u32To01F32(hash((scrambled.x ^ scrambled.y))), u32To01F32(hash((rotl(scrambled.x, 16u) ^ scrambled.y)))) * 2f) - 1f);
+        seed_1 = ((vec2f(u32To01F32(hash((scrambled.x ^ scrambled.y))), u32To01F32(hash((rotl(scrambled.x, 16u) ^ scrambled.y)))) * 2f) - 1f);
       }
 
       fn randSeed2(seed: vec2f) {
@@ -69,11 +69,11 @@ describe('jump flood (voronoi) example', () => {
       }
 
       fn sample() -> f32 {
-        let a = dot(seed, vec2f(23.140779495239258, 232.6168975830078));
-        let b = dot(seed, vec2f(54.47856521606445, 345.8415222167969));
-        seed.x = fract((cos(a) * 136.8168f));
-        seed.y = fract((cos(b) * 534.7645f));
-        return seed.y;
+        let a = dot(seed_1, vec2f(23.140779495239258, 232.6168975830078));
+        let b = dot(seed_1, vec2f(54.47856521606445, 345.8415222167969));
+        seed_1.x = fract((cos(a) * 136.8168f));
+        seed_1.y = fract((cos(b) * 534.7645f));
+        return seed_1.y;
       }
 
       fn randFloat01() -> f32 {
diff --git a/apps/typegpu-docs/tests/individual-example-tests/perlin-noise.test.ts b/apps/typegpu-docs/tests/individual-example-tests/perlin-noise.test.ts
index a80f099bad..c4101174ae 100644
--- a/apps/typegpu-docs/tests/individual-example-tests/perlin-noise.test.ts
+++ b/apps/typegpu-docs/tests/individual-example-tests/perlin-noise.test.ts
@@ -55,11 +55,11 @@ describe('perlin noise example', () => {
         return (f - 1f);
       }
 
-      var<private> seed: vec2f;
+      var<private> seed_1: vec2f;
 
       fn seed3(value: vec3f) {
         let scrambled = scrambleSeed3(value);
-        seed = ((vec2f(u32To01F32(hash((scrambled.x ^ rotl(scrambled.z, 16u)))), u32To01F32(hash((rotl(scrambled.y, 16u) ^ scrambled.z)))) * 2f) - 1f);
+        seed_1 = ((vec2f(u32To01F32(hash((scrambled.x ^ rotl(scrambled.z, 16u)))), u32To01F32(hash((rotl(scrambled.y, 16u) ^ scrambled.z)))) * 2f) - 1f);
       }
 
       fn randSeed3(seed: vec3f) {
@@ -67,11 +67,11 @@ describe('perlin noise example', () => {
       }
 
       fn sample() -> f32 {
-        let a = dot(seed, vec2f(23.140779495239258, 232.6168975830078));
-        let b = dot(seed, vec2f(54.47856521606445, 345.8415222167969));
-        seed.x = fract((cos(a) * 136.8168f));
-        seed.y = fract((cos(b) * 534.7645f));
-        return seed.y;
+        let a = dot(seed_1, vec2f(23.140779495239258, 232.6168975830078));
+        let b = dot(seed_1, vec2f(54.47856521606445, 345.8415222167969));
+        seed_1.x = fract((cos(a) * 136.8168f));
+        seed_1.y = fract((cos(b) * 534.7645f));
+        return seed_1.y;
       }
 
       fn randOnUnitSphere() -> vec3f {
diff --git a/apps/typegpu-docs/tests/individual-example-tests/probability.test.ts b/apps/typegpu-docs/tests/individual-example-tests/probability.test.ts
index 6dfdde9453..8a746a8133 100644
--- a/apps/typegpu-docs/tests/individual-example-tests/probability.test.ts
+++ b/apps/typegpu-docs/tests/individual-example-tests/probability.test.ts
@@ -53,11 +53,11 @@ describe('probability distribution plot example', () => {
         return ((x << k) | (x >> (32u - k)));
       }
 
-      var<private> seed: vec2f;
+      var<private> seed_2: vec2f;
 
       fn seed_1(value: f32) {
         let scrambled = scrambleSeed(value);
-        seed = ((vec2f(u32To01F32(hash(scrambled)), u32To01F32(hash(rotl(scrambled, 16u)))) * 2f) - 1f);
+        seed_2 = ((vec2f(u32To01F32(hash(scrambled)), u32To01F32(hash(rotl(scrambled, 16u)))) * 2f) - 1f);
       }
 
       fn randSeed(seed: f32) {
@@ -65,11 +65,11 @@ describe('probability distribution plot example', () => {
       }
 
       fn sample() -> f32 {
-        let a = dot(seed, vec2f(23.140779495239258, 232.6168975830078));
-        let b = dot(seed, vec2f(54.47856521606445, 345.8415222167969));
-        seed.x = fract((cos(a) * 136.8168f));
-        seed.y = fract((cos(b) * 534.7645f));
-        return seed.y;
+        let a = dot(seed_2, vec2f(23.140779495239258, 232.6168975830078));
+        let b = dot(seed_2, vec2f(54.47856521606445, 345.8415222167969));
+        seed_2.x = fract((cos(a) * 136.8168f));
+        seed_2.y = fract((cos(b) * 534.7645f));
+        return seed_2.y;
       }
 
       fn randUniformExclusive() -> f32 {
@@ -130,11 +130,11 @@ describe('probability distribution plot example', () => {
         return ((x << k) | (x >> (32u - k)));
       }
 
-      var<private> seed: vec2f;
+      var<private> seed_2: vec2f;
 
       fn seed_1(value: f32) {
         let scrambled = scrambleSeed(value);
-        seed = ((vec2f(u32To01F32(hash(scrambled)), u32To01F32(hash(rotl(scrambled, 16u)))) * 2f) - 1f);
+        seed_2 = ((vec2f(u32To01F32(hash(scrambled)), u32To01F32(hash(rotl(scrambled, 16u)))) * 2f) - 1f);
       }
 
       fn randSeed(seed: f32) {
@@ -142,11 +142,11 @@ describe('probability distribution plot example', () => {
       }
 
       fn sample() -> f32 {
-        let a = dot(seed, vec2f(23.140779495239258, 232.6168975830078));
-        let b = dot(seed, vec2f(54.47856521606445, 345.8415222167969));
-        seed.x = fract((cos(a) * 136.8168f));
-        seed.y = fract((cos(b) * 534.7645f));
-        return seed.y;
+        let a = dot(seed_2, vec2f(23.140779495239258, 232.6168975830078));
+        let b = dot(seed_2, vec2f(54.47856521606445, 345.8415222167969));
+        seed_2.x = fract((cos(a) * 136.8168f));
+        seed_2.y = fract((cos(b) * 534.7645f));
+        return seed_2.y;
       }
 
       fn randOnUnitSphere() -> vec3f {
@@ -199,11 +199,11 @@ describe('probability distribution plot example', () => {
         return ((x << k) | (x >> (32u - k)));
       }
 
-      var<private> seed: vec2f;
+      var<private> seed_2: vec2f;
 
       fn seed_1(value: f32) {
         let scrambled = scrambleSeed(value);
-        seed = ((vec2f(u32To01F32(hash(scrambled)), u32To01F32(hash(rotl(scrambled, 16u)))) * 2f) - 1f);
+        seed_2 = ((vec2f(u32To01F32(hash(scrambled)), u32To01F32(hash(rotl(scrambled, 16u)))) * 2f) - 1f);
       }
 
       fn randSeed(seed: f32) {
@@ -211,11 +211,11 @@ describe('probability distribution plot example', () => {
       }
 
       fn sample() -> f32 {
-        let a = dot(seed, vec2f(23.140779495239258, 232.6168975830078));
-        let b = dot(seed, vec2f(54.47856521606445, 345.8415222167969));
-        seed.x = fract((cos(a) * 136.8168f));
-        seed.y = fract((cos(b) * 534.7645f));
-        return seed.y;
+        let a = dot(seed_2, vec2f(23.140779495239258, 232.6168975830078));
+        let b = dot(seed_2, vec2f(54.47856521606445, 345.8415222167969));
+        seed_2.x = fract((cos(a) * 136.8168f));
+        seed_2.y = fract((cos(b) * 534.7645f));
+        return seed_2.y;
       }
 
       fn randInUnitCircle() -> vec2f {
@@ -269,11 +269,11 @@ describe('probability distribution plot example', () => {
         return ((x << k) | (x >> (32u - k)));
       }
 
-      var<private> seed: vec2f;
+      var<private> seed_2: vec2f;
 
       fn seed_1(value: f32) {
         let scrambled = scrambleSeed(value);
-        seed = ((vec2f(u32To01F32(hash(scrambled)), u32To01F32(hash(rotl(scrambled, 16u)))) * 2f) - 1f);
+        seed_2 = ((vec2f(u32To01F32(hash(scrambled)), u32To01F32(hash(rotl(scrambled, 16u)))) * 2f) - 1f);
       }
 
       fn randSeed(seed: f32) {
@@ -281,11 +281,11 @@ describe('probability distribution plot example', () => {
       }
 
       fn sample() -> f32 {
-        let a = dot(seed, vec2f(23.140779495239258, 232.6168975830078));
-        let b = dot(seed, vec2f(54.47856521606445, 345.8415222167969));
-        seed.x = fract((cos(a) * 136.8168f));
-        seed.y = fract((cos(b) * 534.7645f));
-        return seed.y;
+        let a = dot(seed_2, vec2f(23.140779495239258, 232.6168975830078));
+        let b = dot(seed_2, vec2f(54.47856521606445, 345.8415222167969));
+        seed_2.x = fract((cos(a) * 136.8168f));
+        seed_2.y = fract((cos(b) * 534.7645f));
+        return seed_2.y;
       }
 
       fn randOnUnitCircle() -> vec2f {
@@ -338,11 +338,11 @@ describe('probability distribution plot example', () => {
         return ((x << k) | (x >> (32u - k)));
       }
 
-      var<private> seed: vec2f;
+      var<private> seed_2: vec2f;
 
       fn seed_1(value: f32) {
         let scrambled = scrambleSeed(value);
-        seed = ((vec2f(u32To01F32(hash(scrambled)), u32To01F32(hash(rotl(scrambled, 16u)))) * 2f) - 1f);
+        seed_2 = ((vec2f(u32To01F32(hash(scrambled)), u32To01F32(hash(rotl(scrambled, 16u)))) * 2f) - 1f);
       }
 
       fn randSeed(seed: f32) {
@@ -350,11 +350,11 @@ describe('probability distribution plot example', () => {
       }
 
       fn sample() -> f32 {
-        let a = dot(seed, vec2f(23.140779495239258, 232.6168975830078));
-        let b = dot(seed, vec2f(54.47856521606445, 345.8415222167969));
-        seed.x = fract((cos(a) * 136.8168f));
-        seed.y = fract((cos(b) * 534.7645f));
-        return seed.y;
+        let a = dot(seed_2, vec2f(23.140779495239258, 232.6168975830078));
+        let b = dot(seed_2, vec2f(54.47856521606445, 345.8415222167969));
+        seed_2.x = fract((cos(a) * 136.8168f));
+        seed_2.y = fract((cos(b) * 534.7645f));
+        return seed_2.y;
       }
 
       fn randInUnitCube() -> vec3f {
@@ -402,11 +402,11 @@ describe('probability distribution plot example', () => {
         return ((x << k) | (x >> (32u - k)));
       }
 
-      var<private> seed: vec2f;
+      var<private> seed_2: vec2f;
 
       fn seed_1(value: f32) {
         let scrambled = scrambleSeed(value);
-        seed = ((vec2f(u32To01F32(hash(scrambled)), u32To01F32(hash(rotl(scrambled, 16u)))) * 2f) - 1f);
+        seed_2 = ((vec2f(u32To01F32(hash(scrambled)), u32To01F32(hash(rotl(scrambled, 16u)))) * 2f) - 1f);
       }
 
       fn randSeed(seed: f32) {
@@ -414,11 +414,11 @@ describe('probability distribution plot example', () => {
       }
 
       fn sample() -> f32 {
-        let a = dot(seed, vec2f(23.140779495239258, 232.6168975830078));
-        let b = dot(seed, vec2f(54.47856521606445, 345.8415222167969));
-        seed.x = fract((cos(a) * 136.8168f));
-        seed.y = fract((cos(b) * 534.7645f));
-        return seed.y;
+        let a = dot(seed_2, vec2f(23.140779495239258, 232.6168975830078));
+        let b = dot(seed_2, vec2f(54.47856521606445, 345.8415222167969));
+        seed_2.x = fract((cos(a) * 136.8168f));
+        seed_2.y = fract((cos(b) * 534.7645f));
+        return seed_2.y;
       }
 
       fn randOnUnitCube() -> vec3f {
@@ -472,11 +472,11 @@ describe('probability distribution plot example', () => {
         return ((x << k) | (x >> (32u - k)));
       }
 
-      var<private> seed: vec2f;
+      var<private> seed_2: vec2f;
 
       fn seed_1(value: f32) {
         let scrambled = scrambleSeed(value);
-        seed = ((vec2f(u32To01F32(hash(scrambled)), u32To01F32(hash(rotl(scrambled, 16u)))) * 2f) - 1f);
+        seed_2 = ((vec2f(u32To01F32(hash(scrambled)), u32To01F32(hash(rotl(scrambled, 16u)))) * 2f) - 1f);
       }
 
       fn randSeed(seed: f32) {
@@ -484,11 +484,11 @@ describe('probability distribution plot example', () => {
       }
 
       fn sample() -> f32 {
-        let a = dot(seed, vec2f(23.140779495239258, 232.6168975830078));
-        let b = dot(seed, vec2f(54.47856521606445, 345.8415222167969));
-        seed.x = fract((cos(a) * 136.8168f));
-        seed.y = fract((cos(b) * 534.7645f));
-        return seed.y;
+        let a = dot(seed_2, vec2f(23.140779495239258, 232.6168975830078));
+        let b = dot(seed_2, vec2f(54.47856521606445, 345.8415222167969));
+        seed_2.x = fract((cos(a) * 136.8168f));
+        seed_2.y = fract((cos(b) * 534.7645f));
+        return seed_2.y;
       }
 
       fn randUniformExclusive() -> f32 {
@@ -559,11 +559,11 @@ describe('probability distribution plot example', () => {
         return ((x << k) | (x >> (32u - k)));
       }
 
-      var<private> seed: vec2f;
+      var<private> seed_2: vec2f;
 
       fn seed_1(value: f32) {
         let scrambled = scrambleSeed(value);
-        seed = ((vec2f(u32To01F32(hash(scrambled)), u32To01F32(hash(rotl(scrambled, 16u)))) * 2f) - 1f);
+        seed_2 = ((vec2f(u32To01F32(hash(scrambled)), u32To01F32(hash(rotl(scrambled, 16u)))) * 2f) - 1f);
       }
 
       fn randSeed(seed: f32) {
@@ -571,11 +571,11 @@ describe('probability distribution plot example', () => {
       }
 
       fn sample() -> f32 {
-        let a = dot(seed, vec2f(23.140779495239258, 232.6168975830078));
-        let b = dot(seed, vec2f(54.47856521606445, 345.8415222167969));
-        seed.x = fract((cos(a) * 136.8168f));
-        seed.y = fract((cos(b) * 534.7645f));
-        return seed.y;
+        let a = dot(seed_2, vec2f(23.140779495239258, 232.6168975830078));
+        let b = dot(seed_2, vec2f(54.47856521606445, 345.8415222167969));
+        seed_2.x = fract((cos(a) * 136.8168f));
+        seed_2.y = fract((cos(b) * 534.7645f));
+        return seed_2.y;
       }
 
       fn randOnUnitSphere() -> vec3f {
@@ -638,11 +638,11 @@ describe('probability distribution plot example', () => {
         return ((x << k) | (x >> (32u - k)));
       }
 
-      var<private> seed: vec2f;
+      var<private> seed_2: vec2f;
 
       fn seed_1(value: f32) {
         let scrambled = scrambleSeed(value);
-        seed = ((vec2f(u32To01F32(hash(scrambled)), u32To01F32(hash(rotl(scrambled, 16u)))) * 2f) - 1f);
+        seed_2 = ((vec2f(u32To01F32(hash(scrambled)), u32To01F32(hash(rotl(scrambled, 16u)))) * 2f) - 1f);
       }
 
       fn randSeed(seed: f32) {
@@ -650,11 +650,11 @@ describe('probability distribution plot example', () => {
       }
 
       fn sample() -> f32 {
-        let a = dot(seed, vec2f(23.140779495239258, 232.6168975830078));
-        let b = dot(seed, vec2f(54.47856521606445, 345.8415222167969));
-        seed.x = fract((cos(a) * 136.8168f));
-        seed.y = fract((cos(b) * 534.7645f));
-        return seed.y;
+        let a = dot(seed_2, vec2f(23.140779495239258, 232.6168975830078));
+        let b = dot(seed_2, vec2f(54.47856521606445, 345.8415222167969));
+        seed_2.x = fract((cos(a) * 136.8168f));
+        seed_2.y = fract((cos(b) * 534.7645f));
+        return seed_2.y;
       }
 
       fn randBernoulli(p: f32) -> f32 {
@@ -707,11 +707,11 @@ describe('probability distribution plot example', () => {
         return ((x << k) | (x >> (32u - k)));
       }
 
-      var<private> seed: vec2f;
+      var<private> seed_2: vec2f;
 
       fn seed_1(value: f32) {
         let scrambled = scrambleSeed(value);
-        seed = ((vec2f(u32To01F32(hash(scrambled)), u32To01F32(hash(rotl(scrambled, 16u)))) * 2f) - 1f);
+        seed_2 = ((vec2f(u32To01F32(hash(scrambled)), u32To01F32(hash(rotl(scrambled, 16u)))) * 2f) - 1f);
       }
 
       fn randSeed(seed: f32) {
@@ -719,11 +719,11 @@ describe('probability distribution plot example', () => {
       }
 
       fn sample() -> f32 {
-        let a = dot(seed, vec2f(23.140779495239258, 232.6168975830078));
-        let b = dot(seed, vec2f(54.47856521606445, 345.8415222167969));
-        seed.x = fract((cos(a) * 136.8168f));
-        seed.y = fract((cos(b) * 534.7645f));
-        return seed.y;
+        let a = dot(seed_2, vec2f(23.140779495239258, 232.6168975830078));
+        let b = dot(seed_2, vec2f(54.47856521606445, 345.8415222167969));
+        seed_2.x = fract((cos(a) * 136.8168f));
+        seed_2.y = fract((cos(b) * 534.7645f));
+        return seed_2.y;
       }
 
       fn randFloat01() -> f32 {
@@ -775,11 +775,11 @@ describe('probability distribution plot example', () => {
         return ((x << k) | (x >> (32u - k)));
       }
 
-      var<private> seed: vec2f;
+      var<private> seed_2: vec2f;
 
       fn seed_1(value: f32) {
         let scrambled = scrambleSeed(value);
-        seed = ((vec2f(u32To01F32(hash(scrambled)), u32To01F32(hash(rotl(scrambled, 16u)))) * 2f) - 1f);
+        seed_2 = ((vec2f(u32To01F32(hash(scrambled)), u32To01F32(hash(rotl(scrambled, 16u)))) * 2f) - 1f);
       }
 
       fn randSeed(seed: f32) {
@@ -787,11 +787,11 @@ describe('probability distribution plot example', () => {
       }
 
       fn sample() -> f32 {
-        let a = dot(seed, vec2f(23.140779495239258, 232.6168975830078));
-        let b = dot(seed, vec2f(54.47856521606445, 345.8415222167969));
-        seed.x = fract((cos(a) * 136.8168f));
-        seed.y = fract((cos(b) * 534.7645f));
-        return seed.y;
+        let a = dot(seed_2, vec2f(23.140779495239258, 232.6168975830078));
+        let b = dot(seed_2, vec2f(54.47856521606445, 345.8415222167969));
+        seed_2.x = fract((cos(a) * 136.8168f));
+        seed_2.y = fract((cos(b) * 534.7645f));
+        return seed_2.y;
       }
 
       fn randUniformExclusive() -> f32 {
@@ -848,11 +848,11 @@ describe('probability distribution plot example', () => {
         return ((x << k) | (x >> (32u - k)));
       }
 
-      var<private> seed: vec2f;
+      var<private> seed_2: vec2f;
 
       fn seed_1(value: f32) {
         let scrambled = scrambleSeed(value);
-        seed = ((vec2f(u32To01F32(hash(scrambled)), u32To01F32(hash(rotl(scrambled, 16u)))) * 2f) - 1f);
+        seed_2 = ((vec2f(u32To01F32(hash(scrambled)), u32To01F32(hash(rotl(scrambled, 16u)))) * 2f) - 1f);
       }
 
       fn randSeed(seed: f32) {
@@ -860,11 +860,11 @@ describe('probability distribution plot example', () => {
       }
 
       fn sample() -> f32 {
-        let a = dot(seed, vec2f(23.140779495239258, 232.6168975830078));
-        let b = dot(seed, vec2f(54.47856521606445, 345.8415222167969));
-        seed.x = fract((cos(a) * 136.8168f));
-        seed.y = fract((cos(b) * 534.7645f));
-        return seed.y;
+        let a = dot(seed_2, vec2f(23.140779495239258, 232.6168975830078));
+        let b = dot(seed_2, vec2f(54.47856521606445, 345.8415222167969));
+        seed_2.x = fract((cos(a) * 136.8168f));
+        seed_2.y = fract((cos(b) * 534.7645f));
+        return seed_2.y;
       }
 
       fn randUniformExclusive() -> f32 {
@@ -922,11 +922,11 @@ describe('probability distribution plot example', () => {
         return ((x << k) | (x >> (32u - k)));
       }
 
-      var<private> seed: vec2f;
+      var<private> seed_2: vec2f;
 
       fn seed_1(value: f32) {
         let scrambled = scrambleSeed(value);
-        seed = ((vec2f(u32To01F32(hash(scrambled)), u32To01F32(hash(rotl(scrambled, 16u)))) * 2f) - 1f);
+        seed_2 = ((vec2f(u32To01F32(hash(scrambled)), u32To01F32(hash(rotl(scrambled, 16u)))) * 2f) - 1f);
       }
 
       fn randSeed(seed: f32) {
@@ -934,11 +934,11 @@ describe('probability distribution plot example', () => {
       }
 
       fn sample() -> f32 {
-        let a = dot(seed, vec2f(23.140779495239258, 232.6168975830078));
-        let b = dot(seed, vec2f(54.47856521606445, 345.8415222167969));
-        seed.x = fract((cos(a) * 136.8168f));
-        seed.y = fract((cos(b) * 534.7645f));
-        return seed.y;
+        let a = dot(seed_2, vec2f(23.140779495239258, 232.6168975830078));
+        let b = dot(seed_2, vec2f(54.47856521606445, 345.8415222167969));
+        seed_2.x = fract((cos(a) * 136.8168f));
+        seed_2.y = fract((cos(b) * 534.7645f));
+        return seed_2.y;
       }
 
       fn randUniformExclusive() -> f32 {
diff --git a/apps/typegpu-docs/tests/individual-example-tests/ripple-cube.test.ts b/apps/typegpu-docs/tests/individual-example-tests/ripple-cube.test.ts
index 14bc6a211f..1f9fff8e3b 100644
--- a/apps/typegpu-docs/tests/individual-example-tests/ripple-cube.test.ts
+++ b/apps/typegpu-docs/tests/individual-example-tests/ripple-cube.test.ts
@@ -55,11 +55,11 @@ describe('ripple-cube example', () => {
         return (f - 1f);
       }
 
-      var<private> seed: vec2f;
+      var<private> seed_1: vec2f;
 
       fn seed3(value: vec3f) {
         let scrambled = scrambleSeed3(value);
-        seed = ((vec2f(u32To01F32(hash((scrambled.x ^ rotl(scrambled.z, 16u)))), u32To01F32(hash((rotl(scrambled.y, 16u) ^ scrambled.z)))) * 2f) - 1f);
+        seed_1 = ((vec2f(u32To01F32(hash((scrambled.x ^ rotl(scrambled.z, 16u)))), u32To01F32(hash((rotl(scrambled.y, 16u) ^ scrambled.z)))) * 2f) - 1f);
       }
 
       fn randSeed3(seed: vec3f) {
@@ -67,11 +67,11 @@ describe('ripple-cube example', () => {
       }
 
       fn sample() -> f32 {
-        let a = dot(seed, vec2f(23.140779495239258, 232.6168975830078));
-        let b = dot(seed, vec2f(54.47856521606445, 345.8415222167969));
-        seed.x = fract((cos(a) * 136.8168f));
-        seed.y = fract((cos(b) * 534.7645f));
-        return seed.y;
+        let a = dot(seed_1, vec2f(23.140779495239258, 232.6168975830078));
+        let b = dot(seed_1, vec2f(54.47856521606445, 345.8415222167969));
+        seed_1.x = fract((cos(a) * 136.8168f));
+        seed_1.y = fract((cos(b) * 534.7645f));
+        return seed_1.y;
       }
 
       fn randOnUnitSphere() -> vec3f {
@@ -133,11 +133,11 @@ describe('ripple-cube example', () => {
         return (f - 1f);
       }
 
-      var<private> seed: vec2f;
+      var<private> seed_1: vec2f;
 
       fn seed3(value: vec3f) {
         let scrambled = scrambleSeed3(value);
-        seed = ((vec2f(u32To01F32(hash((scrambled.x ^ rotl(scrambled.z, 16u)))), u32To01F32(hash((rotl(scrambled.y, 16u) ^ scrambled.z)))) * 2f) - 1f);
+        seed_1 = ((vec2f(u32To01F32(hash((scrambled.x ^ rotl(scrambled.z, 16u)))), u32To01F32(hash((rotl(scrambled.y, 16u) ^ scrambled.z)))) * 2f) - 1f);
       }
 
       fn randSeed3(seed: vec3f) {
@@ -145,11 +145,11 @@ describe('ripple-cube example', () => {
       }
 
       fn sample() -> f32 {
-        let a = dot(seed, vec2f(23.140779495239258, 232.6168975830078));
-        let b = dot(seed, vec2f(54.47856521606445, 345.8415222167969));
-        seed.x = fract((cos(a) * 136.8168f));
-        seed.y = fract((cos(b) * 534.7645f));
-        return seed.y;
+        let a = dot(seed_1, vec2f(23.140779495239258, 232.6168975830078));
+        let b = dot(seed_1, vec2f(54.47856521606445, 345.8415222167969));
+        seed_1.x = fract((cos(a) * 136.8168f));
+        seed_1.y = fract((cos(b) * 534.7645f));
+        return seed_1.y;
       }
 
       fn randOnUnitSphere() -> vec3f {
@@ -274,11 +274,11 @@ describe('ripple-cube example', () => {
         return (f - 1f);
       }
 
-      var<private> seed: vec2f;
+      var<private> seed_1: vec2f;
 
       fn seed3(value: vec3f) {
         let scrambled = scrambleSeed3(value);
-        seed = ((vec2f(u32To01F32(hash((scrambled.x ^ rotl(scrambled.z, 16u)))), u32To01F32(hash((rotl(scrambled.y, 16u) ^ scrambled.z)))) * 2f) - 1f);
+        seed_1 = ((vec2f(u32To01F32(hash((scrambled.x ^ rotl(scrambled.z, 16u)))), u32To01F32(hash((rotl(scrambled.y, 16u) ^ scrambled.z)))) * 2f) - 1f);
       }
 
       fn randSeed3(seed: vec3f) {
@@ -286,11 +286,11 @@ describe('ripple-cube example', () => {
       }
 
       fn sample_1() -> f32 {
-        let a = dot(seed, vec2f(23.140779495239258, 232.6168975830078));
-        let b = dot(seed, vec2f(54.47856521606445, 345.8415222167969));
-        seed.x = fract((cos(a) * 136.8168f));
-        seed.y = fract((cos(b) * 534.7645f));
-        return seed.y;
+        let a = dot(seed_1, vec2f(23.140779495239258, 232.6168975830078));
+        let b = dot(seed_1, vec2f(54.47856521606445, 345.8415222167969));
+        seed_1.x = fract((cos(a) * 136.8168f));
+        seed_1.y = fract((cos(b) * 534.7645f));
+        return seed_1.y;
       }
 
       fn randFloat01() -> f32 {
@@ -411,11 +411,11 @@ describe('ripple-cube example', () => {
         return ((x << k) | (x >> (32u - k)));
       }
 
-      var<private> seed: vec2f;
+      var<private> seed_1: vec2f;
 
       fn seed2(value: vec2f) {
         let scrambled = scrambleSeed2(value);
-        seed = ((vec2f(u32To01F32(hash((scrambled.x ^ scrambled.y))), u32To01F32(hash((rotl(scrambled.x, 16u) ^ scrambled.y)))) * 2f) - 1f);
+        seed_1 = ((vec2f(u32To01F32(hash((scrambled.x ^ scrambled.y))), u32To01F32(hash((rotl(scrambled.x, 16u) ^ scrambled.y)))) * 2f) - 1f);
       }
 
       fn randSeed2(seed: vec2f) {
diff --git a/apps/typegpu-docs/tests/individual-example-tests/slime-mold-3d.test.ts b/apps/typegpu-docs/tests/individual-example-tests/slime-mold-3d.test.ts
index 380588b372..d9a55d124a 100644
--- a/apps/typegpu-docs/tests/individual-example-tests/slime-mold-3d.test.ts
+++ b/apps/typegpu-docs/tests/individual-example-tests/slime-mold-3d.test.ts
@@ -50,11 +50,11 @@ describe('slime mold 3d example', () => {
         return ((x << k) | (x >> (32u - k)));
       }
 
-      var<private> seed: vec2f;
+      var<private> seed_2: vec2f;
 
       fn seed_1(value: f32) {
         let scrambled = scrambleSeed(value);
-        seed = ((vec2f(u32To01F32(hash(scrambled)), u32To01F32(hash(rotl(scrambled, 16u)))) * 2f) - 1f);
+        seed_2 = ((vec2f(u32To01F32(hash(scrambled)), u32To01F32(hash(rotl(scrambled, 16u)))) * 2f) - 1f);
       }
 
       fn randSeed(seed: f32) {
@@ -62,11 +62,11 @@ describe('slime mold 3d example', () => {
       }
 
       fn sample() -> f32 {
-        let a = dot(seed, vec2f(23.140779495239258, 232.6168975830078));
-        let b = dot(seed, vec2f(54.47856521606445, 345.8415222167969));
-        seed.x = fract((cos(a) * 136.8168f));
-        seed.y = fract((cos(b) * 534.7645f));
-        return seed.y;
+        let a = dot(seed_2, vec2f(23.140779495239258, 232.6168975830078));
+        let b = dot(seed_2, vec2f(54.47856521606445, 345.8415222167969));
+        seed_2.x = fract((cos(a) * 136.8168f));
+        seed_2.y = fract((cos(b) * 534.7645f));
+        return seed_2.y;
       }
 
       fn randUniformExclusive() -> f32 {
@@ -178,11 +178,11 @@ describe('slime mold 3d example', () => {
         return ((x << k) | (x >> (32u - k)));
       }
 
-      var<private> seed: vec2f;
+      var<private> seed_2: vec2f;
 
       fn seed_1(value: f32) {
         let scrambled = scrambleSeed(value);
-        seed = ((vec2f(u32To01F32(hash(scrambled)), u32To01F32(hash(rotl(scrambled, 16u)))) * 2f) - 1f);
+        seed_2 = ((vec2f(u32To01F32(hash(scrambled)), u32To01F32(hash(rotl(scrambled, 16u)))) * 2f) - 1f);
       }
 
       fn randSeed(seed: f32) {
@@ -329,11 +329,11 @@ describe('slime mold 3d example', () => {
       }
 
       fn sample() -> f32 {
-        let a = dot(seed, vec2f(23.140779495239258, 232.6168975830078));
-        let b = dot(seed, vec2f(54.47856521606445, 345.8415222167969));
-        seed.x = fract((cos(a) * 136.8168f));
-        seed.y = fract((cos(b) * 534.7645f));
-        return seed.y;
+        let a = dot(seed_2, vec2f(23.140779495239258, 232.6168975830078));
+        let b = dot(seed_2, vec2f(54.47856521606445, 345.8415222167969));
+        seed_2.x = fract((cos(a) * 136.8168f));
+        seed_2.y = fract((cos(b) * 534.7645f));
+        return seed_2.y;
       }
 
       fn randOnUnitSphere() -> vec3f {
@@ -469,11 +469,11 @@ describe('slime mold 3d example', () => {
         return ((x << k) | (x >> (32u - k)));
       }
 
-      var<private> seed: vec2f;
+      var<private> seed_1: vec2f;
 
       fn seed2(value: vec2f) {
         let scrambled = scrambleSeed2(value);
-        seed = ((vec2f(u32To01F32(hash((scrambled.x ^ scrambled.y))), u32To01F32(hash((rotl(scrambled.x, 16u) ^ scrambled.y)))) * 2f) - 1f);
+        seed_1 = ((vec2f(u32To01F32(hash((scrambled.x ^ scrambled.y))), u32To01F32(hash((rotl(scrambled.x, 16u) ^ scrambled.y)))) * 2f) - 1f);
       }
 
       fn randSeed2(seed: vec2f) {
@@ -507,11 +507,11 @@ describe('slime mold 3d example', () => {
       }
 
       fn sample() -> f32 {
-        let a = dot(seed, vec2f(23.140779495239258, 232.6168975830078));
-        let b = dot(seed, vec2f(54.47856521606445, 345.8415222167969));
-        seed.x = fract((cos(a) * 136.8168f));
-        seed.y = fract((cos(b) * 534.7645f));
-        return seed.y;
+        let a = dot(seed_1, vec2f(23.140779495239258, 232.6168975830078));
+        let b = dot(seed_1, vec2f(54.47856521606445, 345.8415222167969));
+        seed_1.x = fract((cos(a) * 136.8168f));
+        seed_1.y = fract((cos(b) * 534.7645f));
+        return seed_1.y;
       }
 
       fn randFloat01() -> f32 {
diff --git a/apps/typegpu-docs/tests/individual-example-tests/slime-mold.test.ts b/apps/typegpu-docs/tests/individual-example-tests/slime-mold.test.ts
index 47e5f1c474..24d40c897d 100644
--- a/apps/typegpu-docs/tests/individual-example-tests/slime-mold.test.ts
+++ b/apps/typegpu-docs/tests/individual-example-tests/slime-mold.test.ts
@@ -50,11 +50,11 @@ describe('slime mold example', () => {
         return ((x << k) | (x >> (32u - k)));
       }
 
-      var<private> seed: vec2f;
+      var<private> seed_2: vec2f;
 
       fn seed_1(value: f32) {
         let scrambled = scrambleSeed(value);
-        seed = ((vec2f(u32To01F32(hash(scrambled)), u32To01F32(hash(rotl(scrambled, 16u)))) * 2f) - 1f);
+        seed_2 = ((vec2f(u32To01F32(hash(scrambled)), u32To01F32(hash(rotl(scrambled, 16u)))) * 2f) - 1f);
       }
 
       fn randSeed(seed: f32) {
@@ -62,11 +62,11 @@ describe('slime mold example', () => {
       }
 
       fn sample() -> f32 {
-        let a = dot(seed, vec2f(23.140779495239258, 232.6168975830078));
-        let b = dot(seed, vec2f(54.47856521606445, 345.8415222167969));
-        seed.x = fract((cos(a) * 136.8168f));
-        seed.y = fract((cos(b) * 534.7645f));
-        return seed.y;
+        let a = dot(seed_2, vec2f(23.140779495239258, 232.6168975830078));
+        let b = dot(seed_2, vec2f(54.47856521606445, 345.8415222167969));
+        seed_2.x = fract((cos(a) * 136.8168f));
+        seed_2.y = fract((cos(b) * 534.7645f));
+        return seed_2.y;
       }
 
       fn randInUnitCircle() -> vec2f {
@@ -249,11 +249,11 @@ describe('slime mold example', () => {
         return ((x << k) | (x >> (32u - k)));
       }
 
-      var<private> seed: vec2f;
+      var<private> seed_2: vec2f;
 
       fn seed_1(value: f32) {
         let scrambled = scrambleSeed(value);
-        seed = ((vec2f(u32To01F32(hash(scrambled)), u32To01F32(hash(rotl(scrambled, 16u)))) * 2f) - 1f);
+        seed_2 = ((vec2f(u32To01F32(hash(scrambled)), u32To01F32(hash(rotl(scrambled, 16u)))) * 2f) - 1f);
       }
 
       fn randSeed(seed: f32) {
@@ -270,11 +270,11 @@ describe('slime mold example', () => {
       @group(0) @binding(0) var<storage, read_write> agentsData: array<Agent, 200000>;
 
       fn sample() -> f32 {
-        let a = dot(seed, vec2f(23.140779495239258, 232.6168975830078));
-        let b = dot(seed, vec2f(54.47856521606445, 345.8415222167969));
-        seed.x = fract((cos(a) * 136.8168f));
-        seed.y = fract((cos(b) * 534.7645f));
-        return seed.y;
+        let a = dot(seed_2, vec2f(23.140779495239258, 232.6168975830078));
+        let b = dot(seed_2, vec2f(54.47856521606445, 345.8415222167969));
+        seed_2.x = fract((cos(a) * 136.8168f));
+        seed_2.y = fract((cos(b) * 534.7645f));
+        return seed_2.y;
       }
 
       fn randFloat01() -> f32 {
diff --git a/apps/typegpu-docs/tests/individual-example-tests/smoky-triangle.test.ts b/apps/typegpu-docs/tests/individual-example-tests/smoky-triangle.test.ts
index f0c730330f..7f185a31ad 100644
--- a/apps/typegpu-docs/tests/individual-example-tests/smoky-triangle.test.ts
+++ b/apps/typegpu-docs/tests/individual-example-tests/smoky-triangle.test.ts
@@ -53,11 +53,11 @@ describe('smoky triangle', () => {
         return (f - 1f);
       }
 
-      var<private> seed: vec2f;
+      var<private> seed_1: vec2f;
 
       fn seed3(value: vec3f) {
         let scrambled = scrambleSeed3(value);
-        seed = ((vec2f(u32To01F32(hash((scrambled.x ^ rotl(scrambled.z, 16u)))), u32To01F32(hash((rotl(scrambled.y, 16u) ^ scrambled.z)))) * 2f) - 1f);
+        seed_1 = ((vec2f(u32To01F32(hash((scrambled.x ^ rotl(scrambled.z, 16u)))), u32To01F32(hash((rotl(scrambled.y, 16u) ^ scrambled.z)))) * 2f) - 1f);
       }
 
       fn randSeed3(seed: vec3f) {
@@ -65,11 +65,11 @@ describe('smoky triangle', () => {
       }
 
       fn sample() -> f32 {
-        let a = dot(seed, vec2f(23.140779495239258, 232.6168975830078));
-        let b = dot(seed, vec2f(54.47856521606445, 345.8415222167969));
-        seed.x = fract((cos(a) * 136.8168f));
-        seed.y = fract((cos(b) * 534.7645f));
-        return seed.y;
+        let a = dot(seed_1, vec2f(23.140779495239258, 232.6168975830078));
+        let b = dot(seed_1, vec2f(54.47856521606445, 345.8415222167969));
+        seed_1.x = fract((cos(a) * 136.8168f));
+        seed_1.y = fract((cos(b) * 534.7645f));
+        return seed_1.y;
       }
 
       fn randOnUnitSphere() -> vec3f {
diff --git a/apps/typegpu-docs/tests/individual-example-tests/uniformity.test.ts b/apps/typegpu-docs/tests/individual-example-tests/uniformity.test.ts
index ee398120c4..c24dd1cf87 100644
--- a/apps/typegpu-docs/tests/individual-example-tests/uniformity.test.ts
+++ b/apps/typegpu-docs/tests/individual-example-tests/uniformity.test.ts
@@ -149,11 +149,11 @@ describe('uniformity test example', () => {
         return ((x << k) | (x >> (32u - k)));
       }
 
-      var<private> seed: vec2f;
+      var<private> seed_1: vec2f;
 
       fn seed2(value: vec2f) {
         let scrambled = scrambleSeed2(value);
-        seed = ((vec2f(u32To01F32(hash((scrambled.x ^ scrambled.y))), u32To01F32(hash((rotl(scrambled.x, 16u) ^ scrambled.y)))) * 2f) - 1f);
+        seed_1 = ((vec2f(u32To01F32(hash((scrambled.x ^ scrambled.y))), u32To01F32(hash((rotl(scrambled.x, 16u) ^ scrambled.y)))) * 2f) - 1f);
       }
 
       fn randSeed2(seed: vec2f) {
@@ -161,11 +161,11 @@ describe('uniformity test example', () => {
       }
 
       fn sample() -> f32 {
-        let a = dot(seed, vec2f(23.140779495239258, 232.6168975830078));
-        let b = dot(seed, vec2f(54.47856521606445, 345.8415222167969));
-        seed.x = fract((cos(a) * 136.8168f));
-        seed.y = fract((cos(b) * 534.7645f));
-        return seed.y;
+        let a = dot(seed_1, vec2f(23.140779495239258, 232.6168975830078));
+        let b = dot(seed_1, vec2f(54.47856521606445, 345.8415222167969));
+        seed_1.x = fract((cos(a) * 136.8168f));
+        seed_1.y = fract((cos(b) * 534.7645f));
+        return seed_1.y;
       }
 
       fn randFloat01() -> f32 {
diff --git a/apps/typegpu-docs/tests/individual-example-tests/vaporrave.test.ts b/apps/typegpu-docs/tests/individual-example-tests/vaporrave.test.ts
index 46a4036740..36d35ef161 100644
--- a/apps/typegpu-docs/tests/individual-example-tests/vaporrave.test.ts
+++ b/apps/typegpu-docs/tests/individual-example-tests/vaporrave.test.ts
@@ -53,11 +53,11 @@ describe('vaporrave example', () => {
         return (f - 1f);
       }
 
-      var<private> seed: vec2f;
+      var<private> seed_1: vec2f;
 
       fn seed3(value: vec3f) {
         let scrambled = scrambleSeed3(value);
-        seed = ((vec2f(u32To01F32(hash((scrambled.x ^ rotl(scrambled.z, 16u)))), u32To01F32(hash((rotl(scrambled.y, 16u) ^ scrambled.z)))) * 2f) - 1f);
+        seed_1 = ((vec2f(u32To01F32(hash((scrambled.x ^ rotl(scrambled.z, 16u)))), u32To01F32(hash((rotl(scrambled.y, 16u) ^ scrambled.z)))) * 2f) - 1f);
       }
 
       fn randSeed3(seed: vec3f) {
@@ -65,11 +65,11 @@ describe('vaporrave example', () => {
       }
 
       fn sample() -> f32 {
-        let a = dot(seed, vec2f(23.140779495239258, 232.6168975830078));
-        let b = dot(seed, vec2f(54.47856521606445, 345.8415222167969));
-        seed.x = fract((cos(a) * 136.8168f));
-        seed.y = fract((cos(b) * 534.7645f));
-        return seed.y;
+        let a = dot(seed_1, vec2f(23.140779495239258, 232.6168975830078));
+        let b = dot(seed_1, vec2f(54.47856521606445, 345.8415222167969));
+        seed_1.x = fract((cos(a) * 136.8168f));
+        seed_1.y = fract((cos(b) * 534.7645f));
+        return seed_1.y;
       }
 
       fn randOnUnitSphere() -> vec3f {
diff --git a/packages/typegpu/src/resolutionCtx.ts b/packages/typegpu/src/resolutionCtx.ts
index 4d234a8eb6..e3889112ea 100644
--- a/packages/typegpu/src/resolutionCtx.ts
+++ b/packages/typegpu/src/resolutionCtx.ts
@@ -230,6 +230,9 @@ class ItemStateStackImpl implements ItemStateStack {
     return undefined;
   }
 
+  /**
+   * Returns whether the given identifier is taken in any block scope up to the nearest function scope.
+   */
   isIdentifierTakenLocally(id: string): boolean {
     for (let i = this._stack.length - 1; i >= 0; --i) {
       const layer = this._stack[i];
@@ -250,6 +253,24 @@ class ItemStateStackImpl implements ItemStateStack {
     return false;
   }
 
+  /**
+   * Returns whether the given identifier is taken in any block scope on the stack.
+   *
+   * This is useful when resolving a global identifier for the first time within a nested function.
+   */
+  isIdentifierTakenInCallStack(id: string): boolean {
+    for (let i = this._stack.length - 1; i >= 0; --i) {
+      const layer = this._stack[i];
+      if (layer?.type === 'blockScope') {
+        if (layer.takenLocalIdentifiers.has(id)) {
+          return true;
+        }
+      }
+    }
+
+    return false;
+  }
+
   defineBlockVariable(id: string, snippet: Snippet): void {
     if (snippet.dataType === UnknownData) {
       throw Error(`Tried to define variable '${id}' of unknown type`);
@@ -435,10 +456,12 @@ export class ResolutionCtxImpl implements ResolutionCtx {
     return bannedTokens.has(name);
   }
 
-  isIdentifierTaken(name: string): boolean {
+  isIdentifierTaken(name: string, scope: 'global' | 'block'): boolean {
     return (
       this.#namespaceInternal.takenGlobalIdentifiers.has(name) ||
-      this._itemStateStack.isIdentifierTakenLocally(name)
+      (scope === 'block'
+        ? this._itemStateStack.isIdentifierTakenLocally(name)
+        : this._itemStateStack.isIdentifierTakenInCallStack(name))
     );
   }
 
@@ -446,7 +469,7 @@ export class ResolutionCtxImpl implements ResolutionCtx {
     if (
       scope === 'block' &&
       validateIdentifier(primer).success &&
-      !this.isIdentifierTaken(primer)
+      !this.isIdentifierTaken(primer, scope)
     ) {
       // Preserving local definitions as they are, provided they are valid and not already taken.
       this.reserveIdentifier(primer, 'block');
@@ -457,7 +480,7 @@ export class ResolutionCtxImpl implements ResolutionCtx {
     let index = 0;
     const random = this.#namespaceInternal.strategy === 'random';
     let name = random ? `${base}_${this.#lastUniqueId++}` : base;
-    while (this.isIdentifierTaken(name)) {
+    while (this.isIdentifierTaken(name, scope)) {
       name = random ? `${base}_${this.#lastUniqueId++}` : `${base}_${++index}`;
     }
 
diff --git a/packages/typegpu/src/types.ts b/packages/typegpu/src/types.ts
index dc570eeab4..99565d82d9 100644
--- a/packages/typegpu/src/types.ts
+++ b/packages/typegpu/src/types.ts
@@ -360,7 +360,11 @@ export interface ResolutionCtx {
   makeUniqueIdentifier(primer: string | undefined, scope: 'global' | 'block'): string;
 
   isIdentifierBanned(name: string): boolean;
-  isIdentifierTaken(name: string): boolean;
+  /**
+   * @param name The name to check.
+   * @param scope The scope in which we want to place the identifier.
+   */
+  isIdentifierTaken(name: string, scope: 'global' | 'block'): boolean;
 
   /**
    * Makes sure the given identifier cannot be generated by {@link makeUniqueIdentifier}
diff --git a/packages/typegpu/tests/tgsl/nameClashes.test.ts b/packages/typegpu/tests/tgsl/nameClashes.test.ts
index f50a048c2f..2bbe3bd0f8 100644
--- a/packages/typegpu/tests/tgsl/nameClashes.test.ts
+++ b/packages/typegpu/tests/tgsl/nameClashes.test.ts
@@ -257,3 +257,74 @@ test('should give declarations new names when they are shadowed', () => {
     }"
   `);
 });
+
+test('should give different names to global declaration accessed inside nested function and argument of wrapping function', () => {
+  const myConst = tgpu.const(d.u32, 1).$name('COLLISION');
+
+  const helper = () => {
+    'use gpu';
+    return myConst.$;
+  };
+
+  const test = (COLLISION: number) => {
+    'use gpu';
+    helper();
+    const x = COLLISION;
+    const y = myConst.$;
+  };
+
+  const main = () => {
+    'use gpu';
+    test(1);
+  };
+
+  expect(tgpu.resolve([main])).toMatchInlineSnapshot(`
+    "const COLLISION_1: u32 = 1u;
+
+    fn helper() -> u32 {
+      return COLLISION_1;
+    }
+
+    fn test(COLLISION: i32) {
+      helper();
+      let x = COLLISION;
+      const y = COLLISION_1;
+    }
+
+    fn main() {
+      test(1i);
+    }"
+  `);
+});
+
+test('should give different names to global declaration accessed inside nested function and local variable of wrapping function', () => {
+  const myConst = tgpu.const(d.u32, 1).$name('COLLISION');
+
+  const helper = () => {
+    'use gpu';
+    return myConst.$;
+  };
+
+  const test = () => {
+    'use gpu';
+    const COLLISION = 1;
+    helper();
+    const x = COLLISION;
+    const y = myConst.$;
+  };
+
+  expect(tgpu.resolve([test])).toMatchInlineSnapshot(`
+    "const COLLISION_1: u32 = 1u;
+
+    fn helper() -> u32 {
+      return COLLISION_1;
+    }
+
+    fn test() {
+      const COLLISION = 1;
+      helper();
+      let x = COLLISION;
+      const y = COLLISION_1;
+    }"
+  `);
+});