From b2edca2cb475c372b2365e5ec8f1725ffcecac78 Mon Sep 17 00:00:00 2001
From: ktkk <dezuttereluka@gmail.com>
Date: Tue, 13 Jan 2026 19:52:23 +0000
Subject: [PATCH] Initial commit

---
 .envrc         |    1 +
 .gitignore     |    5 +
 CMakeLists.txt |   49 +++
 chunk.c        |   43 ++
 chunk.h        |   61 +++
 common.h       |   14 +
 compiler.c     | 1081 ++++++++++++++++++++++++++++++++++++++++++++++++
 compiler.h     |   11 +
 debug.c        |  159 +++++++
 debug.h        |   10 +
 flake.lock     |   62 +++
 flake.nix      |   43 ++
 main.c         |   86 ++++
 memory.c       |  269 ++++++++++++
 memory.h       |   29 ++
 object.c       |  179 ++++++++
 object.h       |  116 ++++++
 scanner.c      |  274 ++++++++++++
 scanner.h      |   58 +++
 table.c        |  173 ++++++++
 table.h        |   29 ++
 value.c        |   89 ++++
 value.h        |   95 +++++
 vm.c           |  605 +++++++++++++++++++++++++++
 vm.h           |   49 +++
 25 files changed, 3590 insertions(+)
 create mode 100644 .envrc
 create mode 100644 .gitignore
 create mode 100644 CMakeLists.txt
 create mode 100644 chunk.c
 create mode 100644 chunk.h
 create mode 100644 common.h
 create mode 100644 compiler.c
 create mode 100644 compiler.h
 create mode 100644 debug.c
 create mode 100644 debug.h
 create mode 100644 flake.lock
 create mode 100644 flake.nix
 create mode 100644 main.c
 create mode 100644 memory.c
 create mode 100644 memory.h
 create mode 100644 object.c
 create mode 100644 object.h
 create mode 100644 scanner.c
 create mode 100644 scanner.h
 create mode 100644 table.c
 create mode 100644 table.h
 create mode 100644 value.c
 create mode 100644 value.h
 create mode 100644 vm.c
 create mode 100644 vm.h

diff --git a/.envrc b/.envrc
new file mode 100644
index 0000000..8392d15
--- /dev/null
+++ b/.envrc
@@ -0,0 +1 @@
+use flake
\ No newline at end of file
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..8ed7e73
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,5 @@
+build/
+
+# Misc
+.direnv
+.cache
diff --git a/CMakeLists.txt b/CMakeLists.txt
new file mode 100644
index 0000000..e257918
--- /dev/null
+++ b/CMakeLists.txt
@@ -0,0 +1,49 @@
+cmake_minimum_required(VERSION 4.1)
+
+project(
+    clox
+    LANGUAGES
+        C
+)
+
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+
+add_executable(
+    ${PROJECT_NAME}
+    main.c
+    vm.c
+    chunk.c
+    memory.c
+    debug.c
+    value.c
+    compiler.c
+    scanner.c
+    object.c
+    table.c
+)
+set_target_properties(
+    ${PROJECT_NAME}
+    PROPERTIES
+        C_STANDARD 23
+        C_STANDARD_REQUIRED ON
+        C_EXTENSIONS OFF
+)
+target_compile_options(
+    ${PROJECT_NAME}
+    PRIVATE
+        -Wall -Wextra -Wpedantic
+)
+target_compile_definitions(
+    ${PROJECT_NAME}
+    PRIVATE
+        $<$<AND:$<CONFIG:Debug>,$<BOOL:${PRINT_CODE}>>:DEBUG_PRINT_CODE>
+        $<$<AND:$<CONFIG:Debug>,$<BOOL:${TRACE_EXECUTION}>>:DEBUG_TRACE_EXECUTION>
+        $<$<AND:$<CONFIG:Debug>,$<BOOL:${STRESS_GC}>>:DEBUG_STRESS_GC>
+        $<$<AND:$<CONFIG:Debug>,$<BOOL:${LOG_GC}>>:DEBUG_LOG_GC>
+)
+target_compile_definitions(
+    ${PROJECT_NAME}
+    PRIVATE
+        $<$<BOOL:${NAN_BOXING}>:NAN_BOXING>
+)
+
diff --git a/chunk.c b/chunk.c
new file mode 100644
index 0000000..3c64c35
--- /dev/null
+++ b/chunk.c
@@ -0,0 +1,43 @@
+#include "chunk.h"
+#include "memory.h"
+#include "vm.h"
+
+void initChunk(Chunk* chunk)
+{
+    chunk->count = 0;
+    chunk->capacity = 0;
+    chunk->code = nullptr;
+    chunk->lines = nullptr;
+    initValueArray(&chunk->constants);
+}
+
+void freeChunk(Chunk* chunk)
+{
+    FREE_ARRAY(uint8_t, chunk->code, chunk->capacity);
+    FREE_ARRAY(int, chunk->lines, chunk->capacity);
+    freeValueArray(&chunk->constants);
+    initChunk(chunk);
+}
+
+void writeChunk(Chunk* chunk, uint8_t byte, int line)
+{
+    if (chunk->capacity < chunk->count + 1) {
+        int oldCapacity = chunk->capacity;
+        chunk->capacity = GROW_CAPACITY(oldCapacity);
+        chunk->code = GROW_ARRAY(uint8_t, chunk->code, oldCapacity, chunk->capacity);
+        chunk->lines = GROW_ARRAY(int, chunk->lines, oldCapacity, chunk->capacity);
+    }
+
+    chunk->code[chunk->count] = byte;
+    chunk->lines[chunk->count] = line;
+    chunk->count++;
+}
+
+int addConstant(Chunk* chunk, Value value)
+{
+    push(value);
+    writeValueArray(&chunk->constants, value);
+    pop();
+    return chunk->constants.count - 1;
+}
+
diff --git a/chunk.h b/chunk.h
new file mode 100644
index 0000000..a0a7ea5
--- /dev/null
+++ b/chunk.h
@@ -0,0 +1,61 @@
+#ifndef clox_chunk_h
+#define clox_chunk_h
+
+#include "common.h"
+#include "value.h"
+
+typedef enum {
+    OP_CONSTANT,
+    OP_NIL,
+    OP_TRUE,
+    OP_FALSE,
+    OP_POP,
+    OP_GET_LOCAL,
+    OP_SET_LOCAL,
+    OP_GET_GLOBAL,
+    OP_DEFINE_GLOBAL,
+    OP_SET_GLOBAL,
+    OP_GET_UPVALUE,
+    OP_SET_UPVALUE,
+    OP_GET_PROPERTY,
+    OP_SET_PROPERTY,
+    OP_GET_SUPER,
+    OP_EQUAL,
+    OP_GREATER,
+    OP_LESS,
+    OP_ADD,
+    OP_SUBTRACT,
+    OP_MULTIPLY,
+    OP_DIVIDE,
+    OP_NOT,
+    OP_NEGATE,
+    OP_PRINT,
+    OP_JUMP,
+    OP_JUMP_IF_FALSE,
+    OP_LOOP,
+    OP_CALL,
+    OP_INVOKE,
+    OP_SUPER_INVOKE,
+    OP_CLOSURE,
+    OP_CLOSE_UPVALUE,
+    OP_RETURN,
+    OP_CLASS,
+    OP_INHERIT,
+    OP_METHOD,
+} OpCode;
+
+typedef struct {
+    int count;
+    int capacity;
+    uint8_t* code;
+    int* lines;
+    ValueArray constants;
+} Chunk;
+
+void initChunk(Chunk* chunk);
+void freeChunk(Chunk* chunk);
+void writeChunk(Chunk* chunk, uint8_t byte, int line);
+int addConstant(Chunk* chunk, Value value);
+
+#endif // clox_chunk_h
+
diff --git a/common.h b/common.h
new file mode 100644
index 0000000..1bdb9c1
--- /dev/null
+++ b/common.h
@@ -0,0 +1,14 @@
+#ifndef clox_common_h
+#define clox_common_h
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+//#define DEBUG_PRINT_CODE
+//#define DEBUG_TRACE_EXECUTION
+
+#define UINT8_COUNT (UINT8_MAX + 1)
+
+#endif // clox_common_h
+
diff --git a/compiler.c b/compiler.c
new file mode 100644
index 0000000..77f386e
--- /dev/null
+++ b/compiler.c
@@ -0,0 +1,1081 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "common.h"
+#include "compiler.h"
+#include "memory.h"
+#include "scanner.h"
+
+#ifdef DEBUG_PRINT_CODE
+#include "debug.h"
+#endif
+
+typedef struct {
+    Token current;
+    Token previous;
+    bool hadError;
+    bool panicMode;
+} Parser;
+
+typedef enum {
+    PREC_NONE,
+    PREC_ASSIGNMENT,
+    PREC_OR,
+    PREC_AND,
+    PREC_EQUALITY,
+    PREC_COMPARISON,
+    PREC_TERM,
+    PREC_FACTOR,
+    PREC_UNARY,
+    PREC_CALL,
+    PREC_PRIMARY,
+} Precedence;
+
+typedef void (*ParseFn)(bool canAssign);
+
+typedef struct {
+    ParseFn prefix;
+    ParseFn infix;
+    Precedence precedence;
+} ParseRule;
+
+typedef struct {
+    Token name;
+    int depth;
+    bool isCaptured;
+} Local;
+
+typedef struct {
+    uint8_t index;
+    bool isLocal;
+} Upvalue;
+
+typedef enum {
+    TYPE_FUNCTION,
+    TYPE_INITIALIZER,
+    TYPE_METHOD,
+    TYPE_SCRIPT,
+} FunctionType;
+
+typedef struct Compiler {
+    struct Compiler* enclosing;
+    ObjFunction* function;
+    FunctionType type;
+    Local locals[UINT8_COUNT];
+    int localCount;
+    Upvalue upvalues[UINT8_COUNT];
+    int scopeDepth;
+} Compiler;
+
+typedef struct ClassCompiler {
+    struct ClassCompiler* enclosing;
+    bool hasSuperclass;
+} ClassCompiler;
+
+Parser parser;
+Compiler* current = nullptr;
+ClassCompiler* currentClass = nullptr;
+
+static Chunk* currentChunk()
+{
+    return &current->function->chunk;
+}
+
+static void errorAt(Token* token, const char* message)
+{
+    if (parser.panicMode) {
+        return;
+    }
+    parser.panicMode = true;
+
+    fprintf(stderr, "[line %d] Error", token->line);
+
+    if (token->type == TOKEN_EOF) {
+        fprintf(stderr, " at end");
+    } else if (token->type == TOKEN_ERROR) {
+    } else {
+        fprintf(stderr, " at '%.*s'", token->length, token->start);
+    }
+
+    fprintf(stderr, ": %s\n", message);
+    parser.hadError = true;
+}
+
+static void error(const char* message)
+{
+    errorAt(&parser.previous, message);
+}
+
+static void errorAtCurrent(const char* message)
+{
+    errorAt(&parser.current, message);
+}
+
+static void advance()
+{
+    parser.previous = parser.current;
+
+    for (;;) {
+        parser.current = scanToken();
+        if (parser.current.type != TOKEN_ERROR) {
+            break;
+        }
+        errorAtCurrent(parser.current.start);
+    }
+}
+
+static void consume(TokenType type, const char* message)
+{
+    if (parser.current.type == type) {
+        advance();
+        return;
+    }
+
+    errorAtCurrent(message);
+}
+
+static bool check(TokenType type)
+{
+    return parser.current.type == type;
+}
+
+static bool match(TokenType type)
+{
+    if (!check(type)) {
+        return false;
+    }
+
+    advance();
+
+    return true;
+}
+
+static void emitByte(uint8_t byte)
+{
+    writeChunk(currentChunk(), byte, parser.previous.line);
+}
+
+static void emitBytes(uint8_t byte1, uint8_t byte2)
+{
+    emitByte(byte1);
+    emitByte(byte2);
+}
+
+static void emitLoop(int loopStart)
+{
+    emitByte(OP_LOOP);
+
+    auto offset = currentChunk()->count - loopStart + 2;
+    if (offset > UINT16_MAX) {
+        error("Loop body too large.");
+    }
+
+    emitByte((offset >> 8) & 0xff);
+    emitByte(offset & 0xff);
+}
+
+static int emitJump(uint8_t instruction)
+{
+    emitByte(instruction);
+    emitByte(0xff);
+    emitByte(0xff);
+    return currentChunk()->count - 2;
+}
+
+static void emitReturn()
+{
+    if (current->type == TYPE_INITIALIZER) {
+        emitBytes(OP_GET_LOCAL, 0);
+    } else {
+        emitByte(OP_NIL);
+    }
+    emitByte(OP_RETURN);
+}
+
+static uint8_t makeConstant(Value value)
+{
+    auto constant = addConstant(currentChunk(), value);
+    if (constant > UINT8_MAX) {
+        error("Too many constants in one chunk.");
+        return 0;
+    }
+
+    return (uint8_t)constant;
+}
+
+static void emitConstant(Value value)
+{
+    emitBytes(OP_CONSTANT, makeConstant(value));
+}
+
+static void patchJump(int offset)
+{
+    auto jump = currentChunk()->count - offset - 2;
+
+    if (jump > UINT16_MAX) {
+        error("Too much code to jump over.");
+    }
+
+    currentChunk()->code[offset] = (jump >> 8) & 0xff;
+    currentChunk()->code[offset + 1] = jump & 0xff;
+}
+
+static void initCompiler(Compiler* compiler, FunctionType type)
+{
+    compiler->enclosing = current;
+    compiler->function = nullptr;
+    compiler->type = type;
+    compiler->localCount = 0;
+    compiler->scopeDepth = 0;
+    compiler->function = newFunction();
+    current = compiler;
+    if (type != TYPE_SCRIPT) {
+        current->function->name = copyString(parser.previous.start, parser.previous.length);
+    }
+
+    Local* local = &current->locals[current->localCount++];
+    local->depth = 0;
+    local->isCaptured = false;
+    if (type != TYPE_FUNCTION) {
+        local->name.start = "this";
+        local->name.length = 4;
+    } else {
+        local->name.start = "";
+        local->name.length = 0;
+    }
+}
+
+static ObjFunction* endCompiler()
+{
+    emitReturn();
+    ObjFunction* function = current->function;
+
+#ifdef DEBUG_PRINT_CODE
+    if (!parser.hadError) {
+        disassembleChunk(currentChunk(), function->name != nullptr ? function->name->chars : "<script>");
+    }
+#endif
+
+    current = current->enclosing;
+
+    return function;
+}
+
+static void beginScope()
+{
+    current->scopeDepth++;
+}
+
+static void endScope()
+{
+    current->scopeDepth--;
+
+    while (current->localCount > 0 && current->locals[current->localCount - 1].depth > current->scopeDepth) {
+        if (current->locals[current->localCount - 1].isCaptured) {
+            emitByte(OP_CLOSE_UPVALUE);
+        } else {
+            emitByte(OP_POP);
+        }
+        current->localCount--;
+    }
+}
+
+static void expression();
+static void statement();
+static void declaration();
+static ParseRule* getRule(TokenType type);
+static void parsePrecedence(Precedence precedence);
+
+static uint8_t identifierConstant(Token* name)
+{
+    return makeConstant(OBJ_VAL(copyString(name->start, name->length)));
+}
+
+static bool identifiersEqual(Token* a, Token* b)
+{
+    if (a->length != b->length) {
+        return false;
+    }
+    return memcmp(a->start, b->start, a->length) == 0;
+}
+
+static int resolveLocal(Compiler* compiler, Token* name)
+{
+    for (auto i = compiler->localCount - 1; i >= 0; i--) {
+        Local* local = &compiler->locals[i];
+        if (identifiersEqual(name, &local->name)) {
+            if (local->depth == -1) {
+                error("Can't read local variable in its own initializer.");
+            }
+            return i;
+        }
+    }
+
+    return -1;
+}
+
+static int addUpvalue(Compiler* compiler, uint8_t index, bool isLocal)
+{
+    auto upvalueCount = compiler->function->upvalueCount;
+
+    for (auto i = 0; i < upvalueCount; i++) {
+        Upvalue* upvalue = &compiler->upvalues[i];
+        if (upvalue->index == index && upvalue->isLocal == isLocal) {
+            return i;
+        }
+    }
+
+    if (upvalueCount == UINT8_COUNT) {
+        error("Too many closure variables in function.");
+        return 0;
+    }
+
+    compiler->upvalues[upvalueCount].isLocal = isLocal;
+    compiler->upvalues[upvalueCount].index = index;
+    return compiler->function->upvalueCount++;
+}
+
+static int resolveUpvalue(Compiler* compiler, Token* name)
+{
+    if (compiler->enclosing == nullptr) {
+        return -1;
+    }
+
+    auto local = resolveLocal(compiler->enclosing, name);
+    if (local != -1) {
+        compiler->enclosing->locals[local].isCaptured = true;
+        return addUpvalue(compiler, (uint8_t)local, true);
+    }
+
+    auto upvalue = resolveUpvalue(compiler->enclosing, name);
+    if (upvalue != -1) {
+        return addUpvalue(compiler, (uint8_t)upvalue, false);
+    }
+
+    return -1;
+}
+
+static void addLocal(Token name)
+{
+    if (current->localCount == UINT8_COUNT) {
+        error("Too many local variables in function.");
+        return;
+    }
+
+    Local* local = &current->locals[current->localCount++];
+    local->name = name;
+    local->depth = -1;
+    local->isCaptured = false;
+}
+
+static void declareVariable()
+{
+    if (current->scopeDepth == 0) {
+        return;
+    }
+
+    Token* name = &parser.previous;
+    for (auto i = current->localCount - 1; i >= 0; i--) {
+        Local* local = &current->locals[i];
+        if (local->depth != -1 && local->depth < current->scopeDepth) {
+            break;
+        }
+
+        if (identifiersEqual(name, &local->name)) {
+            error("Already a variable with this name in this scope.");
+        }
+    }
+
+    addLocal(*name);
+}
+
+static uint8_t parseVariable(const char* errorMessage)
+{
+    consume(TOKEN_IDENTIFIER, errorMessage);
+
+    declareVariable();
+    if (current->scopeDepth > 0) {
+        return 0;
+    }
+
+    return identifierConstant(&parser.previous);
+}
+
+static void markInitialized()
+{
+    if (current->scopeDepth == 0) {
+        return;
+    }
+    current->locals[current->localCount - 1].depth = current->scopeDepth;
+}
+
+static void defineVariable(uint8_t global)
+{
+    if (current->scopeDepth > 0) {
+        markInitialized();
+        return;
+    }
+
+    emitBytes(OP_DEFINE_GLOBAL, global);
+}
+
+static uint8_t argumentList()
+{
+    uint8_t argCount = 0;
+    if (!check(TOKEN_RIGHT_PAREN)) {
+        do {
+            expression();
+            if (argCount == 255) {
+                error("Can't have more than 255 arguments.");
+            }
+            argCount++;
+        } while (match(TOKEN_COMMA));
+    }
+    consume(TOKEN_RIGHT_PAREN, "Expect ')' after arguments.");
+    return argCount;
+}
+
+static void and_(bool canAssign)
+{
+    (void)canAssign;
+
+    auto endJump = emitJump(OP_JUMP_IF_FALSE);
+
+    emitByte(OP_POP);
+    parsePrecedence(PREC_AND);
+
+    patchJump(endJump);
+}
+
+static void binary(bool canAssign)
+{
+    (void)canAssign;
+
+    auto operatorType = parser.previous.type;
+    ParseRule* rule = getRule(operatorType);
+
+    parsePrecedence((Precedence)(rule->precedence + 1));
+
+    switch (operatorType) {
+    case TOKEN_BANG_EQUAL:
+        emitBytes(OP_EQUAL, OP_NOT);
+        break;
+    case TOKEN_EQUAL_EQUAL:
+        emitByte(OP_EQUAL);
+        break;
+    case TOKEN_GREATER:
+        emitByte(OP_GREATER);
+        break;
+    case TOKEN_GREATER_EQUAL:
+        emitBytes(OP_LESS, OP_NOT);
+        break;
+    case TOKEN_LESS:
+        emitByte(OP_LESS);
+        break;
+    case TOKEN_LESS_EQUAL:
+        emitBytes(OP_GREATER, OP_NOT);
+        break;
+    case TOKEN_PLUS:
+        emitByte(OP_ADD);
+        break;
+    case TOKEN_MINUS:
+        emitByte(OP_SUBTRACT);
+        break;
+    case TOKEN_STAR:
+        emitByte(OP_MULTIPLY);
+        break;
+    case TOKEN_SLASH:
+        emitByte(OP_DIVIDE);
+        break;
+    default:
+        return;
+    }
+}
+
+static void call(bool canAssign)
+{
+    (void)canAssign;
+
+    auto argCount = argumentList();
+    emitBytes(OP_CALL, argCount);
+}
+
+static void dot(bool canAssign)
+{
+    consume(TOKEN_IDENTIFIER, "Expect property name after '.'.");
+    auto name = identifierConstant(&parser.previous);
+
+    if (canAssign && match(TOKEN_EQUAL)) {
+        expression();
+        emitBytes(OP_SET_PROPERTY, name);
+    } else if (match(TOKEN_LEFT_PAREN)) {
+        auto argCount = argumentList();
+        emitBytes(OP_INVOKE, name);
+        emitByte(argCount);
+    } else {
+        emitBytes(OP_GET_PROPERTY, name);
+    }
+}
+
+static void literal(bool canAssign)
+{
+    (void)canAssign;
+
+    switch (parser.previous.type) {
+    case TOKEN_FALSE:
+        emitByte(OP_FALSE);
+        break;
+    case TOKEN_NIL:
+        emitByte(OP_NIL);
+        break;
+    case TOKEN_TRUE:
+        emitByte(OP_TRUE);
+        break;
+    default:
+        return;
+    }
+}
+
+static void grouping(bool canAssign)
+{
+    (void)canAssign;
+
+    expression();
+    consume(TOKEN_RIGHT_PAREN, "Expect ')' after expression.");
+}
+
+static void number(bool canAssign)
+{
+    (void)canAssign;
+
+    auto value = strtod(parser.previous.start, nullptr);
+    emitConstant(NUMBER_VAL(value));
+}
+
+static void or_(bool canAssign)
+{
+    (void)canAssign;
+
+    auto elseJump = emitJump(OP_JUMP_IF_FALSE);
+    auto endJump = emitJump(OP_JUMP);
+
+    patchJump(elseJump);
+    emitByte(OP_POP);
+
+    parsePrecedence(PREC_OR);
+
+    patchJump(endJump);
+}
+
+static void string(bool canAssign)
+{
+    (void)canAssign;
+
+    emitConstant(OBJ_VAL(copyString(parser.previous.start + 1, parser.previous.length - 2)));
+}
+
+static void namedVariable(Token name, bool canAssign)
+{
+    uint8_t getOp, setOp;
+    auto arg = resolveLocal(current, &name);
+    if (arg != -1) {
+        getOp = OP_GET_LOCAL;
+        setOp = OP_SET_LOCAL;
+    } else if ((arg = resolveUpvalue(current, &name)) != -1) {
+        getOp = OP_GET_UPVALUE;
+        setOp = OP_GET_UPVALUE;
+    } else {
+        arg = identifierConstant(&name);
+        getOp = OP_GET_GLOBAL;
+        setOp = OP_SET_GLOBAL;
+    }
+
+    if (canAssign && match(TOKEN_EQUAL)) {
+        expression();
+        emitBytes(setOp, arg);
+    } else {
+        emitBytes(getOp, arg);
+    }
+}
+
+static void variable(bool canAssign)
+{
+    namedVariable(parser.previous, canAssign);
+}
+
+static Token syntheticToken(const char* text)
+{
+    return (Token){
+        .start = text,
+        .length = (int)strlen(text),
+    };
+}
+
+static void super_(bool canAssign)
+{
+    (void)canAssign;
+
+    if (currentClass == nullptr) {
+        error("Can't use 'super' outside of a class.");
+    } else if (!currentClass->hasSuperclass) {
+        error("Can't use 'super' in a class with no superclass.");
+    }
+
+    consume(TOKEN_DOT, "Expect '.' after 'super'.");
+    consume(TOKEN_IDENTIFIER, "Expect superclass method name.");
+    auto name = identifierConstant(&parser.previous);
+
+    namedVariable(syntheticToken("this"), false);
+    if (match(TOKEN_LEFT_PAREN)) {
+        auto argCount = argumentList();
+        namedVariable(syntheticToken("super"), false);
+        emitBytes(OP_SUPER_INVOKE, name);
+        emitByte(argCount);
+    } else {
+        namedVariable(syntheticToken("super"), false);
+        emitBytes(OP_GET_SUPER, name);
+    }
+}
+
+static void this_(bool canAssign)
+{
+    if (currentClass == nullptr) {
+        error("Can't use 'this' outside of a class.");
+        return;
+    }
+
+    (void)canAssign;
+    variable(false);
+}
+
+static void unary(bool canAssign)
+{
+    (void)canAssign;
+
+    auto operatorType = parser.previous.type;
+
+    parsePrecedence(PREC_UNARY);
+
+    switch (operatorType) {
+    case TOKEN_BANG:
+        emitByte(OP_NOT);
+        break;
+    case TOKEN_MINUS:
+        emitByte(OP_NEGATE);
+        break;
+    default:
+        return;
+    }
+}
+
+ParseRule rules[] = {
+    [TOKEN_LEFT_PAREN]    = { .prefix = grouping, .infix = call,    .precedence = PREC_CALL },
+    [TOKEN_RIGHT_PAREN]   = { .prefix = nullptr,  .infix = nullptr, .precedence = PREC_NONE },
+    [TOKEN_LEFT_BRACE]    = { .prefix = nullptr,  .infix = nullptr, .precedence = PREC_NONE },
+    [TOKEN_RIGHT_BRACE]   = { .prefix = nullptr,  .infix = nullptr, .precedence = PREC_NONE },
+    [TOKEN_COMMA]         = { .prefix = nullptr,  .infix = nullptr, .precedence = PREC_NONE },
+    [TOKEN_DOT]           = { .prefix = nullptr,  .infix = dot,     .precedence = PREC_CALL },
+    [TOKEN_MINUS]         = { .prefix = unary,    .infix = binary,  .precedence = PREC_TERM },
+    [TOKEN_PLUS]          = { .prefix = nullptr,  .infix = binary,  .precedence = PREC_TERM },
+    [TOKEN_SEMICOLON]     = { .prefix = nullptr,  .infix = nullptr, .precedence = PREC_NONE },
+    [TOKEN_SLASH]         = { .prefix = nullptr,  .infix = binary,  .precedence = PREC_FACTOR },
+    [TOKEN_STAR]          = { .prefix = nullptr,  .infix = binary,  .precedence = PREC_FACTOR },
+    [TOKEN_BANG]          = { .prefix = unary,    .infix = nullptr, .precedence = PREC_NONE },
+    [TOKEN_BANG_EQUAL]    = { .prefix = nullptr,  .infix = binary,  .precedence = PREC_EQUALITY },
+    [TOKEN_EQUAL]         = { .prefix = nullptr,  .infix = nullptr, .precedence = PREC_NONE },
+    [TOKEN_EQUAL_EQUAL]   = { .prefix = nullptr,  .infix = binary,  .precedence = PREC_EQUALITY },
+    [TOKEN_GREATER]       = { .prefix = nullptr,  .infix = binary,  .precedence = PREC_COMPARISON },
+    [TOKEN_GREATER_EQUAL] = { .prefix = nullptr,  .infix = binary,  .precedence = PREC_COMPARISON },
+    [TOKEN_LESS]          = { .prefix = nullptr,  .infix = binary,  .precedence = PREC_COMPARISON },
+    [TOKEN_LESS_EQUAL]    = { .prefix = nullptr,  .infix = binary,  .precedence = PREC_COMPARISON },
+    [TOKEN_IDENTIFIER]    = { .prefix = variable, .infix = nullptr, .precedence = PREC_NONE },
+    [TOKEN_STRING]        = { .prefix = string,   .infix = nullptr, .precedence = PREC_NONE },
+    [TOKEN_NUMBER]        = { .prefix = number,   .infix = nullptr, .precedence = PREC_NONE },
+    [TOKEN_AND]           = { .prefix = nullptr,  .infix = and_,     .precedence = PREC_AND },
+    [TOKEN_CLASS]         = { .prefix = nullptr,  .infix = nullptr, .precedence = PREC_NONE },
+    [TOKEN_ELSE]          = { .prefix = nullptr,  .infix = nullptr, .precedence = PREC_NONE },
+    [TOKEN_FALSE]         = { .prefix = literal,  .infix = nullptr, .precedence = PREC_NONE },
+    [TOKEN_FOR]           = { .prefix = nullptr,  .infix = nullptr, .precedence = PREC_NONE },
+    [TOKEN_FUN]           = { .prefix = nullptr,  .infix = nullptr, .precedence = PREC_NONE },
+    [TOKEN_IF]            = { .prefix = nullptr,  .infix = nullptr, .precedence = PREC_NONE },
+    [TOKEN_NIL]           = { .prefix = literal,  .infix = nullptr, .precedence = PREC_NONE },
+    [TOKEN_OR]            = { .prefix = nullptr,  .infix = or_,      .precedence = PREC_OR },
+    [TOKEN_PRINT]         = { .prefix = nullptr,  .infix = nullptr, .precedence = PREC_NONE },
+    [TOKEN_RETURN]        = { .prefix = nullptr,  .infix = nullptr, .precedence = PREC_NONE },
+    [TOKEN_SUPER]         = { .prefix = super_,   .infix = nullptr, .precedence = PREC_NONE },
+    [TOKEN_THIS]          = { .prefix = this_,    .infix = nullptr, .precedence = PREC_NONE },
+    [TOKEN_TRUE]          = { .prefix = literal,  .infix = nullptr, .precedence = PREC_NONE },
+    [TOKEN_VAR]           = { .prefix = nullptr,  .infix = nullptr, .precedence = PREC_NONE },
+    [TOKEN_WHILE]         = { .prefix = nullptr,  .infix = nullptr, .precedence = PREC_NONE },
+    [TOKEN_ERROR]         = { .prefix = nullptr,  .infix = nullptr, .precedence = PREC_NONE },
+    [TOKEN_EOF]           = { .prefix = nullptr,  .infix = nullptr, .precedence = PREC_NONE },
+};
+
+static void parsePrecedence(Precedence precedence)
+{
+    advance();
+    auto prefixRule = getRule(parser.previous.type)->prefix;
+    if (prefixRule == nullptr) {
+        error("Expected expression.");
+        return;
+    }
+
+    auto canAssign = precedence <= PREC_ASSIGNMENT;
+    prefixRule(canAssign);
+
+    while (precedence < getRule(parser.current.type)->precedence) {
+        advance();
+        auto infixRule = getRule(parser.previous.type)->infix;
+
+        infixRule(canAssign);
+    }
+
+    if (canAssign && match(TOKEN_EQUAL)) {
+        error("Invalid assignment target.");
+    }
+}
+
+static ParseRule* getRule(TokenType type)
+{
+    return &rules[type];
+}
+
+static void expression()
+{
+    parsePrecedence(PREC_ASSIGNMENT);
+}
+
+static void block()
+{
+    while (!check(TOKEN_RIGHT_BRACE) && !check(TOKEN_EOF)) {
+        declaration();
+    }
+
+    consume(TOKEN_RIGHT_BRACE, "Expect '}' after block.");
+}
+
+static void function(FunctionType type)
+{
+    Compiler compiler;
+    initCompiler(&compiler, type);
+    beginScope();
+
+    consume(TOKEN_LEFT_PAREN, "Expect '(' after function name.");
+    if (!check(TOKEN_RIGHT_PAREN)) {
+        do {
+            current->function->arity++;
+            if (current->function->arity > 255) {
+                errorAtCurrent("Can't have more than 255 parameters.");
+            }
+            auto constant = parseVariable("Expect parameter name.");
+            defineVariable(constant);
+        } while (match(TOKEN_COMMA));
+    }
+    consume(TOKEN_RIGHT_PAREN, "Expect ')' after parameters.");
+    consume(TOKEN_LEFT_BRACE, "Expect '{' before function body.");
+    block();
+
+    ObjFunction* function = endCompiler();
+    emitBytes(OP_CLOSURE, makeConstant(OBJ_VAL(function)));
+
+    for (auto i = 0; i < function->upvalueCount; i++) {
+        emitByte(compiler.upvalues[i].isLocal ? 1 : 0);
+        emitByte(compiler.upvalues[i].index);
+    }
+}
+
+static void method()
+{
+    consume(TOKEN_IDENTIFIER, "Expect method name.");
+    auto constant = identifierConstant(&parser.previous);
+
+    FunctionType type = TYPE_METHOD;
+    if (parser.previous.length == 4 && memcmp(parser.previous.start, "init", 4) == 0) {
+        type = TYPE_INITIALIZER;
+    }
+    function(type);
+    emitBytes(OP_METHOD, constant);
+}
+
+static void classDeclaration()
+{
+    consume(TOKEN_IDENTIFIER, "Expect class name");
+    auto className = parser.previous;
+    auto nameConstant = identifierConstant(&parser.previous);
+    declareVariable();
+
+    emitBytes(OP_CLASS, nameConstant);
+    defineVariable(nameConstant);
+
+    ClassCompiler classCompiler;
+    classCompiler.hasSuperclass = false;
+    classCompiler.enclosing = currentClass;
+    currentClass = &classCompiler;
+
+    if (match(TOKEN_LESS)) {
+        consume(TOKEN_IDENTIFIER, "Expect superclass name.");
+        variable(false);
+
+        if (identifiersEqual(&className, &parser.previous)) {
+            error("A class can't inherit from itself.");
+        }
+
+        beginScope();
+        addLocal(syntheticToken("super"));
+        defineVariable(0);
+
+        namedVariable(className, false);
+        emitByte(OP_INHERIT);
+        classCompiler.hasSuperclass = true;
+    }
+
+    namedVariable(className, false);
+    consume(TOKEN_LEFT_BRACE, "Expect '{' before class body.");
+    while (!check(TOKEN_RIGHT_BRACE) && !check(TOKEN_EOF)) {
+        method();
+    }
+    consume(TOKEN_RIGHT_BRACE, "Expect '}' after class body");
+    emitByte(OP_POP);
+
+    if (classCompiler.hasSuperclass) {
+        endScope();
+    }
+
+    currentClass = currentClass->enclosing;
+}
+
+static void funDeclaration()
+{
+    auto global = parseVariable("Expect function name.");
+    markInitialized();
+    function(TYPE_FUNCTION);
+    defineVariable(global);
+}
+
+static void varDeclaration()
+{
+    auto global = parseVariable("Expected variable name.");
+
+    if (match(TOKEN_EQUAL)) {
+        expression();
+    } else {
+        emitByte(OP_NIL);
+    }
+    consume(TOKEN_SEMICOLON, "Expected ';' after variable declaration.");
+
+    defineVariable(global);
+}
+
+static void expressionStatement()
+{
+    expression();
+    consume(TOKEN_SEMICOLON, "Expect ';' after expression.");
+    emitByte(OP_POP);
+}
+
+static void forStatement()
+{
+    beginScope();
+
+    consume(TOKEN_LEFT_PAREN, "Expect '(' after 'for'.");
+    if (match(TOKEN_SEMICOLON)) {
+        // No initializer
+    } else if (match(TOKEN_VAR)) {
+        varDeclaration();
+    } else {
+        expressionStatement();
+    }
+
+    auto loopStart = currentChunk()->count;
+    auto exitJump = -1;
+    if (!match(TOKEN_SEMICOLON)) {
+        expression();
+        consume(TOKEN_SEMICOLON, "Expect ';' after loop condition.");
+
+        exitJump = emitJump(OP_JUMP_IF_FALSE);
+        emitByte(OP_POP);
+    }
+
+    if (!match(TOKEN_RIGHT_PAREN)) {
+        auto bodyJump = emitJump(OP_JUMP);
+        auto incrementStart = currentChunk()->count;
+        expression();
+        emitByte(OP_POP);
+        consume(TOKEN_RIGHT_PAREN, "Expect ')' after for clauses.");
+
+        emitLoop(loopStart);
+        loopStart = incrementStart;
+        patchJump(bodyJump);
+    }
+
+    statement();
+    emitLoop(loopStart);
+
+    if (exitJump != -1) {
+        patchJump(exitJump);
+        emitByte(OP_POP);
+    }
+
+    endScope();
+}
+
+static void ifStatement()
+{
+    consume(TOKEN_LEFT_PAREN, "Expect '(' after 'if'.");
+    expression();
+    consume(TOKEN_RIGHT_PAREN, "Expect ')' after condition.");
+
+    auto thenJump = emitJump(OP_JUMP_IF_FALSE);
+    emitByte(OP_POP);
+    statement();
+
+    int elseJump = emitJump(OP_JUMP);
+
+    patchJump(thenJump);
+    emitByte(OP_POP);
+
+    if (match(TOKEN_ELSE)) {
+        statement();
+    }
+
+    patchJump(elseJump);
+}
+
+static void printStatement()
+{
+    expression();
+    consume(TOKEN_SEMICOLON, "Expected ';' after value.");
+    emitByte(OP_PRINT);
+}
+
+static void returnStatement()
+{
+    if (current->type == TYPE_SCRIPT) {
+        error("Can't return from top-level code.");
+    }
+
+    if (match(TOKEN_SEMICOLON)) {
+        emitReturn();
+    } else {
+        if (current->type == TYPE_INITIALIZER) {
+            error("Can't return a value from an initializer.");
+        }
+
+        expression();
+        consume(TOKEN_SEMICOLON, "Expect ';' after return value.");
+        emitByte(OP_RETURN);
+    }
+}
+
+static void whileStatement()
+{
+    auto loopStart = currentChunk()->count;
+
+    consume(TOKEN_LEFT_PAREN, "EXPECT '(' after 'while'.");
+    expression();
+    consume(TOKEN_RIGHT_PAREN, "Expect ')' after condition.");
+
+    auto exitJump = emitJump(OP_JUMP_IF_FALSE);
+    emitByte(OP_POP);
+    statement();
+    emitLoop(loopStart);
+
+    patchJump(exitJump);
+
+    emitByte(OP_POP);
+}
+
+static void synchronize()
+{
+    parser.panicMode = false;
+
+    while (parser.current.type != TOKEN_EOF) {
+        if (parser.previous.type == TOKEN_SEMICOLON) {
+            return;
+        }
+
+        switch (parser.current.type) {
+        case TOKEN_CLASS:
+        case TOKEN_FUN:
+        case TOKEN_VAR:
+        case TOKEN_FOR:
+        case TOKEN_IF:
+        case TOKEN_WHILE:
+        case TOKEN_PRINT:
+        case TOKEN_RETURN:
+            return;
+        default:
+            ;
+        }
+
+        advance();
+    }
+}
+
+static void declaration()
+{
+    if (match(TOKEN_CLASS)) {
+        classDeclaration();
+    } else if (match(TOKEN_FUN)) {
+        funDeclaration();
+    } else if (match(TOKEN_VAR)) {
+        varDeclaration();
+    } else {
+        statement();
+    }
+
+    if (parser.panicMode) {
+        synchronize();
+    }
+}
+
+static void statement()
+{
+    if (match(TOKEN_PRINT)) {
+        printStatement();
+    } else if (match(TOKEN_IF)) {
+        ifStatement();
+    } else if (match(TOKEN_RETURN)) {
+        returnStatement();
+    } else if (match(TOKEN_WHILE)) {
+        whileStatement();
+    } else if (match(TOKEN_FOR)) {
+        forStatement();
+    } else if (match(TOKEN_LEFT_BRACE)) {
+        beginScope();
+        block();
+        endScope();
+    } else {
+        expressionStatement();
+    }
+}
+
+ObjFunction* compile(const char* source)
+{
+    initScanner(source);
+    Compiler compiler;
+    initCompiler(&compiler, TYPE_SCRIPT);
+
+    parser.hadError = false;
+    parser.panicMode = false;
+
+    advance();
+
+    while (!match(TOKEN_EOF)) {
+        declaration();
+    }
+
+    ObjFunction* function = endCompiler();
+    return parser.hadError ? nullptr : function;
+}
+
+void markCompilerRoots()
+{
+    Compiler* compiler = current;
+    while (compiler != nullptr) {
+        markObject((Obj*)compiler->function);
+        compiler = compiler->enclosing;
+    }
+}
+
diff --git a/compiler.h b/compiler.h
new file mode 100644
index 0000000..ee7b428
--- /dev/null
+++ b/compiler.h
@@ -0,0 +1,11 @@
+#ifndef clox_compiler_h
+#define clox_compiler_h
+
+#include "object.h"
+#include "vm.h"
+
+ObjFunction* compile(const char* source);
+void markCompilerRoots();
+
+#endif // clox_compiler_h
+
diff --git a/debug.c b/debug.c
new file mode 100644
index 0000000..b220863
--- /dev/null
+++ b/debug.c
@@ -0,0 +1,159 @@
+#include <stdio.h>
+
+#include "debug.h"
+#include "object.h"
+#include "value.h"
+
+void disassembleChunk(Chunk* chunk, const char* name)
+{
+    printf("== %s ==\n", name);
+    for (int offset = 0; offset < chunk->count;) {
+        offset = disassembleInstruction(chunk, offset);
+    }
+}
+
+static int constantInstruction(const char* name, Chunk* chunk, int offset)
+{
+    auto constant = chunk->code[offset + 1];
+    printf("%-16s %4d '", name, constant);
+    printValue(chunk->constants.values[constant]);
+    printf("'\n");
+    return offset + 2;
+}
+
+static int invokeInstruction(const char* name, Chunk* chunk, int offset)
+{
+    auto constant = chunk->code[offset + 1];
+    auto argCount = chunk->code[offset + 2];
+    printf("%-16s (%d args) %4d '", name, argCount, constant);
+    printValue(chunk->constants.values[constant]);
+    printf("'\n");
+    return offset + 3;
+}
+
+static int simpleInstruction(const char* name, int offset)
+{
+    printf("%s\n", name);
+    return offset + 1;
+}
+
+static int byteInstruction(const char* name, Chunk* chunk, int offset)
+{
+    auto slot = chunk->code[offset + 1];
+    printf("%-16s %4d\n", name, slot);
+    return offset + 2;
+}
+
+static int jumpInstruction(const char* name, int sign, Chunk* chunk, int offset)
+{
+    auto jump = (uint16_t)(chunk->code[offset + 1] << 8);
+    jump |= chunk->code[offset + 2];
+    printf("%-16s %4d -> %d\n", name, offset, offset + 3 + sign * jump);
+    return offset + 3;
+}
+
+int disassembleInstruction(Chunk* chunk, int offset)
+{
+    printf("%04d ", offset);
+    if (offset > 0 && chunk->lines[offset] == chunk->lines[offset - 1]) {
+        printf("   | ");
+    } else {
+        printf("%4d ", chunk->lines[offset]);
+    }
+    auto instruction = chunk->code[offset];
+    switch (instruction) {
+    case OP_CONSTANT:
+        return constantInstruction("OP_CONSTANT", chunk, offset);
+    case OP_NIL:
+        return simpleInstruction("OP_NIL", offset);
+    case OP_TRUE:
+        return simpleInstruction("OP_TRUE", offset);
+    case OP_FALSE:
+        return simpleInstruction("OP_FALSE", offset);
+    case OP_POP:
+        return simpleInstruction("OP_POP", offset);
+    case OP_GET_LOCAL:
+        return byteInstruction("OP_GET_LOCAL", chunk, offset);
+    case OP_SET_LOCAL:
+        return byteInstruction("OP_SET_LOCAL", chunk, offset);
+    case OP_GET_GLOBAL:
+        return constantInstruction("OP_GET_GLOBAL", chunk, offset);
+    case OP_DEFINE_GLOBAL:
+        return constantInstruction("OP_DEFINE_GLOBAL", chunk, offset);
+    case OP_SET_GLOBAL:
+        return constantInstruction("OP_SET_GLOBAL", chunk, offset);
+    case OP_GET_UPVALUE:
+        return byteInstruction("OP_GET_UPVALUE", chunk, offset);
+    case OP_SET_UPVALUE:
+        return byteInstruction("OP_SET_UPVALUE", chunk, offset);
+    case OP_GET_PROPERTY:
+        return constantInstruction("OP_GET_PROPERTY", chunk, offset);
+    case OP_SET_PROPERTY:
+        return constantInstruction("OP_SET_PROPERTY", chunk, offset);
+    case OP_GET_SUPER:
+        return constantInstruction("OP_GET_SUPER", chunk, offset);
+    case OP_EQUAL:
+        return simpleInstruction("OP_EQUAL", offset);
+    case OP_GREATER:
+        return simpleInstruction("OP_GREATER", offset);
+    case OP_LESS:
+        return simpleInstruction("OP_LESS", offset);
+    case OP_ADD:
+        return simpleInstruction("OP_ADD", offset);
+    case OP_SUBTRACT:
+        return simpleInstruction("OP_SUBTRACT", offset);
+    case OP_MULTIPLY:
+        return simpleInstruction("OP_MULTIPLY", offset);
+    case OP_DIVIDE:
+        return simpleInstruction("OP_DIVIDE", offset);
+    case OP_NOT:
+        return simpleInstruction("OP_NOT", offset);
+    case OP_NEGATE:
+        return simpleInstruction("OP_NEGATE", offset);
+    case OP_PRINT:
+        return simpleInstruction("OP_PRINT", offset);
+    case OP_JUMP:
+        return jumpInstruction("OP_JUMP", 1, chunk, offset);
+    case OP_JUMP_IF_FALSE:
+        return jumpInstruction("OP_JUMP_IF_FALSE", 1, chunk, offset);
+    case OP_LOOP:
+        return jumpInstruction("OP_LOOP", -1, chunk, offset);
+    case OP_CALL:
+        return byteInstruction("OP_CALL", chunk, offset);
+    case OP_INVOKE:
+        return invokeInstruction("OP_INVOKE", chunk, offset);
+    case OP_SUPER_INVOKE:
+        return invokeInstruction("OP_SUPER_INVOKE", chunk, offset);
+    case OP_CLOSURE:
+        {
+            offset++;
+            auto constant = chunk->code[offset++];
+            printf("%-16s %4d ", "OP_CLOSURE", constant);
+            printValue(chunk->constants.values[constant]);
+            printf("\n");
+
+            ObjFunction* function = AS_FUNCTION(chunk->constants.values[constant]);
+            for (auto j = 0; j < function->upvalueCount; j++) {
+                auto isLocal = chunk->code[offset++];
+                auto index = chunk->code[offset++];
+                printf("%04d      |                     %s %d\n", offset - 2, isLocal ? "local" : "upvalue", index);
+            }
+
+            return offset;
+        }
+    case OP_CLOSE_UPVALUE:
+        return simpleInstruction("OP_CLOSE_UPVALUE", offset);
+    case OP_RETURN:
+        return simpleInstruction("OP_RETURN", offset);
+    case OP_CLASS:
+        return constantInstruction("OP_CLASS", chunk, offset);
+    case OP_INHERIT:
+        return simpleInstruction("OP_INHERIT", offset);
+    case OP_METHOD:
+        return constantInstruction("OP_METHOD", chunk, offset);
+    default:
+        printf("Unknown opcode %d\n", instruction);
+        return offset + 1;
+    }
+}
+
diff --git a/debug.h b/debug.h
new file mode 100644
index 0000000..7d05f2f
--- /dev/null
+++ b/debug.h
@@ -0,0 +1,10 @@
+#ifndef clox_debug_h
+#define clox_debug_h
+
+#include "chunk.h"
+
+void disassembleChunk(Chunk* chunk, const char* name);
+int disassembleInstruction(Chunk* chunk, int offset);
+
+#endif // clox_debug_h
+
diff --git a/flake.lock b/flake.lock
new file mode 100644
index 0000000..6d616e2
--- /dev/null
+++ b/flake.lock
@@ -0,0 +1,62 @@
+{
+  "nodes": {
+    "flake-utils": {
+      "inputs": {
+        "systems": [
+          "systems"
+        ]
+      },
+      "locked": {
+        "lastModified": 1731533236,
+        "narHash": "sha256-l0KFg5HjrsfsO/JpG+r7fRrqm12kzFHyUHqHCVpMMbI=",
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "rev": "11707dc2f618dd54ca8739b309ec4fc024de578b",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "type": "github"
+      }
+    },
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1766471942,
+        "narHash": "sha256-Wv+xrUNXgtxAXAMZE3EDzzeRgN1MEw+PnKr8zDozeLU=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "cfc52a405c6e85462364651a8f11e28ae8065c91",
+        "type": "github"
+      },
+      "original": {
+        "id": "nixpkgs",
+        "type": "indirect"
+      }
+    },
+    "root": {
+      "inputs": {
+        "flake-utils": "flake-utils",
+        "nixpkgs": "nixpkgs",
+        "systems": "systems"
+      }
+    },
+    "systems": {
+      "locked": {
+        "lastModified": 1680978846,
+        "narHash": "sha256-Gtqg8b/v49BFDpDetjclCYXm8mAnTrUzR0JnE2nv5aw=",
+        "owner": "nix-systems",
+        "repo": "x86_64-linux",
+        "rev": "2ecfcac5e15790ba6ce360ceccddb15ad16d08a8",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-systems",
+        "repo": "x86_64-linux",
+        "type": "github"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}
diff --git a/flake.nix b/flake.nix
new file mode 100644
index 0000000..0358deb
--- /dev/null
+++ b/flake.nix
@@ -0,0 +1,43 @@
+{
+  description = "C Template";
+
+  inputs = {
+    nixpkgs.url = "nixpkgs";
+    systems.url = "github:nix-systems/x86_64-linux";
+    flake-utils = {
+      url = "github:numtide/flake-utils";
+      inputs.systems.follows = "systems";
+    };
+  };
+
+  outputs =
+    { self
+    , nixpkgs
+    , flake-utils
+    , ...
+    }:
+    flake-utils.lib.eachDefaultSystem (system:
+    let
+      pkgs = nixpkgs.legacyPackages.${system};
+      pname = "hello-world"; #package name
+      version = "0.0.1";
+      src = ./.;
+      buildInputs = with pkgs; [
+      ];
+      nativeBuildInputs = with pkgs; [
+        ninja
+        cmake
+        clang-tools
+        lldb
+      ];
+    in
+    {
+      devShells.default = pkgs.mkShell.override { stdenv = pkgs.clangStdenv; } {
+        inherit buildInputs nativeBuildInputs;
+      };
+
+      packages.default = pkgs.stdenv.mkDerivation {
+        inherit buildInputs nativeBuildInputs pname version src;
+      };
+    });
+}
diff --git a/main.c b/main.c
new file mode 100644
index 0000000..60de204
--- /dev/null
+++ b/main.c
@@ -0,0 +1,86 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "common.h"
+#include "chunk.h"
+#include "debug.h"
+#include "vm.h"
+
+static void repl()
+{
+    char line[1024];
+    for (;;) {
+        printf("> ");
+        if (!fgets(line, sizeof(line), stdin)) {
+            printf("\n");
+            break;
+        }
+
+        interpret(line);
+    }
+}
+
+static char* readFile(const char* path)
+{
+    FILE* file = fopen(path, "rb");
+    if (file == nullptr) {
+        fprintf(stderr, "Could not open file \"%s\".\n", path);
+        exit(74);
+    }
+
+    fseek(file, 0L, SEEK_END);
+    auto fileSize = ftell(file);
+    if (fileSize < 0) {
+        fprintf(stderr, "Could not tell file size.");
+        exit(74);
+    }
+    rewind(file);
+
+    char* buffer = (char*)malloc(fileSize + 1);
+    if (buffer == nullptr) {
+        fprintf(stderr, "Not enough memory to read \"%s\".\n", path);
+        exit(74);
+    }
+    auto bytesRead = fread(buffer, sizeof(char), fileSize, file);
+    if (bytesRead < (size_t)fileSize) {
+        fprintf(stderr, "Could not read file \"%s\".\n", path);
+        exit(74);
+    }
+
+    fclose(file);
+    return buffer;
+}
+
+static void runFile(const char* path)
+{
+    char* source = readFile(path);
+    auto result = interpret(source);
+    free(source);
+
+    if (result == INTERPRET_COMPILE_ERROR) {
+        exit(65);
+    }
+    if (result == INTERPRET_RUNTIME_ERROR) {
+        exit(70);
+    }
+}
+
+int main(int argc, const char* argv[])
+{
+    initVM();
+
+    if (argc == 1) {
+        repl();
+    } else if (argc == 2) {
+        runFile(argv[1]);
+    } else {
+        fprintf(stderr, "Usage: %s [path]\n", argv[0]);
+        exit(64);
+    }
+
+    freeVM();
+
+    return 0;
+}
+
diff --git a/memory.c b/memory.c
new file mode 100644
index 0000000..9b6d40f
--- /dev/null
+++ b/memory.c
@@ -0,0 +1,269 @@
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "compiler.h"
+#include "memory.h"
+#include "vm.h"
+
+#ifdef DEBUG_LOG_GC
+#include <stdio.h>
+#include "debug.h"
+#endif
+
+#define GC_HEAP_GROW_FACTOR 2
+
+void* reallocate(void* pointer, size_t oldSize, size_t newSize)
+{
+    vm.bytesAllocated += newSize - oldSize;
+    if (newSize > oldSize) {
+#ifdef DEBUG_STRESS_GC
+        collectGarbage();
+#endif
+    }
+
+    if (vm.bytesAllocated > vm.nextGC) {
+        collectGarbage();
+    }
+
+    if (newSize == 0) {
+        free(pointer);
+        return nullptr;
+    }
+
+    void* result = realloc(pointer, newSize);
+    if (result == nullptr) {
+        exit(1);
+    }
+    return result;
+}
+
+void markObject(Obj* object)
+{
+    if (object == nullptr) {
+        return;
+    }
+    if (object->isMarked) {
+        return;
+    }
+#ifdef DEBUG_LOG_GC
+    printf("%p mark ", (void*)object);
+    printValue(OBJ_VAL(object));
+    printf("\n");
+#endif
+
+    object->isMarked = true;
+
+    if (vm.grayCapacity < vm.grayCount + 1) {
+        vm.grayCapacity = GROW_CAPACITY(vm.grayCapacity);
+        vm.grayStack = (Obj**)realloc(vm.grayStack, sizeof(Obj*) * vm.grayCapacity);
+
+        if (vm.grayStack == nullptr) {
+            fprintf(stderr, "failed to realloc grayStack\n");
+            exit(1);
+        }
+    }
+
+    vm.grayStack[vm.grayCount++] = object;
+}
+
+void markValue(Value value)
+{
+    if (IS_OBJ(value)) {
+        markObject(AS_OBJ(value));
+    }
+}
+
+static void markArray(ValueArray* array)
+{
+    for (auto i = 0; i < array->count; i++) {
+        markValue(array->values[i]);
+    }
+}
+
+static void blackenObject(Obj* object)
+{
+#ifdef DEBUG_LOG_GC
+    printf("%p blacken ", (void*)object);
+    printValue(OBJ_VAL(object));
+    printf("\n");
+#endif
+
+    switch (object->type) {
+    case OBJ_BOUND_METHOD:
+        {
+            ObjBoundMethod* bound = (ObjBoundMethod*)object;
+            markValue(bound->receiver);
+            markObject((Obj*)bound->method);
+        }
+        break;
+    case OBJ_CLASS:
+        {
+            ObjClass* klass = (ObjClass*)object;
+            markObject((Obj*)klass->name);
+            markTable(&klass->methods);
+        }
+        break;
+    case OBJ_CLOSURE:
+        {
+            ObjClosure* closure = (ObjClosure*)object;
+            markObject((Obj*)closure->function);
+            for (auto i = 0; i < closure->upvalueCount; i++) {
+                markObject((Obj*)closure->upvalues[i]);
+            }
+        }
+        break;
+    case OBJ_FUNCTION:
+        {
+            ObjFunction* function = (ObjFunction*)object;
+            markObject((Obj*)function->name);
+            markArray(&function->chunk.constants);
+        }
+        break;
+    case OBJ_INSTANCE:
+        {
+            ObjInstance* instance = (ObjInstance*)object;
+            markObject((Obj*)instance->klass);
+            markTable(&instance->fields);
+        }
+        break;
+    case OBJ_UPVALUE:
+        markValue(((ObjUpvalue*)object)->closed);
+        break;
+    case OBJ_NATIVE:
+    case OBJ_STRING:
+        break;
+    }
+}
+
+static void freeObject(Obj* object)
+{
+#ifdef DEBUG_LOG_GC
+    printf("%p free type %d\n", (void*)object, object->type);
+#endif
+
+    switch (object->type) {
+    case OBJ_BOUND_METHOD:
+        FREE(ObjBoundMethod, object);
+        break;
+    case OBJ_CLASS:
+        {
+            ObjClass* klass = (ObjClass*)object;
+            freeTable(&klass->methods);
+            FREE(ObjClass, object);
+        }
+        break;
+    case OBJ_CLOSURE:
+        FREE(ObjClosure, object);
+        break;
+    case OBJ_FUNCTION:
+        {
+            ObjFunction* function = (ObjFunction*)object;
+            freeChunk(&function->chunk);
+            FREE(ObjFunction, object);
+        }
+        break;
+    case OBJ_INSTANCE:
+        {
+            ObjInstance* instance = (ObjInstance*)object;
+            freeTable(&instance->fields);
+            FREE(ObjInstance, object);
+        }
+        break;
+    case OBJ_NATIVE:
+        FREE(ObjNative, object);
+        break;
+    case OBJ_STRING:
+        {
+            ObjString* string = (ObjString*)object;
+            FREE_ARRAY(char, string->chars, string->length + 1);
+            FREE(ObjString, object);
+        }
+        break;
+    case OBJ_UPVALUE:
+        FREE(ObjUpvalue, object);
+        break;
+    }
+}
+
+static void markRoots()
+{
+    for (Value* slot = vm.stack; slot < vm.stackTop; slot++) {
+        markValue(*slot);
+    }
+
+    for (auto i = 0; i < vm.frameCount; i++) {
+        markObject((Obj*)vm.frames[i].closure);
+    }
+
+    for (ObjUpvalue* upvalue = vm.openUpvalues; upvalue != nullptr; upvalue = upvalue->next) {
+        markObject((Obj*)upvalue);
+    }
+
+    markTable(&vm.globals);
+    markCompilerRoots();
+    markObject((Obj*)vm.initString);
+}
+
+static void traceReferences()
+{
+    while (vm.grayCount > 0) {
+        Obj* object = vm.grayStack[--vm.grayCount];
+        blackenObject(object);
+    }
+}
+
+static void sweep()
+{
+    Obj* previous = nullptr;
+    Obj* object = vm.objects;
+    while (object != nullptr) {
+        if (object->isMarked) {
+            object->isMarked = false;
+            previous = object;
+            object = object->next;
+        } else {
+            Obj* unreached = object;
+            object = object->next;
+            if (previous != nullptr) {
+                previous->next = object;
+            } else {
+                vm.objects = object;
+            }
+
+            freeObject(unreached);
+        }
+    }
+}
+
+void collectGarbage()
+{
+#ifdef DEBUG_LOG_GC
+    printf("-- gc begin\n");
+    size_t before = vm.bytesAllocated;
+#endif
+
+    markRoots();
+    traceReferences();
+    tableRemoveWhite(&vm.strings);
+    sweep();
+
+    vm.nextGC = vm.bytesAllocated * GC_HEAP_GROW_FACTOR;
+
+#ifdef DEBUG_LOG_GC
+    printf("-- gc end\n");
+    printf("   collected %zu bytes (from %zu to %zu) next at %zu\n", before - vm.bytesAllocated, before, vm.bytesAllocated, vm.nextGC);
+#endif
+}
+
+void freeObjects()
+{
+    Obj* object = vm.objects;
+    while (object != nullptr) {
+        Obj* next = object->next;
+        freeObject(object);
+        object = next;
+    }
+
+    free(vm.grayStack);
+}
+
diff --git a/memory.h b/memory.h
new file mode 100644
index 0000000..34ba23b
--- /dev/null
+++ b/memory.h
@@ -0,0 +1,29 @@
+#ifndef clox_memory_h
+#define clox_memory_h
+
+#include "common.h"
+#include "object.h"
+
+#define ALLOCATE(type, count) \
+    (type*)reallocate(nullptr, 0, sizeof(type) * (count))
+
+#define FREE(type, pointer) \
+    reallocate(pointer, sizeof(type), 0)
+
+#define GROW_CAPACITY(capacity) \
+    ((capacity) < 8 ? 8 : (capacity) * 2)
+
+#define GROW_ARRAY(type, pointer, oldCount, newCount) \
+    (type*)reallocate(pointer, sizeof(type) * (oldCount), sizeof(type) * (newCount))
+
+#define FREE_ARRAY(type, pointer, oldCount) \
+    reallocate(pointer, sizeof(type) * (oldCount), 0)
+
+void* reallocate(void* pointer, size_t oldSize, size_t newSize);
+void markObject(Obj* object);
+void markValue(Value value);
+void collectGarbage();
+void freeObjects();
+
+#endif // clox_memory_h
+
diff --git a/object.c b/object.c
new file mode 100644
index 0000000..02b3cc0
--- /dev/null
+++ b/object.c
@@ -0,0 +1,179 @@
+#include <stdio.h>
+#include <string.h>
+
+#include "memory.h"
+#include "object.h"
+#include "table.h"
+#include "value.h"
+#include "vm.h"
+
+#define ALLOCATE_OBJ(type, objectType) \
+    (type*)allocateObject(sizeof(type), objectType)
+
+static Obj* allocateObject(size_t size, ObjType type)
+{
+    Obj* object = (Obj*)reallocate(nullptr, 0, size);
+    object->type = type;
+    object->isMarked = false;
+
+    object->next = vm.objects;
+    vm.objects = object;
+
+#ifdef DEBUG_LOG_GC
+    printf("%p allocate %zu for %d\n", (void*)object, size, type);
+#endif
+
+    return object;
+}
+
+ObjBoundMethod* newBoundMethod(Value receiver, ObjClosure* method)
+{
+    ObjBoundMethod* bound = ALLOCATE_OBJ(ObjBoundMethod, OBJ_BOUND_METHOD);
+    bound->receiver = receiver;
+    bound->method = method;
+    return bound;
+}
+
+ObjClass* newClass(ObjString* name)
+{
+    ObjClass* klass = ALLOCATE_OBJ(ObjClass, OBJ_CLASS);
+    klass->name = name;
+    initTable(&klass->methods);
+    return klass;
+}
+
+ObjClosure* newClosure(ObjFunction* function)
+{
+    ObjUpvalue** upvalues = ALLOCATE(ObjUpvalue*, function->upvalueCount);
+    for (auto i = 0; i < function->upvalueCount; i++) {
+        upvalues[i] = nullptr;
+    }
+
+    ObjClosure* closure = ALLOCATE_OBJ(ObjClosure, OBJ_CLOSURE);
+    closure->function = function;
+    closure->upvalues = upvalues;
+    closure->upvalueCount = function->upvalueCount;
+    return closure;
+}
+
+ObjFunction* newFunction()
+{
+    ObjFunction* function = ALLOCATE_OBJ(ObjFunction, OBJ_FUNCTION);
+    function->arity = 0;
+    function->upvalueCount = 0;
+    function->name = nullptr;
+    initChunk(&function->chunk);
+    return function;
+}
+
+ObjInstance* newInstance(ObjClass* klass)
+{
+    ObjInstance* instance = ALLOCATE_OBJ(ObjInstance, OBJ_INSTANCE);
+    instance->klass = klass;
+    initTable(&instance->fields);
+    return instance;
+}
+
+ObjNative* newNative(NativeFn function)
+{
+    ObjNative* native = ALLOCATE_OBJ(ObjNative, OBJ_NATIVE);
+    native->function = function;
+    return native;
+}
+
+static ObjString* allocateString(char* chars, int length, uint32_t hash)
+{
+    ObjString* string = ALLOCATE_OBJ(ObjString, OBJ_STRING);
+    string->length = length;
+    string->chars = chars;
+    string->hash = hash;
+
+    push(OBJ_VAL(string));
+    tableSet(&vm.strings, string, NIL_VAL);
+    pop();
+
+    return string;
+}
+
+static uint32_t hashString(const char* key, int length)
+{
+    uint32_t hash = 2166136261u;
+    for (auto i = 0; i < length; i++) {
+        hash ^= (uint8_t)key[i];
+        hash *= 16777619;
+    }
+    return hash;
+}
+
+ObjString* takeString(char* chars, int length)
+{
+    auto hash = hashString(chars, length);
+    ObjString* interned = tableFindString(&vm.strings, chars, length, hash);
+    if (interned != nullptr) {
+        FREE_ARRAY(char, chars, length + 1);
+        return interned;
+    }
+    return allocateString(chars, length, hash);
+}
+
+ObjString* copyString(const char* chars, int length)
+{
+    auto hash = hashString(chars, length);
+    ObjString* interned = tableFindString(&vm.strings, chars, length, hash);
+    if (interned != nullptr) {
+        return interned;
+    }
+    char* heapChars = ALLOCATE(char, length + 1);
+    memcpy(heapChars, chars, length);
+    heapChars[length] = '\0';
+    return allocateString(heapChars, length, hash);
+}
+
+ObjUpvalue* newUpvalue(Value* slot)
+{
+    ObjUpvalue* upvalue = ALLOCATE_OBJ(ObjUpvalue, OBJ_UPVALUE);
+    upvalue->closed = NIL_VAL;
+    upvalue->location = slot;
+    upvalue->next = nullptr;
+    return upvalue;
+}
+
+static void printFunction(ObjFunction* function)
+{
+    if (function->name == nullptr) {
+        printf("<script>");
+        return;
+    }
+    printf("<fn %s>", function->name->chars);
+}
+
+void printObject(Value value)
+{
+    switch (OBJ_TYPE(value)) {
+    case OBJ_BOUND_METHOD:
+        printFunction(AS_BOUND_METHOD(value)->method->function);
+        break;
+    case OBJ_CLASS:
+        printf("%s", AS_CLASS(value)->name->chars);
+        break;
+    case OBJ_CLOSURE:
+        printFunction(AS_CLOSURE(value)->function);
+        break;
+    case OBJ_FUNCTION:
+        printFunction(AS_FUNCTION(value));
+        break;
+    case OBJ_INSTANCE:
+        printf("%s instance", AS_INSTANCE(value)->klass->name->chars);
+        break;
+    case OBJ_NATIVE:
+        printf("<native fn>");
+        break;
+    case OBJ_STRING:
+        printf("%s", AS_CSTRING(value));
+        break;
+    case OBJ_UPVALUE:
+        printf("upvalue");
+        break;
+    }
+}
+
diff --git a/object.h b/object.h
new file mode 100644
index 0000000..445da2e
--- /dev/null
+++ b/object.h
@@ -0,0 +1,116 @@
+#ifndef clox_object_h
+#define clox_object_h
+
+#include "common.h"
+#include "chunk.h"
+#include "table.h"
+#include "value.h"
+
+#define OBJ_TYPE(value) (AS_OBJ(value)->type)
+
+#define IS_BOUND_METHOD(value) isObjType(value, OBJ_BOUND_METHOD)
+#define IS_CLASS(value) isObjType(value, OBJ_CLASS)
+#define IS_CLOSURE(value) isObjType(value, OBJ_CLOSURE)
+#define IS_FUNCTION(value) isObjType(value, OBJ_FUNCTION)
+#define IS_INSTANCE(value) isObjType(value, OBJ_INSTANCE)
+#define IS_NATIVE(value) isObjTyep(value, OBJ_NATIVE)
+#define IS_STRING(value) isObjType(value, OBJ_STRING)
+
+#define AS_BOUND_METHOD(value) ((ObjBoundMethod*)AS_OBJ(value))
+#define AS_CLASS(value) ((ObjClass*)AS_OBJ(value))
+#define AS_CLOSURE(value) ((ObjClosure*)AS_OBJ(value))
+#define AS_FUNCTION(value) ((ObjFunction*)AS_OBJ(value))
+#define AS_INSTANCE(value) ((ObjInstance*)AS_OBJ(value))
+#define AS_NATIVE(value) (((ObjNative*)AS_OBJ(value))->function)
+#define AS_STRING(value) ((ObjString*)AS_OBJ(value))
+#define AS_CSTRING(value) (((ObjString*)AS_OBJ(value))->chars)
+
+typedef enum {
+    OBJ_BOUND_METHOD,
+    OBJ_CLASS,
+    OBJ_CLOSURE,
+    OBJ_FUNCTION,
+    OBJ_INSTANCE,
+    OBJ_NATIVE,
+    OBJ_STRING,
+    OBJ_UPVALUE,
+} ObjType;
+
+struct Obj {
+    ObjType type;
+    bool isMarked;
+    struct Obj* next;
+};
+
+typedef struct {
+    Obj obj;
+    int arity;
+    int upvalueCount;
+    Chunk chunk;
+    ObjString* name;
+} ObjFunction;
+
+typedef Value (*NativeFn)(int argCount, Value* args);
+
+typedef struct {
+    Obj obj;
+    NativeFn function;
+} ObjNative;
+
+struct ObjString {
+    Obj obj;
+    int length;
+    char* chars;
+    uint32_t hash;
+};
+
+typedef struct ObjUpvalue {
+    Obj obj;
+    Value* location;
+    Value closed;
+    struct ObjUpvalue* next;
+} ObjUpvalue;
+
+typedef struct {
+    Obj obj;
+    ObjFunction* function;
+    ObjUpvalue** upvalues;
+    int upvalueCount;
+} ObjClosure;
+
+typedef struct {
+    Obj obj;
+    ObjString* name;
+    Table methods;
+} ObjClass;
+
+typedef struct {
+    Obj obj;
+    ObjClass* klass;
+    Table fields;
+} ObjInstance;
+
+typedef struct {
+    Obj obj;
+    Value receiver;
+    ObjClosure* method;
+} ObjBoundMethod;
+
+ObjBoundMethod* newBoundMethod(Value receiver, ObjClosure* method);
+ObjClass* newClass(ObjString* name);
+ObjClosure* newClosure(ObjFunction* function);
+ObjFunction* newFunction();
+ObjInstance* newInstance(ObjClass* klass);
+ObjNative* newNative(NativeFn function);
+ObjString* takeString(char* chars, int length);
+ObjString* copyString(const char* chars, int length);
+ObjUpvalue* newUpvalue(Value* slot);
+void printObject(Value value);
+
+static inline bool isObjType(Value value, ObjType type)
+{
+    return IS_OBJ(value) && AS_OBJ(value)->type == type;
+}
+
+#endif // clox_object_h
+
diff --git a/scanner.c b/scanner.c
new file mode 100644
index 0000000..46853b4
--- /dev/null
+++ b/scanner.c
@@ -0,0 +1,274 @@
+#include <stdio.h>
+#include <string.h>
+
+#include "common.h"
+#include "scanner.h"
+
+typedef struct {
+    const char* start;
+    const char* current;
+    int line;
+} Scanner;
+
+Scanner scanner;
+
+void initScanner(const char* source)
+{
+    scanner.start = source;
+    scanner.current = source;
+    scanner.line = 1;
+}
+
+static bool isAlpha(char c)
+{
+    return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '_';
+}
+
+static bool isDigit(char c)
+{
+    return c >= '0' && c <= '9';
+}
+
+static bool isAtEnd()
+{
+    return *scanner.current == '\0';
+}
+
+static char advance()
+{
+    scanner.current++;
+    return scanner.current[-1];
+}
+
+static char peek()
+{
+    return *scanner.current;
+}
+
+static char peekNext()
+{
+    if (isAtEnd()) {
+        return '\0';
+    }
+    return scanner.current[1];
+}
+
+static bool match(char expected)
+{
+    if (isAtEnd()) {
+        return false;
+    }
+    if (*scanner.current != expected) {
+        return false;
+    }
+    scanner.current++;
+    return true;
+}
+
+static Token makeToken(TokenType type)
+{
+    return (Token){
+        .type = type,
+        .start = scanner.start,
+        .length = (int)(scanner.current - scanner.start),
+        .line = scanner.line,
+    };
+}
+
+static Token errorToken(const char* message)
+{
+    return (Token){
+        .type = TOKEN_ERROR,
+        .start = message,
+        .length = (int)strlen(message),
+        .line = scanner.line,
+    };
+}
+
+static void skipWhitespace()
+{
+    for (;;) {
+        auto c = peek();
+        switch (c) {
+        case ' ':
+        case '\r':
+        case '\t':
+            advance();
+            break;
+        case '\n':
+            scanner.line++;
+            advance();
+            break;
+        case '/':
+            if (peekNext() == '/') {
+                while (peek() != '\n' && !isAtEnd()) {
+                    advance();
+                }
+            } else {
+                return;
+            }
+            break;
+        default:
+            return;
+        }
+    }
+}
+
+static TokenType checkKeyword(int start, int length, const char* rest, TokenType type)
+{
+    if (scanner.current - scanner.start == start + length && memcmp(scanner.start + start, rest, length) == 0) {
+        return type;
+    }
+    return TOKEN_IDENTIFIER;
+}
+
+static TokenType identifierType()
+{
+    switch (scanner.start[0]) {
+    case 'a':
+        return checkKeyword(1, 2, "nd", TOKEN_AND);
+    case 'c':
+        return checkKeyword(1, 4, "lass", TOKEN_CLASS);
+    case 'e':
+        return checkKeyword(1, 3, "lse", TOKEN_ELSE);
+    case 'f':
+        if (scanner.current - scanner.start > 1) {
+            switch (scanner.start[1]) {
+            case 'a':
+                return checkKeyword(2, 3, "lse", TOKEN_FALSE);
+            case 'o':
+                return checkKeyword(2, 1, "r", TOKEN_FOR);
+            case 'u':
+                return checkKeyword(2, 1, "n", TOKEN_FUN);
+            }
+        }
+        break;
+    case 'i':
+        return checkKeyword(1, 1, "f", TOKEN_IF);
+    case 'n':
+        return checkKeyword(1, 2, "il", TOKEN_NIL);
+    case 'o':
+        return checkKeyword(1, 1, "r", TOKEN_OR);
+    case 'p':
+        return checkKeyword(1, 4, "rint", TOKEN_PRINT);
+    case 'r':
+        return checkKeyword(1, 5, "eturn", TOKEN_RETURN);
+    case 's':
+        return checkKeyword(1, 4, "uper", TOKEN_SUPER);
+    case 't':
+        if (scanner.current - scanner.start > 1) {
+            switch (scanner.start[1]) {
+            case 'h':
+                return checkKeyword(2, 2, "is", TOKEN_THIS);
+            case 'r':
+                return checkKeyword(2, 2, "ue", TOKEN_TRUE);
+            }
+        }
+    case 'v':
+        return checkKeyword(1, 2, "ar", TOKEN_VAR);
+    case 'w':
+        return checkKeyword(1, 4, "hile", TOKEN_WHILE);
+    }
+
+    return TOKEN_IDENTIFIER;
+}
+
+static Token identifier()
+{
+    while (isAlpha(peek()) || isDigit(peek())) {
+        advance();
+    }
+    return makeToken(identifierType());
+}
+
+static Token number()
+{
+    while (isDigit(peek())) {
+        advance();
+    }
+
+    if (peek() == '.' && isDigit(peekNext())) {
+        advance();
+
+        while (isDigit(peek())) {
+            advance();
+        }
+    }
+
+    return makeToken(TOKEN_NUMBER);
+}
+
+static Token string()
+{
+    while (peek() != '"' && !isAtEnd()) {
+        if (peek() == '\n') {
+            scanner.line++;
+        }
+        advance();
+    }
+
+    if (isAtEnd()) {
+        return errorToken("Unterminated string.");
+    }
+
+    advance();
+
+    return makeToken(TOKEN_STRING);
+}
+
+Token scanToken()
+{
+    skipWhitespace();
+
+    scanner.start = scanner.current;
+    if (isAtEnd()) {
+        return makeToken(TOKEN_EOF);
+    }
+
+    auto c = advance();
+
+    if (isAlpha(c)) {
+        return identifier();
+    }
+    if (isDigit(c)) {
+        return number();
+    }
+
+    switch (c) {
+    case '(':
+        return makeToken(TOKEN_LEFT_PAREN);
+    case ')':
+        return makeToken(TOKEN_RIGHT_PAREN);
+    case '{':
+        return makeToken(TOKEN_LEFT_BRACE);
+    case '}':
+        return makeToken(TOKEN_RIGHT_BRACE);
+    case ';':
+        return makeToken(TOKEN_SEMICOLON);
+    case ',':
+        return makeToken(TOKEN_COMMA);
+    case '.':
+        return makeToken(TOKEN_DOT);
+    case '-':
+        return makeToken(TOKEN_MINUS);
+    case '+':
+        return makeToken(TOKEN_PLUS);
+    case '/':
+        return makeToken(TOKEN_SLASH);
+    case '*':
+        return makeToken(TOKEN_STAR);
+    case '!':
+        return makeToken(match('=') ? TOKEN_BANG_EQUAL : TOKEN_BANG);
+    case '=':
+        return makeToken(match('=') ? TOKEN_EQUAL_EQUAL : TOKEN_EQUAL);
+    case '<':
+        return makeToken(match('=') ? TOKEN_LESS_EQUAL : TOKEN_LESS);
+    case '>':
+        return makeToken(match('=') ? TOKEN_GREATER_EQUAL : TOKEN_GREATER);
+    case '"':
+        return string();
+    }
+
+    return errorToken("Unexpected character.");
+}
+
diff --git a/scanner.h b/scanner.h
new file mode 100644
index 0000000..210cafc
--- /dev/null
+++ b/scanner.h
@@ -0,0 +1,58 @@
+#ifndef clox_scanner_h
+#define clox_scanner_h
+
+typedef enum {
+    TOKEN_LEFT_PAREN,
+    TOKEN_RIGHT_PAREN,
+    TOKEN_LEFT_BRACE,
+    TOKEN_RIGHT_BRACE,
+    TOKEN_COMMA,
+    TOKEN_DOT,
+    TOKEN_MINUS,
+    TOKEN_PLUS,
+    TOKEN_SEMICOLON,
+    TOKEN_SLASH,
+    TOKEN_STAR,
+    TOKEN_BANG,
+    TOKEN_BANG_EQUAL,
+    TOKEN_EQUAL,
+    TOKEN_EQUAL_EQUAL,
+    TOKEN_GREATER,
+    TOKEN_GREATER_EQUAL,
+    TOKEN_LESS,
+    TOKEN_LESS_EQUAL,
+    TOKEN_IDENTIFIER,
+    TOKEN_STRING,
+    TOKEN_NUMBER,
+    TOKEN_AND,
+    TOKEN_CLASS,
+    TOKEN_ELSE,
+    TOKEN_FALSE,
+    TOKEN_FOR,
+    TOKEN_FUN,
+    TOKEN_IF,
+    TOKEN_NIL,
+    TOKEN_OR,
+    TOKEN_PRINT,
+    TOKEN_RETURN,
+    TOKEN_SUPER,
+    TOKEN_THIS,
+    TOKEN_TRUE,
+    TOKEN_VAR,
+    TOKEN_WHILE,
+    TOKEN_ERROR,
+    TOKEN_EOF,
+} TokenType;
+
+typedef struct {
+    TokenType type;
+    const char* start;
+    int length;
+    int line;
+} Token;
+
+void initScanner(const char* source);
+Token scanToken();
+
+#endif // clox_scanner_h
+
diff --git a/table.c b/table.c
new file mode 100644
index 0000000..906bd27
--- /dev/null
+++ b/table.c
@@ -0,0 +1,173 @@
+#include <stdlib.h>
+#include <string.h>
+
+#include "memory.h"
+#include "object.h"
+#include "table.h"
+#include "value.h"
+
+#define TABLE_MAX_LOAD 0.75
+
+void initTable(Table* table)
+{
+    table->count = 0;
+    table->capacity = 0;
+    table->entries = nullptr;
+}
+
+void freeTable(Table* table)
+{
+    FREE_ARRAY(Entry, table->entries, table->capacity);
+    initTable(table);
+}
+
+static Entry* findEntry(Entry* entries, int capacity, ObjString* key)
+{
+    auto index = key->hash & (capacity - 1);
+    Entry* tombstone = nullptr;
+
+    for (;;) {
+        Entry* entry = &entries[index];
+        if (entry->key == nullptr) {
+            if (IS_NIL(entry->value)) {
+                return tombstone != nullptr ? tombstone : entry;
+            } else {
+                if (tombstone == nullptr) {
+                    tombstone = entry;
+                }
+            }
+        } else if (entry->key == key) {
+            return entry;
+        }
+
+        index = (index + 1) & (capacity - 1);
+    }
+}
+
+bool tableGet(Table* table, ObjString* key, Value* value)
+{
+    if (table->count == 0) {
+        return false;
+    }
+
+    Entry* entry = findEntry(table->entries, table->capacity, key);
+    if (entry->key == nullptr) {
+        return false;
+    }
+
+    *value = entry->value;
+    return true;
+}
+
+static void adjustCapacity(Table* table, int capacity)
+{
+    Entry* entries = ALLOCATE(Entry, capacity);
+    for (auto i = 0; i < capacity; i++) {
+        entries[i].key = nullptr;
+        entries[i].value = NIL_VAL;
+    }
+
+    table->count = 0;
+    for (auto i = 0; i < table->capacity; i++) {
+        Entry* entry = &table->entries[i];
+        if (entry->key == nullptr) {
+            continue;
+        }
+
+        Entry* dest = findEntry(entries, capacity, entry->key);
+        dest->key = entry->key;
+        dest->value = entry->value;
+        table->count++;
+    }
+
+    FREE_ARRAY(Entry, table->entries, table->capacity);
+
+    table->entries = entries;
+    table->capacity = capacity;
+}
+
+bool tableSet(Table* table, ObjString* key, Value value)
+{
+    if (table->count + 1 > table->capacity * TABLE_MAX_LOAD) {
+        auto capacity = GROW_CAPACITY(table->capacity);
+        adjustCapacity(table, capacity);
+    }
+
+    Entry* entry = findEntry(table->entries, table->capacity, key);
+    auto isNewKey = entry->key == nullptr;
+    if (isNewKey && IS_NIL(entry->value)) {
+        table->count++;
+    }
+
+    entry->key = key;
+    entry->value = value;
+
+    return isNewKey;
+}
+
+bool tableDelete(Table* table, ObjString* key)
+{
+    if (table->count == 0) {
+        return false;
+    }
+
+    Entry* entry = findEntry(table->entries, table->capacity, key);
+    if (entry->key == nullptr) {
+        return false;
+    }
+
+    entry->key = nullptr;
+    entry->value = BOOL_VAL(true);
+    return true;
+}
+
+void tableAddAll(Table* from, Table* to)
+{
+    for (auto i = 0; i < from->capacity; i++) {
+        Entry* entry = &from->entries[i];
+        if (entry->key != nullptr) {
+            tableSet(to, entry->key, entry->value);
+        }
+    }
+}
+
+ObjString* tableFindString(Table* table, const char* chars, int length, uint32_t hash)
+{
+    if (table->count == 0) {
+        return nullptr;
+    }
+
+    auto index = hash & (table->capacity - 1);
+    for (;;) {
+        Entry* entry = &table->entries[index];
+        if (entry->key == nullptr) {
+            if (IS_NIL(entry->value)) {
+                return nullptr;
+            }
+        } else if (entry->key->length == length && entry->key->hash == hash && memcmp(entry->key->chars, chars, length) == 0) {
+            return entry->key;
+        }
+
+        index = (index + 1) & (table->capacity - 1);
+    }
+}
+
+void tableRemoveWhite(Table* table)
+{
+    for (auto i = 0; i < table->capacity; i++) {
+        Entry* entry = &table->entries[i];
+        if (entry->key != nullptr && !entry->key->obj.isMarked) {
+            tableDelete(table, entry->key);
+        }
+    }
+}
+
+void markTable(Table* table)
+{
+    for (auto i = 0; i < table->capacity; i++) {
+        Entry* entry = &table->entries[i];
+        markObject((Obj*)entry->key);
+        markValue(entry->value);
+    }
+}
+
diff --git a/table.h b/table.h
new file mode 100644
index 0000000..23f1364
--- /dev/null
+++ b/table.h
@@ -0,0 +1,29 @@
+#ifndef clox_table_h
+#define clox_table_h
+
+#include "common.h"
+#include "value.h"
+
+typedef struct {
+    ObjString* key;
+    Value value;
+} Entry;
+
+typedef struct {
+    int count;
+    int capacity;
+    Entry* entries;
+} Table;
+
+void initTable(Table* table);
+void freeTable(Table* table);
+bool tableGet(Table* table, ObjString* key, Value* value);
+bool tableSet(Table* table, ObjString* key, Value value);
+bool tableDelete(Table* table, ObjString* key);
+void tableAddAll(Table* from, Table* to);
+ObjString* tableFindString(Table* table, const char* chars, int length, uint32_t hash);
+void tableRemoveWhite(Table* table);
+void markTable(Table* table);
+
+#endif // clox_table_h
+
diff --git a/value.c b/value.c
new file mode 100644
index 0000000..c83f16e
--- /dev/null
+++ b/value.c
@@ -0,0 +1,89 @@
+#include <stdio.h>
+#include <string.h>
+
+#include "object.h"
+#include "memory.h"
+#include "value.h"
+
+void initValueArray(ValueArray* array)
+{
+    array->values = nullptr;
+    array->capacity = 0;
+    array->count = 0;
+}
+
+void freeValueArray(ValueArray* array)
+{
+    FREE_ARRAY(Value, array->values, array->capacity);
+    initValueArray(array);
+}
+
+void writeValueArray(ValueArray* array, Value value)
+{
+    if (array->capacity < array->count + 1) {
+        int oldCapacity = array->capacity;
+        array->capacity = GROW_CAPACITY(oldCapacity);
+        array->values = GROW_ARRAY(Value, array->values, oldCapacity, array->capacity);
+    }
+
+    array->values[array->count] = value;
+    array->count++;
+}
+
+void printValue(Value value)
+{
+#ifdef NAN_BOXING
+    if (IS_BOOL(value)) {
+        printf(AS_BOOL(value) ? "true" : "false");
+    } else if (IS_NIL(value)) {
+        printf("nil");
+    } else if (IS_NUMBER(value)) {
+        printf("%g", AS_NUMBER(value));
+    } else if (IS_OBJ(value)) {
+        printObject(value);
+    }
+#else
+    switch (value.type) {
+    case VAL_BOOL:
+        printf(AS_BOOL(value) ? "true" : "false");
+        break;
+    case VAL_NIL:
+        printf("nil");
+        break;
+    case VAL_NUMBER:
+        printf("%g", AS_NUMBER(value));
+        break;
+    case VAL_OBJ:
+        printObject(value);
+        break;
+    }
+#endif
+}
+
+bool valuesEqual(Value a, Value b)
+{
+#ifdef NAN_BOXING
+    if (IS_NUMBER(a) && IS_NUMBER(b)) {
+        return AS_NUMBER(a) == AS_NUMBER(b);
+    }
+    return a == b;
+#else
+    if (a.type != b.type) {
+        return false;
+    }
+
+    switch (a.type) {
+    case VAL_BOOL:
+        return AS_BOOL(a) == AS_BOOL(b);
+    case VAL_NIL:
+        return true;
+    case VAL_NUMBER:
+        return AS_NUMBER(a) == AS_NUMBER(b);
+    case VAL_OBJ:
+        return AS_OBJ(a) == AS_OBJ(b);
+    default:
+        return false;
+    }
+#endif
+}
+
diff --git a/value.h b/value.h
new file mode 100644
index 0000000..8864fe3
--- /dev/null
+++ b/value.h
@@ -0,0 +1,95 @@
+#ifndef clox_value_h
+#define clox_value_h
+
+#include <string.h>
+
+#include "common.h"
+
+typedef struct Obj Obj;
+typedef struct ObjString ObjString;
+
+#ifdef NAN_BOXING
+#define SIGN_BIT ((uint64_t)0b1000000000000000000000000000000000000000000000000000000000000000)
+#define QNAN ((uint64_t)0b0111111111111100000000000000000000000000000000000000000000000000)
+
+#define TAG_NIL 0b01
+#define TAG_FALSE 0b10
+#define TAG_TRUE 0b11
+
+typedef uint64_t Value;
+
+#define IS_BOOL(value) (((value) | 0b01) == TRUE_VAL)
+#define IS_NIL(value) ((value) == NIL_VAL)
+#define IS_NUMBER(value) (((value) & QNAN) != QNAN)
+#define IS_OBJ(value) (((value) & (QNAN | SIGN_BIT)) == (QNAN | SIGN_BIT))
+
+#define AS_OBJ(value) ((Obj*)(uintptr_t)((value) & ~(SIGN_BIT | QNAN)))
+#define AS_BOOL(value) ((value) == TRUE_VAL)
+#define AS_NUMBER(value) valueToNum(value)
+
+#define BOOL_VAL(value) ((value) ? TRUE_VAL : FALSE_VAL)
+#define FALSE_VAL ((Value)(uint64_t)(QNAN | TAG_FALSE))
+#define TRUE_VAL ((Value)(uint64_t)(QNAN | TAG_TRUE))
+#define NIL_VAL ((Value)(uint64_t)(QNAN | TAG_NIL))
+#define NUMBER_VAL(value) numToValue(value)
+#define OBJ_VAL(object) ((Value)(SIGN_BIT | QNAN | (uint64_t)(uintptr_t)(object)))
+
+static inline double valueToNum(Value value)
+{
+    double num;
+    memcpy(&num, &value, sizeof(Value));
+    return num;
+}
+
+static inline Value numToValue(double num)
+{
+    Value value;
+    memcpy(&value, &num, sizeof(double));
+    return value;
+}
+#else
+typedef enum {
+    VAL_BOOL,
+    VAL_NIL,
+    VAL_NUMBER,
+    VAL_OBJ,
+} ValueType;
+
+typedef struct {
+    ValueType type;
+    union {
+        bool boolean;
+        double number;
+        Obj* obj;
+    } as;
+} Value;
+
+#define IS_BOOL(value) ((value).type == VAL_BOOL)
+#define IS_NIL(value) ((value).type == VAL_NIL)
+#define IS_NUMBER(value) ((value).type == VAL_NUMBER)
+#define IS_OBJ(value) ((value).type == VAL_OBJ)
+
+#define AS_OBJ(value) ((value).as.obj)
+#define AS_BOOL(value) ((value).as.boolean)
+#define AS_NUMBER(value) ((value).as.number)
+
+#define BOOL_VAL(value) ((Value){ .type = VAL_BOOL, .as = { .boolean = value } })
+#define NIL_VAL ((Value){ .type = VAL_NIL, .as = { .number = 0 } })
+#define NUMBER_VAL(value) ((Value){ .type = VAL_NUMBER, .as = { .number = value } })
+#define OBJ_VAL(object) ((Value){ .type = VAL_OBJ, .as = { .obj = (Obj*)object } })
+#endif
+
+typedef struct {
+    int capacity;
+    int count;
+    Value* values;
+} ValueArray;
+
+bool valuesEqual(Value a, Value b);
+void initValueArray(ValueArray* array);
+void writeValueArray(ValueArray* array, Value value);
+void freeValueArray(ValueArray* array);
+void printValue(Value value);
+
+#endif // clox_value_h
+
diff --git a/vm.c b/vm.c
new file mode 100644
index 0000000..f342d82
--- /dev/null
+++ b/vm.c
@@ -0,0 +1,605 @@
+#include <stdarg.h>
+#include <stdio.h>
+#include <string.h>
+#include <time.h>
+
+#include "common.h"
+#include "compiler.h"
+#include "debug.h"
+#include "object.h"
+#include "memory.h"
+#include "vm.h"
+
+VM vm;
+
+static Value clockNative(int argCount, Value* args)
+{
+    (void)argCount;
+    (void)args;
+
+    return NUMBER_VAL((double)clock() / CLOCKS_PER_SEC);
+}
+
+static void resetStack()
+{
+    vm.stackTop = vm.stack;
+    vm.frameCount = 0;
+    vm.openUpvalues = nullptr;
+}
+
+static void runtimeError(const char* format, ...)
+{
+    va_list args;
+    va_start(args, format);
+    vfprintf(stderr, format, args);
+    va_end(args);
+    fputs("\n", stderr);
+
+    for (auto i = vm.frameCount - 1; i >= 0; i--) {
+        CallFrame* frame = &vm.frames[i];
+        ObjFunction* function = frame->closure->function;
+        auto instruction = frame->ip - function->chunk.code - 1;
+        fprintf(stderr, "[line %d] in ", function->chunk.lines[instruction]);
+        if (function->name == nullptr) {
+            fprintf(stderr, "script\n");
+        } else {
+            fprintf(stderr, "%s()\n", function->name->chars);
+        }
+    }
+
+    resetStack();
+}
+
+static void defineNative(const char* name, NativeFn function)
+{
+    push(OBJ_VAL(copyString(name, (int)strlen(name))));
+    push(OBJ_VAL(newNative(function)));
+    tableSet(&vm.globals, AS_STRING(vm.stack[0]), vm.stack[1]);
+    pop();
+    pop();
+}
+
+void initVM()
+{
+    resetStack();
+    vm.objects = nullptr;
+    vm.bytesAllocated = 0;
+    vm.nextGC = 1024 * 1024;
+
+    vm.grayCount = 0;
+    vm.grayCapacity = 0;
+    vm.grayStack = nullptr;
+
+    initTable(&vm.globals);
+    initTable(&vm.strings);
+
+    vm.initString = nullptr;
+    vm.initString = copyString("init", 4);
+
+    defineNative("clock", clockNative);
+}
+
+void freeVM()
+{
+    freeTable(&vm.globals);
+    freeTable(&vm.strings);
+    vm.initString = nullptr;
+    freeObjects();
+}
+
+void push(Value value)
+{
+    *vm.stackTop = value;
+    vm.stackTop++;
+}
+
+Value pop()
+{
+    vm.stackTop--;
+    return *vm.stackTop;
+}
+
+static Value peek(int distance)
+{
+    return vm.stackTop[-1 - distance];
+}
+
+static bool call(ObjClosure* closure, int argCount)
+{
+    if (argCount != closure->function->arity) {
+        runtimeError("Expected %d arguments but got %d.", closure->function->arity, argCount);
+        return false;
+    }
+
+    if (vm.frameCount == FRAMES_MAX) {
+        runtimeError("Stack overflow.");
+        return false;
+    }
+
+    CallFrame* frame = &vm.frames[vm.frameCount++];
+    frame->closure = closure;
+    frame->ip = closure->function->chunk.code;
+    frame->slots = vm.stackTop - argCount - 1;
+    return true;
+}
+
+static bool callValue(Value callee, int argCount)
+{
+    if (IS_OBJ(callee)) {
+        switch (OBJ_TYPE(callee)) {
+        case OBJ_BOUND_METHOD:
+            {
+                ObjBoundMethod* bound = AS_BOUND_METHOD(callee);
+                vm.stackTop[-argCount - 1] = bound->receiver;
+                return call(bound->method, argCount);
+            }
+        case OBJ_CLASS:
+            {
+                ObjClass* klass = AS_CLASS(callee);
+                vm.stackTop[-argCount - 1] = OBJ_VAL(newInstance(klass));
+                Value initializer;
+                if (tableGet(&klass->methods, vm.initString, &initializer)) {
+                    return call(AS_CLOSURE(initializer), argCount);
+                } else if (argCount != 0) {
+                    runtimeError("Expected 0 arguments but got %d.", argCount);
+                    return false;
+                }
+                return true;
+            }
+        case OBJ_CLOSURE:
+            return call(AS_CLOSURE(callee), argCount);
+        case OBJ_NATIVE:
+            {
+                auto native = AS_NATIVE(callee);
+                auto result = native(argCount, vm.stackTop - argCount);
+                vm.stackTop -= argCount + 1;
+                push(result);
+                return true;
+            }
+        default:
+            break;
+        }
+    }
+    runtimeError("Can only call functions and classes.");
+    return false;
+}
+
+static bool invokeFromClass(ObjClass* klass, ObjString* name, int argCount)
+{
+    Value method;
+    if (!tableGet(&klass->methods, name, &method)) {
+        runtimeError("Undefined property '%s'.", name->chars);
+        return false;
+    }
+    return call(AS_CLOSURE(method), argCount);
+}
+
+static bool invoke(ObjString* name, int argCount)
+{
+    auto receiver = peek(argCount);
+
+    if (!IS_INSTANCE(receiver)) {
+        runtimeError("Only instances have methods.");
+        return false;
+    }
+
+    ObjInstance* instance = AS_INSTANCE(receiver);
+
+    Value value;
+    if (tableGet(&instance->fields, name, &value)) {
+        vm.stackTop[-argCount - 1] = value;
+        return callValue(value, argCount);
+    }
+
+    return invokeFromClass(instance->klass, name, argCount);
+}
+
+static bool bindMethod(ObjClass* klass, ObjString* name)
+{
+    Value method;
+    if (!tableGet(&klass->methods, name, &method)) {
+        runtimeError("Undefined property '%s'.", name->chars);
+        return false;
+    }
+
+    ObjBoundMethod* bound = newBoundMethod(peek(0), AS_CLOSURE(method));
+    pop();
+    push(OBJ_VAL(bound));
+    return true;
+}
+
+static ObjUpvalue* captureUpvalue(Value* local)
+{
+    ObjUpvalue* prevUpvalue = nullptr;
+    ObjUpvalue* upvalue = vm.openUpvalues;
+    while (upvalue != nullptr && upvalue->location > local) {
+        prevUpvalue = upvalue;
+        upvalue = upvalue->next;
+    }
+
+    if (upvalue != nullptr && upvalue->location == local) {
+        return upvalue;
+    }
+
+    ObjUpvalue* createdUpvalue = newUpvalue(local);
+    createdUpvalue->next = upvalue;
+
+    if (prevUpvalue == nullptr) {
+        vm.openUpvalues = createdUpvalue;
+    } else {
+        prevUpvalue->next = createdUpvalue;
+    }
+
+    return createdUpvalue;
+}
+
+static void closeUpvalues(Value* last)
+{
+    while (vm.openUpvalues != nullptr && vm.openUpvalues->location >= last) {
+        ObjUpvalue* upvalue = vm.openUpvalues;
+        upvalue->closed = *upvalue->location;
+        upvalue->location = &upvalue->closed;
+        vm.openUpvalues = upvalue->next;
+    }
+}
+
+static void defineMethod(ObjString* name)
+{
+    auto method = peek(0);
+    ObjClass* klass = AS_CLASS(peek(1));
+    tableSet(&klass->methods, name, method);
+    pop();
+}
+
+static bool isFalsey(Value value)
+{
+    return IS_NIL(value) || (IS_BOOL(value) && !AS_BOOL(value));
+}
+
+static void concatenate()
+{
+    ObjString* b = AS_STRING(peek(0));
+    ObjString* a = AS_STRING(peek(1));
+
+    auto length = a->length + b->length;
+    char* chars = ALLOCATE(char, length + 1);
+    memcpy(chars, a->chars, a->length);
+    memcpy(chars + a->length, b->chars, b->length);
+    chars[length] = '\0';
+
+    ObjString* result = takeString(chars, length);
+    pop();
+    pop();
+    push(OBJ_VAL(result));
+}
+
+static InterpretResult run()
+{
+    CallFrame* frame = &vm.frames[vm.frameCount - 1];
+
+#define READ_BYTE() (*frame->ip++)
+#define READ_SHORT() (frame->ip += 2, (uint16_t)((frame->ip[-2] << 8) | frame->ip[-1]))
+#define READ_CONSTANT() (frame->closure->function->chunk.constants.values[READ_BYTE()])
+#define READ_STRING() AS_STRING(READ_CONSTANT())
+
+#define BINARY_OP(valueType, op)                          \
+    do {                                                  \
+        if (!IS_NUMBER(peek(0)) || !IS_NUMBER(peek(1))) { \
+            runtimeError("Operands must be numbers.");    \
+            return INTERPRET_RUNTIME_ERROR;               \
+        }                                                 \
+        auto b = AS_NUMBER(pop());                        \
+        auto a = AS_NUMBER(pop());                        \
+        push(valueType(a op b));                          \
+    } while (false)
+
+    for (;;) {
+#ifdef DEBUG_TRACE_EXECUTION
+        printf("          ");
+        for (Value* slot = vm.stack; slot < vm.stackTop; slot++) {
+            printf("[ ");
+            printValue(*slot);
+            printf(" ]");
+        }
+        printf("\n");
+        disassembleInstruction(&frame->closure->function->chunk, (int)(frame->ip - frame->closure->function->chunk.code));
+#endif
+
+        uint8_t instruction;
+        switch (instruction = READ_BYTE()) {
+        case OP_CONSTANT:
+            {
+                auto constant = READ_CONSTANT();
+                push(constant);
+            }
+            break;
+        case OP_NIL:
+            push(NIL_VAL);
+            break;
+        case OP_TRUE:
+            push(BOOL_VAL(true));
+            break;
+        case OP_FALSE:
+            push(BOOL_VAL(false));
+            break;
+        case OP_POP:
+            pop();
+            break;
+        case OP_GET_LOCAL:
+            {
+                auto slot = READ_BYTE();
+                push(frame->slots[slot]);
+            }
+            break;
+        case OP_SET_LOCAL:
+            {
+                auto slot = READ_BYTE();
+                frame->slots[slot] = peek(0);
+            }
+            break;
+        case OP_GET_GLOBAL:
+            {
+                ObjString* name = READ_STRING();
+                Value value;
+                if (!tableGet(&vm.globals, name, &value)) {
+                    runtimeError("Undefined variable '%s'.", name->chars);
+                    return INTERPRET_RUNTIME_ERROR;
+                }
+                push(value);
+            }
+            break;
+        case OP_DEFINE_GLOBAL:
+            {
+                ObjString* name = READ_STRING();
+                tableSet(&vm.globals, name, peek(0));
+                pop();
+            }
+            break;
+        case OP_SET_GLOBAL:
+            {
+                ObjString* name = READ_STRING();
+                if (tableSet(&vm.globals, name, peek(0))) {
+                    tableDelete(&vm.globals, name);
+                    runtimeError("Undefined variable '%s'.", name->chars);
+                    return INTERPRET_RUNTIME_ERROR;
+                }
+            }
+            break;
+        case OP_GET_UPVALUE:
+            {
+                auto slot = READ_BYTE();
+                push(*frame->closure->upvalues[slot]->location);
+            }
+            break;
+        case OP_SET_UPVALUE:
+            {
+                auto slot = READ_BYTE();
+                *frame->closure->upvalues[slot]->location = peek(0);
+            }
+            break;
+        case OP_GET_PROPERTY:
+            {
+                if (!IS_INSTANCE(peek(0))) {
+                    runtimeError("Only instances have properties.");
+                    return INTERPRET_RUNTIME_ERROR;
+                }
+
+                ObjInstance* instance = AS_INSTANCE(peek(0));
+                ObjString* name = READ_STRING();
+
+                Value value;
+                if (tableGet(&instance->fields, name, &value)) {
+                    pop();
+                    push(value);
+                    break;
+                }
+
+                if (!bindMethod(instance->klass, name)) {
+                    return INTERPRET_RUNTIME_ERROR;
+                }
+            }
+            break;
+        case OP_SET_PROPERTY:
+            {
+                if (!IS_INSTANCE(peek(1))) {
+                    runtimeError("Only instances have fields.");
+                    return INTERPRET_RUNTIME_ERROR;
+                }
+
+                ObjInstance* instance = AS_INSTANCE(peek(1));
+                tableSet(&instance->fields, READ_STRING(), peek(0));
+                auto value = pop();
+                pop();
+                push(value);
+            }
+            break;
+        case OP_GET_SUPER:
+            {
+                ObjString* name = READ_STRING();
+                ObjClass* superclass = AS_CLASS(pop());
+
+                if (!bindMethod(superclass, name)) {
+                    return INTERPRET_RUNTIME_ERROR;
+                }
+            }
+            break;
+        case OP_EQUAL:
+            {
+                auto b = pop();
+                auto a = pop();
+                push(BOOL_VAL(valuesEqual(a, b)));
+            }
+            break;
+        case OP_GREATER:
+            BINARY_OP(BOOL_VAL, >);
+            break;
+        case OP_LESS:
+            BINARY_OP(BOOL_VAL, <);
+            break;
+        case OP_ADD:
+            {
+                if (IS_STRING(peek(0)) && IS_STRING(peek(1))) {
+                    concatenate();
+                } else if (IS_NUMBER(peek(0)) && IS_NUMBER(peek(1))) {
+                    auto b = AS_NUMBER(pop());
+                    auto a = AS_NUMBER(pop());
+                    push(NUMBER_VAL(a + b));
+                } else {
+                    runtimeError("Operands must be two numbers or two strings.");
+                    return INTERPRET_RUNTIME_ERROR;
+                }
+            }
+            break;
+        case OP_SUBTRACT:
+            BINARY_OP(NUMBER_VAL, -);
+            break;
+        case OP_MULTIPLY:
+            BINARY_OP(NUMBER_VAL, *);
+            break;
+        case OP_DIVIDE:
+            BINARY_OP(NUMBER_VAL, /);
+            break;
+        case OP_NOT:
+            push(BOOL_VAL(isFalsey(pop())));
+            break;
+        case OP_NEGATE:
+            if (!IS_NUMBER(peek(0))) {
+                runtimeError("Operand must be a number.");
+                return INTERPRET_RUNTIME_ERROR;
+            }
+            push(NUMBER_VAL(-AS_NUMBER(pop())));
+            break;
+        case OP_PRINT:
+            printValue(pop());
+            printf("\n");
+            break;
+        case OP_JUMP:
+            {
+                auto offset = READ_SHORT();
+                frame->ip += offset;
+            }
+            break;
+        case OP_JUMP_IF_FALSE:
+            {
+                auto offset = READ_SHORT();
+                if (isFalsey(peek(0))) {
+                    frame->ip += offset;
+                }
+            }
+            break;
+        case OP_LOOP:
+            {
+                auto offset = READ_SHORT();
+                frame->ip -= offset;
+            }
+            break;
+        case OP_CALL:
+            {
+                auto argCount = READ_BYTE();
+                if (!callValue(peek(argCount), argCount)) {
+                    return INTERPRET_RUNTIME_ERROR;
+                }
+                frame = &vm.frames[vm.frameCount - 1];
+            }
+            break;
+        case OP_INVOKE:
+            {
+                ObjString* method = READ_STRING();
+                auto argCount = READ_BYTE();
+                if (!invoke(method, argCount)) {
+                    return INTERPRET_RUNTIME_ERROR;
+                }
+                frame = &vm.frames[vm.frameCount - 1];
+            }
+            break;
+        case OP_SUPER_INVOKE:
+            {
+                ObjString* method = READ_STRING();
+                auto argCount = READ_BYTE();
+                ObjClass* superclass = AS_CLASS(pop());
+                if (!invokeFromClass(superclass, method, argCount)) {
+                    return INTERPRET_RUNTIME_ERROR;
+                }
+                frame = &vm.frames[vm.frameCount - 1];
+            }
+            break;
+        case OP_CLOSURE:
+            {
+                ObjFunction* function = AS_FUNCTION(READ_CONSTANT());
+                ObjClosure* closure = newClosure(function);
+                push(OBJ_VAL(closure));
+                for (auto i = 0; i < closure->upvalueCount; i++) {
+                    auto isLocal = READ_BYTE();
+                    auto index = READ_BYTE();
+                    if (isLocal) {
+                        closure->upvalues[i] = captureUpvalue(frame->slots + index);
+                    } else {
+                        closure->upvalues[i] = frame->closure->upvalues[index];
+                    }
+                }
+            }
+            break;
+        case OP_CLOSE_UPVALUE:
+            closeUpvalues(vm.stackTop - 1);
+            pop();
+            break;
+        case OP_RETURN:
+            {
+                auto result = pop();
+                closeUpvalues(frame->slots);
+                vm.frameCount--;
+                if (vm.frameCount == 0) {
+                    pop();
+                    return INTERPRET_OK;
+                }
+
+                vm.stackTop = frame->slots;
+                push(result);
+                frame = &vm.frames[vm.frameCount - 1];
+            }
+            break;
+        case OP_CLASS:
+            push(OBJ_VAL(newClass(READ_STRING())));
+            break;
+        case OP_INHERIT:
+            {
+                auto superClass = peek(1);
+                if (!IS_CLASS(superClass)) {
+                    runtimeError("Superclass must be a class.");
+                    return INTERPRET_RUNTIME_ERROR;
+                }
+                ObjClass* subClass = AS_CLASS(peek(0));
+                tableAddAll(&AS_CLASS(superClass)->methods, &subClass->methods);
+                pop();
+            }
+            break;
+        case OP_METHOD:
+            defineMethod(READ_STRING());
+            break;
+        }
+    }
+
+#undef READ_BYTE
+#undef READ_SHORT
+#undef READ_CONSTANT
+#undef READ_STRING
+
+#undef BINARY_OP
+}
+
+InterpretResult interpret(const char* source)
+{
+    ObjFunction* function = compile(source);
+    if (function == nullptr) {
+        return INTERPRET_COMPILE_ERROR;
+    }
+
+    push(OBJ_VAL(function));
+    ObjClosure* closure = newClosure(function);
+    pop();
+    push(OBJ_VAL(closure));
+    call(closure, 0);
+
+    return run();
+}
+
diff --git a/vm.h b/vm.h
new file mode 100644
index 0000000..41eda6c
--- /dev/null
+++ b/vm.h
@@ -0,0 +1,49 @@
+#ifndef clox_vm_h
+#define clox_vm_h
+
+#include "object.h"
+#include "table.h"
+#include "value.h"
+
+#define FRAMES_MAX 64
+#define STACK_MAX (FRAMES_MAX * UINT8_COUNT)
+
+typedef struct {
+    ObjClosure* closure;
+    uint8_t* ip;
+    Value* slots;
+} CallFrame;
+
+typedef struct {
+    CallFrame frames[FRAMES_MAX];
+    int frameCount;
+    Value stack[STACK_MAX];
+    Value* stackTop;
+    Table globals;
+    Table strings;
+    ObjString* initString;
+    ObjUpvalue* openUpvalues;
+    size_t bytesAllocated;
+    size_t nextGC;
+    Obj* objects;
+    int grayCount;
+    int grayCapacity;
+    Obj** grayStack;
+} VM;
+
+typedef enum {
+    INTERPRET_OK,
+    INTERPRET_COMPILE_ERROR,
+    INTERPRET_RUNTIME_ERROR,
+} InterpretResult;
+
+extern VM vm;
+
+void initVM();
+void freeVM();
+InterpretResult interpret(const char* source);
+void push(Value value);
+Value pop();
+
+#endif // clox_vm_h
+