diff --git a/src/backend/vm.nim b/src/backend/vm.nim
index bde82cc..db55717 100644
--- a/src/backend/vm.nim
+++ b/src/backend/vm.nim
@@ -287,6 +287,41 @@ proc constReadFloat64(self: PeonVM, idx: int): PeonObject =
     copyMem(result.`float`.addr, arr.addr, sizeof(arr))
 
 
+proc `$`(self: PeonObject): string =
+    case self.kind:
+        of Int64:
+            result = &"{self.long}'i64"
+        of UInt64:
+            result = &"{self.uLong}'u64"
+        of Int32:
+            result = &"{self.`int`}'i32"
+        of UInt32:
+            result = &"{self.uInt}'u32"
+        of Int16:
+            result = &"{self.short}'i16"
+        of UInt16:
+            result = &"{self.uShort}'u16"
+        of Int8:
+            result = &"{self.tiny}'i8"
+        of UInt8:
+            result = &"{self.uTiny}'u8"
+        of Float32:
+            result = &"{self.halfFloat}'f32"
+        of Float64:
+            result = &"{self.`float`}'f64"
+        of ObjectKind.Inf:
+            if self.positive:
+                result ="inf"
+            else:
+                result ="-inf"
+        of ObjectKind.Nan, Nil:
+            result =($self.kind).toLowerAscii()
+        of Function:
+            result = &"fn(ip: {self.ip})"
+        else:
+            discard
+
+
 proc dispatch*(self: PeonVM) =
     ## Main bytecode dispatch loop
     var instruction {.register.}: OpCode
@@ -342,11 +377,13 @@ proc dispatch*(self: PeonVM) =
             of LoadFloat64:
                 self.push(self.constReadFloat64(int(self.readLong())))
             of LoadFunction:
-                self.pushc(PeonObject(kind: Function, ip: self.readLong()))
-            of LoadFunctionObj:
+                # Loads a function onto the operand stack by reading its
+                # instruction pointer
                 self.push(PeonObject(kind: Function, ip: self.readLong()))
             of LoadReturnAddress:
-                self.pushc(PeonObject(kind: UInt32, uInt: self.readUInt()))
+                # Loads a 32-bit unsigned integer. Used to load function
+                # return addresses
+                self.push(PeonObject(kind: UInt32, uInt: self.readUInt()))
             of Call:
                 # Calls a function. The calling convention for peon
                 # functions is pretty simple: the first item in the
@@ -354,20 +391,34 @@ proc dispatch*(self: PeonVM) =
                 # instruction pointer to jump to, followed by a 32-bit
                 # return address. After that, all arguments and locals 
                 # follow
-                var size {.used.} = self.readLong().int
-                self.frames.add(self.calls.len() - 2)
-                self.ip = self.peekc(-1).ip
+                var argc {.used.} = self.readLong().int
+                let retAddr = self.peek(-argc)       # Return address
+                let fnObj = self.peek(-argc - 1)     # Function object
+                self.ip = fnObj.ip
+                self.pushc(fnObj)
+                self.pushc(retAddr)
+                # Creates a new result slot for the
+                # function's return value
                 self.results.add(self.getNil())
-                # TODO: Use the frame size once
+                # Creates a new call frame
+                self.frames.add(self.calls.len() - 2)
+                # Loads the arguments onto the stack
+                for _ in 0..<argc:
+                    self.pushc(self.pop())
+                # Pops the function object and
+                # return address off the operand
+                # stack since they're not needed
+                # there anymore
+                discard self.pop()
+                discard self.pop()
+                # TODO: Use the frame's initial size once
                 # we have more control over the
                 # memory
-                #[while size > 0:
-                    dec(size)
+                #[while argc > 0:
+                    dec(argc)
                     self.pushc(self.getNil())
                 ]#
-            of LoadArgument:
-                self.pushc(self.pop())
-            of OpCode.Return:
+            of Return:
                 # Returns from a function.
                 # Every peon program is wrapped
                 # in a hidden function, so this 
@@ -380,6 +431,7 @@ proc dispatch*(self: PeonVM) =
                     self.push(self.results.pop())
                 else:
                     discard self.results.pop()
+                # Discard a stack frame
                 discard self.frames.pop()
                 if self.frames.len() == 0:
                     # End of the program!
@@ -392,11 +444,11 @@ proc dispatch*(self: PeonVM) =
             of StoreVar:
                 # Stores the value at the top of the operand stack
                 # into the given call stack index
-                let idx = int(self.readLong()) + self.frames[^1]
-                if idx <= self.calls.high():
+                let idx = int(self.readLong())
+                if idx + self.frames[^1] <= self.calls.high():
                     self.setc(idx, self.pop())
                 else:
-                    self.calls.add(self.pop())
+                    self.pushc(self.pop())
             of StoreClosure:
                 # Stores/updates the value of a closed-over
                 # variable
@@ -411,56 +463,30 @@ proc dispatch*(self: PeonVM) =
                 # Loads a closed-over variable onto the
                 # stack
                 self.push(self.closedOver[self.readLong()])
-            of PopClosure:
-                # Removes a closed-over variable from the closure
-                # array
-                discard self.closedOver.pop()
             of LoadVar:
+                # Pushes a variable onto the operand
+                # stack
                 self.push(self.getc(int(self.readLong())))
             of NoOp:
+                # Does nothing
                 continue
             of PopC:
+                # Pops a value off the call stack
                 discard self.popc()
             of Pop:
+                # Pops a value off the operand stack
                 discard self.pop()
             of PushC:
+                # Pushes a value from the operand stack
+                # onto the call stack
                 self.pushc(self.pop())
             of PopRepl:
                 if self.frames.len() > 1:
                     discard self.pop()
                     continue
-                let popped = self.pop()
-                case popped.kind:
-                of Int64:
-                    echo &"{popped.long}'i64"
-                of UInt64:
-                    echo &"{popped.uLong}'u64"
-                of Int32:
-                    echo &"{popped.`int`}'i32"
-                of UInt32:
-                    echo &"{popped.uInt}'u32"
-                of Int16:
-                    echo &"{popped.short}'i16"
-                of UInt16:
-                    echo &"{popped.uShort}'u16"
-                of Int8:
-                    echo &"{popped.tiny}'i8"
-                of UInt8:
-                    echo &"{popped.uTiny}'u8"
-                of Float32:
-                    echo &"{popped.halfFloat}'f32"
-                of Float64:
-                    echo &"{popped.`float`}'f64"
-                of ObjectKind.Inf:
-                    if popped.positive:
-                        echo "inf"
-                    else:
-                        echo "-inf"
-                of ObjectKind.Nan, Nil:
-                    echo ($popped.kind).toLowerAscii()
-                else:
-                    discard
+                echo self.pop()
             of PopN:
+                # Pops N elements off the call stack
                 for _ in 0..<int(self.readShort()):
                     discard self.popc()
             # Jump opcodes
diff --git a/src/config.nim b/src/config.nim
index 12c2291..218807b 100644
--- a/src/config.nim
+++ b/src/config.nim
@@ -27,7 +27,7 @@ when len(PEON_COMMIT_HASH) != 40:
 const PEON_BRANCH* = "master"
 when len(PEON_BRANCH) > 255:
     {.fatal: "The git branch name's length must be less than or equal to 255 characters".}
-const DEBUG_TRACE_VM* = false # Traces VM execution
+const DEBUG_TRACE_VM* = true # Traces VM execution
 const DEBUG_TRACE_GC* = false # Traces the garbage collector (TODO)
 const DEBUG_TRACE_ALLOCATION* = false # Traces memory allocation/deallocation
 const DEBUG_TRACE_COMPILER* = false # Traces the compiler
diff --git a/src/frontend/compiler.nim b/src/frontend/compiler.nim
index 266a27a..b43d8e5 100644
--- a/src/frontend/compiler.nim
+++ b/src/frontend/compiler.nim
@@ -102,6 +102,10 @@ type
         isFunctionArgument: bool
         # Where is this node declared in the file?
         line: int
+        # Is this a function declaration or a variable
+        # with a function as value? (The distinction *is*
+        # important! Check emitFunction())
+        isFunDecl: bool
     Loop = object
         ## A "loop object" used
         ## by the compiler to emit
@@ -181,11 +185,11 @@ proc declaration(self: Compiler, node: Declaration)
 proc peek(self: Compiler, distance: int = 0): ASTNode
 proc identifier(self: Compiler, node: IdentExpr)
 proc varDecl(self: Compiler, node: VarDecl)
-proc inferType(self: Compiler, node: LiteralExpr, strictMutable: bool = true): Type
-proc inferType(self: Compiler, node: Expression, strictMutable: bool = true): Type
+proc inferType(self: Compiler, node: LiteralExpr): Type
+proc inferType(self: Compiler, node: Expression): Type
 proc findByName(self: Compiler, name: string): seq[Name]
-proc findByType(self: Compiler, name: string, kind: Type, strictMutable: bool = true): seq[Name]
-proc compareTypes(self: Compiler, a, b: Type, strictMutable: bool = true): bool
+proc findByType(self: Compiler, name: string, kind: Type): seq[Name]
+proc compareTypes(self: Compiler, a, b: Type): bool
 proc patchReturnAddress(self: Compiler, pos: int)
 proc handleMagicPragma(self: Compiler, pragma: Pragma, node: ASTnode)
 proc handlePurePragma(self: Compiler, pragma: Pragma, node: ASTnode)
@@ -372,22 +376,25 @@ proc resolve(self: Compiler, name: IdentExpr,
 proc getStackPos(self: Compiler, name: IdentExpr, depth: int = self.scopeDepth): int =
     ## Returns the predicted call stack position of a given name, relative
     ## to the current frame
-    result = 2
     var found = false
-    for variable in reversed(self.names):
+    result = 2
+    for variable in self.names:
+        if variable.valueType.kind == Function:
+            continue
+        inc(result)
         if name.name.lexeme == variable.name.name.lexeme:
             if variable.isPrivate and variable.owner != self.currentModule:
                 continue
-            if variable.depth == depth or variable.depth == 0:
+            elif variable.depth == depth or variable.depth == 0:
                 # variable.depth == 0 for globals!
                 found = true
+                dec(result)
                 break
-            inc(result)
     if not found:
         return -1
 
 
-proc getClosurePos(self: Compiler, name: IdentExpr, depth: int = self.scopeDepth): int =
+proc getClosurePos(self: Compiler, name: IdentExpr): int =
     ## Iterates the internal list of declared closure names backwards and
     ## returns the predicted closure array position of a given name.
     ## Returns -1 if the name can't be found (this includes names that
@@ -398,7 +405,7 @@ proc getClosurePos(self: Compiler, name: IdentExpr, depth: int = self.scopeDepth
         if name.name.lexeme == variable.name.name.lexeme:
             if variable.isPrivate and variable.owner != self.currentModule:
                 continue
-            elif variable.depth == depth:
+            else:
                 found = true
                 break
         dec(result)
@@ -423,7 +430,7 @@ proc resolve(self: Compiler, name: string,
     return nil
 
 
-proc detectClosureVariable(self: Compiler, name: Name, depth: int = self.scopeDepth) =
+proc detectClosureVariable(self: Compiler, name: var Name, depth: int = self.scopeDepth, decl: bool = false) =
     ## Detects if the given name is used in a local scope deeper
     ## than the given one and modifies the code emitted for it
     ## to store it as a closure variable if it is. Does nothing if the name
@@ -434,27 +441,25 @@ proc detectClosureVariable(self: Compiler, name: Name, depth: int = self.scopeDe
     ## unpredictably or crash
     if name.isNil() or name.depth == 0:
         return
-    elif name.depth < depth and not name.isClosedOver:            
+    elif name.depth < depth:            
         # Ding! The given name is closed over: we need to
         # change the dummy Jump instruction that self.declareName
         # put in place for us into a StoreClosure. We also update
         # the name's isClosedOver field so that self.identifier() 
         # can emit a LoadClosure instruction instead of a LoadVar
-        self.closedOver.add(name)
-        let idx = self.closedOver.high().toTriple()
+        if not name.isClosedOver:
+            self.closedOver.add(name)
         if self.closedOver.len() >= 16777216:
             self.error("too many consecutive closed-over variables (max is 16777215)")
-        self.chunk.code[name.codePos] = StoreClosure.uint8
-        self.chunk.code[name.codePos + 1] = idx[0]
-        self.chunk.code[name.codePos + 2] = idx[1]
-        self.chunk.code[name.codePos + 3] = idx[2]
         name.isClosedOver = true
+        if decl:
+            self.emitByte(StoreClosure)
+            self.emitBytes(self.closedOver.high().toTriple())
 
 
-proc compareTypes(self: Compiler, a, b: Type, strictMutable: bool = true): bool =
+proc compareTypes(self: Compiler, a, b: Type): bool =
     ## Compares two type objects
     ## for equality (works with nil!)
-    
     # The nil code here is for void functions (when
     # we compare their return types)
     if a.isNil():
@@ -477,10 +482,6 @@ proc compareTypes(self: Compiler, a, b: Type, strictMutable: bool = true): bool
         # If they're different, then they can't
         # be the same type!
         return false
-    elif a.mutable != b.mutable and strictMutable:
-        # Are they both (im)mutable? If not,
-        # they're different
-        return false
     case a.kind:
         # If all previous checks pass, it's time
         # to go through each possible type peon
@@ -504,10 +505,11 @@ proc compareTypes(self: Compiler, a, b: Type, strictMutable: bool = true): bool
             elif not self.compareTypes(a.returnType, b.returnType):
                 return false
             for (argA, argB) in zip(a.args, b.args):
-                if not self.compareTypes(argA.kind, argB.kind, strictMutable):
+                if not self.compareTypes(argA.kind, argB.kind):
                     return false
             return true         
         else:
+            # TODO: Custom types
             discard
 
 
@@ -553,7 +555,7 @@ proc toIntrinsic(name: string): Type =
         return nil
 
 
-proc inferType(self: Compiler, node: LiteralExpr, strictMutable: bool = true): Type =
+proc inferType(self: Compiler, node: LiteralExpr): Type =
     ## Infers the type of a given literal expression
     if node.isNil():
         return nil
@@ -565,7 +567,7 @@ proc inferType(self: Compiler, node: LiteralExpr, strictMutable: bool = true): T
             if size.len() == 1:
                 return Type(kind: Int64)
             let typ = size[1].toIntrinsic()
-            if not self.compareTypes(typ, nil, strictMutable):
+            if not self.compareTypes(typ, nil):
                 return typ
             else:
                 self.error(&"invalid type specifier '{size[1]}' for int")
@@ -576,7 +578,7 @@ proc inferType(self: Compiler, node: LiteralExpr, strictMutable: bool = true): T
             if size.len() == 1 or size[1] == "f64":
                 return Type(kind: Float64)
             let typ = size[1].toIntrinsic()
-            if not self.compareTypes(typ, nil, strictMutable):
+            if not self.compareTypes(typ, nil):
                 return typ
             else:
                 self.error(&"invalid type specifier '{size[1]}' for float")
@@ -594,7 +596,7 @@ proc inferType(self: Compiler, node: LiteralExpr, strictMutable: bool = true): T
             discard # TODO
 
 
-proc inferType(self: Compiler, node: Expression, strictMutable: bool = true): Type =
+proc inferType(self: Compiler, node: Expression): Type =
     ## Infers the type of a given expression and
     ## returns it
     if node.isNil():
@@ -611,9 +613,9 @@ proc inferType(self: Compiler, node: Expression, strictMutable: bool = true): Ty
             return self.inferType(UnaryExpr(node).a)
         of binaryExpr:
             let node = BinaryExpr(node)
-            var a = self.inferType(node.a, strictMutable)
-            var b = self.inferType(node.b, strictMutable)
-            if not self.compareTypes(a, b, strictMutable):
+            var a = self.inferType(node.a)
+            var b = self.inferType(node.b)
+            if not self.compareTypes(a, b):
                 return nil
             return a
         of {intExpr, hexExpr, binExpr, octExpr,
@@ -627,7 +629,7 @@ proc inferType(self: Compiler, node: Expression, strictMutable: bool = true): Ty
             if not node.returnType.isNil():
                 result.returnType = self.inferType(node.returnType)
             for argument in node.arguments:
-                result.args.add((argument.name.token.lexeme, self.inferType(argument.valueType, strictMutable)))
+                result.args.add((argument.name.token.lexeme, self.inferType(argument.valueType)))
         of callExpr:
             var node = CallExpr(node)
             case node.callee.kind:
@@ -640,16 +642,16 @@ proc inferType(self: Compiler, node: Expression, strictMutable: bool = true): Ty
                     else:
                         result = nil
                 of lambdaExpr:
-                    result = self.inferType(LambdaExpr(node.callee).returnType, strictMutable)
+                    result = self.inferType(LambdaExpr(node.callee).returnType)
                 else:
                     discard  # Unreachable
         of varExpr:
             result = self.inferType(Var(node).value)
             result.mutable = true
         of refExpr:
-            result = Type(kind: Reference, value: self.inferType(Ref(node).value, strictMutable))
+            result = Type(kind: Reference, value: self.inferType(Ref(node).value))
         of ptrExpr:
-            result = Type(kind: Pointer, value: self.inferType(Ptr(node).value, strictMutable))
+            result = Type(kind: Pointer, value: self.inferType(Ptr(node).value))
         else:
             discard # Unreachable
 
@@ -715,19 +717,29 @@ proc findByName(self: Compiler, name: string): seq[Name] =
             result.add(obj)
 
 
-proc findByType(self: Compiler, name: string, kind: Type, strictMutable: bool = true): seq[Name] =
+proc findByType(self: Compiler, name: string, kind: Type): seq[Name] =
     ## Looks for objects that have already been declared
     ## with the given name and type
     for obj in self.findByName(name):
-        if self.compareTypes(obj.valueType, kind, strictMutable):
+        if self.compareTypes(obj.valueType, kind):
             result.add(obj)
 
+#[
+proc findAtDepth(self: Compiler, name: string, depth: int): seq[Name] =
+    ## Looks for objects that have been already declared
+    ## with the given name at the given scope depth.
+    ## Returns all objects that apply
+    for obj in self.findByName(name):
+        if obj.depth == depth:
+            result.add(obj)
+]#
 
-proc matchImpl(self: Compiler, name: string, kind: Type, strictMutable: bool = true): Name =
+
+proc matchImpl(self: Compiler, name: string, kind: Type): Name =
     ## Tries to find a matching function implementation
     ## compatible with the given type and returns its
     ## name object
-    let impl = self.findByType(name, kind, strictMutable)
+    let impl = self.findByType(name, kind)
     if impl.len() == 0:
         var msg = &"cannot find a suitable implementation for '{name}'"
         let names = self.findByName(name)
@@ -761,9 +773,20 @@ proc matchImpl(self: Compiler, name: string, kind: Type, strictMutable: bool = t
 
 proc emitFunction(self: Compiler, name: Name) =
     ## Wrapper to emit LoadFunction instructions
-    self.emitByte(LoadFunction)
-    self.emitBytes(name.codePos.toTriple())
-
+    if name.isFunDecl:
+        self.emitByte(LoadFunction)
+        self.emitBytes(name.codePos.toTriple())
+    # If we're not loading a statically declared
+    # function, then it must be a function object
+    # created by previous LoadFunction instructions
+    # that is now bound to some variable, so we just
+    # load it
+    elif not name.isClosedOver:
+        self.emitByte(LoadVar)
+        self.emitBytes(self.getStackPos(name.name).toTriple())
+    else:
+        self.emitByte(LoadClosure)
+        self.emitBytes(self.getClosurePos(name.name).toTriple())
 
 ## End of utility functions
 
@@ -850,11 +873,11 @@ proc literal(self: Compiler, node: ASTNode) =
 
 
 proc handleBuiltinFunction(self: Compiler, fn: Name, args: seq[Expression]) =
-    ## Emits single instructions for builtin functions
+    ## Emits instructions for builtin functions
     ## such as addition or subtraction
     if fn.valueType.builtinOp notin ["GenericLogicalOr", "GenericLogicalAnd"]:
-        for argument in args:
-            self.expression(argument)
+        self.expression(args[1])
+        self.expression(args[0])
     case fn.valueType.builtinOp:
         of "AddInt64":
             self.emitByte(AddInt64)
@@ -936,29 +959,27 @@ proc handleBuiltinFunction(self: Compiler, fn: Name, args: seq[Expression]) =
             self.emitByte(DivFloat32)
         of "MulFloat32":
             self.emitByte(MulFloat32)
-        of "GenericLogicalOr":
+        of "LogicalOr":
             self.expression(args[0])
             let jump = self.emitJump(JumpIfTrue)
             self.expression(args[1])
             self.patchJump(jump)
-        of "GenericLogicalAnd":
+        of "LogicalAnd":
             self.expression(args[0])
-            var jump: int
-            if self.enableOptimizations:
-                jump = self.emitJump(JumpIfFalseOrPop)
-            else:
-                jump = self.emitJump(JumpIfFalse)
-                self.emitByte(Pop)
+            var jump = self.emitJump(JumpIfFalseOrPop)
             self.expression(args[1])
             self.patchJump(jump)
         else:
-            discard  # Unreachable
+            self.error(&"unknown built-in: '{fn.valueType.builtinOp}'")
 
 
 proc generateCall(self: Compiler, fn: Name, args: seq[Expression]) =
     ## Small wrapper that abstracts emitting a call instruction
     ## for a given function
     if fn.valueType.isBuiltinFunction:
+        # Builtins map to individual instructions
+        # (usually 1, but some use more) so we handle
+        # them differently
         self.handleBuiltinFunction(fn, args)
         return
     if any(fn.valueType.args, proc (arg: tuple[name: string, kind: Type]): bool = arg[1].kind == Generic):
@@ -968,41 +989,19 @@ proc generateCall(self: Compiler, fn: Name, args: seq[Expression]) =
     self.emitFunction(fn)
     self.emitByte(LoadReturnAddress)
     let pos = self.chunk.code.len()
+    # We initially emit a dummy return
+    # address. It is patched later
     self.emitBytes(0.toQuad())
-    for argument in args:
+    for argument in reversed(args):
+        # We pass the arguments in reverse
+        # because of how stack semantics
+        # work. They'll be fixed at runtime
         self.expression(argument)
-    self.emitByte(Call)         # Creates a new call frame
-    var size = 2  # We start at 2 because each call frame
-                  # contains at least 2 elements (function
-                  # object and return address)
-    for name in reversed(self.names):
-        # Then, for each local variable
-        # we increase the frame size by 1
-        if name.depth == self.scopeDepth:
-            inc(size)
-    self.emitBytes(size.toTriple())
-    self.patchReturnAddress(pos)
-
-
-proc generateObjCall(self: Compiler, args: seq[Expression]) =
-    ## Small wrapper that abstracts emitting a call instruction
-    ## for a given function already loaded on the operand stack
-    self.emitByte(PushC)   # Pops the function off the operand stack onto the call stack
-    self.emitByte(LoadReturnAddress)
-    let pos = self.chunk.code.len()
-    self.emitBytes(0.toQuad())
-    for argument in args:
-        self.expression(argument)
-    self.emitByte(Call)         # Creates a new call frame
-    var size = 2  # We start at 2 because each call frame
-                  # contains at least 2 elements (function
-                  # object and return address)
-    for name in reversed(self.names):
-        # Then, for each local variable
-        # we increase the frame size by 1
-        if name.depth == self.scopeDepth:
-            inc(size)
-    self.emitBytes(size.toTriple())
+    # Creates a new call frame and jumps
+    # to the function's first instruction
+    # in the code
+    self.emitByte(Call)
+    self.emitBytes(fn.valueType.args.len().toTriple())
     self.patchReturnAddress(pos)
 
 
@@ -1013,23 +1012,22 @@ proc callUnaryOp(self: Compiler, fn: Name, op: UnaryExpr) =
 
 proc callBinaryOp(self: Compiler, fn: Name, op: BinaryExpr) =
     ## Emits the code to call a binary operator
-    # Pushes the return address
     self.generateCall(fn, @[op.a, op.b])
 
 
 proc unary(self: Compiler, node: UnaryExpr) =
     ## Compiles unary expressions such as decimal
     ## and bitwise negation
-    let valueType = self.inferType(node.a, strictMutable=false)
-    let funct = self.matchImpl(node.token.lexeme, Type(kind: Function, returnType: Type(kind: Any), args: @[("", valueType)]), strictMutable=false)
+    let valueType = self.inferType(node.a)
+    let funct = self.matchImpl(node.token.lexeme, Type(kind: Function, returnType: Type(kind: Any), args: @[("", valueType)]))
     self.callUnaryOp(funct, node)
 
 
 proc binary(self: Compiler, node: BinaryExpr) =
     ## Compiles all binary expressions
-    let typeOfA = self.inferType(node.a, strictMutable=false)
-    let typeOfB = self.inferType(node.b, strictMutable=false)
-    let funct = self.matchImpl(node.token.lexeme, Type(kind: Function, returnType: Type(kind: Any), args: @[("", typeOfA), ("", typeOfB)]), strictMutable=false)
+    let typeOfA = self.inferType(node.a)
+    let typeOfB = self.inferType(node.b)
+    let funct = self.matchImpl(node.token.lexeme, Type(kind: Function, returnType: Type(kind: Any), args: @[("", typeOfA), ("", typeOfB)]))
     self.callBinaryOp(funct, node)
 
 
@@ -1049,8 +1047,8 @@ proc declareName(self: Compiler, node: Declaration, mutable: bool = false) =
                 # slap myself 100 times with a sign saying "I'm dumb". Mark my words
                 self.error("cannot declare more than 16777215 variables at a time")
             for name in self.findByName(node.name.token.lexeme):
-                if name.depth == self.scopeDepth and name.valueType.kind notin {Function, CustomType} and not name.isFunctionArgument:
-                    # Trying to redeclare a variable in the same module is an error, but it's okay
+                if name.depth == self.scopeDepth and not name.isFunctionArgument:
+                    # Trying to redeclare a variable in the same scope/context is an error, but it's okay
                     # if it's a function argument (for example, if you want to copy a number to
                     # mutate it)
                     self.error(&"attempt to redeclare '{node.name.token.lexeme}', which was previously defined in '{name.owner}' at line {name.line}")
@@ -1066,21 +1064,6 @@ proc declareName(self: Compiler, node: Declaration, mutable: bool = false) =
                                 line: node.token.line))
             if mutable:
                 self.names[^1].valueType.mutable = true
-            # We emit a jump of 0 because this may become a 
-            # StoreHeap instruction. If they variable is
-            # not closed over, we'll sadly be wasting a
-            # VM cycle. The previous implementation used 4 no-op
-            # instructions, which wasted 4 times as many clock
-            # cycles.
-            # TODO: Optimize this. It's a bit tricky because
-            # deleting bytecode would render all of our
-            # jump offsets and other absolute indeces in the
-            # bytecode wrong
-            if self.scopeDepth > 0:
-                # Closure variables are only used in local
-                # scopes
-                self.emitByte(JumpForwards)
-                self.emitBytes(0.toTriple())
         of NodeKind.funDecl:
             var node = FunDecl(node)
             # We declare the generics before the function so we
@@ -1106,14 +1089,15 @@ proc declareName(self: Compiler, node: Declaration, mutable: bool = false) =
                                 name: node.name,
                                 isLet: false,
                                 isClosedOver: false,
-                                line: node.token.line))
+                                line: node.token.line,
+                                isFunDecl: true))
             let fn = self.names[^1]
             var name: Name
             for argument in node.arguments:
                 if self.names.high() > 16777215:
                     self.error("cannot declare more than 16777215 variables at a time")
                 # wait, no LoadVar? Yes! That's because when calling functions, 
-                # arguments will already be on the stack so there's no need to
+                # arguments will already be on the stack, so there's no need to
                 # load them here
                 name = Name(depth: self.scopeDepth + 1,
                             isPrivate: true,
@@ -1138,7 +1122,7 @@ proc declareName(self: Compiler, node: Declaration, mutable: bool = false) =
 
 proc identifier(self: Compiler, node: IdentExpr) =
     ## Compiles access to identifiers
-    let s = self.resolve(node)
+    var s = self.resolve(node)
     if s.isNil():
         self.error(&"reference to undeclared name '{node.token.lexeme}'")
     elif s.isConst:
@@ -1148,11 +1132,11 @@ proc identifier(self: Compiler, node: IdentExpr) =
     else:
         self.detectClosureVariable(s)
         if s.valueType.kind == Function:
-            if not s.valueType.isBuiltinFunction:
-                self.emitByte(LoadFunctionObj)
-                self.emitBytes(s.codePos.toTriple())
-            else:
-                self.emitByte(LoadNil)
+            # Functions have no runtime
+            # representation, so we need
+            # to create one on the fly
+            self.emitByte(LoadFunction)
+            self.emitBytes(s.codePos.toTriple())
         elif not s.isClosedOver:
             # Static name resolution, loads value at index in the stack. Very fast. Much wow.
             self.emitByte(LoadVar)
@@ -1163,7 +1147,7 @@ proc identifier(self: Compiler, node: IdentExpr) =
             # align its semantics with the call stack. This makes closures work as expected and is
             # not much slower than indexing our stack (since they're both dynamic arrays at runtime anyway)
             self.emitByte(LoadClosure)
-            self.emitBytes(self.closedOver.high().toTriple())
+            self.emitBytes(self.getClosurePos(s.name).toTriple())
 
 
 
@@ -1173,7 +1157,7 @@ proc assignment(self: Compiler, node: ASTNode) =
         of assignExpr:
             let node = AssignExpr(node)
             let name = IdentExpr(node.name)
-            let r = self.resolve(name)
+            var r = self.resolve(name)
             if r.isNil():
                 self.error(&"assignment to undeclared name '{name.token.lexeme}'")
             elif r.isConst:
@@ -1207,7 +1191,7 @@ proc beginScope(self: Compiler) =
     inc(self.scopeDepth)
 
 
-proc endScope(self: Compiler, deleteNames: bool = true, fromFunc: bool = false) =
+proc endScope(self: Compiler) =
     ## Ends the current local scope
     if self.scopeDepth < 0:
         self.error("cannot call endScope with scopeDepth < 0 (This is an internal error and most likely a bug)")
@@ -1216,11 +1200,7 @@ proc endScope(self: Compiler, deleteNames: bool = true, fromFunc: bool = false)
     for name in self.names:
         if name.depth > self.scopeDepth:
             names.add(name)
-            if not self.enableOptimizations and not fromFunc:
-                # All variables with a scope depth larger than the current one
-                # are now out of scope. Begone, you're now homeless!
-                self.emitByte(PopC)
-    if self.enableOptimizations and len(names) > 1 and not fromFunc:
+    if len(names) > 1:
         # If we're popping less than 65535 variables, then
         # we can emit a PopN instruction. This is true for
         # 99.99999% of the use cases of the language (who the
@@ -1234,32 +1214,25 @@ proc endScope(self: Compiler, deleteNames: bool = true, fromFunc: bool = false)
             for i in countdown(self.names.high(), len(names) - uint16.high().int()):
                 if self.names[i].depth > self.scopeDepth:
                     self.emitByte(PopC)
-    elif len(names) == 1 and not fromFunc:
+    elif len(names) == 1:
         # We only emit PopN if we're popping more than one value
         self.emitByte(PopC)
     # This seems *really* slow, but
     # what else should I do? Nim doesn't
     # allow the removal of items during
     # seq iteration so ¯\_(ツ)_/¯
-    if deleteNames:
-        var idx = 0
-        while idx < self.names.len():
-            for name in names:
-                if self.names[idx] == name:
-                    self.names.delete(idx)
-            inc(idx)
-        idx = 0
-        while idx < self.closedOver.len():
-            for name in names:
-                if name.isClosedOver:
-                    self.closedOver.delete(idx)
-                    self.emitByte(PopClosure)
-            inc(idx)
+    var idx = 0
+    while idx < self.names.len():
+        for name in names:
+            if self.names[idx] == name:
+                self.names.delete(idx)
+        inc(idx)
+
 
 
 proc blockStmt(self: Compiler, node: BlockStmt) =
     ## Compiles block statements, which create a new
-    ## local scope.
+    ## local scope
     self.beginScope()
     for decl in node.code:
         self.declaration(decl)
@@ -1270,25 +1243,13 @@ proc ifStmt(self: Compiler, node: IfStmt) =
     ## Compiles if/else statements for conditional
     ## execution of code
     var cond = self.inferType(node.condition)
+    self.expression(node.condition)
     if not self.compareTypes(cond, Type(kind: Bool)):
         if cond.isNil():
-            if node.condition.kind == identExpr:
-                self.error(&"reference to undeclared identifier '{IdentExpr(node.condition).name.lexeme}'")
-            elif node.condition.kind == callExpr and CallExpr(node.condition).callee.kind == identExpr:
-                self.error(&"reference to undeclared identifier '{IdentExpr(CallExpr(node.condition).callee).name.lexeme}'")
-            else:
-                self.error(&"expecting value of type 'bool', but expression has no type")
+            self.error(&"expecting value of type 'bool', but expression has no type")
         else:
             self.error(&"expecting value of type 'bool', got '{self.typeToStr(cond)}' instead")
-    self.expression(node.condition)
-    var jumpCode: OpCode
-    if self.enableOptimizations:
-        jumpCode = JumpIfFalsePop
-    else:
-        jumpCode = JumpIfFalse
-    let jump = self.emitJump(jumpCode)
-    if not self.enableOptimizations:
-        self.emitByte(Pop)
+    let jump = self.emitJump(JumpIfFalsePop)
     self.statement(node.thenBranch)
     let jump2 = self.emitJump(JumpForwards)
     self.patchJump(jump)
@@ -1310,51 +1271,23 @@ proc emitLoop(self: Compiler, begin: int) =
 proc whileStmt(self: Compiler, node: WhileStmt) =
     ## Compiles C-style while loops and
     ## desugared C-style for loops
-    let start = self.chunk.code.len()
+    var cond = self.inferType(node.condition)
     self.expression(node.condition)
-    var jump: int
-    if self.enableOptimizations:
-        jump = self.emitJump(JumpIfFalsePop)
-    else:
-        jump = self.emitJump(JumpIfFalse)
-        self.emitByte(Pop)
+    if not self.compareTypes(cond, Type(kind: Bool)):
+        if cond.isNil():
+            self.error(&"expecting value of type 'bool', but expression has no type")
+        else:
+            self.error(&"expecting value of type 'bool', got '{self.typeToStr(cond)}' instead")
+    let start = self.chunk.code.len()
+    var jump = self.emitJump(JumpIfFalsePop)
     self.statement(node.body)
     self.patchJump(jump)
     self.emitLoop(start)
 
 
-proc isPure(self: Compiler, node: ASTNode): bool =
-    ## Checks if a function has any side effects
-    var pragmas: seq[Pragma]
-    case node.kind:
-        of lambdaExpr:
-            pragmas = LambdaExpr(node).pragmas
-        else:
-            pragmas = Declaration(node).pragmas
-    if pragmas.len() == 0:
-        return false
-    for pragma in pragmas:
-        if pragma.name.name.lexeme == "pure":
-            return true
-    return false
-
-
 proc checkCallIsPure(self: Compiler, node: ASTnode): bool =
     ## Checks if a call has any side effects
-    if not self.isPure(node):
-        return true
-    var pragmas: seq[Pragma]
-    case node.kind:
-        of lambdaExpr:
-            pragmas = LambdaExpr(node).pragmas
-        else:
-            pragmas = Declaration(node).pragmas
-    if pragmas.len() == 0:
-        return false
-    for pragma in pragmas:
-        if pragma.name.name.lexeme == "pure":
-            return true
-    return false
+    return true   # TODO
 
 
 proc callExpr(self: Compiler, node: CallExpr) =
@@ -1362,7 +1295,6 @@ proc callExpr(self: Compiler, node: CallExpr) =
     var args: seq[tuple[name: string, kind: Type]] = @[]
     var argExpr: seq[Expression] = @[]
     var kind: Type
-    var strictMutable = true
     # TODO: Keyword arguments
     for i, argument in node.arguments.positionals:
         kind = self.inferType(argument)
@@ -1370,8 +1302,6 @@ proc callExpr(self: Compiler, node: CallExpr) =
             if argument.kind == identExpr:
                 self.error(&"reference to undeclared identifier '{IdentExpr(argument).name.lexeme}'")
             self.error(&"cannot infer the type of argument {i + 1} in function call")
-        if kind.mutable:
-            strictMutable = false
         args.add(("", kind))
         argExpr.add(argument)
     for argument in node.arguments.keyword:
@@ -1381,7 +1311,7 @@ proc callExpr(self: Compiler, node: CallExpr) =
     var funct: Name
     case node.callee.kind:
         of identExpr:
-            funct = self.matchImpl(IdentExpr(node.callee).name.lexeme, Type(kind: Function, returnType: Type(kind: Any), args: args), strictMutable)
+            funct = self.matchImpl(IdentExpr(node.callee).name.lexeme, Type(kind: Function, returnType: Type(kind: Any), args: args))
         of NodeKind.callExpr:
             var node = node.callee
             while node.kind == callExpr:
@@ -1394,13 +1324,15 @@ proc callExpr(self: Compiler, node: CallExpr) =
                 self.error(&"expression has no type")
             else:
                 self.error(&"object of type '{self.typeToStr(typ)}' is not callable")
-    if not funct.isNil():
-        if funct.valueType.isBuiltinFunction:
-            self.handleBuiltinFunction(funct, argExpr)
-        else:
-            self.generateCall(funct, argExpr)
+    if any(funct.valueType.args, proc (arg: tuple[name: string, kind: Type]): bool = arg[1].kind == Generic):
+        # The function has generic arguments! We need to compile a version
+        # of it with the right type data
+        self.funDecl(nil, funct, argExpr)
+        # TODO: What next?
+    elif funct.valueType.isBuiltinFunction:
+        self.handleBuiltinFunction(funct, argExpr)
     else:
-        self.generateObjCall(argExpr)
+        self.generateCall(funct, argExpr)        
     if self.scopeDepth > 0 and not self.checkCallIsPure(node.callee):
         if self.currentFunction.name != "":
             self.error(&"cannot make sure that calls to '{self.currentFunction.name}' are side-effect free")
@@ -1477,9 +1409,9 @@ proc endFunctionBeforeReturn(self: Compiler) =
     ## its return instruction
     var popped = 0
     for name in self.names:
-        if name.depth == self.scopeDepth and name.valueType.kind notin {Function, Generic}:
+        if name.depth == self.scopeDepth and name.valueType.kind notin {Function, Generic, CustomType} and not name.isClosedOver:
             inc(popped)
-    if self.enableOptimizations and popped > 1:
+    if popped > 1:
         self.emitByte(PopN)
         self.emitBytes(popped.toDouble())
         dec(popped, uint16.high().int)
@@ -1491,17 +1423,19 @@ proc endFunctionBeforeReturn(self: Compiler) =
 proc returnStmt(self: Compiler, node: ReturnStmt) =
     ## Compiles return statements
     let actual = self.inferType(node.value)
-    let expected = self.currentFunction
-    if actual.isNil() and not expected.returnType.isNil():
+    var expected = self.currentFunction.returnType
+    if not expected.isNil() and expected.kind == Generic:
+        expected = actual
+    if actual.isNil() and not expected.isNil():
         if not node.value.isNil():
             if node.value.kind == identExpr:
                 self.error(&"reference to undeclared identifier '{node.value.token.lexeme}'")
             elif node.value.kind == callExpr and CallExpr(node.value).callee.kind == identExpr:
                 self.error(&"call to undeclared function '{CallExpr(node.value).callee.token.lexeme}'")
-        self.error(&"expected return value of type '{self.typeToStr(expected.returnType)}', but expression has no type")
-    elif expected.returnType.isNil() and not actual.isNil():
-        self.error("non-empty return statement is not allowed in void functions")
-    elif not self.compareTypes(actual, expected.returnType):
+        self.error(&"expected return value of type '{self.typeToStr(expected)}', but expression has no type")
+    elif expected.isNil() and not actual.isNil():
+        self.error("empty return statement is only allowed in void functions")
+    elif not self.compareTypes(actual, expected):
         self.error(&"expected return value of type '{self.typeToStr(expected)}', got '{self.typeToStr(actual)}' instead")
     if not node.value.isNil():
         self.expression(node.value)
@@ -1653,8 +1587,10 @@ proc varDecl(self: Compiler, node: VarDecl) =
             self.error(&"expected value of type '{self.typeToStr(expected)}', but '{node.name.token.lexeme}' is of type '{self.typeToStr(actual)}'")
     self.expression(node.value)
     self.declareName(node, mutable=node.token.kind == TokenType.Var)
+    var r = self.names[^1]
+    self.detectClosureVariable(r, decl=true)
     self.emitByte(StoreVar)
-    self.emitBytes(self.names.len().toTriple())
+    self.emitBytes((self.getStackPos(r.name) + 1).toTriple())
 
 
 proc typeDecl(self: Compiler, node: TypeDecl) =
@@ -1708,12 +1644,16 @@ proc dispatchPragmas(self: Compiler, node: ASTnode) =
 
 proc fixGenericFunc(self: Compiler, name: Name, args: seq[Expression]): Type =
     ## Specializes generic arguments in functions
-    var fn = name.valueType
-    result = fn.deepCopy()
-    var node = fn.fun
+    var fn = name.valueType.deepCopy()
+    result = fn
+    var typ: Type
     for i in 0..args.high():
         if fn.args[i].kind.kind == Generic:
-            self.resolve(fn.args[i].name).valueType = self.inferType(args[i])
+            typ = self.inferType(args[i])
+            fn.args[i].kind = typ
+            self.resolve(fn.args[i].name).valueType = typ
+            if fn.args[i].kind.isNil():
+                self.error(&"cannot specialize generic function: argument {i + 1} has no type")
 
 
 proc funDecl(self: Compiler, node: FunDecl, fn: Name = nil, args: seq[Expression] = @[]) =
@@ -1728,9 +1668,12 @@ proc funDecl(self: Compiler, node: FunDecl, fn: Name = nil, args: seq[Expression
         self.dispatchPragmas(node)
     var node = node
     var fn = if fn.isNil(): self.names[^(node.arguments.len() + 1)] else: fn
-    if fn.valueType.returnType.isNil():
-        self.error(&"cannot infer the type of '{node.returnType.token.lexeme}'")
-    if not fn.valueType.isBuiltinFunction:
+    if fn.valueType.isBuiltinFunction:
+        # We take the arguments off of our name list
+        # because they become temporaries on the stack
+        for i in self.names.high() - node.arguments.high()..self.names.high():
+            self.names.delete(i)
+    else:
         var function = self.currentFunction
         var jmp: int
         # Builtin functions map to a single
@@ -1747,11 +1690,6 @@ proc funDecl(self: Compiler, node: FunDecl, fn: Name = nil, args: seq[Expression
         fn.codePos = self.chunk.code.len()
         # We store the current function
         self.currentFunction = fn.valueType
-        let argLen = if node.isNil(): fn.valueType.args.len() else: node.arguments.len()
-        for _ in 0..<argLen:
-            # Pops off the operand stack onto the
-            # call stack
-            self.emitByte(LoadArgument)
         if node.isNil():
             # We got called back with more specific type
             # arguments: time to fix them!
@@ -1795,13 +1733,14 @@ proc funDecl(self: Compiler, node: FunDecl, fn: Name = nil, args: seq[Expression
                     hasVal = LambdaExpr(Declaration(self.currentFunction.fun)).hasExplicitReturn
             else:
                 discard  # Unreachable
-        if hasVal and self.currentFunction.returnType.isNil() and not typ.returnType.isNil():
-            self.error("non-empty return statement is not allowed in void functions")
-        elif not hasVal and not self.currentFunction.returnType.isNil():
+        if not hasVal and not typ.isNil():
+            # There is no explicit return statement anywhere in the function's
+            # body: while this is not a tremendously useful piece of information (since
+            # the presence of at least one doesn't mean all control flow cases are
+            # covered), it definitely is an error worth reporting
             self.error("function has an explicit return type, but no return statement was found")
-        self.endFunctionBeforeReturn()
         hasVal = hasVal and not typ.isNil()
-        self.endScope(deleteNames=true, fromFunc=true)
+        self.endScope()
         # Terminates the function's context
         self.emitByte(OpCode.Return)
         if hasVal:
@@ -1895,15 +1834,16 @@ proc compile*(self: Compiler, ast: seq[Declaration], file: string): Chunk =
     self.names.add(main)
     self.emitByte(LoadFunction)
     self.emitBytes(main.codePos.toTriple())
+
     self.emitByte(LoadReturnAddress)
     let pos = self.chunk.code.len()
     self.emitBytes(0.toQuad())
     self.emitByte(Call)
-    self.emitBytes(2.toTriple())
+    self.emitBytes(0.toTriple())
     while not self.done():
         self.declaration(Declaration(self.step()))
-    self.endScope(fromFunc=true)
+    self.endFunctionBeforeReturn()
     self.patchReturnAddress(pos)
     self.emitByte(OpCode.Return)
-    self.emitByte(0)
+    self.emitByte(0)   # Entry point has no return value
     result = self.chunk
diff --git a/src/frontend/meta/bytecode.nim b/src/frontend/meta/bytecode.nim
index 0a605e8..c8d1035 100644
--- a/src/frontend/meta/bytecode.nim
+++ b/src/frontend/meta/bytecode.nim
@@ -138,15 +138,13 @@ type
         ## Basic stack operations
         Pop, # Pops an element off the stack and discards it
         PopRepl, # Same as Pop, but also prints the value of what's popped (used in REPL mode)
-        Push, # Pushes x onto the stack
-        PopN, # Pops x elements off the stack (optimization for exiting local scopes which usually pop many elements)
+        PopN, # Pops x elements off the call stack (optimization for exiting local scopes which usually pop many elements)
         ## Name resolution/handling
         LoadAttribute, # Pushes the attribute b of object a onto the stack
         LoadVar, # Pushes the object at position x in the stack onto the stack
         StoreVar, # Stores the value of b at position a in the stack
         LoadClosure, # Pushes the object position x in the closure array onto the stack
         StoreClosure, # Stores the value of b at position a in the closure array
-        PopClosure,  # Pops a closed-over variable from the closure array
         ## Looping and jumping
         Jump, # Absolute, unconditional jump into the bytecode
         JumpForwards, # Relative, unconditional, positive jump in the bytecode
@@ -168,10 +166,8 @@ type
         ## Coroutines
         Await, # Calls an asynchronous function
         ## Misc
-        Assert, # Raises an AssertionFailed exception if x is false
-        NoOp, # Just a no-op
-        LoadArgument,   # The caller uses this to pop off the argument from the operand stack onto the call stack
-        LoadFunctionObj,  # Creates and pushes a function object onto the stack with ip X
+        Assert,  # Raises an AssertionFailed exception if x is false
+        NoOp,    # Just a no-op
         PopC,    # Pop off the call stack onto the operand stack
         PushC    # Pop off the operand stack onto the call stack
 
@@ -185,7 +181,7 @@ const simpleInstructions* = {Return, LoadNil,
                              Pop, PopRepl, Raise, 
                              BeginTry, FinishTry, Yield, 
                              Await, NoOp, SetResult,
-                             LoadArgument, PopC, PushC,
+                             PopC, PushC,
                              AddInt64, AddUInt64, AddInt32,
                              AddUInt32, AddInt16, AddUInt16,
                              AddInt8, AddUInt8, SubInt64,
@@ -222,7 +218,7 @@ const stackDoubleInstructions* = {}
 const argumentDoubleInstructions* = {PopN, }
 
 # Argument double argument instructions take hardcoded arguments as 24 bit integers
-const argumentTripleInstructions* = {LoadFunctionObj, StoreClosure, PopClosure}
+const argumentTripleInstructions* = {StoreClosure}
 
 # Instructions that call functions
 const callInstructions* = {Call, }
diff --git a/src/frontend/parser.nim b/src/frontend/parser.nim
index 087a013..f9f98c8 100644
--- a/src/frontend/parser.nim
+++ b/src/frontend/parser.nim
@@ -314,7 +314,7 @@ proc primary(self: Parser): Expression =
             self.expect(RightParen, "unterminated parenthesized expression")
         of Yield:
             let tok = self.step()
-            if self.currentFunction == nil:
+            if self.currentFunction.isNil():
                 self.error("'yield' cannot be used outside functions")
             elif self.currentFunction.token.kind != Generator:
                 # It's easier than doing conversions for lambda/funDecl
@@ -327,7 +327,7 @@ proc primary(self: Parser): Expression =
                 result = newYieldExpr(newNilExpr(Token()), tok)
         of Await:
             let tok = self.step()
-            if self.currentFunction == nil:
+            if self.currentFunction.isNil():
                 self.error("'await' cannot be used outside functions")
             if self.currentFunction.token.kind != Coroutine:
                 self.error("'await' can only be used inside coroutines")
@@ -549,7 +549,7 @@ proc blockStmt(self: Parser): Statement =
     var code: seq[Declaration] = @[]
     while not self.check(RightBrace) and not self.done():
         code.add(self.declaration())
-        if code[^1] == nil:
+        if code[^1].isNil():
             code.delete(code.high())
     self.expect(RightBrace, "expecting '}'")
     result = newBlockStmt(code, tok)
@@ -568,7 +568,7 @@ proc breakStmt(self: Parser): Statement =
 proc deferStmt(self: Parser): Statement =
     ## Parses defer statements
     let tok = self.peek(-1)
-    if self.currentFunction == nil:
+    if self.currentFunction.isNil():
         self.error("'defer' cannot be used outside functions")
     result = newDeferStmt(self.expression(), tok)
     endOfLine("missing semicolon after defer statement")
@@ -586,7 +586,7 @@ proc continueStmt(self: Parser): Statement =
 proc returnStmt(self: Parser): Statement =
     ## Parses return statements
     let tok = self.peek(-1)
-    if self.currentFunction == nil:
+    if self.currentFunction.isNil():
         self.error("'return' cannot be used outside functions")
     var value: Expression
     if not self.check(Semicolon):
@@ -606,7 +606,7 @@ proc returnStmt(self: Parser): Statement =
 proc yieldStmt(self: Parser): Statement =
     ## Parses yield statements
     let tok = self.peek(-1)
-    if self.currentFunction == nil:
+    if self.currentFunction.isNil():
         self.error("'yield' cannot be outside functions")
     elif self.currentFunction.token.kind != Generator:
         self.error("'yield' can only be used inside generators")
@@ -620,7 +620,7 @@ proc yieldStmt(self: Parser): Statement =
 proc awaitStmt(self: Parser): Statement =
     ## Parses await statements
     let tok = self.peek(-1)
-    if self.currentFunction == nil:
+    if self.currentFunction.isNil():
         self.error("'await' cannot be used outside functions")
     if self.currentFunction.token.kind != Coroutine:
         self.error("'await' can only be used inside coroutines")
@@ -690,10 +690,10 @@ proc tryStmt(self: Parser): Statement =
         elseClause = self.statement()
     if self.match(Finally):
         finallyClause = self.statement()
-    if handlers.len() == 0 and elseClause == nil and finallyClause == nil:
+    if handlers.len() == 0 and elseClause.isNil() and finallyClause.isNil():
         self.error("expecting 'except', 'finally' or 'else' statement after 'try' block")
     for i, handler in handlers:
-        if handler.exc == nil and i != handlers.high():
+        if handler.exc.isNil() and i != handlers.high():
             self.error("catch-all exception handler with bare 'except' must come last in try statement")
     result = newTryStmt(body, handlers, finallyClause, elseClause, tok)
 
@@ -737,18 +737,18 @@ proc forStmt(self: Parser): Statement =
         increment = self.expression()
     self.expect(RightParen, "unterminated for loop increment")
     var body = self.statement()
-    if increment != nil:
+    if not increment.isNil():
         # The increment runs after each iteration, so we
         # inject it into the block as the last statement
         body = newBlockStmt(@[Declaration(body), newExprStmt(increment,
                 increment.token)], tok)
-    if condition == nil:
+    if condition.isNil():
         ## An empty condition is functionally
         ## equivalent to "true"
         condition = newTrueExpr(Token(lexeme: "true"))
     # We can use a while loop, which in this case works just as well
     body = newWhileStmt(condition, body, tok)
-    if initializer != nil:
+    if not initializer.isNil():
         # Nested blocks, so the initializer is
         # only executed once
         body = newBlockStmt(@[Declaration(initializer), Declaration(body)], tok)
@@ -777,7 +777,7 @@ proc ifStmt(self: Parser): Statement =
     var condition = self.expression()
     self.expect(RightParen, "expecting ')' after if condition")
     var thenBranch = self.statement()
-    var elseBranch: Statement = nil
+    var elseBranch: Statement
     if self.match(Else):
         elseBranch = self.statement()
     result = newIfStmt(condition, thenBranch, elseBranch, tok)
@@ -790,7 +790,6 @@ template checkDecl(self: Parser, isPrivate: bool) =
         self.error("cannot bind public names inside local scopes")
 
 
-
 proc parsePragmas(self: Parser): seq[Pragma] =
     ## Parses pragmas
     var
@@ -871,7 +870,7 @@ proc varDecl(self: Parser, isLet: bool = false,
                     isLet = isLet, valueType = valueType, pragmas = (@[]))
         else:
             discard # Unreachable
-    if not hasInit and VarDecl(result).valueType == nil:
+    if not hasInit and VarDecl(result).valueType.isNil():
         self.error("expecting initializer or explicit type declaration, but neither was found")
     result.pragmas = pragmas
 
@@ -904,7 +903,7 @@ proc parseDeclArguments(self: Parser, arguments: var seq[tuple[name: IdentExpr,
             break
     self.expect(RightParen)
     for argument in arguments:
-        if argument.valueType == nil:
+        if argument.valueType.isNil():
             self.error(&"missing type declaration for '{argument.name.token.lexeme}' in function declaration")
 
 
diff --git a/src/main.nim b/src/main.nim
index b81f235..a0f79e7 100644
--- a/src/main.nim
+++ b/src/main.nim
@@ -227,9 +227,12 @@ proc runFile(f: string, interactive: bool = false, fromString: bool = false) =
             styledEcho fgCyan, "Compilation step:\n"
             debugger.disassembleChunk(compiled, f)
             echo ""
-
-        serializer.dumpFile(compiled, f, splitFile(f).dir & "/" & splitFile(f).name & ".pbc")
-        serialized = serializer.loadFile(splitFile(f).dir & "/" & splitFile(f).name & ".pbc")
+        var path = splitFile(f).dir
+        if path.len() > 0:
+            path &= "/"
+        path &= splitFile(f).name & ".pbc"
+        serializer.dumpFile(compiled, f, path)
+        serialized = serializer.loadFile(path)
         when debugSerializer:
             var hashMatches = computeSHA256(input).toHex().toLowerAscii() == serialized.fileHash
             styledEcho fgCyan, "Serialization step: "
diff --git a/src/util/debugger.nim b/src/util/debugger.nim
index 51d5289..62aaa97 100644
--- a/src/util/debugger.nim
+++ b/src/util/debugger.nim
@@ -63,8 +63,8 @@ proc printInstruction(instruction: OpCode, newline: bool = false) =
 
 
 proc checkFrameStart(self: Debugger, n: int) =
-    ## Todo: Checking frame end offsets needs
-    ## fixes
+    ## Checks if a call frame begins at the given
+    ## bytecode offset
     for i, e in self.cfiData:
         if n == e.start and not (e.started or e.stopped):
             e.started = true
@@ -76,6 +76,8 @@ proc checkFrameStart(self: Debugger, n: int) =
 
 
 proc checkFrameEnd(self: Debugger, n: int) =
+    ## Checks if a call frame ends at the given
+    ## bytecode offset
     for i, e in self.cfiData:
         if n == e.stop and e.started and not e.stopped:
             e.stopped = true
@@ -83,6 +85,7 @@ proc checkFrameEnd(self: Debugger, n: int) =
     
 
 proc simpleInstruction(self: Debugger, instruction: OpCode) =
+    ## Debugs simple instructions
     printInstruction(instruction, true)
     self.current += 1
     if instruction == Return:
@@ -152,7 +155,7 @@ proc loadAddressInstruction(self: Debugger, instruction: OpCode) =
     var address = [self.chunk.code[self.current + 1], self.chunk.code[self.current + 2], self.chunk.code[self.current + 3],
                    self.chunk.code[self.current + 4]].fromQuad()
     printInstruction(instruction)
-    styledEcho fgGreen, &" loads address ", fgYellow, $address
+    styledEcho fgGreen, &", loads address ", fgYellow, $address
     self.current += 5