diff --git a/compatibility/2.3.nom b/compatibility/2.3.nom
index 2381010..fb137b8 100644
--- a/compatibility/2.3.nom
+++ b/compatibility/2.3.nom
@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V3.8.7.6
+#!/usr/bin/env nomsu -V4.8.8.6
 #
     This file defines upgrades from Nomsu <2.3 to Nomsu 2.3
 
diff --git a/compatibility/2.4.nom b/compatibility/2.4.nom
index b50fec3..b770840 100644
--- a/compatibility/2.4.nom
+++ b/compatibility/2.4.nom
@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V3.8.7.6
+#!/usr/bin/env nomsu -V4.8.8.6
 #
     This file defines upgrades from Nomsu <2.4 to Nomsu 2.4
 
diff --git a/compatibility/2.5.5.5.nom b/compatibility/2.5.5.5.nom
index b242e57..a3f8b27 100644
--- a/compatibility/2.5.5.5.nom
+++ b/compatibility/2.5.5.5.nom
@@ -1,12 +1,12 @@
-#!/usr/bin/env nomsu -V3.8.7.6
+#!/usr/bin/env nomsu -V4.8.8.6
 #
     This file defines upgrades from Nomsu <2.5.5.5 to Nomsu 2.5.5.5
 
 use "compatibility/compatibility.nom"
 
 upgrade action [hash %, sha1 %] to "2.5.5.5" as (..)
-    =lua ".."
-        \(base64 decode (hash %)):gsub('.', function(c) return ('%x02'):format(c) end)
+    =lua "\
+        ..\(base64 decode (hash %)):gsub('.', function(c) return ('%x02'):format(c) end)"
 
 upgrade action [file with hash %] to "2.5.5.5" as (..)
     file with hash (..)
diff --git a/compatibility/2.5.nom b/compatibility/2.5.nom
index e55915d..fe17dfb 100644
--- a/compatibility/2.5.nom
+++ b/compatibility/2.5.nom
@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V3.8.7.6
+#!/usr/bin/env nomsu -V4.8.8.6
 #
     This file defines upgrades from Nomsu <2.5 to Nomsu 2.5
 
diff --git a/compatibility/2.nom b/compatibility/2.nom
index 3f37cb4..2364f56 100644
--- a/compatibility/2.nom
+++ b/compatibility/2.nom
@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V3.8.7.6
+#!/usr/bin/env nomsu -V4.8.8.6
 #
     This file defines upgrades from Nomsu 1 to Nomsu 2
 
diff --git a/compatibility/3.5.5.6.nom b/compatibility/3.5.5.6.nom
index b46144e..068e65d 100644
--- a/compatibility/3.5.5.6.nom
+++ b/compatibility/3.5.5.6.nom
@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V3.8.7.6
+#!/usr/bin/env nomsu -V4.8.8.6
 #
     This file defines upgrades from Nomsu <3.5.5.6 to Nomsu 3.5.5.6
 
diff --git a/compatibility/3.6.nom b/compatibility/3.6.nom
index 07ad7a5..eec97eb 100644
--- a/compatibility/3.6.nom
+++ b/compatibility/3.6.nom
@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V3.8.7.6
+#!/usr/bin/env nomsu -V4.8.8.6
 #
     This file defines upgrades from Nomsu <3.6 to 3.6
 
diff --git a/compatibility/3.7.nom b/compatibility/3.7.nom
index ca49e3f..5b458de 100644
--- a/compatibility/3.7.nom
+++ b/compatibility/3.7.nom
@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V3.8.7.6
+#!/usr/bin/env nomsu -V4.8.8.6
 #
     This file defines upgrades from Nomsu <3.7 to 3.7
 
diff --git a/compatibility/3.nom b/compatibility/3.nom
index 8f20f1a..36df17d 100644
--- a/compatibility/3.nom
+++ b/compatibility/3.nom
@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V3.8.7.6
+#!/usr/bin/env nomsu -V4.8.8.6
 #
     This file defines upgrades from Nomsu <=2 to Nomsu 3
 
@@ -9,5 +9,5 @@ upgrade action (me) to "3" as %me
 upgrade action (@) to "3" as %me
 upgrade action "as 1 2" to "3" via (..)
     [] -> (..)
-        barf ".."
-            Object API has changed. Use (%obj::action 1 2) instead of (as %obj: action 1 2)
+        barf "\
+            ..Object API has changed. Use (%obj::action 1 2) instead of (as %obj: action 1 2)"
diff --git a/compatibility/compatibility.nom b/compatibility/compatibility.nom
index 2093aff..acd1d11 100644
--- a/compatibility/compatibility.nom
+++ b/compatibility/compatibility.nom
@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V3.8.7.6
+#!/usr/bin/env nomsu -V4.8.8.6
 #
     This file contains code for defining ways to upgrade code between different versions
     of Nomsu.
@@ -51,12 +51,12 @@ compile [upgrade action %actions to %version as %body] to:
         unless ("\%lua" == ""): %lua::append "\n"
         %retval = (make tree %body)
         %lua::append (..)
-            Lua ".."
-                upgrade_action_1_to_2_via_3(\(quote %action.stub), \(%version as lua expr), function(\(..)
+            Lua "\
+                ..upgrade_action_1_to_2_via_3(\(quote %action.stub), \(%version as lua expr), function(\(..)
                     \%tree as lua id
                 ..)
                     return \%retval
-                end)
+                end)"
     
     return %lua
 
diff --git a/core/collections.nom b/core/collections.nom
index bc58c7b..5daaa09 100644
--- a/core/collections.nom
+++ b/core/collections.nom
@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V3.8.7.6
+#!/usr/bin/env nomsu -V4.8.8.6
 #
     This file contains code that supports manipulating and using collections like lists
     and dictionaries.
@@ -154,8 +154,8 @@ compile [set %dict 's metatable to %metatable] to (..)
 test:
     assume (({} with fallback % -> (% + 1)).10 == 11)
 compile [%dict with fallback %key -> %value] to (..)
-    Lua value ".."
-        (function(d)
+    Lua value "\
+        ..(function(d)
             local mt = {}
             for k,v in pairs(getmetatable(d) or {}) do mt[k] = v end
             mt.__index = function(self, \(%key as lua expr))
@@ -164,7 +164,7 @@ compile [%dict with fallback %key -> %value] to (..)
                 return value
             end
             return setmetatable(d, mt)
-        end)(\(%dict as lua expr))
+        end)(\(%dict as lua expr))"
 
 # Sorting
 test:
diff --git a/core/control_flow.nom b/core/control_flow.nom
index b26b870..ee9c8c3 100644
--- a/core/control_flow.nom
+++ b/core/control_flow.nom
@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V3.8.7.6
+#!/usr/bin/env nomsu -V4.8.8.6
 #
     This file contains compile-time actions that define basic control flow structures
     like "if" statements and loops.
@@ -17,10 +17,10 @@ test:
     if (no):
         barf "conditional fail"
 compile [if %condition %if_body] to (..)
-    Lua ".."
-        if \(%condition as lua expr) then
+    Lua "\
+        ..if \(%condition as lua expr) then
             \(%if_body as lua statements)
-        end
+        end"
 
 test:
     unless (yes):
@@ -29,12 +29,12 @@ parse [unless %condition %unless_body] as (if (not %condition) %unless_body)
 compile [..]
     if %condition %if_body else %else_body, unless %condition %else_body else %if_body
 ..to (..)
-    Lua ".."
-        if \(%condition as lua expr) then
+    Lua "\
+        ..if \(%condition as lua expr) then
             \(%if_body as lua statements)
         else
             \(%else_body as lua statements)
-        end
+        end"
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -54,23 +54,23 @@ compile [..]
         equivalent of a conditional expression: (cond and if_true or if_false)
     if {Text:yes, List:yes, Dict:yes, Number:yes}.(%when_true_expr.type):
         return (..)
-            Lua value ".."
-                (\(%condition as lua expr) and \(%when_true_expr as lua expr) or \(..)
+            Lua value "\
+                ..(\(%condition as lua expr) and \(%when_true_expr as lua expr) or \(..)
                     %when_false_expr as lua expr
-                ..)
+                ..)"
     ..else:
         #   Otherwise, need to do an anonymous inline function (yuck, too bad lua 
             doesn't have a proper ternary operator!)
             To see why this is necessary consider: (random()<.5 and false or 99)
         return (..)
-            Lua value ".."
-                ((function()
+            Lua value "\
+                ..((function()
                     if \(%condition as lua expr) then
                         return \(%when_true_expr as lua expr)
                     else
                         return \(%when_false_expr as lua expr)
                     end
-                end)())
+                end)())"
 
 # GOTOs
 test:
@@ -112,9 +112,9 @@ compile [do next repeat] to (Lua "goto continue_repeat")
 compile [stop repeating] to (Lua "goto stop_repeat")
 compile [repeat while %condition %body] to:
     %lua = (..)
-        Lua ".."
-            while \(%condition as lua expr) do
-                \(%body as lua statements)
+        Lua "\
+            ..while \(%condition as lua expr) do
+                \(%body as lua statements)"
     
     if (%body has subtree \(do next)):
         %lua::append "\n    ::continue::"
@@ -123,11 +123,11 @@ compile [repeat while %condition %body] to:
     %lua::append "\nend --while-loop"
     if (%body has subtree \(stop repeating)):
         %lua = (..)
-            Lua ".."
-                do -- scope of "stop repeating" label
+            Lua "\
+                ..do -- scope of "stop repeating" label
                     \%lua
                     ::stop_repeat::
-                end -- end of "stop repeating" label scope
+                end -- end of "stop repeating" label scope"
     
     return %lua
 
@@ -141,9 +141,9 @@ test:
 compile [repeat %n times %body] to:
     define mangler
     %lua = (..)
-        Lua ".."
-            for \(mangle "i")=1,\(%n as lua expr) do
-                \(%body as lua statements)
+        Lua "\
+            ..for \(mangle "i")=1,\(%n as lua expr) do
+                \(%body as lua statements)"
     
     if (%body has subtree \(do next)):
         %lua::append "\n    ::continue::"
@@ -152,11 +152,11 @@ compile [repeat %n times %body] to:
     %lua::append "\nend --numeric for-loop"
     if (%body has subtree \(stop repeating)):
         %lua = (..)
-            Lua ".."
-                do -- scope of "stop repeating" label
+            Lua "\
+                ..do -- scope of "stop repeating" label
                     \%lua
                     ::stop_repeat::
-                end -- end of "stop repeating" label scope
+                end -- end of "stop repeating" label scope"
     
     return %lua
 
@@ -199,11 +199,11 @@ compile [..]
     unless (%var.type is "Var"):
         compile error at %var.source "Loop expected variable, not: %s"
     %lua = (..)
-        Lua ".."
-            for \(%var as lua expr)=\(%start as lua expr),\(%stop as lua expr),\(..)
+        Lua "\
+            ..for \(%var as lua expr)=\(%start as lua expr),\(%stop as lua expr),\(..)
                 %step as lua expr
             .. do
-                \(%body as lua statements)
+                \(%body as lua statements)"
     
     if (%body has subtree \(do next)):
         %lua::append "\n    ::continue::"
@@ -212,11 +212,11 @@ compile [..]
     %lua::append "\nend --numeric for-loop"
     if (%body has subtree \(stop %var)):
         %lua = (..)
-            Lua ".."
-                do -- scope for stopping for-loop
+            Lua "\
+                ..do -- scope for stopping for-loop
                     \%lua
                     \(compile as (===stop %var ===))
-                end -- end of scope for stopping for-loop
+                end -- end of scope for stopping for-loop"
     
     return %lua
 
@@ -245,9 +245,9 @@ compile [for %var in %iterable %body] to:
         compile error at %var.source "Loop expected variable, not: %s"
     define mangler
     %lua = (..)
-        Lua ".."
-            for \(mangle "i"),\(%var as lua identifier) in ipairs(\(%iterable as lua expr)) do
-                \(%body as lua statements)
+        Lua "\
+            ..for \(mangle "i"),\(%var as lua identifier) in ipairs(\(%iterable as lua expr)) do
+                \(%body as lua statements)"
     
     if (%body has subtree \(do next)):
         %lua::append "\n    ::continue::"
@@ -256,11 +256,11 @@ compile [for %var in %iterable %body] to:
     %lua::append "\nend --foreach-loop"
     if (%body has subtree \(stop %var)):
         %lua = (..)
-            Lua ".."
-                do -- scope for stopping for-loop
+            Lua "\
+                ..do -- scope for stopping for-loop
                     \%lua
                     \(compile as (===stop %var ===))
-                end -- end of scope for stopping for-loop
+                end -- end of scope for stopping for-loop"
     
     return %lua
 
@@ -284,11 +284,11 @@ compile [..]
     unless (%value.type is "Var"):
         compile error at %value.source "Loop expected variable, not: %s"
     %lua = (..)
-        Lua ".."
-            for \(%key as lua identifier),\(%value as lua identifier) in pairs(\(..)
+        Lua "\
+            ..for \(%key as lua identifier),\(%value as lua identifier) in pairs(\(..)
                 %iterable as lua expr
             ..) do
-                \(%body as lua statements)
+                \(%body as lua statements)"
     
     if (%body has subtree \(do next)):
         %lua::append "\n    ::continue::"
@@ -304,10 +304,10 @@ compile [..]
         %stop_labels::append "\n\(compile as (===stop %value ===))"
     if ((size of "\%stop_labels") > 0):
         %lua = (..)
-            Lua ".."
-                do -- scope for stopping for % = % loop
+            Lua "\
+                ..do -- scope for stopping for % = % loop
                     \%lua\%stop_labels
-                end
+                end"
     
     return %lua
 
@@ -337,39 +337,39 @@ compile [if %body, when %body] to:
             ((%line.type is "Action") and ((size of %line) >= 2)) and (..)
                 %line.(size of %line) is "Block" syntax tree
         ..:
-            compile error at %line.source ".."
-                Invalid line for 'if', each line should contain conditional expressions followed by a block, or "else" followed by a block:
-                %s
+            compile error at %line.source "\
+                ..Invalid line for 'if', each line should contain conditional expressions followed by a block, or "else" followed by a block:
+                %s"
         
         %action = %line.(size of %line)
         if ((%line.1 is "else") and ((size of %line) == 2)):
             unless %else_allowed:
                 compile error at %line.source "Can't have two 'else' blocks"
             unless ((size of "\%code") > 0):
-                compile error at %line.source ".."
-                    Can't have an 'else' block without a preceeding condition
+                compile error at %line.source "\
+                    ..Can't have an 'else' block without a preceeding condition"
             
-            %code::append ".."
-                
+            %code::append "\
+                ..
                 else
-                    \(%action as lua statements)
+                    \(%action as lua statements)"
             
             %else_allowed = (no)
         ..else:
             %code::append "\%clause "
             for %i in 1 to ((size of %line) - 1):
                 unless (%line.%i is syntax tree):
-                    compile error at %line.source ".."
-                        Invalid condition for 'if' statement:
-                        %s
+                    compile error at %line.source "\
+                        ..Invalid condition for 'if' statement:
+                        %s"
                 
                 if (%i > 1):
                     %code::append " or "
                 %code::append (%line.%i as lua expr)
             
-            %code::append ".."
-                 then
-                    \(%action as lua statements)
+            %code::append "\
+                .. then
+                    \(%action as lua statements)"
             
             %clause = "\nelseif"
     
@@ -401,39 +401,39 @@ compile [if %branch_value is %body, when %branch_value is %body] to:
             ((%line.type is "Action") and ((size of %line) >= 2)) and (..)
                 %line.(size of %line) is "Block" syntax tree
         ..:
-            compile error at %line.source ".."
-                Invalid line for 'if % is % %', each line should contain expressions followed by a block, or "else" followed by a block:
-                %s
+            compile error at %line.source "\
+                ..Invalid line for 'if % is % %', each line should contain expressions followed by a block, or "else" followed by a block:
+                %s"
         
         %action = %line.(size of %line)
         if ((%line.1 is "else") and ((size of %line) == 2)):
             unless %else_allowed:
                 compile error at %line.source "Can't have two 'else' blocks"
             unless ((size of "\%code") > 0):
-                compile error at %line.source ".."
-                    Can't have an 'else' block without a preceeding condition
+                compile error at %line.source "\
+                    ..Can't have an 'else' block without a preceeding condition"
             
-            %code::append ".."
-                
+            %code::append "\
+                ..
                 else
-                    \(%action as lua statements)
+                    \(%action as lua statements)"
             
             %else_allowed = (no)
         ..else:
             %code::append "\%clause "
             for %i in 1 to ((size of %line) - 1):
                 unless (%line.%i is syntax tree):
-                    compile error at %line.source ".."
-                        Invalid condition for 'if' statement:
-                        %s
+                    compile error at %line.source "\
+                        ..Invalid condition for 'if' statement:
+                        %s"
                 
                 if (%i > 1):
                     %code::append " or "
                 %code::append "\(mangle "branch value") == \(%line.%i as lua expr)"
             
-            %code::append ".."
-                 then
-                    \(%action as lua statements)
+            %code::append "\
+                .. then
+                    \(%action as lua statements)"
             
             %clause = "\nelseif"
     
@@ -441,18 +441,18 @@ compile [if %branch_value is %body, when %branch_value is %body] to:
         compile error at %body.source "'if % is % %' block has an empty body"
     %code::append "\nend --when"
     return (..)
-        Lua ".."
-            do --if % is
+        Lua "\
+            ..do --if % is
                 local \(mangle "branch value") = \(%branch_value as lua expr)
                 \%code
-            end --if % is
+            end --if % is"
 
 # Do/finally
 compile [do %action] to (..)
-    Lua ".."
-        do
+    Lua "\
+        ..do
             \(%action as lua statements)
-        end --do
+        end --do"
 
 test:
     %d = {}
@@ -467,8 +467,8 @@ test:
 compile [do %action then always %final_action] to:
     define mangler
     return (..)
-        Lua ".."
-            do
+        Lua "\
+            ..do
                 local \(mangle "fell_through") = false
                 local \(mangle "ok"), \(mangle "ret") = pcall(function()
                     \(%action as lua statements)
@@ -477,7 +477,7 @@ compile [do %action then always %final_action] to:
                 \(%final_action as lua statements)
                 if not \(mangle "ok") then error(ret, 0) end
                 if not \(mangle "fell_through") then return ret end
-            end
+            end"
 
 test:
     assume ((result of (: return 99)) == 99)
@@ -502,12 +502,12 @@ compile [for %var in recursive %structure %body] to (..)
         compile [recurse %v on %x] to (..)
             Lua "table.insert(\(mangle "stack \(%v.1)"), \(%x as lua expr))"
         %lua = (..)
-            Lua ".."
-                do
+            Lua "\
+                ..do
                     local \(mangle "stack \(%var.1)") = _List{\(%structure as lua expr)}
                     while #\(mangle "stack \(%var.1)") > 0 do
                         \(%var as lua expr) = table.remove(\(mangle "stack \(%var.1)"), 1)
-                        \(%body as lua statements)
+                        \(%body as lua statements)"
         
         if (%body has subtree \(do next)):
             %lua::append "\n        ::continue::"
diff --git a/core/coroutines.nom b/core/coroutines.nom
index d7d1db4..e7ec41e 100644
--- a/core/coroutines.nom
+++ b/core/coroutines.nom
@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V3.8.7.6
+#!/usr/bin/env nomsu -V4.8.8.6
 #
     This file defines the code that creates and manipulates coroutines
 
@@ -15,15 +15,15 @@ test:
     for % in coroutine %co: %nums::add %
     assume (%nums == [4, 5, 6, 6, 6]) or barf "Coroutine iteration failed"
 compile [coroutine %body, generator %body] to (..)
-    Lua value ".."
-        (function()
+    Lua value "\
+        ..(function()
             \(%body as lua statements)
-        end)
+        end)"
 
 compile [->] to (Lua value "coroutine.yield(true)")
 compile [-> %] to (Lua value "coroutine.yield(true, \(% as lua expr))")
 compile [for % in coroutine %co %body] to (..)
-    Lua ".."
-        for junk,\(% as lua expr) in coroutine.wrap(\(%co as lua expr)) do
+    Lua "\
+        ..for junk,\(% as lua expr) in coroutine.wrap(\(%co as lua expr)) do
             \(%body as lua statements)
-        end
+        end"
diff --git a/core/errors.nom b/core/errors.nom
index 53f88be..f5dcb8c 100644
--- a/core/errors.nom
+++ b/core/errors.nom
@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V3.8.7.6
+#!/usr/bin/env nomsu -V4.8.8.6
 #
     This file contains basic error reporting code
 
@@ -10,34 +10,34 @@ compile [compile error at %source %msg] to (..)
     Lua "nomsu:compile_error(\(%source as lua expr), \(%msg as lua expr))"
 
 compile [assume %condition] to:
-    lua> ".."
-        local \%assumption = 'Assumption failed: '..tostring(nomsu:tree_to_nomsu(\%condition))
+    lua> "\
+        ..local \%assumption = 'Assumption failed: '..tostring(nomsu:tree_to_nomsu(\%condition))"
     return (..)
-        Lua ".."
-            if not \(%condition as lua expr) then
+        Lua "\
+            ..if not \(%condition as lua expr) then
                 error(\(quote "\%assumption"), 0)
-            end
+            end"
 
 compile [assume %a == %b] to:
-    lua> ".."
-        local \%assumption = 'Assumption failed: '..tostring(nomsu:tree_to_nomsu(\(\(%a == %b))))
+    lua> "\
+        ..local \%assumption = 'Assumption failed: '..tostring(nomsu:tree_to_nomsu(\(\(%a == %b))))"
     define mangler
     return (..)
-        Lua ".."
-            do
+        Lua "\
+            ..do
                 local \(mangle "a"), \(mangle "b") = \(%a as lua expr), \(%b as lua expr)
                 if \(mangle "a") ~= \(mangle "b") then
                     error(\(quote "\%assumption").."\\n"..tostring(\(mangle "a")).." != "..tostring(\(..)
                 mangle "b"
             ..), 0)
                 end
-            end
+            end"
 
 compile [assume %condition or barf %message] to (..)
-    Lua ".."
-        if not \(%condition as lua expr) then
+    Lua "\
+        ..if not \(%condition as lua expr) then
             error(\(%message as lua expr), 0)
-        end
+        end"
 
 test:
     try (barf) and if it succeeds: barf "try failed."
@@ -57,8 +57,8 @@ compile [..]
     try %action and if it succeeds %success or if it barfs %msg %fallback
     try %action and if it barfs %msg %fallback or if it succeeds %success
 ..to (..)
-    Lua ".."
-        do
+    Lua "\
+        ..do
             local fell_through = false
             local err, erred = nil, false
             local ok, ret = xpcall(function()
@@ -78,7 +78,7 @@ compile [..]
             elseif erred then
                 error(err, 0)
             end
-        end
+        end"
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
diff --git a/core/id.nom b/core/id.nom
index 9f41cfb..9656dd0 100644
--- a/core/id.nom
+++ b/core/id.nom
@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V3.8.7.6
+#!/usr/bin/env nomsu -V4.8.8.6
 #
     A simple UUID function based on RFC 4122: http://www.ietf.org/rfc/rfc4122.txt
 
@@ -13,8 +13,7 @@ use "core/control_flow.nom"
 set %obj_by_id's metatable to {__mode:"v"}
 %id_by_obj = {}
 set %id_by_obj 's metatable to {..}
-    __mode:"k"
-    __index: (..)
+    __mode:"k", __index: (..)
         [%self, %key] ->:
             if (%key == (nil)):
                 return %self.%nil_surrogate
diff --git a/core/io.nom b/core/io.nom
index d656419..1e87209 100644
--- a/core/io.nom
+++ b/core/io.nom
@@ -1,23 +1,23 @@
-#!/usr/bin/env nomsu -V3.8.7.6
+#!/usr/bin/env nomsu -V4.8.8.6
 #
     This file contains basic input/output code
 
 use "core/metaprogramming.nom"
 
 compile [say %message] to (..)
-    lua> ".."
-        if \%message.type == "Text" then
+    lua> "\
+        ..if \%message.type == "Text" then
             return LuaCode(tree.source, "print(", \(%message as lua expr), ");");
         else
             return LuaCode(tree.source, "print(tostring(", \(%message as lua expr), "));");
-        end
+        end"
 
 compile [ask %prompt] to (..)
-    lua> ".."
-        if \%prompt.type == "Text" then
+    lua> "\
+        ..if \%prompt.type == "Text" then
             return LuaCode.Value(tree.source, "(io.write(", \(%prompt as lua expr), ") and io.read())");
         else
             return LuaCode.Value(tree.source, "(io.write(tostring(", \(..)
             %prompt as lua expr
         .., ")) and io.read())");
-        end
+        end"
diff --git a/core/math.nom b/core/math.nom
index 439b698..11282a4 100644
--- a/core/math.nom
+++ b/core/math.nom
@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V3.8.7.6
+#!/usr/bin/env nomsu -V4.8.8.6
 #
     This file defines some common math literals and functions
 
@@ -10,8 +10,8 @@ use "core/collections.nom"
 
 # Literals:
 test:
-    assume (all of [inf, NaN, pi, tau, golden ratio, e]) or barf ".."
-        math constants failed
+    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")
@@ -127,9 +127,9 @@ parse [max of %items by %item = %value_expr] as (..)
 
 # Random functions
 action [seed random with %] (..)
-    lua> ".."
-        math.randomseed(\%);
-        for i=1,20 do math.random(); end
+    lua> "\
+        ..math.randomseed(\%);
+        for i=1,20 do math.random(); end"
 
 parse [seed random] as (seed random with (=lua "os.time()"))
 compile [random number, random, rand] to (Lua value "math.random()")
diff --git a/core/metaprogramming.nom b/core/metaprogramming.nom
index 5c08167..f669493 100644
--- a/core/metaprogramming.nom
+++ b/core/metaprogramming.nom
@@ -1,11 +1,11 @@
-#!/usr/bin/env nomsu -V3.8.7.6
+#!/usr/bin/env nomsu -V4.8.8.6
 #
     This File contains actions for making actions and compile-time actions and some helper
     functions to make that easier.
 
 lua> "NOMSU_CORE_VERSION = 8"
-lua> ".."
-    do
+lua> "\
+    ..do
         local mangle_index = 0
         function mangler()
             local my_mangle_index = mangle_index
@@ -17,10 +17,10 @@ lua> ".."
     end
     COMPILE_ACTIONS["define mangler"] = function(nomsu, tree)
         return LuaCode(tree.source, "local mangle_1 = mangler()")
-    end
+    end"
 
-lua> ".."
-    COMPILE_ACTIONS["1 -> 2"] = function(nomsu, tree, \%args, \%body)
+lua> "\
+    ..COMPILE_ACTIONS["1 -> 2"] = function(nomsu, tree, \%args, \%body)
         local lua = LuaCode.Value(tree.source, "(function(")
         if AST.is_syntax_tree(\%args, "Action") then \%args = \%args:get_args() end
         local lua_args = table.map(\%args, function(a) return AST.is_syntax_tree(a) and tostring(nomsu:compile(a)) or a end)
@@ -30,10 +30,10 @@ lua> ".."
         body_lua:declare_locals()
         lua:append(")\\n    ", body_lua, "\\nend)")
         return lua
-    end
+    end"
 
-lua> ".."
-    COMPILE_ACTIONS["compile as 1"] = function(nomsu, tree, \%action)
+lua> "\
+    ..COMPILE_ACTIONS["compile as 1"] = function(nomsu, tree, \%action)
         local lua = LuaCode.Value(tree.source, "COMPILE_ACTIONS[", repr(\%action.stub), "](")
         local lua_args = table.map(\%action:get_args(), function(a) return nomsu:compile(a) end)
         table.insert(lua_args, 1, "nomsu")
@@ -41,7 +41,7 @@ lua> ".."
         lua:concat_append(lua_args, ", ")
         lua:append(")")
         return lua
-    end
+    end"
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -62,8 +62,8 @@ test:
 test:
     asdf
     assume (%tmp is (nil)) or barf "compile to is leaking variables"
-lua> ".."
-    COMPILE_ACTIONS["compile 1 to 2"] = function(nomsu, tree, \%actions, \%body)
+lua> "\
+    ..COMPILE_ACTIONS["compile 1 to 2"] = function(nomsu, tree, \%actions, \%body)
         local \%args = {"nomsu", "tree", unpack(table.map(\%actions[1]:get_args(), function(a) return tostring(nomsu:compile(\
     ..a)) end))}
         local lua = LuaCode(tree.source, "COMPILE_ACTIONS[", repr(\%actions[1].stub),
@@ -84,16 +84,16 @@ lua> ".."
             end
         end
         return lua
-    end
+    end"
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 compile [call %fn with %args] to:
-    lua> ".."
-        local lua = LuaCode.Value(tree.source, nomsu:compile(\%fn), "(")
+    lua> "\
+        ..local lua = LuaCode.Value(tree.source, nomsu:compile(\%fn), "(")
         lua:concat_append(table.map(\%args, function(a) return nomsu:compile(a) end), ", ")
         lua:append(")")
-        return lua
+        return lua"
 
 test:
     local action [foo %x]: return "outer"
@@ -108,8 +108,8 @@ test:
     
     assume ((foo 1) == "outer")
 compile [local action %actions %body] to:
-    lua> ".."
-        local fn_name = \%actions[1].stub:as_lua_id()
+    lua> "\
+        ..local fn_name = \%actions[1].stub:as_lua_id()
         local \%args = table.map(\%actions[1]:get_args(), function(a) return tostring(nomsu:compile(a)) end)
         local lua = LuaCode(tree.source, fn_name, " = ", \(compile as (%args -> %body)))
         lua:add_free_vars({fn_name})
@@ -129,7 +129,7 @@ compile [local action %actions %body] to:
                 lua:append(")\\nend")
             end
         end
-        return lua
+        return lua"
 
 test:
     action [baz1]: return "baz1"
@@ -138,10 +138,10 @@ test:
     assume ((baz1) == "baz1")
     assume ((baz2) == "baz2")
 compile [action %actions %body] to (..)
-    lua> ".."
-        local lua = \(compile as (local action %actions %body))
+    lua> "\
+        ..local lua = \(compile as (local action %actions %body))
         lua:remove_free_vars(table.map(\%actions, function(a) return a.stub:as_lua_id() end))
-        return lua
+        return lua"
 
 test:
     assume ((action (say %)) == (=lua "say_1"))
@@ -156,15 +156,15 @@ test:
 test:
     set {%1:1, %2:2}
     swap %1 and %2
-    assume ((%1 == 2) and (%2 == 1)) or barf ".."
-        'parse % as %' failed on 'swap % and %'
+    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.
+    assume ((%tmp == 2) and (%tmp2 == 1)) or barf "\
+        ..'parse % as %' variable mangling failed."
 compile [parse %actions as %body] to (..)
-    lua> ".."
-        local replacements = {}
+    lua> "\
+        ..local replacements = {}
         for i,arg in ipairs(\%actions[1]:get_args()) do
             replacements[arg[1]] = tostring(nomsu:compile(arg))
         end
@@ -201,18 +201,18 @@ compile [parse %actions as %body] to (..)
             "\\nlocal lua = nomsu:compile(tree)",
             "\\nreturn lua")
         local ret = \(compile as (compile %actions to %new_body))
-        return ret
+        return ret"
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 action [%tree as lua expr]:
-    lua> ".."
-        \%tree_lua = nomsu:compile(\%tree)
+    lua> "\
+        ..\%tree_lua = nomsu:compile(\%tree)
         if not \%tree_lua.is_value then
             nomsu:compile_error(\%tree.source, "Could not convert %s to a Lua expression",
                 nomsu:tree_to_nomsu(\%tree))
         end
-        return \%tree_lua
+        return \%tree_lua"
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -227,8 +227,8 @@ compile [remove action %action] to (..)
     Lua "\(=lua "(\(%action.stub)):as_lua_id()") = nil"
 
 test:
-    assume ("\(\(foo \%x) as nomsu)" == "foo %x") or barf ".."
-        action source code failed.
+    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))"
 
@@ -236,12 +236,12 @@ compile [%tree as inline nomsu] to (..)
     Lua value "nomsu:tree_to_nomsu(\(%tree as lua expr), true)"
 
 action [%var as lua identifier, %var as lua id] (..)
-    lua> ".."
-        if type(\%var) == 'string' then return \%var:as_lua_id()
+    lua> "\
+        ..if type(\%var) == 'string' then return \%var:as_lua_id()
         elseif AST.is_syntax_tree(\%var, 'Var') then return \%var[1]:as_lua_id()
         elseif AST.is_syntax_tree(\%var, 'Action') then return \%var.stub:as_lua_id()
         else error("Unknown type: "..tostring(\%var))
-        end
+        end"
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -250,39 +250,39 @@ compile [% is %kind syntax tree] to (..)
     Lua value "AST.is_syntax_tree(\(% as lua expr), \(%kind as lua expr))"
 
 compile [%tree with %t -> %replacement] to (..)
-    Lua value ".."
-        \(%tree as lua expr):map(function(\(%t as lua expr))
+    Lua value "\
+        ..\(%tree as lua expr):map(function(\(%t as lua expr))
             \(%replacement as lua return)
-        end)
+        end)"
 
 action [%tree with vars %replacements] (..)
-    =lua ".."
-        \%tree:map(function(\%t)
+    =lua "\
+        ..\%tree:map(function(\%t)
             if \%t.type == "Var" then
                 return \%replacements[\%t[1]]
             end
-        end)
+        end)"
 
 compile [tree %tree with vars %replacements] to (..)
-    Lua value ".."
-        \(=lua "repr(\%tree)"):map(function(t)
+    Lua value "\
+        ..\(=lua "repr(\%tree)"):map(function(t)
             if t.type == "Var" then
                 return \(%replacements as lua expr)[t[1]]
             end
-        end)
+        end)"
 
 compile [%tree has subtree %match_tree] to (..)
-    Lua value ".."
-        (function()
+    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)()
+        end)()"
 
 action [match %tree with %patt]:
-    lua> ".."
-        if \%patt.type == "Var" then return _Dict{[\%patt[1]]=\%tree} end
+    lua> "\
+        ..if \%patt.type == "Var" then return _Dict{[\%patt[1]]=\%tree} end
         if \%patt.type == "Action" and \%patt.stub ~= \%tree.stub then return nil end
         if #\%patt ~= #\%tree then return nil end
         local matches = _Dict{}
@@ -296,11 +296,11 @@ action [match %tree with %patt]:
                 end
             end
         end
-        return matches
+        return matches"
 
 action [%tree with %patt ~> %replacement]:
-    lua> ".."
-        return \%tree:map(function(\%t)
+    lua> "\
+        ..return \%tree:map(function(\%t)
             local \%vars = \(match %t with %patt)
             if not \%vars then return nil end
             for \%k,\%v in pairs(\%vars) do
@@ -311,14 +311,14 @@ action [%tree with %patt ~> %replacement]:
                     return \%vars[\%t[1]]
                 end
             end)
-        end)
+        end)"
 
 test:
     assume (..)
         (..)
-            quote ".."
-                one
-                "two"
+            quote "\
+                ..one
+                "two""
         ..== "\"one\\n\\\"two\\\"\""
 compile [quote %s] to (Lua value "repr(\(%s as lua expr))")
 
@@ -335,10 +335,10 @@ test:
     assume ((parse "\\1") == \(\(1)))
 compile [parse %text] to (Lua value "nomsu:parse(\(%text as lua expr))")
 compile [parse %text from %filename] to (..)
-    Lua value ".."
-        nomsu:parse(NomsuCode(Source(\(%filename as lua expr), 1, #\(%text as lua expr)), \(..)
+    Lua value "\
+        ..nomsu:parse(NomsuCode(Source(\(%filename as lua expr), 1, #\(%text as lua expr)), \(..)
             %text as lua expr
-        ..))
+        ..))"
 
 test:
     assume ((run "return (2 + 99)") == 101)
@@ -347,10 +347,10 @@ test:
         \(external \%passed = \(yes))
     assume %passed
 compile [run %nomsu_code] to (..)
-    Lua value ".."
-        nomsu:run(\(%nomsu_code as lua expr), \(..)
+    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."
@@ -377,13 +377,13 @@ compile [command line args] to (Lua value "arg")
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 compile [with local compile actions %body] to (..)
-    Lua ".."
-        do
+    Lua "\
+        ..do
             local nomsu = table.fork(nomsu, {COMPILE_ACTIONS=table.fork(COMPILE_ACTIONS)})
             \(%body as lua statements)
-        end
+        end"
 
 action [Nomsu version]:
     use "lib/version.nom"
-    return ".."
-        \(Nomsu syntax version).\(core version).\(Nomsu compiler version).\(lib version)
+    return "\
+        ..\(Nomsu syntax version).\(core version).\(Nomsu compiler version).\(lib version)"
diff --git a/core/operators.nom b/core/operators.nom
index 3d18275..161bf83 100644
--- a/core/operators.nom
+++ b/core/operators.nom
@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V3.8.7.6
+#!/usr/bin/env nomsu -V4.8.8.6
 #
     This file contains definitions of operators like "+" and "and".
 
@@ -29,21 +29,21 @@ test:
 compile [%var = %value] to:
     lua> "local \%var_lua = \(%var as lua)"
     assume %var_lua.is_value or barf "Invalid target for assignment: \%var"
-    lua> ".."
-        \%value = \%value:map(function(t)
+    lua> "\
+        ..\%value = \%value:map(function(t)
             if Action:is_instance(t) and t.stub == "?" then
                 return \%var
             end
         end)
-        local \%value_lua = \(%value as lua)
+        local \%value_lua = \(%value as lua)"
     
     assume %value_lua.is_value or barf "Invalid value for assignment: \%value"
-    lua> ".."
-        local lua = LuaCode(tree.source, \%var_lua, ' = ', \%value_lua, ';')
+    lua> "\
+        ..local lua = LuaCode(tree.source, \%var_lua, ' = ', \%value_lua, ';')
         if \%var.type == 'Var' then
             lua:add_free_vars({tostring(nomsu:compile(\%var))})
         end
-        return lua
+        return lua"
 
 test:
     set {%x:10, %y:20}
@@ -53,10 +53,10 @@ test:
 
 # Simultaneous mutli-assignments like: x,y,z = 1,x,3;
 compile [set %assignments] to:
-    assume (%assignments.type is "Dict") or barf ".."
-        Expected a Dict for the assignments part of '<- %' statement, not \%assignments
-    lua> ".."
-        local lhs, rhs = LuaCode(tree.source), LuaCode(tree.source)
+    assume (%assignments.type is "Dict") or barf "\
+        ..Expected a Dict for the assignments part of '<- %' statement, not \%assignments"
+    lua> "\
+        ..local lhs, rhs = LuaCode(tree.source), LuaCode(tree.source)
         for i, item in ipairs(\%assignments) do
             local \%target, \%value = item[1], item[2]
             \%value = \%value:map(function(t)
@@ -82,7 +82,7 @@ compile [set %assignments] to:
             lhs:append(target_lua)
             rhs:append(value_lua)
         end
-        return LuaCode(tree.source, lhs, " = ", rhs, ";")
+        return LuaCode(tree.source, lhs, " = ", rhs, ";")"
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -109,12 +109,12 @@ test:
             %y = "inner"
     
     set global x local y
-    assume ((%foozle == "inner") and (%y == "outer")) or barf ".."
-        'with external' failed.
+    assume ((%foozle == "inner") and (%y == "outer")) or barf "\
+        ..'with external' failed."
 compile [with external %externs %body] to:
     %body_lua = (%body as lua statements)
-    lua> ".."
-        \%body_lua:remove_free_vars(table.map(\%externs, function(v) return tostring(nomsu:compile(v)) end))
+    lua> "\
+        ..\%body_lua:remove_free_vars(table.map(\%externs, function(v) return tostring(nomsu:compile(v)) end))"
     return %body_lua
 
 test:
@@ -128,8 +128,8 @@ test:
     assume (%z == (nil)) or barf "'with' scoping failed"
 compile [with %assignments %body] to:
     %lua = (%body as lua statements)
-    lua> ".."
-        local lhs, rhs = LuaCode(tree.source), LuaCode(tree.source)
+    lua> "\
+        ..local lhs, rhs = LuaCode(tree.source), LuaCode(tree.source)
         local vars = {}
         for i, item in ipairs(\%assignments) do
             local \%target, \%value = item[1], item[2]
@@ -152,13 +152,13 @@ compile [with %assignments %body] to:
             end
         end
         \%lua:remove_free_vars(vars)
-        \%lua:prepend("local ", lhs, " = ", rhs, ";\\n")
+        \%lua:prepend("local ", lhs, " = ", rhs, ";\\n")"
     
     return (..)
-        Lua ".."
-            do
+        Lua "\
+            ..do
                 \%lua
-            end -- 'with' block
+            end -- 'with' block"
 
 # Math Operators
 test:
@@ -175,8 +175,8 @@ test:
         return 1
     
     assume (0 <= (one) <= 2) or barf "Three-way chained comparison failed."
-    assume (%calls == 1) or barf ".."
-        Three-way comparison evaluated middle value multiple times
+    assume (%calls == 1) or barf "\
+        ..Three-way comparison evaluated middle value multiple times"
 parse [%x < %y < %z] as (..)
     call ([%a, %b, %c] -> ((%a < %b) and (%b < %c))) with [%x, %y, %z]
 
@@ -232,28 +232,28 @@ compile [NOT %, ~ %] to (..)
 
 compile [%a OR %b, %a | %b] to (..)
     Lua value (..)
-        (%use_bitops and "bit.bor(\(%a as lua expr), \(%b as lua expr))") or ".."
-            (\(%a as lua expr) | \(%b as lua expr))
+        (%use_bitops and "bit.bor(\(%a as lua expr), \(%b as lua expr))") or "\
+            ..(\(%a as lua expr) | \(%b as lua expr))"
 
 compile [%a XOR %b, %a ~ %b] to (..)
     Lua value (..)
-        (%use_bitops and "bit.bxor(\(%a as lua expr), \(%b as lua expr))") or ".."
-            (\(%a as lua expr) ~ \(%b as lua expr))
+        (%use_bitops and "bit.bxor(\(%a as lua expr), \(%b as lua expr))") or "\
+            ..(\(%a as lua expr) ~ \(%b as lua expr))"
 
 compile [%a AND %b, %a & %b] to (..)
     Lua value (..)
-        (%use_bitops and "bit.band(\(%a as lua expr), \(%b as lua expr))") or ".."
-            (\(%a as lua expr) & \(%b as lua expr))
+        (%use_bitops and "bit.band(\(%a as lua expr), \(%b as lua expr))") or "\
+            ..(\(%a as lua expr) & \(%b as lua expr))"
 
 compile [%x LSHIFT %shift, %x << %shift] to (..)
     Lua value (..)
-        (%use_bitops and "bit.lshift(\(%x as lua expr), \(%shift as lua expr))") or ".."
-            (\(%x as lua expr) << \(%shift as lua expr))
+        (%use_bitops and "bit.lshift(\(%x as lua expr), \(%shift as lua expr))") or "\
+            ..(\(%x as lua expr) << \(%shift as lua expr))"
 
 compile [%x RSHIFT %shift, %x >> %shift] to (..)
     Lua value (..)
-        (%use_bitops and "bit.rshift(\(%x as lua expr), \(%shift as lua expr))") or ".."
-            (\(%x as lua expr) >> \(%shift as lua expr))
+        (%use_bitops and "bit.rshift(\(%x as lua expr), \(%shift as lua expr))") or "\
+            ..(\(%x as lua expr) >> \(%shift as lua expr))"
 
 # Unary operators
 test:
diff --git a/core/scopes.nom b/core/scopes.nom
index 6cc79c0..216222d 100644
--- a/core/scopes.nom
+++ b/core/scopes.nom
@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V3.8.7.6
+#!/usr/bin/env nomsu -V4.8.8.6
 #
     This file contains definitions pertaining to variable scoping
 
@@ -25,9 +25,9 @@ compile [with local %locals %body, with local %locals do %body] to:
     if %locals.type is:
         "Dict":
             %body_lua = (..)
-                Lua ".."
-                    \(compile as (<- %locals))
-                    \%body_lua
+                Lua "\
+                    ..\(compile as (<- %locals))
+                    \%body_lua"
             
             %body_lua::declare locals ("\(%.1 as lua)" for % in %locals)
         
@@ -39,7 +39,7 @@ compile [with local %locals %body, with local %locals do %body] to:
             compile error at %locals.source "Unexpected locals: %s"
     
     return (..)
-        Lua ".."
-            do
+        Lua "\
+            ..do
                 \%body_lua
-            end
+            end"
diff --git a/core/text.nom b/core/text.nom
index da9d550..25e9c3c 100644
--- a/core/text.nom
+++ b/core/text.nom
@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V3.8.7.6
+#!/usr/bin/env nomsu -V4.8.8.6
 #
     This file contains some definitions of text escape sequences, including ANSI console
     color codes.
@@ -8,16 +8,12 @@ use "core/metaprogramming.nom"
 test:
     assume "\[1, 2, 3]" == "[1, 2, 3]"
     assume "foo = \(1 + 2)!" == "foo = 3!"
-    assume (..)
-        ".."
-            one
-            two
-        ..== "one\ntwo"
-    assume (..)
-        ".."
-            no\
-            ..gap
-        ..== "nogap"
+    assume "one\ntwo" == "\
+        ..one
+        two"
+    assume "nogap" == "\
+        ..no\
+        ..gap"
     assume (["x", "y"]::joined with ",") == "x,y"
     assume (["x", "y"]::joined) == "xy"
     assume ("BAR"::byte 2) == 65
@@ -31,10 +27,9 @@ test:
     %こんにちは = "こんにちは"
     アクション [% と言う] "\(%)世界"
     assume (%こんにちは と言う) == "こんにちは世界"
-
 compile [%expr for %match in %text matching %patt] to (..)
-    Lua value ".."
-        (function()
+    Lua value "\
+        ..(function()
             local ret = _List{}
             for \(%match as lua expr) in (\(%text as lua expr)):gmatch(\(..)
             %patt as lua expr
@@ -42,14 +37,14 @@ compile [%expr for %match in %text matching %patt] to (..)
                 ret[#ret+1] = \(%expr as lua statements)
             end
             return ret
-        end)()
+        end)()"
 
 test:
     assume "\n" == (newline)
 
 # Text literals
-lua> ".."
-    do
+lua> "\
+    ..do
         local escapes = {
             nl="\\\\n", newline="\\\\n", tab="\\\\t", bell="\\\\a", cr="\\\\r",
             ["carriage return"]="\\\\r", backspace="\\\\b", ["form feed"]="\\\\f",
@@ -61,4 +56,4 @@ lua> ".."
                 return LuaCode.Value(tree.source, lua)
             end
         end
-    end
+    end"
diff --git a/examples/how_do_i.nom b/examples/how_do_i.nom
index cc9901a..1d43982 100644
--- a/examples/how_do_i.nom
+++ b/examples/how_do_i.nom
@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V3.8.7.6
+#!/usr/bin/env nomsu -V4.8.8.6
 # How do I...
 # Write a comment? Put a # and go till the end of the line
 # How do I write a multi-line comment?
@@ -32,18 +32,19 @@ say %one_two
 
 # How do I define a mutli-line string?
 # In Nomsu, "strings" are called "text", and multi-line text looks like:
-%mutli_text = ".."
-    Start with "..", then put indented lines below it. The indented lines will not include
-    the indentation, except when the lines are indented more than 4 spaces relative
-    to the "..".
+%mutli_text = "\
+    ..Start with a quote mark and a backslash and an indented "..", then put indented
+    lines below it. The indented lines will not include the indentation, except when
+    the lines are indented more than 4 spaces relative to the original quote mark.
       <- E.g. the 2 spaces here will be included as part of the text.
     But this line will have no leading spaces.
     
-    The text will continue until the indentation ends, skipping trailing newlines.
+    The text will continue until a closing quotation at the end of the text's
+    indentation level."
 
 # How do I put values inside text? (AKA string formatting, string interpolation)
-say ".."
-    Text can contain a backslash followed by a variable, list, dict, or parenthesized
+say "\
+    ..Text can contain a backslash followed by a variable, list, dict, or parenthesized
     expression. This escaped value will be converted to readable text, like so:
     The value of %foobar is \%foobar, isn't that nice?
     These are some numbers: \[1 + 1, 2 + 1, 3 + 1]
@@ -60,7 +61,7 @@ say ".."
     
     Similarly, you can put a long interpolated indented value like: \(..)
         1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9
-    .. between a backslash and two periods.
+    .. between a backslash and two periods."
 
 say "Single-line text can contain escape sequences like \", \\, \000, and \n"
 
@@ -236,8 +237,8 @@ say (2 + 3)
 say (2 + 3)
 
 # If you need to keep going after an indented region, you can start the next line with ".."
-say both "Very long first argument that needs its own line" and also ".."
-    short second arg
+say both "Very long first argument that needs its own line" and also "\
+    ..short second arg"
 
 action [my favorite number] (21 + 2)
 
@@ -259,10 +260,10 @@ parse [if %condition is untrue %body] as (if (not %condition) %body)
 
 # Or to transform nomsu code into custom lua code using "compile % to %"
 compile [if %condition on opposite day %body] to (..)
-    Lua ".."
-        if not \(%condition as lua expr) then
+    Lua "\
+        ..if not \(%condition as lua expr) then
             \(%body as lua statements)
-        end
+        end"
 
 # Constants can be defined as macros
 parse [TWENTY] as 20
diff --git a/lib/base64.nom b/lib/base64.nom
index 366ac3e..8fc4e6b 100644
--- a/lib/base64.nom
+++ b/lib/base64.nom
@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V3.8.7.6
+#!/usr/bin/env nomsu -V4.8.8.6
 #
     This file defines actions for encoding/decoding base 64, as specified in:
     https://tools.ietf.org/html/rfc4648
@@ -11,13 +11,8 @@ test:
     %cases = ["", "Zg==", "Zm8=", "Zm9v", "Zm9vYg==", "Zm9vYmE=", "Zm9vYmFy"]
     for %len = %encoded in %cases:
         %plain = "foobar".[1, %len - 1]
-        assume ((base64 %plain) == %encoded) or barf ".."
-            \(quote %plain) base64 encoded to \(quote (base64 %plain)) \
-            ..instead of \(quote %encoded)
-        
-        assume ((base64 decode %encoded) == %plain) or barf ".."
-            \(quote %encoded) base64 decoded to \(quote (base64 decode %encoded)) \
-            ..instead of \(quote %plain)
+        assume (base64 %plain) == %encoded
+        assume (base64 decode %encoded) == %plain
 action [base64 %str, base64 encode %str, %str base64]:
     %chars = []
     for %i in 1 to (size of %str) via 3:
diff --git a/lib/consolecolor.nom b/lib/consolecolor.nom
index c86e6d1..ba40bda 100644
--- a/lib/consolecolor.nom
+++ b/lib/consolecolor.nom
@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V3.8.7.6
+#!/usr/bin/env nomsu -V4.8.8.6
 #
     This file defines actions for ANSI console color escape codes.
 
@@ -14,9 +14,9 @@ test:
 
 for %name = %colornum in %colors:
     with {%escapecode:"\027[\(%colornum)m"}:
-        run ".."
-            compile [\%name] to (..)
+        run "\
+            ..compile [\%name] to (..)
                 Lua value (quote \(quote %escapecode))
             compile [\%name %text] to (..)
-                Lua value ".."
-                    (\\(quote \(quote %escapecode))..\\(%text as lua expr).."\\27[0m")
+                Lua value "\\
+                    ..(\\(quote \(quote %escapecode))..\\(%text as lua expr).."\\27[0m")""
diff --git a/lib/file_hash.nom b/lib/file_hash.nom
index 5553b35..6fdb2f4 100644
--- a/lib/file_hash.nom
+++ b/lib/file_hash.nom
@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V3.8.7.6
+#!/usr/bin/env nomsu -V4.8.8.6
 #
     This file defines some actions for hashing files and looking up files by hash.
 
@@ -8,21 +8,21 @@ use "lib/base64.nom"
 lua> "local \%use_sha1, \%hashlib = pcall(require, 'openssl.digest')"
 
 test:
-    assume ((hash "hello world") == (hash "hello world"))
-    assume ((hash "hello world") != (hash "goodbye")) or barf ".."
-        Hash collision:
+    assume (hash "hello world") == (hash "hello world")
+    assume ((hash "hello world") != (hash "goodbye")) or barf "\
+        ..Hash collision:
             (hash "hello world") = \(hash "hello world")
-            (hash "goodbye") = \(hash "goodbye")
+            (hash "goodbye") = \(hash "goodbye")"
     
     assume (..)
         (..)
-            hash ".."
-                This is a really long string meant to stress test the hashing function and
-                ensure that it's not overflowing with long inputs.
+            hash "\
+                ..This is a really long string meant to stress test the hashing function and
+                ensure that it's not overflowing with long inputs."
         ..!= "inf"
     
-    assume ((hash "\000") != (hash "\000\000\000\000\000")) or barf ".."
-        Incorrect hashing of null strings
+    assume ((hash "\000") != (hash "\000\000\000\000\000")) or barf "\
+        ..Incorrect hashing of null strings"
     if %use_sha1:
         assume ((hash "hello world") == "Kq5sNclPz7QV2+lfQIuc6R7oRu0=")
 if %use_sha1:
@@ -31,8 +31,8 @@ if %use_sha1:
         return (base64 %hash)
 ..else:
     # TODO: remove warning?
-    say ".."
-        \027[31;1mWARNING: OpenSSL module not found. Defaulting to a non-cryptographically secure hash function.\027[0m
+    say "\
+        ..\027[31;1mWARNING: OpenSSL module not found. Defaulting to a non-cryptographically secure hash function.\027[0m"
     action [hash %]:
         %bytes = (%::bytes)
         %hash = (%bytes.1 << 7)
diff --git a/lib/object.nom b/lib/object.nom
index 1645a28..88b9d1e 100644
--- a/lib/object.nom
+++ b/lib/object.nom
@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V3.8.7.6
+#!/usr/bin/env nomsu -V4.8.8.6
 #
     This file contains the implementation of an Object-Oriented programming system.
 
@@ -43,8 +43,8 @@ test:
     with {%d:new Dog {barks:2}}:
         assume ((%d::bark) == "Bark! Bark!")
 compile [my action %actions %body] to:
-    lua> ".."
-        local fn_name = \%actions[1].stub:as_lua_id()
+    lua> "\
+        ..local fn_name = \%actions[1].stub:as_lua_id()
         local \%args = table.map(\%actions[1]:get_args(), function(a) return tostring(nomsu:compile(a)) end)
         table.insert(\%args, \(\%me as lua id))
         local lua = LuaCode(tree.source, "class.", fn_name, " = ", \(..)
@@ -66,12 +66,12 @@ compile [my action %actions %body] to:
                 lua:append(")\\nend")
             end
         end
-        return lua
+        return lua"
 
 compile [object %classname extends %parent %class_body] to:
     return (..)
-        Lua ".."
-            do
+        Lua "\
+            ..do
                 local class = {name=\(%classname as lua expr)}
                 setmetatable(class, {
                     __index=\(%parent as lua expr),
@@ -106,7 +106,7 @@ compile [object %classname extends %parent %class_body] to:
                 for stub,metamethod in pairs(metamethod_map) do
                     class[metamethod] = class[stub:as_lua_id()]
                 end
-            end
+            end"
 
 parse [object %classname %class_body] as (..)
     object %classname extends (nil) %class_body
diff --git a/lib/os.nom b/lib/os.nom
index 2c9addf..e6faa18 100644
--- a/lib/os.nom
+++ b/lib/os.nom
@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V3.8.7.6
+#!/usr/bin/env nomsu -V4.8.8.6
 #
     This file defines some actions that interact with the operating system and filesystem.
 
@@ -9,11 +9,11 @@ action [path of Nomsu file %filename]:
     barf "Could not find file: \%filename"
 
 action [sh> %cmd]:
-    lua> ".."
-        local result = io.popen(\%cmd)
+    lua> "\
+        ..local result = io.popen(\%cmd)
         local contents = result:read("*a")
         result:close()
-        return contents
+        return contents"
 
 test:
     read file "lib/os.nom"
@@ -22,39 +22,39 @@ action [read file %filename] (=lua "Files.read(\%filename)")
 test:
     for file %f in "core": do nothing
 compile [for file %f in %path %body] to (..)
-    Lua ".."
-        for i,\(%f as lua expr) in Files.walk(\(%path as lua expr)) do
+    Lua "\
+        ..for i,\(%f as lua expr) in Files.walk(\(%path as lua expr)) do
             \(%body as lua statements)
             \(compile as (===next %f ===))
         end
-        \(compile as (===stop %f ===))
+        \(compile as (===stop %f ===))"
 
 compile [%expr for file %f in %path] to (..)
-    Lua value ".."
-        (function()
+    Lua value "\
+        ..(function()
             local ret = _List{}
             for i,\(%f as lua expr) in Files.walk(\(%path as lua expr)) do
                 ret[#ret+1] = \(%expr as lua statements)
             end
             return ret
-        end)()
+        end)()"
 
 action [..]
     write to file %filename %text, to file %filename write %text
     write %text to file %filename
 ..:
     assume (%filename != "stdin") or barf "Cannot write to stdin"
-    lua> ".."
-        local file = io.open(\%filename, 'w')
+    lua> "\
+        ..local file = io.open(\%filename, 'w')
         file:write(\%text)
-        file:close()
+        file:close()"
 
 test:
-    assume ((line number of 3 in "x\ny") == 2)
+    assume (line number of 3 in "x\ny") == 2
 action [line number of %pos in %str] (=lua "Files.get_line_number(\%str, \%pos)")
 
 test:
-    assume ((line 2 in "one\ntwo\nthree") == "two")
+    assume (line 2 in "one\ntwo\nthree") == "two"
 action [line %line_num in %str] (=lua "Files.get_line(\%str, \%line_num)")
 
 test:
diff --git a/lib/training_wheels.nom b/lib/training_wheels.nom
index 8e197c4..6155069 100644
--- a/lib/training_wheels.nom
+++ b/lib/training_wheels.nom
@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V3.8.7.6
+#!/usr/bin/env nomsu -V4.8.8.6
 #
     This file contains a set of definitions that bring some familiar language features
     from other languages into nomsu (e.g. "||" and "continue")
diff --git a/lib/version.nom b/lib/version.nom
index 3c876b8..afb9e14 100644
--- a/lib/version.nom
+++ b/lib/version.nom
@@ -1,3 +1,3 @@
-#!/usr/bin/env nomsu -V3.8.7.6
+#!/usr/bin/env nomsu -V4.8.8.6
 # This file sets the current library version.
 lua> "NOMSU_LIB_VERSION = 6"
diff --git a/nomsu.4.peg b/nomsu.4.peg
index b0ce3da..77ff404 100644
--- a/nomsu.4.peg
+++ b/nomsu.4.peg
@@ -63,6 +63,9 @@ disallowed_interpolation (Error):
     {:error: {~ ("\" ('\:' / '(..)' / '[..]' / '{..}') (%nl (&(%nl) / =curr_indent '        ' [^%nl]*))*) -> 
         "Sorry, indented text interpolations are not currently supported on the first line of multi-line text." ~} :}
     {:hint: {~ '' -> 'Move the code for the first line of text to the next line by ending this line with "\" and starting the next line indented with "..", followed by the code for the first line.' ~} :}
+expected_dotdot (Error):
+    {:error: {~ '' -> 'Expected to see a ".." here' ~} :}
+    {:hint: {~ '' -> 'Add a ".." here.' ~} :}
 
 section_division: ("~")^+3 eol
 
@@ -89,7 +92,7 @@ noindex_inline_expression:
       )
 inline_expression: index_chain / noindex_inline_expression 
 indented_expression:
-    cool_indented_text / indented_text / indented_nomsu / indented_list / indented_dict / ({|
+    indented_text / indented_nomsu / indented_list / indented_dict / ({|
         "(..)" nl_indent
             (action / expression) (eol / unexpected_code)
             (%nl (ws* %nl)* nodent (comment / eol / unexpected_code))*
@@ -125,45 +128,39 @@ word: !number { operator_char+ / ident_char+ }
 text_word (Text): word
 
 inline_text (Text):
-    !(cool_indented_text / indented_text)
-    ('"' _inline_text* ('"' / missing_quote_err / unexpected_code))
+    !(indented_text)
+    '"' _inline_text* ('"' / missing_quote_err / unexpected_code)
 _inline_text:
     {~ (('\"' -> '"') / ('\\' -> '\') / escaped_char / [^%nl\"]+)+ ~}
     / inline_text_interpolation
 inline_text_interpolation:
     "\" (
-        variable / inline_list / inline_dict / inline_text
+        variable / inline_list / inline_dict
         / ("("
             ws* (inline_action / inline_expression) ws*
             (ws* ',' ws* (inline_action / inline_expression) ws*)*
-        (")" / missing_paren_err / unexpected_code))
+            (")" / missing_paren_err / unexpected_code))
     )
 
-indented_text (Text):
-    '".."' eol %nl {%nl+}? {:curr_indent: indent :}
-        (indented_plain_text / text_interpolation / {~ %nl+ (=curr_indent -> "") ~})*
-    unexpected_code?
-    {:curr_indent: %nil :}
-
-
-cool_quote:
+nonterminal_quote:
     '"' &([^%nl] / %nl+ =curr_indent)
-cool_indented_text (Text):
+indented_text (Text):
     '"'
     _inline_text* 
-    (('\' %nl+ {:curr_indent: indent :} '..')
+    (('\' %nl+ {:curr_indent: indent :} ('..' / expected_dotdot))
      / disallowed_interpolation? {%nl+} {:curr_indent: indent :})
-    (indented_cool_plain_text / text_interpolation / {~ %nl+ (=curr_indent -> "") ~})*
+    (indented_plain_text / text_interpolation / {~ %nl+ (=curr_indent -> "") ~})*
     ('"' eol / missing_quote_err)
     {:curr_indent: %nil :}
-indented_cool_plain_text (Text):
-    {~ ((("\" blank_lines =curr_indent "..") -> "") / (!text_interpolation ((!("\n") escaped_char) / ('\\' -> '\') / '\')) / (cool_quote / [^%nl"\])+)+
-        (%nl+ (=curr_indent -> ""))* ~}
-
 -- Tracking text-lines-within-indented-text as separate objects allows for better debugging line info
 indented_plain_text (Text):
-    {~ (("\\" -> "\") / (("\" blank_lines =curr_indent "..") -> "") / (!text_interpolation "\") / [^%nl\]+)+
-        (%nl+ (=curr_indent -> ""))* ~}
+    {~ 
+        ((("\" blank_lines =curr_indent "..") -> "") / ('\\' -> '\')
+        / (!text_interpolation ((!("\n") escaped_char) / '\'))
+        / (nonterminal_quote / [^%nl"\])+)+
+        (%nl+ (=curr_indent -> ""))*
+    ~}
+
 text_interpolation:
     inline_text_interpolation / ("\" indented_expression (blank_lines =curr_indent "..")?)
 
diff --git a/nomsu.lua b/nomsu.lua
index 0a0dce1..328ef32 100644
--- a/nomsu.lua
+++ b/nomsu.lua
@@ -280,20 +280,20 @@ run = function()
     end
   end
   if not (args.primary_file or args.exec_strings) then
-    nomsu:run([[#!/usr/bin/env nomsu -V2
+    nomsu:run([[#!/usr/bin/env nomsu -V4
 use "lib/consolecolor.nom"
 action [quit, exit]: lua> "os.exit(0)"
 action [help]:
-    say ".."
-        This is the Nomsu v\(Nomsu version) interactive console.
+    say "\
+        ..This is the Nomsu v\(Nomsu version) interactive console.
         You can type in Nomsu code here and hit 'enter' twice to run it.
-        To exit, type 'exit' or 'quit' and hit enter twice.
-
-say ".."
+        To exit, type 'exit' or 'quit' and hit enter twice."
 
+say "\
+    ..
     \(bright)\(underscore)Welcome to the Nomsu v\(Nomsu version) interactive console!\(reset color)
         press 'enter' twice to run a command
-    \("")]])
+    "]])
     for repl_line = 1, math.huge do
       io.write(colored.bright(colored.yellow(">> ")))
       local buff = { }
diff --git a/nomsu.moon b/nomsu.moon
index 0c989e6..fcae65d 100755
--- a/nomsu.moon
+++ b/nomsu.moon
@@ -184,20 +184,20 @@ run = ->
     unless args.primary_file or args.exec_strings
         -- Run in interactive mode (REPL)
         nomsu\run [[
-#!/usr/bin/env nomsu -V2
+#!/usr/bin/env nomsu -V4
 use "lib/consolecolor.nom"
 action [quit, exit]: lua> "os.exit(0)"
 action [help]:
-    say ".."
-        This is the Nomsu v\(Nomsu version) interactive console.
+    say "\
+        ..This is the Nomsu v\(Nomsu version) interactive console.
         You can type in Nomsu code here and hit 'enter' twice to run it.
-        To exit, type 'exit' or 'quit' and hit enter twice.
-
-say ".."
+        To exit, type 'exit' or 'quit' and hit enter twice."
 
+say "\
+    ..
     \(bright)\(underscore)Welcome to the Nomsu v\(Nomsu version) interactive console!\(reset color)
         press 'enter' twice to run a command
-    \("")]]
+    "]]
         for repl_line=1,math.huge
             io.write(colored.bright colored.yellow ">> ")
             buff = {}
diff --git a/nomsu_compiler.lua b/nomsu_compiler.lua
index f01edf7..d5921cf 100644
--- a/nomsu_compiler.lua
+++ b/nomsu_compiler.lua
@@ -214,37 +214,29 @@ do
       end
       errs = _accum_0
     end
-    if #errs > 4 then
-      local num_errs = #errs
-      do
-        local _accum_0 = { }
-        local _len_0 = 1
-        for i = 1, 3 do
-          _accum_0[_len_0] = errs[i]
-          _len_0 = _len_0 + 1
-        end
-        errs = _accum_0
-      end
-      table.insert(errs, "\027[31;1m +" .. tostring(num_errs - #errs) .. " additional errors...\027[0m\n")
-    end
-    if #errs > 0 then
+    local num_errs = #errs
+    if num_errs > 0 then
       local err_strings
       do
         local _accum_0 = { }
         local _len_0 = 1
-        for _index_0 = 1, #errs do
-          local t = errs[_index_0]
-          _accum_0[_len_0] = pretty_error({
-            error = t.error,
-            hint = t.hint,
-            source = t:get_source_code(),
-            start = t.source.start,
-            stop = t.source.stop
-          })
-          _len_0 = _len_0 + 1
+        for i, t in ipairs(errs) do
+          if i <= 3 then
+            _accum_0[_len_0] = pretty_error({
+              error = t.error,
+              hint = t.hint,
+              source = t:get_source_code(),
+              start = t.source.start,
+              stop = t.source.stop
+            })
+            _len_0 = _len_0 + 1
+          end
         end
         err_strings = _accum_0
       end
+      if num_errs > 3 then
+        table.insert(err_strings, "\027[31;1m +" .. tostring(num_errs - #errs) .. " additional errors...\027[0m\n")
+      end
       error(table.concat(err_strings, '\n\n'), 0)
     end
     return tree
diff --git a/nomsu_compiler.moon b/nomsu_compiler.moon
index b6faba3..432a195 100644
--- a/nomsu_compiler.moon
+++ b/nomsu_compiler.moon
@@ -112,15 +112,14 @@ with NomsuCompiler
                     find_errors(v)
 
         errs = [err for err in coroutine.wrap(-> find_errors(tree))]
-        if #errs > 4
-            num_errs = #errs
-            errs = [errs[i] for i=1,3]
-            table.insert(errs, "\027[31;1m +#{num_errs-#errs} additional errors...\027[0m\n")
-        if #errs > 0
+        num_errs = #errs
+        if num_errs > 0
             err_strings = [pretty_error{
                     error:t.error, hint:t.hint, source:t\get_source_code!
                     start:t.source.start, stop:t.source.stop
-                } for t in *errs]
+                } for i, t in ipairs(errs) when i <= 3]
+            if num_errs > 3
+                table.insert(err_strings, "\027[31;1m +#{num_errs-#errs} additional errors...\027[0m\n")
             error(table.concat(err_strings, '\n\n'), 0)
         return tree
     .can_optimize = -> false
diff --git a/pretty_errors.lua b/pretty_errors.lua
index ae6b48f..9dad1eb 100644
--- a/pretty_errors.lua
+++ b/pretty_errors.lua
@@ -25,7 +25,7 @@ format_error = function(err)
   else
     pointer = (" "):rep(err_linepos + #fmt_str:format(0) - 1) .. "⬆"
   end
-  local err_msg = "\027[33;41;1mParse error at " .. tostring(err.filename) .. ":" .. tostring(err_linenum) .. "\027[0m"
+  local err_msg = "\027[33;41;1mParse error at " .. tostring(err.filename or '???') .. ":" .. tostring(err_linenum) .. "\027[0m"
   for i = err_linenum - context, err_linenum - 1 do
     do
       local line = string2.line(err.source, i)
diff --git a/pretty_errors.moon b/pretty_errors.moon
index b0d81f9..5dafe99 100644
--- a/pretty_errors.moon
+++ b/pretty_errors.moon
@@ -23,7 +23,7 @@ format_error = (err)->
         (" ")\rep(err_linepos+#fmt_str\format(0)-1).."╚#{("═")\rep(err_size-2)}╝"
     else
         (" ")\rep(err_linepos+#fmt_str\format(0)-1).."⬆"
-    err_msg = "\027[33;41;1mParse error at #{err.filename}:#{err_linenum}\027[0m"
+    err_msg = "\027[33;41;1mParse error at #{err.filename or '???'}:#{err_linenum}\027[0m"
     for i=err_linenum-context,err_linenum-1
         if line = string2.line(err.source, i)
             err_msg ..= "\n\027[2m#{fmt_str\format(i)}\027[0m#{line}\027[0m"
diff --git a/syntax_tree.lua b/syntax_tree.lua
index 230a915..38e71ef 100644
--- a/syntax_tree.lua
+++ b/syntax_tree.lua
@@ -42,16 +42,19 @@ for _index_0 = 1, #types do
       return getmetatable(x) == self
     end
     cls.__tostring = function(self)
-      return tostring(self.type) .. tostring(repr(self, (function(x)
-        return Source:is_instance(x) and repr(tostring(x)) or nil
-      end)))
+      return tostring(self.type) .. tostring(repr(self))
     end
     cls.__repr = function(self)
-      return tostring(self.type) .. tostring(repr(self, (function(x)
-        return Source:is_instance(x) and repr(tostring(x)) or nil
-      end)))
+      return tostring(self.type) .. tostring(repr(self))
     end
-    cls.source_code_for_tree = { }
+    cls.source_code_for_tree = setmetatable({ }, {
+      __index = function(self, t)
+        local s = t.source
+        local Files = require('files')
+        local f = Files.read(s.filename)
+        return f
+      end
+    })
     cls.get_source_code = function(self)
       return self.source_code_for_tree[self]
     end
diff --git a/syntax_tree.moon b/syntax_tree.moon
index cd9bccc..633b5ca 100644
--- a/syntax_tree.moon
+++ b/syntax_tree.moon
@@ -19,9 +19,14 @@ for name in *types
         .__name = name
         .type = name
         .is_instance = (x)=> getmetatable(x) == @
-        .__tostring = => "#{@type}#{repr @, ((x)-> Source\is_instance(x) and repr(tostring(x)) or nil)}"
-        .__repr = => "#{@type}#{repr @, ((x)-> Source\is_instance(x) and repr(tostring(x)) or nil)}"
-        .source_code_for_tree = {}
+        .__tostring = => "#{@type}#{repr @}"
+        .__repr = => "#{@type}#{repr @}"
+        .source_code_for_tree = setmetatable({}, {__index:(t)=>
+            s = t.source
+            Files = require 'files'
+            f = Files.read(s.filename)
+            return f
+        })
         .get_source_code = => @source_code_for_tree[@]
         .map = (fn)=>
             replacement = fn(@)
diff --git a/tools/autoformat.nom b/tools/autoformat.nom
index 42e7dca..a915fa4 100755
--- a/tools/autoformat.nom
+++ b/tools/autoformat.nom
@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V3.8.7.6
+#!/usr/bin/env nomsu -V4.8.8.6
 #
     Auto-format Nomsu code. Usage:
         nomsu tools/autoformat.nom [-i] file1 file2 directory1 ...
@@ -16,9 +16,9 @@ if (%args.1 is "-i"):
 for %path in %args:
     for file %filename in %path:
         unless (%filename::matches "%.nom$"): do next %filename
-        %formatted = ".."
-            #!/usr/bin/env nomsu -V\(Nomsu version)
-            \((parse (read file %filename) from %filename) as nomsu)
+        %formatted = "\
+            ..#!/usr/bin/env nomsu -V\(Nomsu version)
+            \((parse (read file %filename) from %filename) as nomsu)"
         
         if %inplace:
             write %formatted to file %filename
diff --git a/tools/find_action.nom b/tools/find_action.nom
index 4918966..e6fe90a 100755
--- a/tools/find_action.nom
+++ b/tools/find_action.nom
@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V3.8.7.6
+#!/usr/bin/env nomsu -V4.8.8.6
 #
     Find an action by its stub. Usage:
         nomsu tools/find_action.nom "foo %" file1 file2 directory1 ...
diff --git a/tools/parse.nom b/tools/parse.nom
index ee4a722..9d728e8 100755
--- a/tools/parse.nom
+++ b/tools/parse.nom
@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V3.8.7.6
+#!/usr/bin/env nomsu -V4.8.8.6
 #
     Tool to print out a parse tree of files in an easy-to-read format. Usage:
         nomsu tools/parse.nom file1 file2 directory1 ...        
diff --git a/tools/replace.nom b/tools/replace.nom
index a0de4cc..c55793a 100755
--- a/tools/replace.nom
+++ b/tools/replace.nom
@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V3.8.7.6
+#!/usr/bin/env nomsu -V4.8.8.6
 #
     Tool to find and replace one tree with another.
         nomsu tools/replace.nom [-i] tree_to_replace replacement file1 file2 directory1 ...
@@ -29,9 +29,9 @@ for %path in %args:
             say "No changes in \%filename"
             do next %filename
         
-        %text = ".."
-            #!/usr/bin/env nomsu -V\(%tree.version or (Nomsu version))
-            \(%tree2 as nomsu)
+        %text = "\
+            ..#!/usr/bin/env nomsu -V\(%tree.version or (Nomsu version))
+            \(%tree2 as nomsu)"
         
         if:
             %inplace:
diff --git a/tools/test.nom b/tools/test.nom
index 5c42ec9..379f968 100755
--- a/tools/test.nom
+++ b/tools/test.nom
@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V3.8.7.6
+#!/usr/bin/env nomsu -V4.8.8.6
 #
     Tool to run all tests in a file (i.e. the code block inside a call to 'test %'). Usage:
         nomsu tools/test.nom file1 file2 directory1 ...
diff --git a/tools/upgrade.nom b/tools/upgrade.nom
index d85465e..cd3fbbb 100755
--- a/tools/upgrade.nom
+++ b/tools/upgrade.nom
@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V3.8.7.6
+#!/usr/bin/env nomsu -V4.8.8.6
 #
     Tool to automatically update code from old versions of Nomsu. Usage:
         nomsu tools/upgrade.nom [-i] file1 file2 directory1 ...
@@ -24,9 +24,9 @@ for %path in %args:
         unless (%filename::matches "%.nom$"): do next %filename
         %tree = (parse (read file %filename) from %filename)
         %uptree = (%tree upgraded)
-        %text = ".."
-            #!/usr/bin/env nomsu -V\(Nomsu version)
-            \(%uptree as nomsu)
+        %text = "\
+            ..#!/usr/bin/env nomsu -V\(Nomsu version)
+            \(%uptree as nomsu)"
         
         if:
             %inplace: