Merge pull request 'Improved randomness' (#1505) from glossing/strudel:glossing/random into main

Reviewed-on: https://codeberg.org/uzu/strudel/pulls/1505

packages/core/bench/signal.bench.mjs

@@ -0,0 +1,49 @@
+import { describe, bench } from 'vitest';
+
+import { calculateSteps, rand, useRNG } from '../index.mjs';
+
+const testingResolution = 128;
+
+const _generateRandomPattern = () => rand.iter(testingResolution).fast(testingResolution).firstCycle();
+
+describe('old random', () => {
+  calculateSteps(true);
+  bench(
+    '+tactus',
+    () => {
+      useRNG('legacy');
+      _generateRandomPattern();
+    },
+    {
+      time: 1000,
+      teardown() {
+        useRNG('legacy');
+      },
+    },
+  );
+
+  calculateSteps(false);
+  bench(
+    '-tactus',
+    () => {
+      useRNG('precise');
+      _generateRandomPattern();
+    },
+    {
+      time: 1000,
+      teardown() {
+        useRNG('legacy');
+      },
+    },
+  );
+});
+
+describe('random', () => {
+  calculateSteps(true);
+  bench('+tactus', _generateRandomPattern, { time: 1000 });
+
+  calculateSteps(false);
+  bench('-tactus', _generateRandomPattern, { time: 1000 });
+});
+
+calculateSteps(true);

packages/core/signal.mjs

@@ -16,7 +16,7 @@ export function steady(value) {
 }
 
 export const signal = (func) => {
-  const query = (state) => [new Hap(undefined, state.span, func(state.span.begin))];
+  const query = (state) => [new Hap(undefined, state.span, func(state.span.begin, state.controls))];
   return new Pattern(query);
 };
 
@@ -186,38 +186,97 @@ export const mouseY = signal(() => _mouseY);
 export const mousex = signal(() => _mouseX);
 export const mouseX = signal(() => _mouseX);
 
-// random signals
+// Random number generators
 
-const xorwise = (x) => {
+// Produce "Avalanche effect" where flipping a single bit of x
+// results in all output bits flipping with probability 0.5
+// See e.g. https://github.com/aappleby/smhasher/blob/0ff96f7835817a27d0487325b6c16033e2992eb5/src/MurmurHash3.cpp#L68-L77
+const _murmurHashFinalizer = (x) => {
+  x |= 0;
+  x ^= x >>> 16;
+  x = Math.imul(x, 0x85ebca6b);
+  x ^= x >>> 13;
+  x = Math.imul(x, 0xc2b2ae35);
+  x ^= x >>> 16;
+  return x >>> 0; // unsigned
+};
+
+// Convert t to a 32 bit integer, preserving temporal resolution down to 1/2^29
+const _tToT = (t) => {
+  return Math.floor(t * 536870912);
+};
+
+// Used to decorrelate nearby T, i, and seed prior to hashing
+const _decorrelate = (T, i = 0, seed = 0) => {
+  const lowBits = (T >>> 0) >>> 0;
+  const highBits = Math.floor(T / 4294967296) >>> 0; // 2^32
+  let key = lowBits ^ Math.imul(highBits ^ 0x85ebca6b, 0xc2b2ae35);
+  key ^= Math.imul(i ^ 0x7f4a7c15, 0x9e3779b9);
+  key ^= Math.imul(seed ^ 0x165667b1, 0x27d4eb2d);
+  return key >>> 0;
+};
+
+const randAt = (T, i = 0, seed = 0) => {
+  return _murmurHashFinalizer(_decorrelate(T, i, seed)) / 4294967296; // 2^32
+};
+
+// n samples at time t
+const timeToRands = (t, n, seed = 0) => {
+  const T = _tToT(t);
+  if (n === 1) {
+    return randAt(T, 0, seed);
+  }
+  const out = new Array(n);
+  for (let i = 0; i < n; i++) out[i] = randAt(T, i, seed);
+  return out;
+};
+
+// Old random signals. Currently the default, but can also be chosen via
+// `useRNG('legacy')`
+
+// stretch 300 cycles over the range of [0,2**29 == 536870912) then apply the xorshift algorithm
+const __xorwise = (x) => {
   const a = (x << 13) ^ x;
   const b = (a >> 17) ^ a;
   return (b << 5) ^ b;
 };
-
-// stretch 300 cycles over the range of [0,2**29 == 536870912) then apply the xorshift algorithm
-const _frac = (x) => x - Math.trunc(x);
-
-const timeToIntSeed = (x) => xorwise(Math.trunc(_frac(x / 300) * 536870912));
-
-const intSeedToRand = (x) => (x % 536870912) / 536870912;
-
-const timeToRand = (x) => Math.abs(intSeedToRand(timeToIntSeed(x)));
-
-const timeToRandsPrime = (seed, n) => {
+const __frac = (x) => x - Math.trunc(x);
+const __timeToIntSeed = (x) => __xorwise(Math.trunc(__frac(x / 300) * 536870912));
+const __intSeedToRand = (x) => (x % 536870912) / 536870912;
+const __timeToRandsPrime = (seed, n) => {
+  if (n === 1) {
+    return Math.abs(__intSeedToRand(seed));
+  }
   const result = [];
-  // eslint-disable-next-line
-  for (let i = 0; i < n; ++i) {
-    result.push(intSeedToRand(seed));
-    seed = xorwise(seed);
+  for (let i = 0; i < n; i++) {
+    result.push(__intSeedToRand(seed));
+    seed = __xorwise(seed);
   }
   return result;
 };
+const __timeToRands = (t, n) => __timeToRandsPrime(__timeToIntSeed(t), n);
 
-const timeToRands = (t, n) => timeToRandsPrime(timeToIntSeed(t), n);
+// End old random
+
+let RNG_MODE = 'legacy';
+export const getRandsAtTime = (t, n = 1, seed = 0) => {
+  return RNG_MODE === 'legacy' ? __timeToRands(t + seed, n) : timeToRands(t, n, seed);
+};
 
 /**
+ * Sets which random number generator to use. Historically Strudel would
+ * use `useRNG('legacy')`, which remains the default. To use a new more statistically
+ * precise RNG, try `useRNG('precise')`.
  *
+ * @name useRNG
+ * @param {string} mod - Mode. One of 'legacy', 'precise'
+ * @example
+ * useRNG('legacy')
+ * // Repeats every 300 cycles
+ * $: n(irand(50)).seg(16).scale("C:minor").ribbon(88, 32)
+ * $: n(irand(50)).seg(16).scale("C:minor").ribbon(388, 32)
  */
+export const useRNG = (mode = 'legacy') => (RNG_MODE = mode);
 
 /**
  * A discrete pattern of numbers from 0 to n-1
@@ -300,13 +359,13 @@ export const binaryNL = (n, nBits = 16) => {
  *   .partials(randL(8))
  */
 export const randL = (n) => {
-  return signal((t) => (nVal) => timeToRands(t, nVal).map(Math.abs)).appLeft(reify(n));
+  return signal((t) => (nVal) => getRandsAtTime(t, nVal).map(Math.abs)).appLeft(reify(n));
 };
 
 export const randrun = (n) => {
-  return signal((t) => {
+  return signal((t, controls) => {
     // Without adding 0.5, the first cycle is always 0,1,2,3,...
-    const rands = timeToRands(t.floor().add(0.5), n);
+    const rands = getRandsAtTime(t.floor().add(0.5), n, controls.randSeed);
     const nums = rands
       .map((n, i) => [n, i])
       .sort((a, b) => (a[0] > b[0]) - (a[0] < b[0]))
@@ -347,6 +406,37 @@ export const scramble = register('scramble', (n, pat) => {
   return _rearrangeWith(_irand(n)._segment(n), n, pat);
 });
 
+/**
+ * Modify a pattern by applying a function to the `randomSeed` control if present
+ *
+ * @param {Function} func Function from seed (or undefined) to seed (or undefined)
+ * @param {Pattern} pat Pattern to update
+ * @returns Pattern
+ */
+export const withSeed = (func, pat) => {
+  return new Pattern((state) => {
+    let { randSeed, ...controls } = state.controls;
+    randSeed = func(randSeed);
+    return pat.query(state.setControls({ ...controls, randSeed }));
+  }, pat._steps);
+};
+
+/**
+ * Change the seed for random signals. Normally, random signals depend on time,
+ * so two patterns at the same time will have the same random values. Specifying
+ * a new seed changes the signal output by `rand`. This also affects other functions
+ * that use randomness, like `shuffle` and `sometimes`.
+ *
+ * @name seed
+ * @param {number} n A new seed. Can be any number.
+ * @example
+ * $: s("hh*4").degrade();
+ * $: s("bd*4").degrade().seed(1); // Will degrade different events from the hi-hat
+ */
+export const seed = register('seed', (n, pat) => {
+  return withSeed(() => n, pat);
+});
+
 /**
  * A continuous pattern of random numbers, between 0 and 1.
  *
@@ -356,7 +446,7 @@ export const scramble = register('scramble', (n, pat) => {
  * s("bd*4,hh*8").cutoff(rand.range(500,8000))
  *
  */
-export const rand = signal(timeToRand);
+export const rand = signal((t, controls) => getRandsAtTime(t, 1, controls.randSeed));
 /**
  * A continuous pattern of random numbers, between -1 and 1
  */
@@ -533,36 +623,32 @@ export const wchooseCycles = (...pairs) => _wchooseWith(rand.segment(1), ...pair
 
 export const wrandcat = wchooseCycles;
 
-function _perlin(t) {
+function _perlin(t, seed = 0) {
   let ta = Math.floor(t);
   let tb = ta + 1;
   const smootherStep = (x) => 6.0 * x ** 5 - 15.0 * x ** 4 + 10.0 * x ** 3;
   const interp = (x) => (a) => (b) => a + smootherStep(x) * (b - a);
-  const v = interp(t - ta)(timeToRand(ta))(timeToRand(tb));
+  const ra = getRandsAtTime(ta, 1, seed);
+  const rb = getRandsAtTime(tb, 1, seed);
+  const v = interp(t - ta)(ra)(rb);
   return v;
 }
-export const perlinWith = (tpat) => {
-  return tpat.fmap(_perlin);
-};
 
-function _berlin(t) {
+function _berlin(t, seed = 0) {
   const prevRidgeStartIndex = Math.floor(t);
   const nextRidgeStartIndex = prevRidgeStartIndex + 1;
 
-  const prevRidgeBottomPoint = timeToRand(prevRidgeStartIndex);
-  const nextRidgeTopPoint = timeToRand(nextRidgeStartIndex) + prevRidgeBottomPoint;
+  const prevRidgeBottomPoint = getRandsAtTime(prevRidgeStartIndex, 1, seed);
+  const height = getRandsAtTime(nextRidgeStartIndex, 1, seed);
+  const nextRidgeTopPoint = prevRidgeBottomPoint + height;
 
   const currentPercent = (t - prevRidgeStartIndex) / (nextRidgeStartIndex - prevRidgeStartIndex);
   const interp = (a, b, t) => {
-    return a + (b - a) * t;
+    return a + t * (b - a);
   };
   return interp(prevRidgeBottomPoint, nextRidgeTopPoint, currentPercent) / 2;
 }
 
-export const berlinWith = (tpat) => {
-  return tpat.fmap(_berlin);
-};
-
 /**
  * Generates a continuous pattern of [perlin noise](https://en.wikipedia.org/wiki/Perlin_noise), in the range 0..1.
  *
@@ -572,7 +658,7 @@ export const berlinWith = (tpat) => {
  * s("bd*4,hh*8").cutoff(perlin.range(500,8000))
  *
  */
-export const perlin = perlinWith(time.fmap((v) => Number(v)));
+export const perlin = signal((t, controls) => _perlin(t, controls.randSeed));
 
 /**
  * Generates a continuous pattern of [berlin noise](conceived by Jame Coyne and Jade Rowland as a joke but turned out to be surprisingly cool and useful,
@@ -584,7 +670,7 @@ export const perlin = perlinWith(time.fmap((v) => Number(v)));
  * n("0!16".add(berlin.fast(4).mul(14))).scale("d:minor")
  *
  */
-export const berlin = berlinWith(time.fmap((v) => Number(v)));
+export const berlin = signal((t, controls) => _berlin(t, controls.randSeed));
 
 export const degradeByWith = register(
   'degradeByWith',

packages/superdough/superdough.mjs

@@ -30,6 +30,17 @@ const DEFAULT_AUDIO_DEVICE_NAME = 'System Standard';
 
 let maxPolyphony = DEFAULT_MAX_POLYPHONY;
 
+/**
+ * Set the max polyphony. If notes are ringing out via `release` then they will
+ * start to die out in first-in-first-out order once the max polyphony has been hit
+ *
+ * @name setMaxPolyphony
+ * @param {number} Max polyphony. Defaults to 128
+ * @example
+ * setMaxPolyphony(4)
+ * n(irand(24).seg(8)).scale("C#3:minor").room(1).release(4).gain(0.5)
+ *
+ */
 export function setMaxPolyphony(polyphony) {
   maxPolyphony = parseInt(polyphony) ?? DEFAULT_MAX_POLYPHONY;
 }
@@ -52,6 +63,17 @@ export function applyGainCurve(val) {
   return gainCurveFunc(val);
 }
 
+/**
+ * Apply a function to all gains provided in patterns. Can be used to rescale gain to be
+ * quadratic, exponential, etc. rather than linear
+ *
+ * @name setGainCurve
+ * @param {Function} function to apply to all gain values
+ * @example
+ * setGainCurve((x) => x * x) // quadratic gain
+ * s("bd*4").gain(0.5) // equivalent to 0.25 gain normally
+ *
+ */
 export function setGainCurve(newGainCurveFunc) {
   gainCurveFunc = newGainCurveFunc;
 }

test/__snapshots__/examples.test.mjs.snap

@@ -10343,6 +10343,18 @@ exports[`runs examples > example "scrub" example index 1 1`] = `
 ]
 `;
 
+exports[`runs examples > example "seed" example index 0 1`] = `
+[
+  "[ 0/1 → 1/4 | s:bd ]",
+  "[ 1/4 → 1/2 | s:bd ]",
+  "[ 1/2 → 3/4 | s:bd ]",
+  "[ 1/1 → 5/4 | s:bd ]",
+  "[ 7/4 → 2/1 | s:bd ]",
+  "[ 9/4 → 5/2 | s:bd ]",
+  "[ 11/4 → 3/1 | s:bd ]",
+]
+`;
+
 exports[`runs examples > example "segment" example index 0 1`] = `
 [
   "[ 0/1 → 1/24 | note:40 ]",
@@ -10526,6 +10538,64 @@ exports[`runs examples > example "seqPLoop" example index 0 1`] = `
 ]
 `;
 
+exports[`runs examples > example "setGainCurve" example index 0 1`] = `
+[
+  "[ 0/1 → 1/4 | s:bd gain:0.5 ]",
+  "[ 1/4 → 1/2 | s:bd gain:0.5 ]",
+  "[ 1/2 → 3/4 | s:bd gain:0.5 ]",
+  "[ 3/4 → 1/1 | s:bd gain:0.5 ]",
+  "[ 1/1 → 5/4 | s:bd gain:0.5 ]",
+  "[ 5/4 → 3/2 | s:bd gain:0.5 ]",
+  "[ 3/2 → 7/4 | s:bd gain:0.5 ]",
+  "[ 7/4 → 2/1 | s:bd gain:0.5 ]",
+  "[ 2/1 → 9/4 | s:bd gain:0.5 ]",
+  "[ 9/4 → 5/2 | s:bd gain:0.5 ]",
+  "[ 5/2 → 11/4 | s:bd gain:0.5 ]",
+  "[ 11/4 → 3/1 | s:bd gain:0.5 ]",
+  "[ 3/1 → 13/4 | s:bd gain:0.5 ]",
+  "[ 13/4 → 7/2 | s:bd gain:0.5 ]",
+  "[ 7/2 → 15/4 | s:bd gain:0.5 ]",
+  "[ 15/4 → 4/1 | s:bd gain:0.5 ]",
+]
+`;
+
+exports[`runs examples > example "setMaxPolyphony" example index 0 1`] = `
+[
+  "[ 0/1 → 1/8 | note:C#3 room:1 release:4 gain:0.5 ]",
+  "[ 1/8 → 1/4 | note:E5 room:1 release:4 gain:0.5 ]",
+  "[ 1/4 → 3/8 | note:D#4 room:1 release:4 gain:0.5 ]",
+  "[ 3/8 → 1/2 | note:E4 room:1 release:4 gain:0.5 ]",
+  "[ 1/2 → 5/8 | note:B3 room:1 release:4 gain:0.5 ]",
+  "[ 5/8 → 3/4 | note:F#3 room:1 release:4 gain:0.5 ]",
+  "[ 3/4 → 7/8 | note:G#3 room:1 release:4 gain:0.5 ]",
+  "[ 7/8 → 1/1 | note:E4 room:1 release:4 gain:0.5 ]",
+  "[ 1/1 → 9/8 | note:A4 room:1 release:4 gain:0.5 ]",
+  "[ 9/8 → 5/4 | note:E5 room:1 release:4 gain:0.5 ]",
+  "[ 5/4 → 11/8 | note:F#5 room:1 release:4 gain:0.5 ]",
+  "[ 11/8 → 3/2 | note:G#3 room:1 release:4 gain:0.5 ]",
+  "[ 3/2 → 13/8 | note:C#5 room:1 release:4 gain:0.5 ]",
+  "[ 13/8 → 7/4 | note:G#4 room:1 release:4 gain:0.5 ]",
+  "[ 7/4 → 15/8 | note:G#3 room:1 release:4 gain:0.5 ]",
+  "[ 15/8 → 2/1 | note:C#5 room:1 release:4 gain:0.5 ]",
+  "[ 2/1 → 17/8 | note:E6 room:1 release:4 gain:0.5 ]",
+  "[ 17/8 → 9/4 | note:C#6 room:1 release:4 gain:0.5 ]",
+  "[ 9/4 → 19/8 | note:D#4 room:1 release:4 gain:0.5 ]",
+  "[ 19/8 → 5/2 | note:B5 room:1 release:4 gain:0.5 ]",
+  "[ 5/2 → 21/8 | note:G#4 room:1 release:4 gain:0.5 ]",
+  "[ 21/8 → 11/4 | note:F#3 room:1 release:4 gain:0.5 ]",
+  "[ 11/4 → 23/8 | note:D#5 room:1 release:4 gain:0.5 ]",
+  "[ 23/8 → 3/1 | note:C#3 room:1 release:4 gain:0.5 ]",
+  "[ 3/1 → 25/8 | note:A3 room:1 release:4 gain:0.5 ]",
+  "[ 25/8 → 13/4 | note:D#4 room:1 release:4 gain:0.5 ]",
+  "[ 13/4 → 27/8 | note:E6 room:1 release:4 gain:0.5 ]",
+  "[ 27/8 → 7/2 | note:E4 room:1 release:4 gain:0.5 ]",
+  "[ 7/2 → 29/8 | note:E4 room:1 release:4 gain:0.5 ]",
+  "[ 29/8 → 15/4 | note:D#6 room:1 release:4 gain:0.5 ]",
+  "[ 15/4 → 31/8 | note:A5 room:1 release:4 gain:0.5 ]",
+  "[ 31/8 → 4/1 | note:F#5 room:1 release:4 gain:0.5 ]",
+]
+`;
+
 exports[`runs examples > example "setcpm" example index 0 1`] = `
 [
   "[ 0/1 → 1/4 | s:bd bank:tr707 ]",
@@ -12871,6 +12941,75 @@ exports[`runs examples > example "unit" example index 0 1`] = `
 ]
 `;
 
+exports[`runs examples > example "useRNG" example index 0 1`] = `
+[
+  "[ 0/1 → 1/16 | note:D8 ]",
+  "[ 1/16 → 1/8 | note:Bb7 ]",
+  "[ 1/8 → 3/16 | note:Ab6 ]",
+  "[ 3/16 → 1/4 | note:D5 ]",
+  "[ 1/4 → 5/16 | note:Ab9 ]",
+  "[ 5/16 → 3/8 | note:D3 ]",
+  "[ 3/8 → 7/16 | note:G5 ]",
+  "[ 7/16 → 1/2 | note:G3 ]",
+  "[ 1/2 → 9/16 | note:Ab3 ]",
+  "[ 9/16 → 5/8 | note:Eb6 ]",
+  "[ 5/8 → 11/16 | note:Eb6 ]",
+  "[ 11/16 → 3/4 | note:Eb5 ]",
+  "[ 3/4 → 13/16 | note:G7 ]",
+  "[ 13/16 → 7/8 | note:Bb5 ]",
+  "[ 7/8 → 15/16 | note:D3 ]",
+  "[ 15/16 → 1/1 | note:Eb7 ]",
+  "[ 1/1 → 17/16 | note:Eb9 ]",
+  "[ 17/16 → 9/8 | note:G8 ]",
+  "[ 9/8 → 19/16 | note:Ab3 ]",
+  "[ 19/16 → 5/4 | note:Ab5 ]",
+  "[ 5/4 → 21/16 | note:C10 ]",
+  "[ 21/16 → 11/8 | note:C7 ]",
+  "[ 11/8 → 23/16 | note:G5 ]",
+  "[ 23/16 → 3/2 | note:Ab7 ]",
+  "[ 3/2 → 25/16 | note:G6 ]",
+  "[ 25/16 → 13/8 | note:Bb6 ]",
+  "[ 13/8 → 27/16 | note:Eb9 ]",
+  "[ 27/16 → 7/4 | note:G9 ]",
+  "[ 7/4 → 29/16 | note:G7 ]",
+  "[ 29/16 → 15/8 | note:C10 ]",
+  "[ 15/8 → 31/16 | note:Eb3 ]",
+  "[ 31/16 → 2/1 | note:Ab7 ]",
+  "[ 2/1 → 33/16 | note:F6 ]",
+  "[ 33/16 → 17/8 | note:C5 ]",
+  "[ 17/8 → 35/16 | note:Ab4 ]",
+  "[ 35/16 → 9/4 | note:G5 ]",
+  "[ 9/4 → 37/16 | note:C9 ]",
+  "[ 37/16 → 19/8 | note:Eb6 ]",
+  "[ 19/8 → 39/16 | note:C9 ]",
+  "[ 39/16 → 5/2 | note:Eb9 ]",
+  "[ 5/2 → 41/16 | note:D5 ]",
+  "[ 41/16 → 21/8 | note:F5 ]",
+  "[ 21/8 → 43/16 | note:F9 ]",
+  "[ 43/16 → 11/4 | note:Bb7 ]",
+  "[ 11/4 → 45/16 | note:Ab6 ]",
+  "[ 45/16 → 23/8 | note:Bb9 ]",
+  "[ 23/8 → 47/16 | note:C8 ]",
+  "[ 47/16 → 3/1 | note:Eb5 ]",
+  "[ 3/1 → 49/16 | note:F3 ]",
+  "[ 49/16 → 25/8 | note:G4 ]",
+  "[ 25/8 → 51/16 | note:D7 ]",
+  "[ 51/16 → 13/4 | note:D4 ]",
+  "[ 13/4 → 53/16 | note:F8 ]",
+  "[ 53/16 → 27/8 | note:C7 ]",
+  "[ 27/8 → 55/16 | note:Ab5 ]",
+  "[ 55/16 → 7/2 | note:Ab3 ]",
+  "[ 7/2 → 57/16 | note:F9 ]",
+  "[ 57/16 → 29/8 | note:D8 ]",
+  "[ 29/8 → 59/16 | note:F5 ]",
+  "[ 59/16 → 15/4 | note:Eb9 ]",
+  "[ 15/4 → 61/16 | note:Bb4 ]",
+  "[ 61/16 → 31/8 | note:C6 ]",
+  "[ 31/8 → 63/16 | note:C4 ]",
+  "[ 63/16 → 4/1 | note:G8 ]",
+]
+`;
+
 exports[`runs examples > example "velocity" example index 0 1`] = `
 [
   "[ 0/1 → 1/8 | s:hh gain:0.4 velocity:0.4 ]",

vitest.config.mjs

@@ -16,5 +16,6 @@ export default defineConfig({
       '**/{karma,rollup,webpack,vite,vitest,jest,ava,babel,nyc,cypress}.config.*',
       '**/shared.test.mjs',
     ],
+    setupFiles: './vitest.setup.mjs',
   },
 });

vitest.setup.mjs

@@ -0,0 +1,7 @@
+import { afterEach } from 'vitest';
+import { useRNG } from './packages/core/signal.mjs';
+
+afterEach(() => {
+  // Avoid bleed between tests
+  useRNG('legacy');
+});

website/src/repl/tunes.mjs

@@ -393,6 +393,8 @@ samples({
   bass: { d2: 'https://cdn.freesound.org/previews/608/608286_13074022-lq.mp3' }
 })
 
+useRNG('legacy')
+
 stack(
   // bells
   n("0").euclidLegato(3,8)
@@ -430,6 +432,7 @@ export const festivalOfFingers3 = `// "Festival of fingers 3"
 // @by Felix Roos
 
 setcps(1)
+useRNG('legacy')
 
 n("[-7*3],0,2,6,[8 7]")
   .echoWith(
@@ -454,6 +457,8 @@ export const meltingsubmarine = `// "Melting submarine"
 // @by Felix Roos
 
 samples('github:tidalcycles/dirt-samples')
+useRNG('legacy')
+
 stack(
   s("bd:5,[~ <sd:1!3 sd:1(3,4,3)>],hh27(3,4,1)") // drums
   .speed(perlin.range(.7,.9)) // random sample speed variation
@@ -602,6 +607,9 @@ export const belldub = `// "Belldub"
 
 samples({ bell: {b4:'https://cdn.freesound.org/previews/339/339809_5121236-lq.mp3'}})
 // "Hand Bells, B, Single.wav" by InspectorJ (www.jshaw.co.uk) of Freesound.org
+
+useRNG('legacy')
+
 stack(
   // bass
   note("[0 ~] [2 [0 2]] [4 4*2] [[4 ~] [2 ~] 0@2]".scale('g1 dorian').superimpose(x=>x.add(.02)))
@@ -638,6 +646,7 @@ export const dinofunk = `// "Dinofunk"
 // @by Felix Roos
 
 setcps(1)
+useRNG('legacy')
 
 samples({bass:'https://cdn.freesound.org/previews/614/614637_2434927-hq.mp3',
 dino:{b4:'https://cdn.freesound.org/previews/316/316403_5123851-hq.mp3'}})
@@ -666,6 +675,8 @@ export const sampleDemo = `// "Sample demo"
 // @license CC BY-NC-SA 4.0 https://creativecommons.org/licenses/by-nc-sa/4.0/
 // @by Felix Roos
 
+useRNG('legacy')
+
 stack(
   // percussion
   s("[woodblock:1 woodblock:2*2] snare_rim:0,gong/8,brakedrum:1(3,8),~@3 cowbell:3")
@@ -684,6 +695,8 @@ export const holyflute = `// "Holy flute"
 // @license CC BY-NC-SA 4.0 https://creativecommons.org/licenses/by-nc-sa/4.0/
 // @by Felix Roos
 
+useRNG('legacy')
+
 "c3 eb3(3,8) c4/2 g3*2"
 .superimpose(
   x=>x.slow(2).add(12),
@@ -699,6 +712,8 @@ export const flatrave = `// "Flatrave"
 // @license CC BY-NC-SA 4.0 https://creativecommons.org/licenses/by-nc-sa/4.0/
 // @by Felix Roos
 
+useRNG('legacy')
+
 stack(
   s("bd*2,~ [cp,sd]").bank('RolandTR909'),
   
@@ -727,6 +742,8 @@ export const amensister = `// "Amensister"
 
 samples('github:tidalcycles/dirt-samples')
 
+useRNG('legacy')
+
 stack(
   // amen
   n("0 1 2 3 4 5 6 7")
@@ -834,6 +851,8 @@ export const arpoon = `// "Arpoon"
 // @license CC BY-NC-SA 4.0 https://creativecommons.org/licenses/by-nc-sa/4.0/
 // @by Felix Roos
 
+useRNG('legacy')
+
 samples('github:tidalcycles/dirt-samples')
 
 n("[0,3] 2 [1,3] 2".fast(3).lastOf(4, fast(2))).clip(2)