diff --git a/core/control_flow.nom b/core/control_flow.nom
index 63d7900..3492b68 100644
--- a/core/control_flow.nom
+++ b/core/control_flow.nom
@@ -43,6 +43,10 @@ compile [..]
 # Conditional expression (ternary operator)
 #   Note: this uses a function instead of "(condition and if_expr or else_expr)"
     because that breaks if %if_expr is falsey, e.g. "x < 5 and false or 99"
+test:
+    assume ((1 if (yes) else 2) == 1)
+    assume ((1 if (no) else 2) == 2)
+
 compile [..]
     %when_true_expr if %condition else %when_false_expr
     %when_true_expr if %condition otherwise %when_false_expr
@@ -74,31 +78,43 @@ compile [..]
 
 
 # GOTOs
+test:
+    %i = 0
+    === %loop ===
+    %i += 1
+    unless (%i == 10): go to %loop
+    assume (%i == 10)
+
 compile [=== %label ===, --- %label ---, *** %label ***] to (..)
     Lua "::label_\(%label as lua identifier)::"
 
 compile [go to %label] to (Lua "goto label_\(%label as lua identifier)")
 
 # Basic loop control
-compile [do next] to (Lua "continue")
+compile [do next] to (Lua "goto continue")
 compile [stop] to (Lua "break")
 
-# Helper function
-#TODO: do "using % compile %" instead so it's actually a helper function
-compile [%tree has subtree %subtree where %condition] to (..)
-    Lua value ".."
-        (function()
-            for \(%subtree as lua expr) in coroutine.wrap(function() \(%tree as lua expr):map(coroutine.yield) end) do
-                if \(%condition as lua expr) then
-                    return true
-                end
-            end
-            return false
-        end)()
-
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
 # While loops
+test:
+    %x = 0
+    repeat while (%x < 10): %x += 1
+    assume (%x == 10)
+    repeat while (%x < 20): stop
+    repeat while (%x < 20): stop repeating
+    assume (%x == 10)
+    repeat while (%x < 20):
+        %x += 1
+        if (yes): do next
+        barf "Failed to 'do next'"
+
+    assume (%x == 20)
+    repeat while (%x < 30):
+        %x += 1
+        if (yes): do next repeat
+        barf "Failed to 'do next repeat'"
+
+    assume (%x == 30)
+
 compile [do next repeat] to (Lua "goto continue_repeat")
 compile [stop repeating] to (Lua "goto stop_repeat")
 compile [repeat while %condition %body] to:
@@ -107,15 +123,14 @@ compile [repeat while %condition %body] to:
             while \(%condition as lua expr) do
                 \(%body as lua statements)
     
-    if (..)
-        %body has subtree % where ((%.type == "Action") and (%.stub is "do next repeat"))
-    ..:
+    if (%body has subtree \(do next)):
+        to %lua write "\n    ::continue::"
+
+    if (%body has subtree \(do next repeat)):
         to %lua write "\n    ::continue_repeat::"
-    
+
     to %lua write "\nend --while-loop"
-    if (..)
-        %body has subtree % where ((%.type == "Action") and (%.stub is "stop repeating"))
-    ..:
+    if (%body has subtree \(stop repeating)):
         %lua = (..)
             Lua ".."
                 do -- scope of "stop repeating" label
@@ -127,21 +142,26 @@ compile [repeat while %condition %body] to:
 
 parse [repeat %body] as (repeat while (yes) %body)
 parse [repeat until %condition %body] as (repeat while (not %condition) %body)
+
+test:
+    %x = 0
+    repeat 10 times: %x += 1
+    assume (%x == 10)
+
 compile [repeat %n times %body] to:
     %lua = (..)
         Lua ".."
             for i=1,\(%n as lua expr) do
                 \(%body as lua statements)
     
-    if (..)
-        %body has subtree % where ((%.type == "Action") and (%.stub is "do next repeat"))
-    ..:
+    if (%body has subtree \(do next)):
+        to %lua write "\n    ::continue::"
+
+    if (%body has subtree \(do next repeat)):
         to %lua write "\n    ::continue_repeat::"
     
     to %lua write "\nend --numeric for-loop"
-    if (..)
-        %body has subtree % where ((%.type == "Action") and (%.stub is "stop repeating"))
-    ..:
+    if (%body has subtree \(stop repeating)):
         %lua = (..)
             Lua ".."
                 do -- scope of "stop repeating" label
@@ -151,7 +171,6 @@ compile [repeat %n times %body] to:
     
     return %lua
 
-
 # For loop control flow
 compile [stop %var] to (Lua "goto stop_\(%var as lua identifier)")
 compile [do next %var] to (Lua "goto continue_\(%var as lua identifier)")
@@ -163,6 +182,23 @@ compile [===next %var ===, ---next %var ---, ***next %var ***] to (..)
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
+test:
+    %nums = []
+    for %x in 1 to 5: add %x to %nums
+    assume (%nums == [1,2,3,4,5])
+    %nums = []
+    for %x in 1 to 5 via 2: add %x to %nums
+    assume (%nums == [1,3,5])
+    %nums = []
+    for %outer in 1 to 100:
+        for %inner in %outer to (%outer + 2):
+            if (%inner == 2):
+                add -2 to %nums
+                do next %inner
+            add %inner to %nums
+            if (%inner == 5): stop %outer
+    assume (%nums == [1,-2,3,-2,3,4,3,4,5])
+
 # Numeric range for loops
 compile [..]
     for %var in %start to %stop by %step %body
@@ -179,18 +215,15 @@ compile [..]
                 %step as lua expr
             .. do
                 \(%body as lua statements)
+
+    if (%body has subtree \(do next)):
+        to %lua write "\n    ::continue::"
     
-    if (..)
-        %body has subtree % where (..)
-            (%.type == "Action") and ((%.stub is "do next %") and (%.(3).1 == %var.1))
-    ..:
+    if (%body has subtree (\(do next %v) with vars {v:%var})):
         to %lua write "\n    \(compile as (===next %var ===))"
     
     to %lua write "\nend --numeric for-loop"
-    if (..)
-        %body has subtree % where (..)
-            (%.type == "Action") and ((%.stub is "stop %") and (%.(2).1 == %var.1))
-    ..:
+    if (%body has subtree (\(stop %v) with vars {v:%var})):
         %lua = (..)
             Lua ".."
                 do -- scope for stopping for-loop
@@ -205,6 +238,17 @@ compile [..]
 parse [for %var in %start to %stop %body] as (..)
     for %var in %start to %stop via 1 %body
 
+test:
+    %a = [10,20,30,40,50]
+    %b = []
+    for %x in %a: add %x to %b
+    assume (%a == %b)
+    %b = []
+    for %x in %a:
+        if (%x == 10): do next %x
+        if (%x == 50): stop %x
+        add %x to %b
+    assume (%b == [20,30,40])
 
 # For-each loop (lua's "ipairs()")
 compile [for %var in %iterable %body] to:
@@ -218,17 +262,14 @@ compile [for %var in %iterable %body] to:
             for i,\(%var as lua identifier) in ipairs(\(%iterable as lua expr)) do
                 \(%body as lua statements)
     
-    if (..)
-        %body has subtree % where (..)
-            (%.type == "Action") and ((%.stub is "do next %") and (%.(3).1 == %var.1))
-    ..:
+    if (%body has subtree \(do next)):
+        to %lua write "\n    ::continue::"
+
+    if (%body has subtree (\(do next %v) with vars {v:%var})):
         to %lua write (Lua "\n\(compile as (===next %var ===))")
     
     to %lua write "\nend --foreach-loop"
-    if (..)
-        %body has subtree % where (..)
-            (%.type == "Action") and ((%.stub is "stop %") and (%.(2).1 == %var.1))
-    ..:
+    if (%body has subtree (\(stop %v) with vars {v:%var})):
         %lua = (..)
             Lua ".."
                 do -- scope for stopping for-loop
@@ -238,6 +279,14 @@ compile [for %var in %iterable %body] to:
     
     return %lua
 
+test:
+    %d = {a:10, b:20, c:30, d:40, e:50}
+    %result = []
+    for %k = %v in %d:
+        if (%k == "a"): do next %k
+        if (%v == 20): do next %v
+        add "\%k = \%v" to %result
+    assume ((%result sorted) == ["c = 30", "d = 40", "e = 50"])
 
 # Dict iteration (lua's "pairs()")
 compile [..]
@@ -257,31 +306,22 @@ compile [..]
                 %iterable as lua expr
             ..) do
                 \(%body as lua statements)
+
+    if (%body has subtree \(do next)):
+        to %lua write "\n    ::continue::"
     
-    if (..)
-        %body has subtree % where (..)
-            (%.type == "Action") and ((%.stub is "do next %") and (%.(3).1 == %key.1))
-    ..:
+    if (%body has subtree (\(do next %v) with vars {v:%key})):
         to %lua write (Lua "\n\(compile as (===next %key ===))")
     
-    if (..)
-        %body has subtree % where (..)
-            (%.type == "Action") and ((%.stub is "do next %") and (%.(3).1 == %value.1))
-    ..:
+    if (%body has subtree (\(do next %v) with vars {v:%value})):
         to %lua write (Lua "\n\(compile as (===next %value ===))")
     
     to %lua write "\nend --foreach-loop"
     %stop_labels = (Lua "")
-    if (..)
-        %body has subtree % where (..)
-            (%.type == "Action") and ((%.stub is "stop %") and (%.(2).1 == %key.1))
-    ..:
+    if (%body has subtree (\(stop %v) with vars {v:%key})):
         to %stop_labels write "\n\(compile as (===stop %key ===))"
     
-    if (..)
-        %body has subtree % where (..)
-            (%.type == "Action") and ((%.stub is "stop %") and (%.(2).1 == %value.1))
-    ..:
+    if (%body has subtree (\(stop %v) with vars {v:%value})):
         to %stop_labels write "\n\(compile as (===stop %value ===))"
     
     if ((length of "\%stop_labels") > 0):
@@ -295,6 +335,14 @@ compile [..]
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
+test:
+    if:
+        (1 == 2) (100 < 0): barf "bad conditional"
+        (1 == 0) (1 == 1) (%not_a_variable.x): do nothing
+        (1 == 1): barf "bad conditional"
+        (1 == 2): barf "bad conditional"
+        else: barf "bad conditional"
+
 # Multi-branch conditional (if..elseif..else)
 compile [if %body, when %body] to:
     %code = (Lua "")
@@ -352,6 +400,12 @@ compile [if %body, when %body] to:
     to %code write "\nend --when"
     return %code
 
+test:
+    if 5 is:
+        1 2 3: barf "bad switch statement"
+        4 5: do nothing
+        5 6: barf "bad switch statement"
+        else: barf "bad switch statement"
 
 # Switch statement
 compile [if %branch_value is %body, when %branch_value is %body] to:
@@ -423,6 +477,17 @@ compile [do %action] to (..)
             \(%action as lua statements)
         end --do
 
+test:
+    %d = {}
+    try:
+        do:
+            %d.x = "bad"
+            barf
+        ..then always:
+            %d.x = "good"
+    ..and if it barfs: do nothing
+    assume (%d.x == "good")
+
 compile [do %action then always %final_action] to (..)
     Lua ".."
         do
@@ -436,24 +501,46 @@ compile [do %action then always %final_action] to (..)
             if not fell_through then return ret end
         end
 
+test:
+    assume ((result of: return 99) == 99)
 
 # Inline thunk:
 compile [result of %body] to (Lua value "(\(compile as ([] -> %body)))()")
 
+test:
+    %t = [1, [2, [[3], 4], 5, [[[6]]]]]
+    %flat = []
+    for % in recursive %t:
+        if ((type of %) is "table"):
+            for %2 in %: recurse % on %2
+        ..else: add % to %flat
+
+    assume ((sorted %flat) == [1, 2, 3, 4, 5, 6])
+
 # Recurion control flow
 compile [for %var in recursive %structure %body] to (..)
     with local compile actions:
         compile [recurse %v on %x] to (..)
             Lua "table.insert(stack\(%v as lua id), \(%x as lua expr))"
         
-        return (..)
+        %lua = (..)
             Lua ".."
                 do
                     local stack\(%var as lua id) = list{\(%structure as lua expr)}
                     while #stack\(%var as lua id) > 0 do
                         \(%var as lua expr) = table.remove(stack\(%var as lua id), 1)
                         \(%body as lua statements)
-                        \(compile as (===next %var ===))
-                    end
-                    \(compile as (===stop %var ===))
-                end
\ No newline at end of file
+
+        if (%body has subtree \(do next)):
+            to %lua write "\n        ::continue::"
+
+        if (%body has subtree (\(do next %v) with vars {v:%var})):
+            to %lua write "\n        \(compile as (===next %var ===))"
+
+        to %lua write "\n    end -- Recursive loop"
+        if (%body has subtree (\(stop %v) with vars {v:%var})):
+            to %lua write "\n        \(compile as (===stop %var ===))"
+
+        to %lua write "\nend -- Recursive scope"
+
+        return %lua
diff --git a/core/coroutines.nom b/core/coroutines.nom
index 52467c1..6e7d9e3 100644
--- a/core/coroutines.nom
+++ b/core/coroutines.nom
@@ -4,6 +4,17 @@
 
 use "core/metaprogramming.nom"
 
+test:
+    %nums = []
+    %co = (..)
+        coroutine:
+            -> 4
+            -> 5
+            repeat 3 times: -> 6
+
+    for % in coroutine %co: add % to %nums
+    assume (%nums == [4, 5, 6, 6, 6]) or barf "Coroutine iteration failed"
+
 compile [coroutine %body, generator %body] to (..)
     Lua value ".."
         (function()
@@ -16,4 +27,4 @@ compile [for % in coroutine %co %body] to (..)
     Lua ".."
         for junk,\(% as lua expr) in coroutine.wrap(\(%co as lua expr)) do
             \(%body as lua statements)
-        end
\ No newline at end of file
+        end
diff --git a/core/errors.nom b/core/errors.nom
index 2744208..53b06a2 100644
--- a/core/errors.nom
+++ b/core/errors.nom
@@ -27,6 +27,18 @@ compile [assume %condition or barf %message] to (..)
             error(\(%message as lua expr), 0)
         end
 
+test:
+    try (barf) and if it succeeds: barf "try failed."
+    %worked = (no)
+    try (barf) and if it barfs: %worked = (yes)
+    assume %worked or barf "try/catch failed"
+    %x = 1
+    try:
+        %x = 2
+        do (barf) then always: %x = 3
+    ..and if it barfs: do nothing
+
+    assume (%x == 3) or barf "do/then always failed"
 
 # Try/except
 compile [..]
@@ -75,4 +87,4 @@ parse [try %action and if it barfs %msg %fallback] as (..)
     try %action and if it succeeds (do nothing) or if it barfs %msg %fallback
 
 parse [try %action and if it succeeds %success] as (..)
-    try %action and if it succeeds %success or if it barfs (do nothing)
\ No newline at end of file
+    try %action and if it succeeds %success or if it barfs (do nothing)
diff --git a/core/math.nom b/core/math.nom
index 95ed6b9..0248956 100644
--- a/core/math.nom
+++ b/core/math.nom
@@ -9,6 +9,11 @@ use "core/control_flow.nom"
 use "core/collections.nom"
 
 # Literals:
+test:
+    assume (all of [inf, NaN, pi, tau, golden ratio, e]) or barf "math constants failed"
+    %nan = (NaN)
+    assume (%nan != %nan) or barf "NaN failed"
+
 compile [infinity, inf] to (Lua value "math.huge")
 compile [not a number, NaN, nan] to (Lua value "(0/0)")
 compile [pi, Pi, PI] to (Lua value "math.pi")
@@ -17,7 +22,18 @@ compile [golden ratio] to (Lua value "((1+math.sqrt(5))/2)")
 compile [e] to (Lua value "math.exp(1)")
 
 # Functions:
+test:
+    assume (("5" as a number) == 5)
+
 compile [% as a number, % as number] to (Lua value "tonumber(\(% as lua expr))")
+test:
+    assume (..)
+        all of [..]
+            abs 5, | 5 |, sqrt 5, √ 5, sine 5, cosine 5, tangent 5, arc sine 5, arc cosine 5
+            arc tangent 5, arc tangent 5 / 10, hyperbolic sine 5, hyperbolic cosine 5
+            hyperbolic tangent 5, e^ 5, ln 5, log base 2 of 5, floor 5, ceiling 5, round 5
+    ..or barf "math functions failed"
+
 compile [absolute value %, | % |, abs %] to (..)
     Lua value "math.abs(\(% as lua expr))"
 
@@ -46,6 +62,11 @@ compile [log % base %base, log base %base of %] to (..)
 compile [floor %] to (Lua value "math.floor(\(% as lua expr))")
 compile [ceiling %, ceil %] to (Lua value "math.ceil(\(% as lua expr))")
 compile [round %, % rounded] to (Lua value "math.floor(\(% as lua expr) + .5)")
+
+test:
+    assume ((463 to the nearest 100) == 500) or barf "rounding failed"
+    assume ((2.6 to the nearest 0.25) == 2.5) or barf "rounding failed"
+
 action [%n to the nearest %rounder] (..)
     =lua "(\%rounder)*math.floor((\%n / \%rounder) + .5)"
 
@@ -88,6 +109,10 @@ compile [min of %items, smallest of %items, lowest of %items] to (..)
 compile [max of %items, biggest of %items, largest of %items, highest of %items] to
 ..(Lua value "utils.max(\(%items as lua expr))")
 
+test:
+    assume ((min of [3, -4, 1, 2] by % = (% * %)) == 1)
+    assume ((max of [3, -4, 1, 2] by % = (% * %)) == -4)
+
 parse [min of %items by %item = %value_expr] as (..)
     result of:
         set {%best:nil, %best_key:nil}
@@ -126,4 +151,4 @@ compile [..]
 ..to (Lua value "math.random(\(%low as lua expr), \(%high as lua expr))")
 
 action [random choice from %elements, random choice %elements, random %elements] (..)
-    =lua "\%elements[math.random(#\%elements)]"
\ No newline at end of file
+    =lua "\%elements[math.random(#\%elements)]"
diff --git a/core/metaprogramming.nom b/core/metaprogramming.nom
index d8d3d77..b3c4356 100644
--- a/core/metaprogramming.nom
+++ b/core/metaprogramming.nom
@@ -30,6 +30,23 @@ lua> ".."
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
+test: compile [five] to (Lua value "5")
+test:
+    assume ((five) == 5) or barf "Compile to expression failed."
+    compile [loc x] to (Lua "local _x = 99;")
+test:
+    lua> "do"
+    loc x
+    assume (%x is 99) or barf "Compile to statements with locals failed."
+    lua> "end"
+    assume (%x is (nil)) or barf "Failed to properly localize a variable."
+    compile [asdf] to:
+        %tmp = ""
+        return (Lua %tmp)
+test:
+    asdf
+    assume (%tmp is (nil)) or barf "compile to is leaking variables"
+
 lua> ".."
     nomsu.COMPILE_ACTIONS["compile % to %"] = function(nomsu, tree, \%actions, \%body)
         local \%args = {"nomsu", "tree", unpack(table.map(\%actions[1]:get_args(), function(a) return tostring(nomsu:compile(\
@@ -63,6 +80,21 @@ compile [call %fn with %args] to (..)
         lua:append(")")
         return lua
 
+test:
+    local action [foo %x]:
+        return "outer"
+
+    with local [action (foo %)]:
+        local action [foo %x]:
+            %y = (%x + 1)
+            return %y
+
+        assume ((foo 10) == 11) or barf "Action didn't work."
+        assume (%y is (nil)) or barf "Action leaked a local into globals."
+        parse [baz %] as (foo %)
+
+    assume ((foo 1) == "outer")
+
 compile [local action %actions %body] to (..)
     lua> ".."
         local fn_name = "A"..string.as_lua_id(\%actions[1].stub)
@@ -87,13 +119,43 @@ compile [local action %actions %body] to (..)
         end
         return lua
 
+test:
+    action [baz1]: return "baz1"
+    action [baz2] "baz2"
+
+test:
+    assume ((baz1) == "baz1")
+    assume ((baz2) == "baz2")
+
 compile [action %actions %body] to (..)
     lua> ".."
         local lua = \(compile as (local action %actions %body))
         lua:remove_free_vars(table.map(\%actions, function(a) return "A"..string.as_lua_id(a.stub) end))
         return lua
 
-compile [action %action] to (Lua value "A\(%action.stub as lua id)")
+test:
+    assume ((action (say %)) == (=lua "A_say_1"))
+
+compile [action %action] to (Lua value (%action as lua id))
+
+test:
+    parse [swap %x and %y] as (..)
+        do:
+            %tmp = %x
+            %x = %y
+            %y = %tmp
+
+test:
+    set {%1:1, %2:2}
+    swap %1 and %2
+    assume ((%1 == 2) and (%2 == 1)) or barf ".."
+        'parse % as %' failed on 'swap % and %'
+
+    set {%tmp:1, %tmp2:2}
+    swap %tmp and %tmp2
+    assume ((%tmp == 2) and (%tmp2 == 1)) or barf ".."
+        'parse % as %' variable mangling failed.
+
 compile [parse %actions as %body] to (..)
     lua> ".."
         local replacements = {}
@@ -142,6 +204,10 @@ compile [%tree as lua return] to (..)
 compile [remove action %action] to (..)
     Lua "A\(=lua "string.as_lua_id(\(%action.stub))") = nil"
 
+test:
+    assume ("\(\(foo %x) as nomsu)" == "foo %x") or barf ".."
+        action source code failed.
+
 compile [%tree as nomsu] to (..)
     Lua value "nomsu:tree_to_nomsu(\(%tree as lua expr))"
 
@@ -175,6 +241,15 @@ action [%tree with vars %replacements] (..)
             end
         end)
 
+compile [%tree has subtree %match_tree] to (..)
+    Lua value ".."
+        (function()
+            local match_tree = \(%match_tree as lua expr)
+            for subtree in coroutine.wrap(function() \(%tree as lua expr):map(coroutine.yield) end) do
+                if subtree == match_tree then return true end
+            end
+        end)()
+
 compile [declare locals in %code] to (..)
     Lua value "\(%code as lua expr):declare_locals()"
 
@@ -194,10 +269,23 @@ compile [to %lua write %code joined by %glue] to (..)
     Lua ".."
         \(%lua as lua expr):concat_append(\(%code as lua expr), \(%glue as lua expr));
 
+test:
+    assume ((quote "one\n\"two\"") == "\"one\\n\\\"two\\\"\"")
+
 compile [quote %s] to (Lua value "repr(\(%s as lua expr))")
+
+test:
+    assume ((type of {}) == "table") or barf "type of failed."
+
 compile [type of %obj] to (Lua value "type(\(%obj as lua expr))")
+
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+test:
+    assume ((parse "foo %") == \(foo %))
+
 compile [parse %text] to (..)
-    Lua value "nomsu:parse(NomsuCode(\"\(%text.source)\", \(%text as lua expr)))"
+    Lua value "nomsu:parse(\(%text as lua expr))"
 
 compile [parse %text from %filename] to (..)
     Lua value ".."
@@ -205,12 +293,21 @@ compile [parse %text from %filename] to (..)
             %text as lua expr
         ..))
 
+test:
+    assume ((run "return (2 + 99)") == 101)
+    external %passed = (no)
+    run \: external %passed = (yes)
+    assume %passed
+
 compile [run %nomsu_code] to (..)
     Lua value ".."
         nomsu:run(\(%nomsu_code as lua expr), \(..)
             =lua "repr(tostring(\(%nomsu_code.source)))"
         ..)
 
+test:
+    assume ((\(5 + 5) as value) == 10) or barf "%tree as value failed."
+
 action [run tree %tree, %tree as value] (lua> "return nomsu:run(\%tree)")
 compile [compile %block, compiled %block, %block compiled] to (..)
     Lua value "nomsu:compile(\(%block as lua))"
@@ -245,4 +342,4 @@ compile [with local compile actions %body] to (..)
 action [Nomsu version]:
     use "lib/version.nom"
     return ".."
-        \(Nomsu syntax version).\(core version).\(Nomsu compiler version).\(lib version)
\ No newline at end of file
+        \(Nomsu syntax version).\(core version).\(Nomsu compiler version).\(lib version)
diff --git a/core/scopes.nom b/core/scopes.nom
index 37405e5..f9dc758 100644
--- a/core/scopes.nom
+++ b/core/scopes.nom
@@ -31,4 +31,4 @@ compile [with local %locals %body, with local %locals do %body] to:
         Lua ".."
             do
                 \%body_lua
-            end
\ No newline at end of file
+            end
diff --git a/lib/os.nom b/lib/os.nom
index 1f8d6a7..1acc41f 100644
--- a/lib/os.nom
+++ b/lib/os.nom
@@ -45,3 +45,11 @@ action [..]
 
 action [line number of %pos in %str] (=lua "Files.get_line_number(\%str, \%pos)")
 action [line %line_num in %str] (=lua "Files.get_line(\%str, \%line_num)")
+action [source lines of %tree]:
+    %source = (%tree.source if (%tree is syntax tree) else %tree)
+    %file = (read file %source.filename)
+    return (..)
+        (..)
+            (line % in %file) for % in (line number of %source.start in %file) to (..)
+                line number of %source.stop in %file
+        ..joined with "\n"
diff --git a/tools/find_action.nom b/tools/find_action.nom
new file mode 100755
index 0000000..03bae54
--- /dev/null
+++ b/tools/find_action.nom
@@ -0,0 +1,21 @@
+#!/usr/bin/env nomsu -V2.5.4.3
+use "core"
+use "lib/os.nom"
+use "lib/consolecolor.nom"
+
+%stub = (command line args).1
+say "Looking for stub: \%stub (from \(command line args))"
+%files = ((command line args).% for % in 2 to (|| (command line args) ||))
+for %path in %files:
+    for file %filename in %path:
+        unless (%filename matches "%.nom$") (do next %filename)
+        %file = (read file %filename)
+        %tree = (parse %file from %filename)
+        for %t in recursive %tree:
+            if (%t is "Action" syntax tree) (..)
+                if (%t.stub is %stub):
+                    %line_num = (line number of %t.source.start in %file)
+                    say (blue "\%filename:\%line_num:")
+                    say (yellow (source lines of %t))
+            
+            if (%t is syntax tree) (for %sub in %t (recurse %t on %sub))
diff --git a/tools/parse.nom b/tools/parse.nom
new file mode 100755
index 0000000..68be3a8
--- /dev/null
+++ b/tools/parse.nom
@@ -0,0 +1,27 @@
+#!/usr/bin/env nomsu -V2.4.4.3
+use "core"
+use "lib/os.nom"
+action [print tree %t at indent %indent]:
+    if %t.type is:
+        "Action":
+            say "\(%indent)Action (\(%t.stub)):"
+            for %arg in %t:
+                if (%arg is syntax tree):
+                    print tree %arg at indent "\%indent  "
+        "Number":
+            say "\(%indent)\(%t.1)"
+        "Var":
+            say "\(%indent)%\(%t.1)"
+        else:
+            say "\(%indent)\(%t.type):"
+            for %arg in %t:
+                if:
+                    (%arg is syntax tree):
+                        print tree %arg at indent "\%indent  "
+                    else:
+                        say "\%indent  \(quote %arg)"
+
+for %path in (=lua "arg"):
+    for file %filename in %path:
+        unless (%filename matches "%.nom$"): do next %filename
+        print tree (parse (read file %filename) from %filename) at indent ""
diff --git a/tools/test.nom b/tools/test.nom
new file mode 100755
index 0000000..3d3329f
--- /dev/null
+++ b/tools/test.nom
@@ -0,0 +1,31 @@
+#!/usr/bin/env nomsu -V2.5.4.3
+use "core"
+use "lib/os.nom"
+use "lib/consolecolor.nom"
+
+%args = (command line args)
+if (%args.1 == "-v"):
+    remove index 1 from %args
+    %verbose = (yes)
+
+%tests = ((=lua "Source:from_string(\%s)") = %t for %s = %t in (tests))
+for %path in (command line args):
+    if (%path is "-i"): %inplace = (yes)
+    for file %filename in %path:
+        unless (%filename matches "%.nom$"): do next %filename
+        %file_tests = []
+        for %src = %test in %tests:
+            if (%src.filename == %filename):
+                add {test:%test, source:%src} to %file_tests
+        unless (%file_tests is empty):
+            sort %file_tests by % -> %.source
+            lua> "io.write('[ .. ] ', \%filename); io.flush()"
+            if %verbose: say ""
+            for % in %file_tests:
+                if %verbose:
+                    say "    \(yellow (%.test with "\n" replaced by "\n    "))"
+                run %.test
+            if %verbose:
+                say (green "PASS")
+            ..else:
+                say "\r[\(green "PASS")"