diff --git a/lib/control_flow.nom b/lib/control_flow.nom
index c16b19d..aeb63ef 100644
--- a/lib/control_flow.nom
+++ b/lib/control_flow.nom
@@ -4,24 +4,24 @@ require "lib/utils.nom"
 
 # Conditionals
 compile [if %condition %if_body] to code: ".."
-    |if \(%condition as lua) then;
+    |if \(%condition as lua) then
     |\(%if_body as lua statements)
-    |end;--end if
+    |end --end if
 compile [unless %condition %body] to code: ".."
-    |if not (\(%condition as lua)) then;
+    |if not (\(%condition as lua)) then
     |\(%body as lua statements)
-    |end;--end if
+    |end --end if
 
 compile [if %condition %if_body else %else_body, unless %condition %else_body else %if_body] to code: ".."
-    |if \(%condition as lua) then;
+    |if \(%condition as lua) then
     |\(%if_body as lua statements)
-    |else;
+    |else
     |\(%else_body as lua statements)
-    |end;--end if
+    |end --end if
 
 # Return
-compile [return] to code: "do; return; end;"
-compile [return %return_value] to code: "do; return \(%return_value as lua); end;"
+compile [return] to code: "do return; end"
+compile [return %return_value] to code: "do return \(%return_value as lua); end"
 
 # GOTOs
 compile [-> %label] to code: ".."
@@ -32,13 +32,13 @@ compile [go to %label] to code: ".."
 rule [tree %tree has function call %call] =:
     lua> ".."
         |local target = (\(%call)).value;
-        |for subtree,_ in coroutine.wrap(function() nomsu:walk_tree(\(%tree)); end) do;
+        |for subtree,_ in coroutine.wrap(function() nomsu:walk_tree(\(%tree)); end) do
         |    if type(subtree) == 'table' and subtree.type == "FunctionCall"
-        |    and nomsu.utils.equivalent(subtree.value, target, 2) then;
+        |    and nomsu.utils.equivalent(subtree.value, target, 2) then
         |        return true;
-        |    end;
-        |end;
-        |do; return false; end;
+        |    end
+        |end
+        |do return false; end
 
 # While loops
 compile [do next repeat-loop] to code: "goto continue_repeat;"
@@ -47,15 +47,15 @@ compile [repeat while %condition %body] to code:
     %continue_labels = (..)
         "\n::continue_repeat::;" if (tree %body has function call \(do next repeat-loop)) else ""
     %code = ".."
-        |while \(%condition as lua) do;
+        |while \(%condition as lua) do
         |\(%body as lua statements)\(%continue_labels)
-        |end;--while-loop
+        |end --while-loop
     if (tree %body has function call \(stop repeat-loop)):
         return ".."
-            |do;--while-loop label scope
+            |do --while-loop label scope
             |\(%code)
             |::stop_repeat::;
-            |end;--while-loop label scope
+            |end --while-loop label scope
     return %code
 parse [repeat %body] as: repeat while (true) %body
 parse [repeat until %condition %body] as: repeat while (not %condition) %body
@@ -79,20 +79,20 @@ compile [..]
     if (tree %body has function call (nomsu "replaced_vars" [\(do next %), =lua "{['']=\(%var)}"])):
         %continue_labels join= "\n::continue_\(nomsu "var_to_lua_identifier" [%var])::;"
     %code = ".."
-        |for i=\(%start as lua),\(%stop as lua),\(%step as lua) do;
+        |for i=\(%start as lua),\(%stop as lua),\(%step as lua) do
         # This trashes the loop variables, just like in Python.
         |\(%var as lua) = i;
         |\(%body as lua statements)\(%continue_labels)
-        |end;--numeric for-loop
+        |end --numeric for-loop
     %stop_labels = ""
     if (tree %body has function call \(stop for-loop)):
         %stop_labels join= "\n::stop_for::;"
     if (tree %body has function call (nomsu "replaced_vars" [\(stop %), =lua "{['']=\(%var)}"])):
         %stop_labels join= "\n::stop_\(nomsu "var_to_lua_identifier" [%var])::;"
     if (%stop_labels != ""): ".."
-        |do;--for-loop label scope
+        |do --for-loop label scope
         |\(%code)\(%stop_labels)
-        |end;--for-loop label scope
+        |end --for-loop label scope
     ..else: %code
 parse [for %var from %start to %stop %body] as: for %var from %start to %stop via 1 %body
 parse [..]
@@ -108,20 +108,20 @@ compile [for %var in %iterable %body] to code:
     if (tree %body has function call (nomsu "replaced_vars" [\(do next %), =lua "{['']=\(%var)}"])):
         %continue_labels join= "\n::continue_\(nomsu "var_to_lua_identifier" [%var])::;"
     %code = ".."
-        |for i,value in ipairs(\(%iterable as lua)) do;
+        |for i,value in ipairs(\(%iterable as lua)) do
         # This trashes the loop variables, just like in Python.
         |\(%var as lua) = value;
         |\(%body as lua statements)\(%continue_labels)
-        |end;--foreach-loop
+        |end --foreach-loop
     %stop_labels = ""
     if (tree %body has function call \(stop for-loop)):
         %stop_labels join= "\n::stop_for::;"
     if (tree %body has function call (nomsu "replaced_vars" [\(stop %), =lua "{['']=\(%var)}"])):
         %stop_labels join= "\n::stop_\(nomsu "var_to_lua_identifier" [%var])::;"
     if (%stop_labels != ""): ".."
-        |do;--for-loop label scope
+        |do --for-loop label scope
         |\(%code)\(%stop_labels)
-        |end;--for-loop label scope
+        |end --for-loop label scope
     ..else: %code
 parse [for all %iterable %body] as: for % in %iterable %body
 
@@ -151,7 +151,7 @@ compile [when %body] to code:
         if (=lua "vars.condition.type == 'Word' and vars.condition.value == 'else'"):
             %result join= ".."
                 |
-                |else;
+                |else
                 |\(%action as lua statements)
             stop for-loop
         ..else:
@@ -160,14 +160,14 @@ compile [when %body] to code:
                 %condition join= " or \(% as lua)"
             %result join= ".."
                 |
-                |\("if" if %first else "elseif") \(%condition) then;
+                |\("if" if %first else "elseif") \(%condition) then
                 |\(%action as lua statements)
 
         %fallthroughs = []
         %first = (no)
 
     if (%result != ""):
-        %result join= "\nend;"
+        %result join= "\nend"
     %result
 
 # Switch statement
@@ -195,7 +195,7 @@ compile [when %branch_value == ? %body] to code:
         if (=lua "vars.condition.type == 'Word' and vars.condition.value == 'else'"):
             %result join= ".."
                 |
-                |else;
+                |else
                 |\(%action as lua statements)
             stop for-loop
         ..else:
@@ -204,7 +204,7 @@ compile [when %branch_value == ? %body] to code:
                 %condition join= " or (branch_value == \(% as lua))"
             %result join= ".."
                 |
-                |\("if" if %first else "elseif") \(%condition) then;
+                |\("if" if %first else "elseif") \(%condition) then
                 |\(%action as lua statements)
 
         %fallthroughs = []
@@ -212,17 +212,17 @@ compile [when %branch_value == ? %body] to code:
 
     if (%result != ""):
         %result = ".."
-            |do;--when == ?
+            |do --when == ?
             |local branch_value = \(%branch_value as lua);\(%result)
-            |end;
-            |end;--when == ?
+            |end
+            |end --when == ?
     %result
 
 # With statement
 compile [with %thing = %value %action] to code: ".."
-    |do;
+    |do
     |    local old_value = \(%thing as lua);
     |    \(%thing as lua) = \(%value as lua);
     |    \(%action as lua statements);
     |    \(%thing as lua) = old_value;
-    |end;
+    |end
diff --git a/lib/metaprogramming.nom b/lib/metaprogramming.nom
index 4feae46..65a625d 100644
--- a/lib/metaprogramming.nom
+++ b/lib/metaprogramming.nom
@@ -19,20 +19,20 @@ rule [escaped parse %shorthand as %longhand] =:
         |local template = nomsu:typecheck(vars, "longhand", "Thunk").value;
         |local function parsing_as(nomsu, vars)
         # Single expression/statement
-        |    if #template == 1 then;
+        |    if #template == 1 then
         |        local replacement = nomsu:replaced_vars(template[1], vars);
         |        return nomsu:tree_to_lua(replacement);
         |    end
         # Multiple statements
         |   local lua_bits = {};
-        |   for _,bit in ipairs(template) do;
+        |   for _,bit in ipairs(template) do
         |       bit = nomsu:replaced_vars(bit, vars);
         |       local expr, statement = nomsu:tree_to_lua(bit);
-        |       if statement then; table.insert(lua_bits, statement); end;
-        |       if expr then; table.insert(lua_bits, "ret = "..expr..";"); end;
-        |   end;
+        |       if statement then table.insert(lua_bits, statement); end
+        |       if expr then table.insert(lua_bits, "ret = "..expr..";"); end
+        |   end
         |   return nil, table.concat(lua_bits, "\\n");
-        |end;
+        |end
         |nomsu:defmacro(aliases, parsing_as, template.src);
 escaped parse \[parse %shorthand as %longhand] as \: escaped parse \%shorthand as \%longhand
 
@@ -48,7 +48,7 @@ rule [escaped compile %macro_def to code %body] =:
         |local aliases = nomsu:get_stubs(nomsu:typecheck(vars, "macro_def", "List").value);
         |local body = nomsu:typecheck(vars, "body", "Thunk");
         |local thunk = nomsu:tree_to_value(body);
-        |local thunk_wrapper = function(nomsu, vars) return nil, thunk(nomsu, vars); end;
+        |local thunk_wrapper = function(nomsu, vars) return nil, thunk(nomsu, vars); end
         |nomsu:defmacro(aliases, thunk_wrapper, body.src);
 parse [compile %macro_def to %body] as: escaped compile \%macro_def to \%body
 parse [compile %macro_def to code %body] as: escaped compile \%macro_def to code \%body
@@ -66,9 +66,9 @@ compile [type %obj, type of %obj] to:
     "type(\(%obj as lua))"
 
 parse [lua do> %block] as:
-    lua> "do;"
+    lua> "do"
     lua> %block
-    lua> "end;"
+    lua> "end"
 rule [%tree as lua statement] =:
     lua do> ".."
         |local _,statement = nomsu:tree_to_lua(\(%tree));
@@ -77,11 +77,11 @@ rule [%tree as lua statements] =:
     lua do> ".."
         |local lua_bits = {};
         |local statements = nomsu:typecheck(vars, "tree", "Thunk").value;
-        |for _,bit in ipairs(statements) do;
+        |for _,bit in ipairs(statements) do
         |    local expr, statement = nomsu:tree_to_lua(bit);
-        |    if statement then; table.insert(lua_bits, statement); end;
-        |    if expr then; table.insert(lua_bits, "ret = "..expr..";"); end;
-        |end;
+        |    if statement then table.insert(lua_bits, statement); end
+        |    if expr then table.insert(lua_bits, "ret = "..expr..";"); end
+        |end
         |return table.concat(lua_bits, "\\n");
 
 compile [nomsu] to: "nomsu"
@@ -92,27 +92,27 @@ compile [nomsu %method %args] to: "nomsu[\(%method as lua)](nomsu, unpack(\(%arg
 rule [help %rule] =:
     lua do> ".."
         |local fn_def = nomsu.defs[nomsu:get_stub(vars.rule)]
-        |if not fn_def then;
+        |if not fn_def then
         |    nomsu:writeln("Rule not found: "..nomsu:repr(vars.rule));
-        |else;
+        |else
         |    local template = fn_def.is_macro and "compile %s to%s" or "rule %s =%s";
         |    local src = fn_def.src or ":\\n    <unknown source code>";
-        |    if src:sub(1,1) ~= ":" and fn_def.is_macro then; template = "parse %s as: %s"; end;
+        |    if src:sub(1,1) ~= ":" and fn_def.is_macro then template = "parse %s as: %s"; end
         |    nomsu:writeln(template:format(nomsu:repr(fn_def.stub), src));
-        |end;
+        |end
 
 # Compiler tools
 parse [eval %code, run %code] as: nomsu "run" [%code]
 rule [source code from tree %tree] =:
     lua do> ".."
         |local _,_,leading_space = vars.tree.src:find("\\n(%s*)%S");
-        |if leading_space then;
+        |if leading_space then
         |    local chunk1, chunk2 = vars.tree.src:match(":%s*([^\\n]*)(\\n.*)");
         |    chunk2 = chunk2:gsub("\\n"..leading_space, "\\n");
         |    return chunk1..chunk2.."\\n";
-        |else;
+        |else
         |    return vars.tree.src:match(":%s*(%S.*)").."\\n";
-        |end;
+        |end
 parse [source code %body] as: source code from tree \%body
 
 parse [parse tree %code] as: nomsu "tree_to_str" [\%code]
diff --git a/lib/moonscript.nom b/lib/moonscript.nom
index 89f5ffb..89468c6 100644
--- a/lib/moonscript.nom
+++ b/lib/moonscript.nom
@@ -6,13 +6,13 @@ parse [moonscript do> %moonscript_code] as:
         |local parse, compile = require('moonscript.parse'), require('moonscript.compile');
         |local moon_code = nomsu:tree_to_value(vars.moonscript_code, vars);
         |local tree, err = parse.string(moon_code);
-        |if not tree then;
+        |if not tree then
         |    nomsu:error("Failed to parse moonscript: "..err);
-        |end;
+        |end
         |local lua_code, err, pos = compile.tree(tree);
-        |if not lua_code then;
+        |if not lua_code then
         |    nomsu:error(compile.format_error(err, pos, moon_code));
-        |end;
+        |end
         |return "do\\n"..lua_code.."\\nend";
 
 parse [moonscript> %moonscript_code] as:
@@ -20,11 +20,11 @@ parse [moonscript> %moonscript_code] as:
         |local parse, compile = require('moonscript.parse'), require('moonscript.compile');
         |local moon_code = nomsu:tree_to_value(vars.moonscript_code, vars);
         |local tree, err = parse.string(moon_code);
-        |if not tree then;
+        |if not tree then
         |    nomsu:error("Failed to parse moonscript: "..err);
-        |end;
+        |end
         |local lua_code, err, pos = compile.tree(tree);
-        |if not lua_code then;
+        |if not lua_code then
         |    nomsu:error(compile.format_error(err, pos, moon_code));
-        |end;
+        |end
         |return "(function(nomsu, vars)\\n"..lua_code.."\\nend)(nomsu, vars)";
diff --git a/lib/operators.nom b/lib/operators.nom
index 5b390e5..d9880fe 100644
--- a/lib/operators.nom
+++ b/lib/operators.nom
@@ -21,11 +21,11 @@ compile [..]
     #.. Note: this uses a function instead of (condition and if_expr or else_expr)
         because that breaks if %if_expr is falsey.
     |(function(nomsu, vars)
-    |    if \(%condition as lua) then;
+    |    if \(%condition as lua) then
     |        return \(%when_true_expr as lua);
-    |    else;
+    |    else
     |        return \(%when_false_expr as lua);
-    |    end;
+    |    end
     |end)(nomsu, vars)
 
 # Indexing:
@@ -46,15 +46,15 @@ compile [%var mod= %val] to code: "\(%var as lua) = \(%var as lua) % \(%val as l
 # Binary Operators
 lua do> ".."
     |local binops = {"-","/","<","<=",">",">=","^",{"===","=="},{"!==","~="},{"mod","%"}};
-    |for _,op in ipairs(binops) do;
+    |for _,op in ipairs(binops) do
     |    local nomsu_alias = op;
     |    if type(op) == 'table' then;
     |        nomsu_alias, op = unpack(op);
-    |    end;
+    |    end
     |    nomsu:defmacro("%a "..nomsu_alias.." %b", (function(nomsu, vars)
     |        return "("..nomsu:tree_to_lua(vars.a).." "..op.." "..nomsu:tree_to_lua(vars.b)..")";
     |    end), [["(\\(%a) ]]..op..[[ \\(%b))"]]);
-    |end;
+    |end
 # TODO: implement OR, XOR, AND for multiple operands
 compile [%a OR %b, %a | %b] to: "bit32.bor(\(%a as lua), \(%b as lua))"
 compile [%a XOR %b] to: "bit32.bxor(\(%a as lua), \(%b as lua))"
@@ -72,54 +72,54 @@ compile [%a != %b] to: "(not nomsu.utils.equivalent(\(%a as lua), \(%b as lua)))
 lua do> ".."
     |local max_operands = 8;
     |local comops = {"+","*","and","or"};
-    |for _,_op in ipairs(comops) do;
+    |for _,_op in ipairs(comops) do
     |    local op = _op;
     |    local spec = "%1 ";
-    |    for n=2,max_operands do;
+    |    for n=2,max_operands do
     |        spec = spec .." "..op.." %"..tostring(n);
     |        nomsu:defmacro(spec, (function(nomsu, vars)
     |            local bits = {};
-    |            for i=1,n do;
+    |            for i=1,n do
     |                table.insert(bits, (nomsu:tree_to_lua(vars[tostring(i)])));
-    |            end;
+    |            end
     |            return "("..table.concat(bits, " "..op.." ")..")";
     |        end));
-    |    end;
-    |end;
+    |    end
+    |end
 
 # Chained compairsions (e.g. x < y <= z) are defined up to 3 operands
 lua do> ".."
     |local max_operands = 3;
-    |for _,chainers in ipairs({{"<","<="},{">",">="}}) do;
+    |for _,chainers in ipairs({{"<","<="},{">",">="}}) do
     |    local function recurse(chainers, chain)
     # The 1-op versions are already more efficiently defined, and a 0-op version doesnt make sense
     |        if #chain >= 2 then;
     |            local spec = "%1";
-    |            for i,op in ipairs(chain) do;
+    |            for i,op in ipairs(chain) do
     |                spec = spec .. " "..op.." %"..tostring(i+1);
-    |            end;
+    |            end
     # Chained comparisons need to be functions to avoid re-evaluating their arguments :\
     |            nomsu:def(spec, function(nomsu, vars)
-    |                for i,op in ipairs(chain) do;
+    |                for i,op in ipairs(chain) do
     |                    local a, b, result = vars[i], vars[i+1];
     |                    if     op == "<"  then; result = a < b;
     |                    elseif op == "<=" then; result = a <= b;
     |                    elseif op == ">"  then; result = a > b;
-    |                    elseif op == ">=" then; result = a >= b; end;
+    |                    elseif op == ">=" then; result = a >= b; end
     # Short circuit
-    |                    if not result then; return false; end;
-    |                end;
+    |                    if not result then; return false; end
+    |                end
     |            end);
-    |        end;
-    |        if #chain + 1 >= max_operands then; return; end;
-    |        for _,c in ipairs(chainers) do;
+    |        end
+    |        if #chain + 1 >= max_operands then; return; end
+    |        for _,c in ipairs(chainers) do
     |            table.insert(chain, c);
     |            recurse(chainers, chain);
     |            table.remove(chain);
-    |        end;
-    |    end;
+    |        end
+    |    end
     |    recurse(chainers, {});
-    |end;
+    |end
 
 # Unary operators
 compile [- %] to: "-(\(% as lua))"
diff --git a/lib/plurals.nom b/lib/plurals.nom
index 52a3294..a1c293f 100644
--- a/lib/plurals.nom
+++ b/lib/plurals.nom
@@ -9,12 +9,12 @@ with secrets:
         |    return key..endings[key:sub(-1)];
         |end});
         |secrets.singulars = setmetatable({}, {__index=function(self,key)
-        |    if key:sub(-2) == "es" and rawget(endings, key:sub(-3,-3)) then; return key:sub(1,-3); end;
-        |    if key:sub(-1) == "s" then; return key:sub(1,-2); end;
+        |    if key:sub(-2) == "es" and rawget(endings, key:sub(-3,-3)) then return key:sub(1,-3); end
+        |    if key:sub(-1) == "s" then return key:sub(1,-2); end
         |    return key;
         |end});
         |secrets.canonicals = setmetatable({}, {__index=function(self,key)
-        |    if key:sub(-1) == "s" then; return secrets.singulars[key]; end;
+        |    if key:sub(-1) == "s" then return secrets.singulars[key]; end
         |    return key;
         |end});