diff --git a/benchmarking/benchmarks.js b/benchmarking/benchmarks.js
index 283112dbe3..795ac3e09e 100644
--- a/benchmarking/benchmarks.js
+++ b/benchmarking/benchmarks.js
@@ -1,24 +1,58 @@
-import { kairo_avoidable } from './benchmarks/kairo/kairo_avoidable.js';
-import { kairo_broad } from './benchmarks/kairo/kairo_broad.js';
-import { kairo_deep } from './benchmarks/kairo/kairo_deep.js';
-import { kairo_diamond } from './benchmarks/kairo/kairo_diamond.js';
-import { kairo_mux } from './benchmarks/kairo/kairo_mux.js';
-import { kairo_repeated } from './benchmarks/kairo/kairo_repeated.js';
-import { kairo_triangle } from './benchmarks/kairo/kairo_triangle.js';
-import { kairo_unstable } from './benchmarks/kairo/kairo_unstable.js';
-import { mol_bench } from './benchmarks/mol_bench.js';
+import {
+	kairo_avoidable_owned,
+	kairo_avoidable_unowned
+} from './benchmarks/kairo/kairo_avoidable.js';
+import { kairo_broad_owned, kairo_broad_unowned } from './benchmarks/kairo/kairo_broad.js';
+import { kairo_deep_owned, kairo_deep_unowned } from './benchmarks/kairo/kairo_deep.js';
+import { kairo_diamond_owned, kairo_diamond_unowned } from './benchmarks/kairo/kairo_diamond.js';
+import { kairo_mux_unowned, kairo_mux_owned } from './benchmarks/kairo/kairo_mux.js';
+import { kairo_repeated_unowned, kairo_repeated_owned } from './benchmarks/kairo/kairo_repeated.js';
+import { kairo_triangle_owned, kairo_triangle_unowned } from './benchmarks/kairo/kairo_triangle.js';
+import { kairo_unstable_owned, kairo_unstable_unowned } from './benchmarks/kairo/kairo_unstable.js';
+import { mol_bench_owned, mol_bench_unowned } from './benchmarks/mol_bench.js';
+import {
+	sbench_create_0to1,
+	sbench_create_1000to1,
+	sbench_create_1to1,
+	sbench_create_1to1000,
+	sbench_create_1to2,
+	sbench_create_1to4,
+	sbench_create_1to8,
+	sbench_create_2to1,
+	sbench_create_4to1,
+	sbench_create_signals
+} from './benchmarks/sbench.js';
 
 // This benchmark has been adapted from the js-reactivity-benchmark (https://github.com/milomg/js-reactivity-benchmark)
 // Not all tests are the same, and many parts have been tweaked to capture different data.
 
 export const benchmarks = [
-	kairo_avoidable,
-	kairo_broad,
-	kairo_deep,
-	kairo_diamond,
-	kairo_triangle,
-	kairo_mux,
-	kairo_repeated,
-	kairo_unstable,
-	mol_bench
+	sbench_create_signals,
+	sbench_create_0to1,
+	sbench_create_1to1,
+	sbench_create_2to1,
+	sbench_create_4to1,
+	sbench_create_1000to1,
+	sbench_create_1to2,
+	sbench_create_1to4,
+	sbench_create_1to8,
+	sbench_create_1to1000,
+	kairo_avoidable_owned,
+	kairo_avoidable_unowned,
+	kairo_broad_owned,
+	kairo_broad_unowned,
+	kairo_deep_owned,
+	kairo_deep_unowned,
+	kairo_diamond_owned,
+	kairo_diamond_unowned,
+	kairo_triangle_owned,
+	kairo_triangle_unowned,
+	kairo_mux_owned,
+	kairo_mux_unowned,
+	kairo_repeated_owned,
+	kairo_repeated_unowned,
+	kairo_unstable_owned,
+	kairo_unstable_unowned,
+	mol_bench_owned,
+	mol_bench_unowned
 ];
diff --git a/benchmarking/benchmarks/kairo/kairo_avoidable.js b/benchmarking/benchmarks/kairo/kairo_avoidable.js
index 636e96ccce..108f79458c 100644
--- a/benchmarking/benchmarks/kairo/kairo_avoidable.js
+++ b/benchmarking/benchmarks/kairo/kairo_avoidable.js
@@ -34,7 +34,7 @@ function setup() {
 	};
 }
 
-export async function kairo_avoidable() {
+export async function kairo_avoidable_unowned() {
 	// Do 10 loops to warm up JIT
 	for (let i = 0; i < 10; i++) {
 		const { run, destroy } = setup();
@@ -53,7 +53,38 @@ export async function kairo_avoidable() {
 	destroy();
 
 	return {
-		benchmark: 'kairo_avoidable',
+		benchmark: 'kairo_avoidable_unowned',
+		time: timing.time.toFixed(2),
+		gc_time: timing.gc_time.toFixed(2)
+	};
+}
+
+export async function kairo_avoidable_owned() {
+	let run, destroy;
+
+	const destroy_owned = $.effect_root(() => {
+		// Do 10 loops to warm up JIT
+		for (let i = 0; i < 10; i++) {
+			const { run, destroy } = setup();
+			run();
+			destroy();
+		}
+
+		({ run, destroy } = setup());
+	});
+
+	const { timing } = await fastest_test(10, () => {
+		for (let i = 0; i < 100; i++) {
+			run();
+		}
+	});
+
+	// @ts-ignore
+	destroy();
+	destroy_owned();
+
+	return {
+		benchmark: 'kairo_avoidable_owned',
 		time: timing.time.toFixed(2),
 		gc_time: timing.gc_time.toFixed(2)
 	};
diff --git a/benchmarking/benchmarks/kairo/kairo_broad.js b/benchmarking/benchmarks/kairo/kairo_broad.js
index 682154f0e3..06ce3cd7b5 100644
--- a/benchmarking/benchmarks/kairo/kairo_broad.js
+++ b/benchmarking/benchmarks/kairo/kairo_broad.js
@@ -28,7 +28,7 @@ function setup() {
 			$.flush_sync(() => {
 				$.set(head, 1);
 			});
-			counter = 0
+			counter = 0;
 			for (let i = 0; i < 50; i++) {
 				$.flush_sync(() => {
 					$.set(head, i);
@@ -40,7 +40,7 @@ function setup() {
 	};
 }
 
-export async function kairo_broad() {
+export async function kairo_broad_unowned() {
 	// Do 10 loops to warm up JIT
 	for (let i = 0; i < 10; i++) {
 		const { run, destroy } = setup();
@@ -59,7 +59,38 @@ export async function kairo_broad() {
 	destroy();
 
 	return {
-		benchmark: 'kairo_broad',
+		benchmark: 'kairo_broad_unowned',
+		time: timing.time.toFixed(2),
+		gc_time: timing.gc_time.toFixed(2)
+	};
+}
+
+export async function kairo_broad_owned() {
+	let run, destroy;
+
+	const destroy_owned = $.effect_root(() => {
+		// Do 10 loops to warm up JIT
+		for (let i = 0; i < 10; i++) {
+			const { run, destroy } = setup();
+			run();
+			destroy();
+		}
+
+		({ run, destroy } = setup());
+	});
+
+	const { timing } = await fastest_test(10, () => {
+		for (let i = 0; i < 100; i++) {
+			run();
+		}
+	});
+
+	// @ts-ignore
+	destroy();
+	destroy_owned();
+
+	return {
+		benchmark: 'kairo_broad_owned',
 		time: timing.time.toFixed(2),
 		gc_time: timing.gc_time.toFixed(2)
 	};
diff --git a/benchmarking/benchmarks/kairo/kairo_deep.js b/benchmarking/benchmarks/kairo/kairo_deep.js
index af985c3e43..ac4ac5641b 100644
--- a/benchmarking/benchmarks/kairo/kairo_deep.js
+++ b/benchmarking/benchmarks/kairo/kairo_deep.js
@@ -8,12 +8,12 @@ function setup() {
 	let head = $.source(0);
 	let current = head;
 	for (let i = 0; i < len; i++) {
-    let c = current;
-    current = $.derived(() => {
-      return $.get(c) + 1;
-    });
-  }
-  let counter = 0;
+		let c = current;
+		current = $.derived(() => {
+			return $.get(c) + 1;
+		});
+	}
+	let counter = 0;
 
 	const destroy = $.effect_root(() => {
 		$.render_effect(() => {
@@ -28,7 +28,7 @@ function setup() {
 			$.flush_sync(() => {
 				$.set(head, 1);
 			});
-			counter = 0
+			counter = 0;
 			for (let i = 0; i < iter; i++) {
 				$.flush_sync(() => {
 					$.set(head, i);
@@ -40,7 +40,7 @@ function setup() {
 	};
 }
 
-export async function kairo_deep() {
+export async function kairo_deep_unowned() {
 	// Do 10 loops to warm up JIT
 	for (let i = 0; i < 10; i++) {
 		const { run, destroy } = setup();
@@ -59,7 +59,38 @@ export async function kairo_deep() {
 	destroy();
 
 	return {
-		benchmark: 'kairo_deep',
+		benchmark: 'kairo_deep_unowned',
+		time: timing.time.toFixed(2),
+		gc_time: timing.gc_time.toFixed(2)
+	};
+}
+
+export async function kairo_deep_owned() {
+	let run, destroy;
+
+	const destroy_owned = $.effect_root(() => {
+		// Do 10 loops to warm up JIT
+		for (let i = 0; i < 10; i++) {
+			const { run, destroy } = setup();
+			run();
+			destroy();
+		}
+
+		({ run, destroy } = setup());
+	});
+
+	const { timing } = await fastest_test(10, () => {
+		for (let i = 0; i < 100; i++) {
+			run();
+		}
+	});
+
+	// @ts-ignore
+	destroy();
+	destroy_owned();
+
+	return {
+		benchmark: 'kairo_deep_owned',
 		time: timing.time.toFixed(2),
 		gc_time: timing.gc_time.toFixed(2)
 	};
diff --git a/benchmarking/benchmarks/kairo/kairo_diamond.js b/benchmarking/benchmarks/kairo/kairo_diamond.js
index 879727c99e..09d65cd89a 100644
--- a/benchmarking/benchmarks/kairo/kairo_diamond.js
+++ b/benchmarking/benchmarks/kairo/kairo_diamond.js
@@ -5,17 +5,17 @@ let width = 5;
 
 function setup() {
 	let head = $.source(0);
-  let current = [];
-  for (let i = 0; i < width; i++) {
-    current.push(
-      $.derived(() => {
-        return $.get(head) + 1;
-      })
-    );
-  }
-  let sum = $.derived(() => {
-    return current.map((x) => $.get(x)).reduce((a, b) => a + b, 0);
-  });
+	let current = [];
+	for (let i = 0; i < width; i++) {
+		current.push(
+			$.derived(() => {
+				return $.get(head) + 1;
+			})
+		);
+	}
+	let sum = $.derived(() => {
+		return current.map((x) => $.get(x)).reduce((a, b) => a + b, 0);
+	});
 	let counter = 0;
 
 	const destroy = $.effect_root(() => {
@@ -44,7 +44,7 @@ function setup() {
 	};
 }
 
-export async function kairo_diamond() {
+export async function kairo_diamond_unowned() {
 	// Do 10 loops to warm up JIT
 	for (let i = 0; i < 10; i++) {
 		const { run, destroy } = setup();
@@ -63,7 +63,38 @@ export async function kairo_diamond() {
 	destroy();
 
 	return {
-		benchmark: 'kairo_diamond',
+		benchmark: 'kairo_diamond_unowned',
+		time: timing.time.toFixed(2),
+		gc_time: timing.gc_time.toFixed(2)
+	};
+}
+
+export async function kairo_diamond_owned() {
+	let run, destroy;
+
+	const destroy_owned = $.effect_root(() => {
+		// Do 10 loops to warm up JIT
+		for (let i = 0; i < 10; i++) {
+			const { run, destroy } = setup();
+			run();
+			destroy();
+		}
+
+		({ run, destroy } = setup());
+	});
+
+	const { timing } = await fastest_test(10, () => {
+		for (let i = 0; i < 100; i++) {
+			run();
+		}
+	});
+
+	// @ts-ignore
+	destroy();
+	destroy_owned();
+
+	return {
+		benchmark: 'kairo_diamond_owned',
 		time: timing.time.toFixed(2),
 		gc_time: timing.gc_time.toFixed(2)
 	};
diff --git a/benchmarking/benchmarks/kairo/kairo_mux.js b/benchmarking/benchmarks/kairo/kairo_mux.js
index d2867f499b..903b8d3758 100644
--- a/benchmarking/benchmarks/kairo/kairo_mux.js
+++ b/benchmarking/benchmarks/kairo/kairo_mux.js
@@ -3,12 +3,12 @@ import * as $ from '../../../packages/svelte/src/internal/client/index.js';
 
 function setup() {
 	let heads = new Array(100).fill(null).map((_) => $.source(0));
-  const mux = $.derived(() => {
-    return Object.fromEntries(heads.map((h) => $.get(h)).entries());
-  });
-  const splited = heads
-    .map((_, index) => $.derived(() => $.get(mux)[index]))
-    .map((x) => $.derived(() => $.get(x) + 1));
+	const mux = $.derived(() => {
+		return Object.fromEntries(heads.map((h) => $.get(h)).entries());
+	});
+	const splited = heads
+		.map((_, index) => $.derived(() => $.get(mux)[index]))
+		.map((x) => $.derived(() => $.get(x) + 1));
 
 	const destroy = $.effect_root(() => {
 		splited.forEach((x) => {
@@ -37,7 +37,7 @@ function setup() {
 	};
 }
 
-export async function kairo_mux() {
+export async function kairo_mux_unowned() {
 	// Do 10 loops to warm up JIT
 	for (let i = 0; i < 10; i++) {
 		const { run, destroy } = setup();
@@ -56,7 +56,38 @@ export async function kairo_mux() {
 	destroy();
 
 	return {
-		benchmark: 'kairo_mux',
+		benchmark: 'kairo_mux_unowned',
+		time: timing.time.toFixed(2),
+		gc_time: timing.gc_time.toFixed(2)
+	};
+}
+
+export async function kairo_mux_owned() {
+	let run, destroy;
+
+	const destroy_owned = $.effect_root(() => {
+		// Do 10 loops to warm up JIT
+		for (let i = 0; i < 10; i++) {
+			const { run, destroy } = setup();
+			run();
+			destroy();
+		}
+
+		({ run, destroy } = setup());
+	});
+
+	const { timing } = await fastest_test(10, () => {
+		for (let i = 0; i < 100; i++) {
+			run();
+		}
+	});
+
+	// @ts-ignore
+	destroy();
+	destroy_owned();
+
+	return {
+		benchmark: 'kairo_mux_owned',
 		time: timing.time.toFixed(2),
 		gc_time: timing.gc_time.toFixed(2)
 	};
diff --git a/benchmarking/benchmarks/kairo/kairo_repeated.js b/benchmarking/benchmarks/kairo/kairo_repeated.js
index fd22c1e563..ef9c284ad0 100644
--- a/benchmarking/benchmarks/kairo/kairo_repeated.js
+++ b/benchmarking/benchmarks/kairo/kairo_repeated.js
@@ -4,14 +4,14 @@ import * as $ from '../../../packages/svelte/src/internal/client/index.js';
 let size = 30;
 
 function setup() {
-  let head = $.source(0);
-  let current = $.derived(() => {
-    let result = 0;
-    for (let i = 0; i < size; i++) {
-      result += $.get(head);
-    }
-    return result;
-  });
+	let head = $.source(0);
+	let current = $.derived(() => {
+		let result = 0;
+		for (let i = 0; i < size; i++) {
+			result += $.get(head);
+		}
+		return result;
+	});
 
 	let counter = 0;
 
@@ -41,7 +41,7 @@ function setup() {
 	};
 }
 
-export async function kairo_repeated() {
+export async function kairo_repeated_unowned() {
 	// Do 10 loops to warm up JIT
 	for (let i = 0; i < 10; i++) {
 		const { run, destroy } = setup();
@@ -60,7 +60,38 @@ export async function kairo_repeated() {
 	destroy();
 
 	return {
-		benchmark: 'kairo_repeated',
+		benchmark: 'kairo_repeated_unowned',
+		time: timing.time.toFixed(2),
+		gc_time: timing.gc_time.toFixed(2)
+	};
+}
+
+export async function kairo_repeated_owned() {
+	let run, destroy;
+
+	const destroy_owned = $.effect_root(() => {
+		// Do 10 loops to warm up JIT
+		for (let i = 0; i < 10; i++) {
+			const { run, destroy } = setup();
+			run();
+			destroy();
+		}
+
+		({ run, destroy } = setup());
+	});
+
+	const { timing } = await fastest_test(10, () => {
+		for (let i = 0; i < 100; i++) {
+			run();
+		}
+	});
+
+	// @ts-ignore
+	destroy();
+	destroy_owned();
+
+	return {
+		benchmark: 'kairo_repeated_owned',
 		time: timing.time.toFixed(2),
 		gc_time: timing.gc_time.toFixed(2)
 	};
diff --git a/benchmarking/benchmarks/kairo/kairo_triangle.js b/benchmarking/benchmarks/kairo/kairo_triangle.js
index 4e8afe1b82..0696efb39e 100644
--- a/benchmarking/benchmarks/kairo/kairo_triangle.js
+++ b/benchmarking/benchmarks/kairo/kairo_triangle.js
@@ -4,26 +4,26 @@ import * as $ from '../../../packages/svelte/src/internal/client/index.js';
 let width = 10;
 
 function count(number) {
-  return new Array(number)
-    .fill(0)
-    .map((_, i) => i + 1)
-    .reduce((x, y) => x + y, 0);
+	return new Array(number)
+		.fill(0)
+		.map((_, i) => i + 1)
+		.reduce((x, y) => x + y, 0);
 }
 
 function setup() {
 	let head = $.source(0);
-  let current = head;
-  let list = [];
-  for (let i = 0; i < width; i++) {
-    let c = current;
-    list.push(current);
-    current = $.derived(() => {
-      return $.get(c) + 1;
-    });
-  }
-  let sum = $.derived(() => {
-    return list.map((x) => $.get(x)).reduce((a, b) => a + b, 0);
-  });
+	let current = head;
+	let list = [];
+	for (let i = 0; i < width; i++) {
+		let c = current;
+		list.push(current);
+		current = $.derived(() => {
+			return $.get(c) + 1;
+		});
+	}
+	let sum = $.derived(() => {
+		return list.map((x) => $.get(x)).reduce((a, b) => a + b, 0);
+	});
 
 	let counter = 0;
 
@@ -54,7 +54,7 @@ function setup() {
 	};
 }
 
-export async function kairo_triangle() {
+export async function kairo_triangle_unowned() {
 	// Do 10 loops to warm up JIT
 	for (let i = 0; i < 10; i++) {
 		const { run, destroy } = setup();
@@ -73,7 +73,38 @@ export async function kairo_triangle() {
 	destroy();
 
 	return {
-		benchmark: 'kairo_triangle',
+		benchmark: 'kairo_triangle_unowned',
+		time: timing.time.toFixed(2),
+		gc_time: timing.gc_time.toFixed(2)
+	};
+}
+
+export async function kairo_triangle_owned() {
+	let run, destroy;
+
+	const destroy_owned = $.effect_root(() => {
+		// Do 10 loops to warm up JIT
+		for (let i = 0; i < 10; i++) {
+			const { run, destroy } = setup();
+			run();
+			destroy();
+		}
+
+		({ run, destroy } = setup());
+	});
+
+	const { timing } = await fastest_test(10, () => {
+		for (let i = 0; i < 100; i++) {
+			run();
+		}
+	});
+
+	// @ts-ignore
+	destroy();
+	destroy_owned();
+
+	return {
+		benchmark: 'kairo_triangle_owned',
 		time: timing.time.toFixed(2),
 		gc_time: timing.gc_time.toFixed(2)
 	};
diff --git a/benchmarking/benchmarks/kairo/kairo_unstable.js b/benchmarking/benchmarks/kairo/kairo_unstable.js
index 0185d12868..3e7120d6d2 100644
--- a/benchmarking/benchmarks/kairo/kairo_unstable.js
+++ b/benchmarking/benchmarks/kairo/kairo_unstable.js
@@ -2,16 +2,16 @@ import { assert, fastest_test } from '../../utils.js';
 import * as $ from '../../../packages/svelte/src/internal/client/index.js';
 
 function setup() {
-  let head = $.source(0);
-  const double = $.derived(() => $.get(head) * 2);
-  const inverse = $.derived(() => -$.get(head));
-  let current = $.derived(() => {
-    let result = 0;
-    for (let i = 0; i < 20; i++) {
-      result += $.get(head) % 2 ? $.get(double) : $.get(inverse);
-    }
-    return result;
-  });
+	let head = $.source(0);
+	const double = $.derived(() => $.get(head) * 2);
+	const inverse = $.derived(() => -$.get(head));
+	let current = $.derived(() => {
+		let result = 0;
+		for (let i = 0; i < 20; i++) {
+			result += $.get(head) % 2 ? $.get(double) : $.get(inverse);
+		}
+		return result;
+	});
 
 	let counter = 0;
 
@@ -40,7 +40,7 @@ function setup() {
 	};
 }
 
-export async function kairo_unstable() {
+export async function kairo_unstable_unowned() {
 	// Do 10 loops to warm up JIT
 	for (let i = 0; i < 10; i++) {
 		const { run, destroy } = setup();
@@ -59,7 +59,38 @@ export async function kairo_unstable() {
 	destroy();
 
 	return {
-		benchmark: 'kairo_unstable',
+		benchmark: 'kairo_unstable_unowned',
+		time: timing.time.toFixed(2),
+		gc_time: timing.gc_time.toFixed(2)
+	};
+}
+
+export async function kairo_unstable_owned() {
+	let run, destroy;
+
+	const destroy_owned = $.effect_root(() => {
+		// Do 10 loops to warm up JIT
+		for (let i = 0; i < 10; i++) {
+			const { run, destroy } = setup();
+			run();
+			destroy();
+		}
+
+		({ run, destroy } = setup());
+	});
+
+	const { timing } = await fastest_test(10, () => {
+		for (let i = 0; i < 100; i++) {
+			run();
+		}
+	});
+
+	// @ts-ignore
+	destroy();
+	destroy_owned();
+
+	return {
+		benchmark: 'kairo_unstable_owned',
 		time: timing.time.toFixed(2),
 		gc_time: timing.gc_time.toFixed(2)
 	};
diff --git a/benchmarking/benchmarks/mol_bench.js b/benchmarking/benchmarks/mol_bench.js
index 7fa49d7df4..adb4aceb23 100644
--- a/benchmarking/benchmarks/mol_bench.js
+++ b/benchmarking/benchmarks/mol_bench.js
@@ -64,7 +64,38 @@ function setup() {
 	};
 }
 
-export async function mol_bench() {
+export async function mol_bench_owned() {
+	let run, destroy;
+
+	const destroy_owned = $.effect_root(() => {
+		// Do 10 loops to warm up JIT
+		for (let i = 0; i < 10; i++) {
+			const { run, destroy } = setup();
+			run(0);
+			destroy();
+		}
+
+		({ run, destroy } = setup());
+	});
+
+	const { timing } = await fastest_test(10, () => {
+		for (let i = 0; i < 1e4; i++) {
+			run(i);
+		}
+	});
+
+	// @ts-ignore
+	destroy();
+	destroy_owned();
+
+	return {
+		benchmark: 'mol_bench_owned',
+		time: timing.time.toFixed(2),
+		gc_time: timing.gc_time.toFixed(2)
+	};
+}
+
+export async function mol_bench_unowned() {
 	// Do 10 loops to warm up JIT
 	for (let i = 0; i < 10; i++) {
 		const { run, destroy } = setup();
@@ -83,7 +114,7 @@ export async function mol_bench() {
 	destroy();
 
 	return {
-		benchmark: 'mol_bench',
+		benchmark: 'mol_bench_unowned',
 		time: timing.time.toFixed(2),
 		gc_time: timing.gc_time.toFixed(2)
 	};
diff --git a/benchmarking/benchmarks/sbench.js b/benchmarking/benchmarks/sbench.js
new file mode 100644
index 0000000000..9bc0cee83c
--- /dev/null
+++ b/benchmarking/benchmarks/sbench.js
@@ -0,0 +1,339 @@
+import { fastest_test } from '../utils.js';
+import * as $ from '../../packages/svelte/src/internal/client/index.js';
+
+const COUNT = 1e5;
+
+/**
+ * @param {number} n
+ * @param {any[]} sources
+ */
+function create_data_signals(n, sources) {
+	for (let i = 0; i < n; i++) {
+		sources[i] = $.source(i);
+	}
+	return sources;
+}
+
+/**
+ * @param {number} i
+ */
+function create_computation_0(i) {
+	$.derived(() => i);
+}
+
+/**
+ * @param {any} s1
+ */
+function create_computation_1(s1) {
+	$.derived(() => $.get(s1));
+}
+/**
+ * @param {any} s1
+ * @param {any} s2
+ */
+function create_computation_2(s1, s2) {
+	$.derived(() => $.get(s1) + $.get(s2));
+}
+
+function create_computation_1000(ss, offset) {
+	$.derived(() => {
+		let sum = 0;
+		for (let i = 0; i < 1000; i++) {
+			sum += $.get(ss[offset + i]);
+		}
+		return sum;
+	});
+}
+
+/**
+ * @param {number} n
+ */
+function create_computations_0to1(n) {
+	for (let i = 0; i < n; i++) {
+		create_computation_0(i);
+	}
+}
+
+/**
+ * @param {number} n
+ * @param {any[]} sources
+ */
+function create_computations_1to1(n, sources) {
+	for (let i = 0; i < n; i++) {
+		const source = sources[i];
+		create_computation_1(source);
+	}
+}
+
+/**
+ * @param {number} n
+ * @param {any[]} sources
+ */
+function create_computations_2to1(n, sources) {
+	for (let i = 0; i < n; i++) {
+		create_computation_2(sources[i * 2], sources[i * 2 + 1]);
+	}
+}
+
+function create_computation_4(s1, s2, s3, s4) {
+	$.derived(() => $.get(s1) + $.get(s2) + $.get(s3) + $.get(s4));
+}
+
+function create_computations_1000to1(n, sources) {
+	for (let i = 0; i < n; i++) {
+		create_computation_1000(sources, i * 1000);
+	}
+}
+
+function create_computations_1to2(n, sources) {
+	for (let i = 0; i < n / 2; i++) {
+		const source = sources[i];
+		create_computation_1(source);
+		create_computation_1(source);
+	}
+}
+
+function create_computations_1to4(n, sources) {
+	for (let i = 0; i < n / 4; i++) {
+		const source = sources[i];
+		create_computation_1(source);
+		create_computation_1(source);
+		create_computation_1(source);
+		create_computation_1(source);
+	}
+}
+
+function create_computations_1to8(n, sources) {
+	for (let i = 0; i < n / 8; i++) {
+		const source = sources[i];
+		create_computation_1(source);
+		create_computation_1(source);
+		create_computation_1(source);
+		create_computation_1(source);
+		create_computation_1(source);
+		create_computation_1(source);
+		create_computation_1(source);
+		create_computation_1(source);
+	}
+}
+
+function create_computations_1to1000(n, sources) {
+	for (let i = 0; i < n / 1000; i++) {
+		const source = sources[i];
+		for (let j = 0; j < 1000; j++) {
+			create_computation_1(source);
+		}
+	}
+}
+
+function create_computations_4to1(n, sources) {
+	for (let i = 0; i < n; i++) {
+		create_computation_4(
+			sources[i * 4],
+			sources[i * 4 + 1],
+			sources[i * 4 + 2],
+			sources[i * 4 + 3]
+		);
+	}
+}
+
+/**
+ * @param {any} fn
+ * @param {number} count
+ * @param {number} scount
+ */
+function bench(fn, count, scount) {
+	let sources = create_data_signals(scount, []);
+
+	fn(count, sources);
+}
+
+export async function sbench_create_signals() {
+	// Do 3 loops to warm up JIT
+	for (let i = 0; i < 3; i++) {
+		bench(create_data_signals, COUNT, COUNT);
+	}
+
+	const { timing } = await fastest_test(10, () => {
+		for (let i = 0; i < 100; i++) {
+			bench(create_data_signals, COUNT, COUNT);
+		}
+	});
+
+	return {
+		benchmark: 'sbench_create_signals',
+		time: timing.time.toFixed(2),
+		gc_time: timing.gc_time.toFixed(2)
+	};
+}
+
+export async function sbench_create_0to1() {
+	// Do 3 loops to warm up JIT
+	for (let i = 0; i < 3; i++) {
+		bench(create_computations_0to1, COUNT, 0);
+	}
+
+	const { timing } = await fastest_test(10, () => {
+		for (let i = 0; i < 100; i++) {
+			bench(create_computations_0to1, COUNT, 0);
+		}
+	});
+
+	return {
+		benchmark: 'sbench_create_0to1',
+		time: timing.time.toFixed(2),
+		gc_time: timing.gc_time.toFixed(2)
+	};
+}
+
+export async function sbench_create_1to1() {
+	// Do 3 loops to warm up JIT
+	for (let i = 0; i < 3; i++) {
+		bench(create_computations_1to1, COUNT, COUNT);
+	}
+
+	const { timing } = await fastest_test(10, () => {
+		for (let i = 0; i < 100; i++) {
+			bench(create_computations_1to1, COUNT, COUNT);
+		}
+	});
+
+	return {
+		benchmark: 'sbench_create_1to1',
+		time: timing.time.toFixed(2),
+		gc_time: timing.gc_time.toFixed(2)
+	};
+}
+
+export async function sbench_create_2to1() {
+	// Do 3 loops to warm up JIT
+	for (let i = 0; i < 3; i++) {
+		bench(create_computations_2to1, COUNT / 2, COUNT);
+	}
+
+	const { timing } = await fastest_test(10, () => {
+		for (let i = 0; i < 100; i++) {
+			bench(create_computations_2to1, COUNT / 2, COUNT);
+		}
+	});
+
+	return {
+		benchmark: 'sbench_create_2to1',
+		time: timing.time.toFixed(2),
+		gc_time: timing.gc_time.toFixed(2)
+	};
+}
+
+export async function sbench_create_4to1() {
+	// Do 3 loops to warm up JIT
+	for (let i = 0; i < 3; i++) {
+		bench(create_computations_4to1, COUNT / 4, COUNT);
+	}
+
+	const { timing } = await fastest_test(10, () => {
+		for (let i = 0; i < 100; i++) {
+			bench(create_computations_4to1, COUNT / 4, COUNT);
+		}
+	});
+
+	return {
+		benchmark: 'sbench_create_4to1',
+		time: timing.time.toFixed(2),
+		gc_time: timing.gc_time.toFixed(2)
+	};
+}
+
+export async function sbench_create_1000to1() {
+	// Do 3 loops to warm up JIT
+	for (let i = 0; i < 3; i++) {
+		bench(create_computations_1000to1, COUNT / 1000, COUNT);
+	}
+
+	const { timing } = await fastest_test(10, () => {
+		for (let i = 0; i < 100; i++) {
+			bench(create_computations_1000to1, COUNT / 1000, COUNT);
+		}
+	});
+
+	return {
+		benchmark: 'sbench_create_1000to1',
+		time: timing.time.toFixed(2),
+		gc_time: timing.gc_time.toFixed(2)
+	};
+}
+
+export async function sbench_create_1to2() {
+	// Do 3 loops to warm up JIT
+	for (let i = 0; i < 3; i++) {
+		bench(create_computations_1to2, COUNT, COUNT / 2);
+	}
+
+	const { timing } = await fastest_test(10, () => {
+		for (let i = 0; i < 100; i++) {
+			bench(create_computations_1to2, COUNT, COUNT / 2);
+		}
+	});
+
+	return {
+		benchmark: 'sbench_create_1to2',
+		time: timing.time.toFixed(2),
+		gc_time: timing.gc_time.toFixed(2)
+	};
+}
+
+export async function sbench_create_1to4() {
+	// Do 3 loops to warm up JIT
+	for (let i = 0; i < 3; i++) {
+		bench(create_computations_1to4, COUNT, COUNT / 4);
+	}
+
+	const { timing } = await fastest_test(10, () => {
+		for (let i = 0; i < 100; i++) {
+			bench(create_computations_1to4, COUNT, COUNT / 4);
+		}
+	});
+
+	return {
+		benchmark: 'sbench_create_1to4',
+		time: timing.time.toFixed(2),
+		gc_time: timing.gc_time.toFixed(2)
+	};
+}
+
+export async function sbench_create_1to8() {
+	// Do 3 loops to warm up JIT
+	for (let i = 0; i < 3; i++) {
+		bench(create_computations_1to8, COUNT, COUNT / 8);
+	}
+
+	const { timing } = await fastest_test(10, () => {
+		for (let i = 0; i < 100; i++) {
+			bench(create_computations_1to8, COUNT, COUNT / 8);
+		}
+	});
+
+	return {
+		benchmark: 'sbench_create_1to8',
+		time: timing.time.toFixed(2),
+		gc_time: timing.gc_time.toFixed(2)
+	};
+}
+
+export async function sbench_create_1to1000() {
+	// Do 3 loops to warm up JIT
+	for (let i = 0; i < 3; i++) {
+		bench(create_computations_1to1000, COUNT, COUNT / 1000);
+	}
+
+	const { timing } = await fastest_test(10, () => {
+		for (let i = 0; i < 100; i++) {
+			bench(create_computations_1to1000, COUNT, COUNT / 1000);
+		}
+	});
+
+	return {
+		benchmark: 'sbench_create_1to1000',
+		time: timing.time.toFixed(2),
+		gc_time: timing.gc_time.toFixed(2)
+	};
+}