diff --git a/cmd/loop_benchmark/loop_benchmarks.py b/cmd/loop_benchmark/loop_benchmarks.py
index aff5d5c0..c6c7ca40 100644
--- a/cmd/loop_benchmark/loop_benchmarks.py
+++ b/cmd/loop_benchmark/loop_benchmarks.py
@@ -71,3 +71,104 @@ def c():
 end_time = time.time()
 print(f"fn-nest: {end_time - start_time} seconds")
 
+
+# function env creation cost
+def a(): pass
+for _ in range(1000000): a()
+
+# argument cost
+def a3(x, y, z): return x
+for _ in range(1000000): a3(1, 2, 3)
+
+# recursion depth cost
+def fib(n): return n if n < 2 else fib(n-1) + fib(n-2)
+fib(25)
+
+
+# closure cost
+def make_counter():
+    n = [0]
+    def inc():
+        n[0] += 1
+        return n[0]
+    return inc
+c = make_counter()
+for _ in range(1000000): c()
+
+# branching cost
+for _ in range(1000000): 1 if 1 > 0 else 2
+
+
+# Python
+def add_nums(x, y):
+    return x + y
+
+start_time = time.time()
+for _ in range(1, 1000000):
+    _ = add_nums(10, 20)
+end_time = time.time()
+print(f"fn-args: {end_time - start_time} seconds")
+
+# Python
+start_time = time.time()
+for _ in range(1, 1000000):
+    _ = 10 + 20 + 30 + 40
+end_time = time.time()
+print(f"math-chain: {end_time - start_time} seconds")
+
+start_time = time.time()
+for _ in range(1, 1000000):
+    _ = [1, 2, 3]
+end_time = time.time()
+print(f"block-alloc: {end_time - start_time} seconds")
+
+# Where python should win the most
+
+d = {"key": 100}
+start_time = time.time()
+acc = 0
+for _ in range(1, 1000000):
+    acc += d["key"]
+print(f"dict-lookup: {time.time() - start_time:.4f}s")
+
+start_time = time.time()
+for i in range(1, 1000000):
+    _ = f"hello-{i}"
+print(f"string-format: {time.time() - start_time:.4f}s")
+
+start_time = time.time()
+acc = 0
+for i in range(1, 1000000):
+    acc += i
+print(f"math-accumulate: {time.time() - start_time:.4f}s")
+
+# offload to c
+data = list(range(1000000))
+start = time.time()
+total = sum(data)
+print(f"sum: {time.time()-start}")
+
+# string building
+
+parts = [str(i) for i in range(100000)]
+start = time.time()
+result = "".join(parts)
+
+
+# regex
+
+import re
+pattern = re.compile(r'\d+')
+start = time.time()
+for _ in range(1000000):
+    pattern.match("12345")
+
+# sets
+
+s = set(range(1000000))
+start = time.time()
+for i in range(1000000):
+    _ = i in s
+
+# list comprehension (absolute killer in py)
+[x * 2 for x in range(1_000_000)]
diff --git a/cmd/loop_benchmark/loop_benchmarks.rye b/cmd/loop_benchmark/loop_benchmarks.rye
index fe1f2f40..ea2ab0a1 100644
--- a/cmd/loop_benchmark/loop_benchmarks.rye
+++ b/cmd/loop_benchmark/loop_benchmarks.rye
@@ -41,12 +41,86 @@ do-benchmarks: fn { dsl } {
 		a: does { b } b: does { c } c: does { 123 }
 		print time-it { dsl { prns loop 1000000 { a } } }
 	}
+
+
+	; NEW checks
+	
+; function env creation
+	a: does { }
+loop 1000000 { a }
+
+; argument cost
+a3: fn { x y z } { x }
+loop 1000000 { a3 1 2 3 }
+
+; recursion depth cost
+fib: fn { n } { either n < 2 { n } { (fib n - 1) + (fib n - 2) } }
+print time-it { fib 25 }
+
+; closure cost
+make-counter: fn { } { n: 0  closure { } { n:: n + 1  n } }
+c: make-counter
+loop 1000000 { c }
+
+
+; branshing cost
+loop 1000000 { either 1 > 0 { 1 } { 2 } }
+
+
+; Rye
+prns "fn-args:"
+private {
+    add-nums: fn { x y } { x + y }
+    print time-it { dsl { prns loop 1000000 { add-nums 10 20 } } }
+}
+
+prns "var-assign:"
+private {
+    a: 0
+    print time-it { dsl { prns loop 1000000 { a: 123 } } }
+}
+
+; expression chain
+; Rye
+prns "math-chain:"
+print time-it { dsl { prns loop 1000000 { 10 + 20 + 30 + 40 } } }
+
+prns "block-alloc:"
+print time-it { dsl { prns loop 1000000 { list [ 1 2 3 ] } } }
+
+; Where python should win the most
+
+; Rye
+prns "dict-lookup:"
+private {
+    d: dict { "key" 100 }
+    print time-it { dsl { prns loop 1000000 { d ? "key" } } }
+}
+
+
+prns "string-format:"
+print time-it { dsl { prns loop 1000000 { concat "hello-" "123" } } }
+
+prns "math-accumulate:"
+private {
+    acc: 0
+    print time-it { dsl { prns loop 1000000 { acc: acc + 1 } } }
+}
+
+; ofload to go
+data: range 1 1000000
+print time-it { sum data }
+
+; list comprehension collector
+
+collect { loop 1000000 { |i| keep _+ i i } }
+
 }
 
 print "== DO mode (base evaluator) =="
 
 do-benchmarks ?do
 
-print "== RYE0 mode (some more optimisations) =="
-
-do-benchmarks ?rye0
\ No newline at end of file
+; print "== RYE0 mode (some more optimisations) =="
+; 
+; do-benchmarks ?rye0
diff --git a/cmd/loop_benchmark/loop_benchmarks2.py b/cmd/loop_benchmark/loop_benchmarks2.py
new file mode 100644
index 00000000..1dbdaa93
--- /dev/null
+++ b/cmd/loop_benchmark/loop_benchmarks2.py
@@ -0,0 +1,198 @@
+import time
+import math
+
+start_time = time.time()
+for _ in range(1, 1000000):
+    _ = 123
+end_time = time.time()
+print(f"integer: " + str(math.ceil((end_time - start_time) * 1000)))
+
+start_time = time.time()
+for _ in range(1, 1000000):
+    _ = "123"
+end_time = time.time()
+print(f"string: " + str(math.ceil((end_time - start_time) * 1000)))
+
+start_time = time.time()
+for _ in range(1, 1000000):
+    _ = [123]
+end_time = time.time()
+print(f"block: " + str(math.ceil((end_time - start_time) * 1000)))
+
+start_time = time.time()
+for _ in range(1, 1000000):
+    _ = 1 + 1 + 1
+end_time = time.time()
+print(f"builtins: " + str(math.ceil((end_time - start_time) * 1000)))
+
+a = 1
+b = "2"
+c = [3]
+start_time = time.time()
+for _ in range(1, 1000000):
+    _ = a
+    _ = b
+    _ = c
+end_time = time.time()
+print(f"word-lookup: " + str(math.ceil((end_time - start_time) * 1000)))
+
+a = 1
+b = "2"
+c = [3]
+start_time = time.time()
+for _ in range(1, 1000000):
+    a = b = c = 123
+end_time = time.time()
+print(f"mod-word: " + str(math.ceil((end_time - start_time) * 1000)))
+
+def a():
+    return 123
+
+start_time = time.time()
+for _ in range(1, 1000000):
+    _ = a()
+    _ = a()
+    _ = a()
+end_time = time.time()
+print(f"fn-flat: " + str(math.ceil((end_time - start_time) * 1000)))
+
+def a():
+    return b()
+def b():
+    return c()
+def c():
+    return 123
+
+start_time = time.time()
+for _ in range(1, 1000000):
+    _ = a()
+end_time = time.time()
+print(f"fn-nest: " + str(math.ceil((end_time - start_time) * 1000)))
+
+def a():
+    pass
+
+start_time = time.time()
+for _ in range(1000000):
+    a()
+end_time = time.time()
+print(f"fn-env: " + str(math.ceil((end_time - start_time) * 1000)))
+
+def a3(x, y, z):
+    return x
+
+start_time = time.time()
+for _ in range(1000000):
+    a3(1, 2, 3)
+end_time = time.time()
+print(f"fn-args3: " + str(math.ceil((end_time - start_time) * 1000)))
+
+def fib(n):
+    return n if n < 2 else fib(n - 1) + fib(n - 2)
+
+start_time = time.time()
+fib(25)
+end_time = time.time()
+print(f"recursion-fib25: " + str(math.ceil((end_time - start_time) * 1000)))
+
+def make_counter():
+    n = [0]
+    def inc():
+        n[0] += 1
+        return n[0]
+    return inc
+
+c = make_counter()
+start_time = time.time()
+for _ in range(1000000):
+    c()
+end_time = time.time()
+print(f"closure: " + str(math.ceil((end_time - start_time) * 1000)))
+
+start_time = time.time()
+for _ in range(1000000):
+    _ = 1 if 1 > 0 else 2
+end_time = time.time()
+print(f"branching: " + str(math.ceil((end_time - start_time) * 1000)))
+
+def add_nums(x, y):
+    return x + y
+
+start_time = time.time()
+for _ in range(1, 1000000):
+    _ = add_nums(10, 20)
+end_time = time.time()
+print(f"fn-args: " + str(math.ceil((end_time - start_time) * 1000)))
+
+a = 0
+start_time = time.time()
+for _ in range(1, 1000000):
+    a = 123
+end_time = time.time()
+print(f"var-assign: " + str(math.ceil((end_time - start_time) * 1000)))
+
+start_time = time.time()
+for _ in range(1, 1000000):
+    _ = 10 + 20 + 30 + 40
+end_time = time.time()
+print(f"math-chain: " + str(math.ceil((end_time - start_time) * 1000)))
+
+start_time = time.time()
+for _ in range(1, 1000000):
+    _ = [1, 2, 3]
+end_time = time.time()
+print(f"block-alloc: " + str(math.ceil((end_time - start_time) * 1000)))
+
+d = {"key": 100}
+acc = 0
+start_time = time.time()
+for _ in range(1, 1000000):
+    acc += d["key"]
+end_time = time.time()
+print(f"dict-lookup: " + str(math.ceil((end_time - start_time) * 1000)))
+
+start_time = time.time()
+for i in range(1, 1000000):
+    _ = f"hello-{i}"
+end_time = time.time()
+print(f"string-format: " + str(math.ceil((end_time - start_time) * 1000)))
+
+acc = 0
+start_time = time.time()
+for i in range(1, 1000000):
+    acc += i
+end_time = time.time()
+print(f"math-accumulate: " + str(math.ceil((end_time - start_time) * 1000)))
+
+data = list(range(1000000))
+start_time = time.time()
+total = sum(data)
+end_time = time.time()
+print(f"offload-sum: " + str(math.ceil((end_time - start_time) * 1000)))
+
+parts = [str(i) for i in range(100000)]
+start_time = time.time()
+result = "".join(parts)
+end_time = time.time()
+print(f"string-build: " + str(math.ceil((end_time - start_time) * 1000)))
+
+import re
+pattern = re.compile(r'\d+')
+start_time = time.time()
+for _ in range(1000000):
+    pattern.match("12345")
+end_time = time.time()
+print(f"regex-match: " + str(math.ceil((end_time - start_time) * 1000)))
+
+s = set(range(1000000))
+start_time = time.time()
+for i in range(1000000):
+    _ = i in s
+end_time = time.time()
+print(f"set-lookup: " + str(math.ceil((end_time - start_time) * 1000)))
+
+start_time = time.time()
+_ = [x * 2 for x in range(1000000)]
+end_time = time.time()
+print(f"list-comprehension: " + str(math.ceil((end_time - start_time) * 1000)))
+
diff --git a/cmd/loop_benchmark/loop_benchmarks2.rye b/cmd/loop_benchmark/loop_benchmarks2.rye
new file mode 100644
index 00000000..9736b649
--- /dev/null
+++ b/cmd/loop_benchmark/loop_benchmarks2.rye
@@ -0,0 +1,96 @@
+;# Loop benchmarks
+; Doing simple loop 1million times to get some basic sense of speedo
+do-benchmarks: fn { dsl } { 
+	prns "integer:"
+	print time-it { dsl { prns loop 1000000 { 123 } } }
+	prns "string:"
+	print time-it { dsl { prns loop 1000000 { "124" } } }
+	prns "block:"
+	print time-it { dsl { prns loop 1000000 { { 123 } } } }
+	prns "builtins:"
+	print time-it { dsl { prns loop 1000000 { _+ _+ 1 1 1 } } }
+	prns "word.lookup:"
+	private {
+		a: 1 b: "2" c: { 3 }
+		print time-it { dsl { prns loop 1000000 { a b c } } }
+	}
+	prns "mod-word:"
+	private {
+		print time-it { dsl { prns loop 1000000 { a:: b:: c:: 123 } } }
+	}
+	prns "fn-flat:"
+	private {
+		a: does { 123 }
+		print time-it { dsl { prns loop 1000000 { a a a } } }
+	}
+	prns "fn-nest:"
+	private {
+		a: does { b } b: does { c } c: does { 123 }
+		print time-it { dsl { prns loop 1000000 { a } } }
+	}
+
+	prns "fn-env:"
+	private {
+		a: does { }
+		print time-it { dsl { prns loop 1000000 { a } } }
+	}
+	prns "fn-args3:"
+	private {
+		a3: fn { x y z } { x }
+		print time-it { dsl { prns loop 1000000 { a3 1 2 3 } } }
+	}
+	prns "recursion-fib25:"
+	private {
+		fib: fn { n } { either n < 2 { n } { ( fib n - 1 ) + ( fib n - 2 ) } }
+		print time-it { dsl { prns fib 25 } }
+	}
+	prns "closure:"
+	private {
+		make-counter: fn { } { n: 0  closure { } { n:: n + 1  n } }
+		c: make-counter
+		print time-it { dsl { prns loop 1000000 { c } } }
+	}
+	prns "branching:"
+	print time-it { dsl { prns loop 1000000 { either 1 > 0 { 1 } { 2 } } } }
+
+	prns "fn-args:"
+	private {
+		add-nums: fn { x y } { x + y }
+		print time-it { dsl { prns loop 1000000 { add-nums 10 20 } } }
+	}
+	prns "var-assign:"
+	private {
+		a:: 0
+		print time-it { dsl { prns loop 1000000 { a:: 123 } } }
+	}
+	prns "math-chain:"
+	print time-it { dsl { prns loop 1000000 { 10 + 20 + 30 + 40 } } }
+	prns "block-alloc:"
+	print time-it { dsl { prns loop 1000000 { list [ 1 2 3 ] } } }
+
+	prns "dict-lookup:"
+	private {
+		d: dict { "key" 100 }
+		print time-it { dsl { prns loop 1000000 { d -> "key" } } }
+	}
+	prns "string-format:"
+	print time-it { dsl { prns loop 1000000 { concat "hello-" "123" } } }
+	prns "math-accumulate:"
+	private {
+		acc:: 0
+		print time-it { dsl { prns loop 1000000 { acc:: acc + 1 } } }
+	}
+
+	prns "offload-sum:"
+	private {
+		data: range 1 1000000
+		print time-it { dsl { prns sum data } }
+	}
+	prns "list-comprehension:"
+	; print time-it { dsl { prns collect { loop 1000000 { |i| keep _+ i i } } } }
+}
+print "== DO mode (base evaluator) =="
+do-benchmarks ?do
+; print "== RYE0 mode (some more optimisations) =="
+; 
+; do-benchmarks ?rye0