diff --git a/.vscode/launch.json b/.vscode/launch.json
index 8eeeb8d..5a4674f 100644
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@@ -7,7 +7,8 @@
 			"request": "launch",
 			"target": "${workspaceRoot}/zig-out/bin/runner",
 			"cwd": "${workspaceRoot}/debug/",
-			"valuesFormatting": "parseText"
+			"valuesFormatting": "parseText",
+			"preLaunchTask": "Build All"
 		},
 	]
 }
diff --git a/debug/app.ona b/debug/app.ona
index 042320c..ea265f4 100644
--- a/debug/app.ona
+++ b/debug/app.ona
@@ -1,10 +1,13 @@
 
 # Test comment.
-@log_info("game is loading")
 
-return {
-    title = "Afterglow",
-    width = 1280,
-    height = 800,
-    tick_rate = 60,
+options = {
+	.title = "Afterglow",
+	.width = 1280,
+	.height = 800,
+	.tick_rate = 60,
 }
+
+@log_info(options.title)
+
+return options
diff --git a/source/coral/io.zig b/source/coral/io.zig
index ad969c9..39025ee 100644
--- a/source/coral/io.zig
+++ b/source/coral/io.zig
@@ -2,6 +2,8 @@ const debug = @import("./debug.zig");
 
 const math = @import("./math.zig");
 
+const std = @import("std");
+
 pub const AllocationError = error {
 	OutOfMemory,
 };
@@ -27,7 +29,7 @@ pub const Allocator = struct {
 		const ErasedActions = struct {
 			fn deallocate(context: *anyopaque, allocation: []Byte) void {
 				if (is_zero_aligned) {
-					return actions.deallocator(@ptrCast(context), allocation);
+					return actions.deallocate(@ptrCast(context), allocation);
 				}
 
 				return actions.deallocate(@ptrCast(@alignCast(context)), allocation);
@@ -35,7 +37,7 @@ pub const Allocator = struct {
 
 			fn reallocate(context: *anyopaque, return_address: usize, existing_allocation: ?[]Byte, size: usize) AllocationError![]Byte {
 				if (is_zero_aligned) {
-					return actions.reallocator(@ptrCast(context), return_address, existing_allocation, size);
+					return actions.reallocate(@ptrCast(context), return_address, existing_allocation, size);
 				}
 
 				return actions.reallocate(@ptrCast(@alignCast(context)), return_address, existing_allocation, size);
@@ -213,6 +215,27 @@ pub fn allocate_copy(allocator: Allocator, source: []const Byte) AllocationError
 	return allocation;
 }
 
+pub fn allocate_many(allocator: Allocator, count: usize, value: anytype) AllocationError![]@TypeOf(value) {
+	const Type = @TypeOf(value);
+	const typeSize = @sizeOf(Type);
+
+	if (typeSize == 0) {
+		@compileError("Cannot allocate memory for 0-byte sized type " ++ @typeName(Type));
+	}
+
+	const allocations = @as([*]Type, @ptrCast(@alignCast(try allocator.actions.reallocate(
+		allocator.context,
+		@returnAddress(),
+		null,
+		typeSize * count))))[0 .. count];
+
+	for (allocations) |*allocation| {
+		allocation.* = value;
+	}
+
+	return allocations;
+}
+
 pub fn allocate_one(allocator: Allocator, value: anytype) AllocationError!*@TypeOf(value) {
 	const Type = @TypeOf(value);
 	const typeSize = @sizeOf(Type);
@@ -232,6 +255,16 @@ pub fn allocate_one(allocator: Allocator, value: anytype) AllocationError!*@Type
 	return allocation;
 }
 
+pub fn allocate_string(allocator: Allocator, source: []const Byte) AllocationError![:0]Byte {
+	const allocation = try allocator.actions.reallocate(allocator.context, @returnAddress(), null, source.len + 1);
+
+	copy(allocation[0 .. source.len], source);
+
+	allocation[source.len] = 0;
+
+	return @ptrCast(allocation);
+}
+
 pub fn bytes_of(value: anytype) []const Byte {
 	const pointer_info = @typeInfo(@TypeOf(value)).Pointer;
 
@@ -265,6 +298,16 @@ pub fn compare(this: []const Byte, that: []const Byte) isize {
 	return @as(isize, @intCast(this.len)) - @as(isize, @intCast(that.len));
 }
 
+pub fn djb2_hash(comptime int: std.builtin.Type.Int, target: []const Byte) math.Int(int) {
+	var hash_code = @as(math.Int(int), 5381);
+
+	for (target) |byte| {
+		hash_code = ((hash_code << 5) +% hash_code) +% byte;
+	}
+
+	return hash_code;
+}
+
 pub fn ends_with(target: []const Byte, match: []const Byte) bool {
 	if (target.len < match.len) {
 		return false;
@@ -297,6 +340,16 @@ pub fn equals(target: []const Byte, match: []const Byte) bool {
 	return true;
 }
 
+pub fn find_first(haystack: []const Byte, needle: Byte) ?usize {
+	for (0 .. haystack.len) |i| {
+		if (haystack[i] == needle) {
+			return i;
+		}
+	}
+
+	return null;
+}
+
 var null_context = @as(usize, 0);
 
 pub const null_writer = Writer.bind(usize, &null_context, struct {
diff --git a/source/coral/list.zig b/source/coral/list.zig
index f02b6ee..56797d8 100644
--- a/source/coral/list.zig
+++ b/source/coral/list.zig
@@ -41,6 +41,10 @@ pub fn Stack(comptime Value: type) type {
 			self.capacity = grown_capacity;
 		}
 
+		pub fn is_empty(self: Self) bool {
+			return self.values.len == 0;
+		}
+
 		pub fn make(allocator: io.Allocator) Self {
 			return .{
 				.allocator = allocator,
diff --git a/source/coral/map.zig b/source/coral/map.zig
index 1bc6a96..30a8bdb 100644
--- a/source/coral/map.zig
+++ b/source/coral/map.zig
@@ -6,118 +6,27 @@ const list = @import("./list.zig");
 
 const math = @import("./math.zig");
 
-pub fn Slab(comptime Value: type) type {
-	return struct {
-		next_index: usize,
-		entries: EntryList,
-
-		const EntryList = list.Stack(union (enum) {
-			value: Value,
-			next_index: usize,
-		});
-
+pub fn StringTable(comptime Value: type) type {
+	return Table([]const io.Byte, Value, struct {
 		const Self = @This();
 
-		pub fn lookup(self: Self, key: usize) ?Value {
-			if (key == 0 or key > self.entries.values.len) {
-				return null;
-			}
-
-			return switch (self.entries.values[key - 1]) {
-				.value => |value| value,
-				.next_index => null,
-			};
+		fn equals(key_a: []const io.Byte, key_b: []const io.Byte) bool {
+			return io.equals(key_a, key_b);
 		}
 
-		pub fn free(self: *Self) void {
-			self.entries.free();
-
-			self.next_index = 0;
+		fn hash(key: []const io.Byte) usize {
+			return io.djb2_hash(@typeInfo(usize).Int, key);
 		}
-
-		pub fn insert(self: *Self, value: Value) io.AllocationError!usize {
-			if (self.next_index < self.entries.values.len) {
-				const index = self.next_index;
-				const entry = &self.entries.values[index];
-
-				debug.assert(entry.* == .next_index);
-
-				self.next_index = entry.next_index;
-				entry.* = .{.value = value};
-
-				return index + 1;
-			} else {
-				try self.entries.push_one(.{.value = value});
-
-				self.next_index += 1;
-
-				return self.next_index;
-			}
-		}
-
-		pub fn insert_at(self: *Self, key: usize, value: Value) bool {
-			if (self.entries.values.len < key) {
-				return false;
-			}
-
-			const entry = &self.entries.values[key - 1];
-
-			if (entry.* == .value) {
-				return false;
-			}
-
-			self.next_index = entry.next_index;
-			entry.* = .{.value = value};
-
-			return true;
-		}
-
-		pub fn make(allocator: io.Allocator) Self {
-			return .{
-				.next_index = 0,
-				.entries = EntryList.make(allocator),
-			};
-		}
-
-		pub fn remove(self: *Self, key: usize) ?Value {
-			if (key == 0 or key > self.entries.values.len) {
-				return null;
-			}
-
-			const index = key - 1;
-			const entry = &self.entries.values[index];
-
-			return switch (entry.*) {
-				.next_index => null,
-
-				.value => get_value: {
-					const value = entry.value;
-
-					entry.* = .{.next_index = self.next_index};
-					self.next_index = index;
-
-					break: get_value value;
-				},
-			};
-		}
-	};
-}
-
-pub fn StringTable(comptime Value: type) type {
-	return Table([]const io.Byte, Value, .{
-		.hash = hash_string,
-		.match = io.equals,
 	});
 }
 
-pub fn Table(comptime Key: type, comptime Value: type, comptime traits: TableTraits(Key)) type {
+pub fn Table(comptime Key: type, comptime Value: type, comptime Traits: type) type {
 	const load_max = 0.75;
-	const hash_int = @typeInfo(usize).Int;
-	const max_int = math.max_int(hash_int);
-	const min_int = math.min_int(hash_int);
+	const max_int = math.max_int(@typeInfo(usize).Int);
 
 	return struct {
 		allocator: io.Allocator,
+		traits: Traits,
 		count: usize,
 		entries: []?Entry,
 
@@ -125,24 +34,26 @@ pub fn Table(comptime Key: type, comptime Value: type, comptime traits: TableTra
 			key: Key,
 			value: Value,
 
-			fn write_into(self: Entry, entry_table: []?Entry) bool {
-				const hash_max = @min(max_int, entry_table.len);
-				var hashed_key = math.wrap(traits.hash(self.key), min_int, hash_max);
+			fn write_into(self: Entry, table: *Self) bool {
+				const hash_max = @min(max_int, table.entries.len);
+				var hashed_key = table.hash_key(self.key) % hash_max;
 				var iterations = @as(usize, 0);
 
 				while (true) : (iterations += 1) {
-					debug.assert(iterations < entry_table.len);
+					debug.assert(iterations < table.entries.len);
 
-					const table_entry = &(entry_table[hashed_key] orelse {
-						entry_table[hashed_key] = .{
+					const table_entry = &(table.entries[hashed_key] orelse {
+						table.entries[hashed_key] = .{
 							.key = self.key,
 							.value = self.value,
 						};
 
+						table.count += 1;
+
 						return true;
 					});
 
-					if (traits.match(table_entry.key, self.key)) {
+					if (table.keys_equal(table_entry.key, self.key)) {
 						return false;
 					}
 
@@ -177,14 +88,18 @@ pub fn Table(comptime Key: type, comptime Value: type, comptime traits: TableTra
 			};
 		}
 
+		fn hash_key(self: Self, key: Key) usize {
+			return if (@sizeOf(Traits) == 0) Traits.hash(key) else self.traits.hash(key);
+		}
+
 		pub fn remove(self: *Self, key: Key) ?Entry {
 			const hash_max = @min(max_int, self.entries.len);
-			var hashed_key = math.wrap(traits.hash(key), min_int, hash_max);
+			var hashed_key = self.hash_key(key) % hash_max;
 
 			while (true) {
 				const entry = &(self.entries[hashed_key] orelse continue);
 
-				if (traits.match(entry.key, key)) {
+				if (self.keys_equal(entry.key, key)) {
 					const original_entry = entry.*;
 
 					self.entries[hashed_key] = null;
@@ -203,7 +118,8 @@ pub fn Table(comptime Key: type, comptime Value: type, comptime traits: TableTra
 
 			{
 				const hash_max = @min(max_int, self.entries.len);
-				var hashed_key = math.wrap(traits.hash(key), min_int, hash_max);
+				const has_context = @sizeOf(Traits) != 0;
+				var hashed_key = (if (has_context) self.traits.hash(key) else Traits.hash(key)) % hash_max;
 
 				while (true) {
 					const entry = &(self.entries[hashed_key] orelse {
@@ -217,15 +133,28 @@ pub fn Table(comptime Key: type, comptime Value: type, comptime traits: TableTra
 						return null;
 					});
 
-					if (traits.match(entry.key, key)) {
-						const original_entry = entry.*;
+					if (has_context) {
+						if (self.traits.equals(entry.key, key)) {
+							const original_entry = entry.*;
 
-						entry.* = .{
-							.key = key,
-							.value = value,
-						};
+							entry.* = .{
+								.key = key,
+								.value = value,
+							};
 
-						return original_entry;
+							return original_entry;
+						}
+					} else {
+						if (Traits.equals(entry.key, key)) {
+							const original_entry = entry.*;
+
+							entry.* = .{
+								.key = key,
+								.value = value,
+							};
+
+							return original_entry;
+						}
 					}
 
 					hashed_key = (hashed_key +% 1) % hash_max;
@@ -261,14 +190,20 @@ pub fn Table(comptime Key: type, comptime Value: type, comptime traits: TableTra
 
 			debug.assert(self.entries.len > self.count);
 
-			defer self.count += 1;
-
 			const entry = Entry{
 				.key = key,
 				.value = value,
 			};
 
-			return entry.write_into(self.entries);
+			return entry.write_into(self);
+		}
+
+		fn keys_equal(self: Self, key_a: Key, key_b: Key) bool {
+			if (@sizeOf(Traits) == 0) {
+				return Traits.equals(key_a, key_b);
+			} else {
+				return self.traits.equals(key_a, key_b);
+			}
 		}
 
 		pub fn lookup(self: Self, key: Key) ?Value {
@@ -277,14 +212,21 @@ pub fn Table(comptime Key: type, comptime Value: type, comptime traits: TableTra
 			}
 
 			const hash_max = @min(max_int, self.entries.len);
-			var hashed_key = math.wrap(traits.hash(key), min_int, hash_max);
+			const has_context = @sizeOf(Traits) != 0;
+			var hashed_key = (if (has_context) self.traits.hash(key) else Traits.hash(key)) % hash_max;
 			var iterations = @as(usize, 0);
 
 			while (iterations < self.count) : (iterations += 1) {
 				const entry = &(self.entries[hashed_key] orelse return null);
 
-				if (traits.match(entry.key, key)) {
-					return entry.value;
+				if (has_context) {
+					if (self.traits.equals(entry.key, key)) {
+						return entry.value;
+					}
+				} else {
+					if (Traits.equals(entry.key, key)) {
+						return entry.value;
+					}
 				}
 
 				hashed_key = (hashed_key +% 1) % hash_max;
@@ -293,11 +235,12 @@ pub fn Table(comptime Key: type, comptime Value: type, comptime traits: TableTra
 			return null;
 		}
 
-		pub fn make(allocator: io.Allocator) Self {
+		pub fn make(allocator: io.Allocator, traits: Traits) Self {
 			return .{
 				.allocator = allocator,
 				.count = 0,
 				.entries = &.{},
+				.traits = traits,
 			};
 		}
 
@@ -306,46 +249,26 @@ pub fn Table(comptime Key: type, comptime Value: type, comptime traits: TableTra
 				return;
 			}
 
-			const min_count = @max(1, self.count);
-			const table_size = min_count * 2;
-			const allocation = @as([*]?Entry, @ptrCast(@alignCast(try self.allocator.reallocate(null, @sizeOf(?Entry) * table_size))))[0 .. table_size];
+			var table = make(self.allocator, self.traits);
 
-			errdefer self.allocator.deallocate(allocation);
+			errdefer table.free();
 
-			self.entries = replace_table: {
-				for (allocation) |*entry| {
-					entry.* = null;
-				}
+			table.entries = allocate: {
+				const min_count = @max(1, self.count);
+				const table_size = min_count * 2;
 
-				if (self.entries.len != 0) {
-					for (self.entries) |maybe_entry| {
-						if (maybe_entry) |entry| {
-							debug.assert(entry.write_into(allocation));
-						}
-					}
-
-					self.allocator.deallocate(self.entries);
-				}
-
-				break: replace_table allocation;
+				break: allocate try io.allocate_many(self.allocator, table_size, @as(?Entry, null));
 			};
+
+			for (self.entries) |maybe_entry| {
+				if (maybe_entry) |entry| {
+					debug.assert(entry.write_into(&table));
+				}
+			}
+
+			self.free();
+
+			self.* = table;
 		}
 	};
 }
-
-pub fn TableTraits(comptime Key: type) type {
-	return struct {
-		hash: fn (key: Key) usize,
-		match: fn (key: Key, key: Key) bool,
-	};
-}
-
-fn hash_string(key: []const io.Byte) usize {
-	var hash_code = @as(usize, 5381);
-
-	for (key) |byte| {
-		hash_code = ((hash_code << 5) +% hash_code) +% byte;
-	}
-
-	return hash_code;
-}
diff --git a/source/coral/math.zig b/source/coral/math.zig
index de8d37f..360da13 100644
--- a/source/coral/math.zig
+++ b/source/coral/math.zig
@@ -8,6 +8,24 @@ pub fn clamp(value: anytype, lower: anytype, upper: anytype) @TypeOf(value, lowe
 	return @max(lower, @min(upper, value));
 }
 
+pub fn checked_add(a: anytype, b: anytype) ?@TypeOf(a + b) {
+	const result = @addWithOverflow(a, b);
+
+	return if (result.@"1" == 0) result.@"0" else null;
+}
+
+pub fn checked_mul(a: anytype, b: anytype) ?@TypeOf(a * b) {
+	const result = @mulWithOverflow(a, b);
+
+	return if (result.@"1" == 0) result.@"0" else null;
+}
+
+pub fn checked_sub(a: anytype, b: anytype) ?@TypeOf(a - b) {
+	const result = @subWithOverflow(a, b);
+
+	return if (result.@"1" == 0) result.@"0" else null;
+}
+
 pub fn clamped_cast(comptime dest_int: std.builtin.Type.Int, value: anytype) Int(dest_int) {
 	const Value = @TypeOf(value);
 
@@ -17,6 +35,8 @@ pub fn clamped_cast(comptime dest_int: std.builtin.Type.Int, value: anytype) Int
 			.unsigned => @intCast(@min(value, max_int(dest_int))),
 		},
 
+		.Float => @intFromFloat(clamp(value, min_int(dest_int), max_int(dest_int))),
+
 		else => @compileError("`" ++ @typeName(Value) ++ "` cannot be cast to an int"),
 	};
 }
@@ -40,9 +60,3 @@ pub fn min_int(comptime int: std.builtin.Type.Int) comptime_int {
 
 	return -(1 << (bit_count - 1));
 }
-
-pub fn wrap(value: anytype, lower: anytype, upper: anytype) @TypeOf(value, lower, upper) {
-	const range = upper - lower;
-
-	return if (range == 0) lower else lower + @mod((@mod((value - lower), range) + range), range);
-}
diff --git a/source/coral/utf8.zig b/source/coral/utf8.zig
index 62fccbc..97fb597 100644
--- a/source/coral/utf8.zig
+++ b/source/coral/utf8.zig
@@ -33,9 +33,10 @@ pub const DecimalFormat = struct {
 
 					switch (code) {
 						'0', '1', '2', '3', '4', '5', '6', '7', '8', '9' => {
-							result = try math.checked_add(
-								try math.checked_mul(result, radix),
-								try math.checked_sub(code, '0'));
+							const offset_code = math.checked_sub(code, '0') orelse return null;
+
+							result = math.checked_mul(result, radix) orelse return null;
+							result = math.checked_add(result, offset_code) orelse return null;
 						},
 
 						else => {
diff --git a/source/ona/app.zig b/source/ona/app.zig
index 6450445..81d51f5 100644
--- a/source/ona/app.zig
+++ b/source/ona/app.zig
@@ -13,18 +13,18 @@ pub const Manifest = struct {
 	tick_rate: f32 = 60.0,
 
 	pub fn load(self: *Manifest, env: *kym.RuntimeEnv, file_access: file.Access) kym.RuntimeError!void {
-		const manifest_ref = try env.execute_file(file_access, file.Path.from(&.{"app.ona"}));
+		const manifest = try env.expect(try env.execute_file(file_access, file.Path.from(&.{"app.ona"})));
 
-		defer env.discard(manifest_ref);
+		defer env.discard(manifest);
 
 		const width = @as(u16, get: {
-			const ref = try kym.get_field(env, manifest_ref, "width");
+			if (try env.get_field(manifest, "width")) |ref| {
+				defer env.discard(ref);
 
-			defer env.discard(ref);
+				const fixed = try env.unbox_fixed(ref);
 
-			if (env.unbox(ref).expect_number()) |number| {
-				if (number > 0 and number < coral.math.max_int(@typeInfo(@TypeOf(self.width)).Int)) {
-					break: get @intFromFloat(number);
+				if (fixed > 0 and fixed < coral.math.max_int(@typeInfo(@TypeOf(self.width)).Int)) {
+					break: get @intCast(fixed);
 				}
 			}
 
@@ -32,13 +32,13 @@ pub const Manifest = struct {
 		});
 
 		const height = @as(u16, get: {
-			const ref = try kym.get_field(env, manifest_ref, "height");
+			if (try env.get_field(manifest, "height")) |ref| {
+				defer env.discard(ref);
 
-			defer env.discard(ref);
+				const fixed = try env.unbox_fixed(ref);
 
-			if (env.unbox(ref).expect_number()) |number| {
-				if (number > 0 and number < coral.math.max_int(@typeInfo(@TypeOf(self.height)).Int)) {
-					break: get @intFromFloat(number);
+				if (fixed > 0 and fixed < coral.math.max_int(@typeInfo(@TypeOf(self.height)).Int)) {
+					break: get @intCast(fixed);
 				}
 			}
 
@@ -46,27 +46,25 @@ pub const Manifest = struct {
 		});
 
 		const tick_rate = @as(f32, get: {
-			const ref = try kym.get_field(env, manifest_ref, "tick_rate");
+			if (try env.get_field(manifest, "tick_rate")) |ref| {
+				defer env.discard(ref);
 
-			defer env.discard(ref);
-
-			if (env.unbox(ref).expect_number()) |number| {
-				break: get @floatCast(number);
+				break: get @floatCast(try env.unbox_float(ref));
 			}
 
 			break: get self.tick_rate;
 		});
 
-		{
-			const title_ref = try kym.get_field(env, manifest_ref, "title");
+		if (try env.get_field(manifest, "title")) |ref| {
+			defer env.discard(ref);
 
-			defer env.discard(title_ref);
-
-			const title_string = env.unbox(title_ref).expect_string() orelse "";
+			const title_string = try env.unbox_string(ref);
 			const limited_title_len = @min(title_string.len, self.title.len);
 
 			coral.io.copy(&self.title, title_string[0 .. limited_title_len]);
 			coral.io.zero(self.title[limited_title_len .. self.title.len]);
+		} else {
+			coral.io.zero(&self.title);
 		}
 
 		self.tick_rate = tick_rate;
diff --git a/source/ona/heap.zig b/source/ona/heap.zig
index 8639461..8f5d785 100644
--- a/source/ona/heap.zig
+++ b/source/ona/heap.zig
@@ -159,7 +159,7 @@ pub fn trace_leaks() void {
 			var current_node = context.head;
 
 			while (current_node) |node| : (current_node = node.next) {
-				std.debug.print("{d} byte leak at 0x{x} detected:\n", .{
+				std.debug.print("{d} byte leak at 0x{x} detected", .{
 					node.size,
 					@intFromPtr(node) + @sizeOf(AllocationNode),
 				});
diff --git a/source/ona/kym.zig b/source/ona/kym.zig
index 0553851..0ee0442 100644
--- a/source/ona/kym.zig
+++ b/source/ona/kym.zig
@@ -1,57 +1,11 @@
 const Ast = @import("./kym/Ast.zig");
 
-const Chunk = @import("./kym/Chunk.zig");
-
-const Table = @import("./kym/Table.zig");
-
 const coral = @import("coral");
 
 const file = @import("./file.zig");
 
-pub const Any = union (enum) {
-	nil,
-	boolean: bool,
-	number: Float,
-	string: []const coral.io.Byte,
-	dynamic: *DynamicObject,
-
-	pub fn expect_dynamic(self: Any) ?*DynamicObject {
-		return switch (self) {
-			.dynamic => |dynamic| dynamic,
-			else => null,
-		};
-	}
-
-	pub fn expect_number(self: Any) ?Float {
-		return switch (self) {
-			.number => |number| number,
-			else => null,
-		};
-	}
-
-	pub fn expect_string(self: Any) ?[]const coral.io.Byte {
-		return switch (self) {
-			.string => |string| string,
-			else => null,
-		};
-	}
-};
-
 pub const Caller = coral.io.Generator(RuntimeError!?*RuntimeRef, *RuntimeEnv);
 
-pub const DynamicObject = struct {
-	userdata: []coral.io.Byte,
-	typeinfo: *const Typeinfo,
-
-	pub fn as_caller(self: *DynamicObject) Caller {
-		return Caller.bind(DynamicObject, self, DynamicObject.call);
-	}
-
-	fn call(self: *DynamicObject, env: *RuntimeEnv) RuntimeError!?*RuntimeRef {
-		return self.typeinfo.call(env);
-	}
-};
-
 pub const ErrorHandler = coral.io.Generator(void, ErrorInfo);
 
 pub const ErrorInfo = struct {
@@ -59,6 +13,8 @@ pub const ErrorInfo = struct {
 	frames: []const Frame,
 };
 
+pub const Fixed = i32;
+
 pub const Float = f64;
 
 pub const Frame = struct {
@@ -67,254 +23,1154 @@ pub const Frame = struct {
 	locals_top: usize,
 };
 
-pub const IndexContext = struct {
-	env: *RuntimeEnv,
-	userdata: []coral.io.Byte,
-	index_ref: ?*const RuntimeRef,
-};
-
 pub const RuntimeEnv = struct {
+	interned_symbols: SymbolSet,
 	allocator: coral.io.Allocator,
 	error_handler: ErrorHandler,
-	syscallers: SyscallerTable,
-	local_refs: RefStack,
+	system_bindings: RefTable,
+	locals: RefList,
 	frames: FrameStack,
-	ref_values: RefSlab,
+
+	const Chunk = struct {
+		env: *RuntimeEnv,
+		name: []coral.io.Byte,
+		opcodes: OpcodeList,
+		constants: ConstList,
+
+		const Constant = union (enum) {
+			fixed: Fixed,
+			float: Float,
+			string: []const coral.io.Byte,
+			symbol: []const coral.io.Byte,
+		};
+
+		const Opcode = union (enum) {
+			push_nil,
+			push_true,
+			push_false,
+			push_const: u16,
+			push_local: u8,
+			push_table: u32,
+			push_system: u16,
+			local_set: u8,
+			object_get,
+			object_set,
+			object_call: u8,
+
+			not,
+			neg,
+
+			add,
+			sub,
+			mul,
+			div,
+
+			eql,
+			cgt,
+			clt,
+			cge,
+			cle,
+		};
+
+		const OpcodeList = coral.list.Stack(Opcode);
+
+		const CompilationUnit = struct {
+			local_identifiers_buffer: [255][]const coral.io.Byte = [_][]const coral.io.Byte{""} ** 255,
+			local_identifiers_count: u8 = 0,
+
+			fn compile_expression(self: *CompilationUnit, chunk: *Chunk, expression: Ast.Expression) RuntimeError!void {
+				const number_format = coral.utf8.DecimalFormat{
+					.delimiter = "_",
+					.positive_prefix = .none,
+				};
+
+				switch (expression) {
+					.nil_literal => try chunk.opcodes.push_one(.push_nil),
+					.true_literal => try chunk.opcodes.push_one(.push_true),
+					.false_literal => try chunk.opcodes.push_one(.push_false),
+
+					.number_literal => |literal| {
+						for (literal) |codepoint| {
+							if (codepoint == '.') {
+								return chunk.opcodes.push_one(.{
+									.push_const = try chunk.declare_constant(.{
+										.float = number_format.parse(literal, Float) orelse unreachable,
+									}),
+								});
+							}
+						}
+
+						try chunk.opcodes.push_one(.{
+							.push_const = try chunk.declare_constant(.{
+								.fixed = number_format.parse(literal, Fixed) orelse unreachable,
+							}),
+						});
+					},
+
+					.string_literal => |literal| {
+						try chunk.opcodes.push_one(.{
+							.push_const = try chunk.declare_constant(.{.string = literal}),
+						});
+					},
+
+					.symbol_literal => |literal| {
+						try chunk.opcodes.push_one(.{
+							.push_const = try chunk.declare_constant(.{.symbol = literal}),
+						});
+					},
+
+					.table_literal => |fields| {
+						if (fields.values.len > coral.math.max_int(@typeInfo(u32).Int)) {
+							return error.OutOfMemory;
+						}
+
+						for (fields.values) |field| {
+							try self.compile_expression(chunk, field.value_expression);
+							try self.compile_expression(chunk, field.key_expression);
+						}
+
+						try chunk.opcodes.push_one(.{.push_table = @intCast(fields.values.len)});
+					},
+
+					.binary_operation => |operation| {
+						try self.compile_expression(chunk, operation.lhs_expression.*);
+						try self.compile_expression(chunk, operation.rhs_expression.*);
+
+						try chunk.opcodes.push_one(switch (operation.operator) {
+							.addition => .add,
+							.subtraction => .sub,
+							.multiplication => .mul,
+							.divsion => .div,
+							.greater_equals_comparison => .eql,
+							.greater_than_comparison => .cgt,
+							.equals_comparison => .cge,
+							.less_than_comparison => .clt,
+							.less_equals_comparison => .cle,
+						});
+					},
+
+					.unary_operation => |operation| {
+						try self.compile_expression(chunk, operation.expression.*);
+
+						try chunk.opcodes.push_one(switch (operation.operator) {
+							.boolean_negation => .not,
+							.numeric_negation => .neg,
+						});
+					},
+
+					.invoke => |invoke| {
+						if (invoke.argument_expressions.values.len > coral.math.max_int(@typeInfo(u8).Int)) {
+							return chunk.env.raise(error.BadSyntax, "lambdas may contain a maximum of 255 arguments");
+						}
+
+						for (invoke.argument_expressions.values) |argument_expression| {
+							try self.compile_expression(chunk, argument_expression);
+						}
+
+						try self.compile_expression(chunk, invoke.object_expression.*);
+						try chunk.opcodes.push_one(.{.object_call = @intCast(invoke.argument_expressions.values.len)});
+					},
+
+					.grouped_expression => |grouped_expression| {
+						try self.compile_expression(chunk, grouped_expression.*);
+					},
+
+					.get_system => |get_system| {
+						try chunk.opcodes.push_one(.{
+							.push_system = try chunk.declare_constant(.{.symbol = get_system}),
+						});
+					},
+
+					.local_get => |local_get| {
+						try chunk.opcodes.push_one(.{
+							.push_local = self.resolve_local(local_get) orelse {
+								return chunk.env.raise(error.OutOfMemory, "undefined local");
+							},
+						});
+					},
+
+					.local_set => |local_set| {
+						if (self.resolve_local(local_set)) |index| {
+							try chunk.opcodes.push_one(.{.local_set = index});
+						} else {
+							if (self.local_identifiers_count == self.local_identifiers_buffer.len) {
+								return chunk.env.raise(error.BadSyntax, "chunks may have a maximum of 255 locals");
+							}
+
+							self.local_identifiers_buffer[self.local_identifiers_count] = local_set;
+							self.local_identifiers_count += 1;
+						}
+					},
+
+					.field_get => |field_get| {
+						try self.compile_expression(chunk, field_get.object_expression.*);
+
+						try chunk.opcodes.push_one(.{
+							.push_const = try chunk.declare_constant(.{.symbol = field_get.identifier}),
+						});
+
+						try chunk.opcodes.push_one(.object_get);
+					},
+
+					.field_set => |field_set| {
+						try self.compile_expression(chunk, field_set.object_expression.*);
+
+						try chunk.opcodes.push_one(.{
+							.push_const = try chunk.declare_constant(.{.symbol = field_set.identifier}),
+						});
+
+						try self.compile_expression(chunk, field_set.value_expression.*);
+						try chunk.opcodes.push_one(.object_set);
+					},
+				}
+			}
+
+			fn compile_statement(self: *CompilationUnit, chunk: *Chunk, statement: Ast.Statement) RuntimeError!void {
+				switch (statement) {
+					.@"return" => |@"return"| {
+						if (@"return".expression) |expression| {
+							try self.compile_expression(chunk, expression);
+						} else {
+							try chunk.opcodes.push_one(.push_nil);
+						}
+					},
+
+					.expression => |expression| try self.compile_expression(chunk, expression),
+				}
+			}
+
+			fn resolve_local(self: *CompilationUnit, local_identifier: []const coral.io.Byte) ?u8 {
+				if (self.local_identifiers_count == 0) {
+					return null;
+				}
+
+				var index = @as(u8, self.local_identifiers_count - 1);
+
+				while (true) : (index -= 1) {
+					if (coral.io.equals(local_identifier, self.local_identifiers_buffer[index])) {
+						return index;
+					}
+
+					if (index == 0) {
+						return null;
+					}
+				}
+			}
+		};
+
+		fn compile(self: *Chunk, ast: Ast) RuntimeError!void {
+			var unit = CompilationUnit{};
+
+			for (ast.list_statements()) |statement| {
+				try unit.compile_statement(self, statement);
+			}
+		}
+
+		fn declare_constant(self: *Chunk, constant: Constant) RuntimeError!u16 {
+			if (self.constants.values.len == coral.math.max_int(@typeInfo(u16).Int)) {
+				return self.env.raise(error.BadSyntax, "chunks cannot contain more than 65,535 constants");
+			}
+
+			const constant_index = self.constants.values.len;
+
+			try self.constants.push_one(try switch (constant) {
+				.fixed => |fixed| self.env.new_fixed(fixed),
+				.float => |float| self.env.new_float(float),
+				.string => |string| self.env.new_string(string),
+				.symbol => |symbol| self.env.new_symbol(symbol),
+			});
+
+			return @intCast(constant_index);
+		}
+
+		fn execute(self: *Chunk) RuntimeError!?*RuntimeRef {
+			try self.env.frames.push_one(.{
+				.arg_count = 0,
+				.locals_top = self.env.locals.values.len,
+				.name = self.name,
+			});
+
+			defer coral.debug.assert(self.env.frames.pop() != null);
+
+			for (self.opcodes.values) |opcode| {
+				switch (opcode) {
+					.push_nil => try self.env.locals.push_one(null),
+					.push_true => try self.env.locals.push_one(try self.env.new_boolean(true)),
+					.push_false => try self.env.locals.push_one(try self.env.new_boolean(false)),
+
+					.push_const => |push_const| {
+						if (push_const >= self.constants.values.len) {
+							return self.env.raise(error.IllegalState, "invalid const");
+						}
+
+						try self.env.locals.push_one(try self.env.acquire(self.constants.values[push_const]));
+					},
+
+					.push_local => |push_local| {
+						if (self.env.locals.values[push_local]) |local| {
+							try self.env.locals.push_one(try self.env.acquire(local));
+						} else {
+							try self.env.locals.push_one(null);
+						}
+					},
+
+					.push_table => |push_table| {
+						const table = try self.env.new_table();
+
+						errdefer self.env.discard(table);
+
+						{
+							const dynamic = table.object().payload.dynamic;
+							const userdata = dynamic.userdata();
+							var popped = @as(usize, 0);
+
+							while (popped < push_table) : (popped += 1) {
+								const index = try self.env.expect(try self.pop_local());
+
+								defer self.env.discard(index);
+
+								const maybe_value = try self.pop_local();
+
+								defer {
+									if (maybe_value) |value| {
+										self.env.discard(value);
+									}
+								}
+
+								try dynamic.typeinfo().set(.{
+									.userdata = userdata,
+									.env = self.env,
+								}, index, maybe_value);
+							}
+						}
+
+						try self.env.locals.push_one(table);
+					},
+
+					.push_system => |push_system| {
+						if (self.env.system_bindings.lookup(self.constants.values[push_system])) |syscallable| {
+							try self.env.locals.push_one(try self.env.acquire(syscallable));
+						} else {
+							try self.env.locals.push_one(null);
+						}
+					},
+
+					.local_set => |local_set| {
+						const local = &self.env.locals.values[local_set];
+
+						if (local.*) |previous_local| {
+							self.env.discard(previous_local);
+						}
+
+						local.* = try self.pop_local();
+					},
+
+					.object_get => {
+						const index = (try self.pop_local()) orelse {
+							return self.env.raise(error.TypeMismatch, "nil is not a valid index");
+						};
+
+						defer self.env.discard(index);
+
+						const indexable = (try self.pop_local()) orelse {
+							return self.env.raise(error.TypeMismatch, "nil is not a valid indexable");
+						};
+
+						defer self.env.discard(indexable);
+
+						const value = try self.env.get(indexable, index);
+
+						errdefer {
+							if (value) |ref| {
+								self.env.discard(ref);
+							}
+						}
+
+						try self.env.locals.push_one(value);
+					},
+
+					.object_set => {
+						const value = try self.pop_local();
+
+						defer {
+							if (value) |ref| {
+								self.env.discard(ref);
+							}
+						}
+
+						const index = try self.pop_local() orelse {
+							return self.env.raise(error.TypeMismatch, "nil is not a valid index");
+						};
+
+						defer self.env.discard(index);
+
+						const indexable = try self.pop_local() orelse {
+							return self.env.raise(error.TypeMismatch, "nil is not a valid indexable");
+						};
+
+						defer self.env.discard(indexable);
+
+						try self.env.set(indexable, index, value);
+					},
+
+					.object_call => |object_call| {
+						const result = call: {
+							const callable = try self.env.expect(try self.pop_local());
+
+							defer self.env.discard(callable);
+
+							try self.env.frames.push_one(.{
+								.name = "<lambda>",
+								.arg_count = object_call,
+								.locals_top = self.env.locals.values.len,
+							});
+
+							defer coral.debug.assert(self.env.frames.pop() != null);
+
+							break: call try switch (callable.object().payload) {
+								.dynamic => |dynamic| dynamic.typeinfo().call(.{
+									.userdata = dynamic.userdata(),
+									.env = self.env,
+								}),
+
+								else => self.env.raise(error.TypeMismatch, "object is not callable"),
+							};
+						};
+
+						for (0 .. object_call) |_| {
+							if (try self.pop_local()) |popped_arg| {
+								self.env.discard(popped_arg);
+							}
+						}
+
+						errdefer {
+							if (result) |ref| {
+								self.env.discard(ref);
+							}
+						}
+
+						try self.env.locals.push_one(result);
+					},
+
+					.not => {
+						if (try self.pop_local()) |value| {
+							defer self.env.discard(value);
+
+							try self.env.locals.push_one(try self.env.new_boolean(!value.is_truthy()));
+						} else {
+							try self.env.locals.push_one(try self.env.new_boolean(true));
+						}
+					},
+
+					.neg => {
+						const value = try self.env.expect(try self.pop_local());
+
+						defer self.env.discard(value);
+
+						try self.env.locals.push_one(try switch (value.object().payload) {
+							.fixed => |fixed| self.env.new_fixed(-fixed),
+							.float => |float| self.env.new_float(-float),
+							else => self.env.raise(error.TypeMismatch, "object is not negatable"),
+						});
+					},
+
+					.add => {
+						const rhs = try self.env.expect(try self.pop_local());
+
+						defer self.env.discard(rhs);
+
+						const lhs = try self.env.expect(try self.pop_local());
+
+						defer self.env.discard(lhs);
+
+						try self.env.locals.push_one(try switch (lhs.object().payload) {
+							.fixed => |lhs_fixed| switch (rhs.object().payload) {
+								.fixed => |rhs_fixed| add: {
+									if (coral.math.checked_add(lhs_fixed, rhs_fixed)) |fixed| {
+										break: add self.env.new_fixed(fixed);
+									}
+
+									break: add self.env.new_float(@as(Float,
+										@floatFromInt(lhs_fixed)) +
+										@as(Float, @floatFromInt(rhs_fixed)));
+								},
+
+								.float => |rhs_float| self.env.new_float(
+									@as(Float, @floatFromInt(lhs_fixed)) + rhs_float),
+
+								else => self.env.raise(error.TypeMismatch, "right-hand object is not addable"),
+							},
+
+							.float => |lhs_float| switch (rhs.object().payload) {
+								.float => |rhs_float| self.env.new_float(lhs_float + rhs_float),
+
+								.fixed => |rhs_fixed| self.env.new_float(
+									lhs_float + @as(Float, @floatFromInt(rhs_fixed))),
+
+								else => self.env.raise(error.TypeMismatch, "right-hand object is not addable"),
+							},
+
+							else => self.env.raise(error.TypeMismatch, "left-hand object is not addable"),
+						});
+					},
+
+					.sub => {
+						const rhs = try self.env.expect(try self.pop_local());
+
+						defer self.env.discard(rhs);
+
+						const lhs = try self.env.expect(try self.pop_local());
+
+						defer self.env.discard(lhs);
+
+						try self.env.locals.push_one(try switch (lhs.object().payload) {
+							.fixed => |lhs_fixed| switch (rhs.object().payload) {
+								.fixed => |rhs_fixed| sub: {
+									if (coral.math.checked_sub(lhs_fixed, rhs_fixed)) |fixed| {
+										break: sub self.env.new_fixed(fixed);
+									}
+
+									break: sub self.env.new_float(@as(Float,
+										@floatFromInt(lhs_fixed)) -
+										@as(Float, @floatFromInt(rhs_fixed)));
+								},
+
+								.float => |rhs_float| self.env.new_float(
+									@as(Float, @floatFromInt(lhs_fixed)) - rhs_float),
+
+								else => self.env.raise(error.TypeMismatch, "right-hand object is not subtractable"),
+							},
+
+							.float => |lhs_float| switch (rhs.object().payload) {
+								.float => |rhs_float| self.env.new_float(lhs_float - rhs_float),
+
+								.fixed => |rhs_fixed| self.env.new_float(
+									lhs_float - @as(Float, @floatFromInt(rhs_fixed))),
+
+								else => self.env.raise(error.TypeMismatch, "right-hand object is not subtractable"),
+							},
+
+							else => self.env.raise(error.TypeMismatch, "left-hand object is not subtractable"),
+						});
+					},
+
+					.mul => {
+						const rhs = try self.env.expect(try self.pop_local());
+
+						defer self.env.discard(rhs);
+
+						const lhs = try self.env.expect(try self.pop_local());
+
+						defer self.env.discard(lhs);
+
+						try self.env.locals.push_one(try switch (lhs.object().payload) {
+							.fixed => |lhs_fixed| switch (rhs.object().payload) {
+								.fixed => |rhs_fixed| mul: {
+									if (coral.math.checked_mul(lhs_fixed, rhs_fixed)) |fixed| {
+										break: mul self.env.new_fixed(fixed);
+									}
+
+									break: mul self.env.new_float(@as(Float,
+										@floatFromInt(lhs_fixed)) *
+										@as(Float, @floatFromInt(rhs_fixed)));
+								},
+
+								.float => |rhs_float| self.env.new_float(
+									@as(Float, @floatFromInt(lhs_fixed)) * rhs_float),
+
+								else => self.env.raise(error.TypeMismatch, "right-hand object is not multiplicable"),
+							},
+
+							.float => |lhs_float| switch (rhs.object().payload) {
+								.float => |rhs_float| self.env.new_float(lhs_float * rhs_float),
+
+								.fixed => |rhs_fixed| self.env.new_float(
+									lhs_float * @as(Float, @floatFromInt(rhs_fixed))),
+
+								else => self.env.raise(error.TypeMismatch, "right-hand object is not multiplicable"),
+							},
+
+							else => self.env.raise(error.TypeMismatch, "left-hand object is not multiplicable"),
+						});
+					},
+
+					.div => {
+						const rhs = try self.env.expect(try self.pop_local());
+
+						defer self.env.discard(rhs);
+
+						const lhs = try self.env.expect(try self.pop_local());
+
+						defer self.env.discard(lhs);
+
+						try self.env.locals.push_one(try switch (lhs.object().payload) {
+							.fixed => |lhs_fixed| switch (rhs.object().payload) {
+								.fixed => |rhs_fixed| self.env.new_float(@as(Float,
+										@floatFromInt(lhs_fixed)) /
+										@as(Float, @floatFromInt(rhs_fixed))),
+
+								.float => |rhs_float| self.env.new_float(
+									@as(Float, @floatFromInt(lhs_fixed)) / rhs_float),
+
+								else => self.env.raise(error.TypeMismatch, "right-hand object is not divisible"),
+							},
+
+							.float => |lhs_float| switch (rhs.object().payload) {
+								.float => |rhs_float| self.env.new_float(lhs_float / rhs_float),
+
+								.fixed => |rhs_fixed| self.env.new_float(
+									lhs_float / @as(Float, @floatFromInt(rhs_fixed))),
+
+								else => self.env.raise(error.TypeMismatch, "right-hand object is not divisible"),
+							},
+
+							else => self.env.raise(error.TypeMismatch, "left-hand object is not divisible"),
+						});
+					},
+
+					.eql => {
+						if (try self.pop_local()) |rhs| {
+							self.env.discard(rhs);
+
+							if (try self.pop_local()) |lhs| {
+								self.env.discard(lhs);
+
+								try self.env.locals.push_one(try self.env.new_boolean(lhs.equals(rhs)));
+							} else {
+								try self.env.locals.push_one(try self.env.new_boolean(false));
+							}
+						} else {
+							if (try self.pop_local()) |lhs| {
+								self.env.discard(lhs);
+
+								try self.env.locals.push_one(try self.env.new_boolean(false));
+							} else {
+								try self.env.locals.push_one(try self.env.new_boolean(true));
+							}
+						}
+					},
+
+					.cgt => {
+						const rhs = try self.env.expect(try self.pop_local());
+
+						defer self.env.discard(rhs);
+
+						const lhs = try self.env.expect(try self.pop_local());
+
+						defer self.env.discard(lhs);
+
+						try self.env.locals.push_one(try self.env.new_boolean(switch (lhs.object().payload) {
+							.fixed => |lhs_fixed| switch (rhs.object().payload) {
+								.fixed => |rhs_fixed| lhs_fixed > rhs_fixed,
+								.float => |rhs_float| @as(Float, @floatFromInt(lhs_fixed)) > rhs_float,
+								else => return self.env.raise(error.TypeMismatch, "right-hand object is not comparable"),
+							},
+
+							.float => |lhs_float| switch (rhs.object().payload) {
+								.float => |rhs_float| lhs_float > rhs_float,
+								.fixed => |rhs_fixed| lhs_float > @as(Float, @floatFromInt(rhs_fixed)),
+								else => return self.env.raise(error.TypeMismatch, "right-hand object is not comparable"),
+							},
+
+							else => return self.env.raise(error.TypeMismatch, "left-hand object is not comparable"),
+						}));
+					},
+
+					.clt => {
+						const rhs = try self.env.expect(try self.pop_local());
+
+						defer self.env.discard(rhs);
+
+						const lhs = try self.env.expect(try self.pop_local());
+
+						defer self.env.discard(lhs);
+
+						try self.env.locals.push_one(try self.env.new_boolean(switch (lhs.object().payload) {
+							.fixed => |lhs_fixed| switch (rhs.object().payload) {
+								.fixed => |rhs_fixed| lhs_fixed < rhs_fixed,
+								.float => |rhs_float| @as(Float, @floatFromInt(lhs_fixed)) < rhs_float,
+								else => return self.env.raise(error.TypeMismatch, "right-hand object is not comparable"),
+							},
+
+							.float => |lhs_float| switch (rhs.object().payload) {
+								.float => |rhs_float| lhs_float < rhs_float,
+								.fixed => |rhs_fixed| lhs_float < @as(Float, @floatFromInt(rhs_fixed)),
+								else => return self.env.raise(error.TypeMismatch, "right-hand object is not comparable"),
+							},
+
+							else => return self.env.raise(error.TypeMismatch, "left-hand object is not comparable"),
+						}));
+					},
+
+					.cge => {
+						const rhs = try self.env.expect(try self.pop_local());
+
+						defer self.env.discard(rhs);
+
+						const lhs = try self.env.expect(try self.pop_local());
+
+						defer self.env.discard(lhs);
+
+						try self.env.locals.push_one(try self.env.new_boolean(switch (lhs.object().payload) {
+							.fixed => |lhs_fixed| switch (rhs.object().payload) {
+								.fixed => |rhs_fixed| lhs_fixed >= rhs_fixed,
+								.float => |rhs_float| @as(Float, @floatFromInt(lhs_fixed)) >= rhs_float,
+								else => return self.env.raise(error.TypeMismatch, "right-hand object is not comparable"),
+							},
+
+							.float => |lhs_float| switch (rhs.object().payload) {
+								.float => |rhs_float| lhs_float >= rhs_float,
+								.fixed => |rhs_fixed| lhs_float >= @as(Float, @floatFromInt(rhs_fixed)),
+								else => return self.env.raise(error.TypeMismatch, "right-hand object is not comparable"),
+							},
+
+							else => return self.env.raise(error.TypeMismatch, "left-hand object is not comparable"),
+						}));
+					},
+
+					.cle => {
+						const rhs = try self.env.expect(try self.pop_local());
+
+						defer self.env.discard(rhs);
+
+						const lhs = try self.env.expect(try self.pop_local());
+
+						defer self.env.discard(lhs);
+
+						try self.env.locals.push_one(try self.env.new_boolean(switch (lhs.object().payload) {
+							.fixed => |lhs_fixed| switch (rhs.object().payload) {
+								.fixed => |rhs_fixed| lhs_fixed <= rhs_fixed,
+								.float => |rhs_float| @as(Float, @floatFromInt(lhs_fixed)) <= rhs_float,
+								else => return self.env.raise(error.TypeMismatch, "right-hand object is not comparable"),
+							},
+
+							.float => |lhs_float| switch (rhs.object().payload) {
+								.float => |rhs_float| lhs_float <= rhs_float,
+								.fixed => |rhs_fixed| lhs_float <= @as(Float, @floatFromInt(rhs_fixed)),
+								else => return self.env.raise(error.TypeMismatch, "right-hand object is not comparable"),
+							},
+
+							else => return self.env.raise(error.TypeMismatch, "left-hand object is not comparable"),
+						}));
+					},
+
+				}
+			}
+
+			return self.pop_local();
+		}
+
+		fn free(self: *Chunk) void {
+			while (self.constants.pop()) |constant| {
+				self.env.discard(constant);
+			}
+
+			self.constants.free();
+			self.opcodes.free();
+			self.env.allocator.deallocate(self.name);
+		}
+
+		fn make(env: *RuntimeEnv, name: []const coral.io.Byte) coral.io.AllocationError!Chunk {
+			return .{
+				.name = try coral.io.allocate_copy(env.allocator, name),
+				.opcodes = OpcodeList.make(env.allocator),
+				.constants = ConstList.make(env.allocator),
+				.env = env,
+			};
+		}
+
+		fn pop_local(self: *Chunk) RuntimeError!?*RuntimeRef {
+			return self.env.locals.pop() orelse self.env.raise(error.IllegalState, "stack underflow");
+		}
+	};
+
+	const ConstList = coral.list.Stack(*RuntimeRef);
 
 	const FrameStack = coral.list.Stack(Frame);
 
-	const SyscallerTable = coral.map.StringTable(Caller);
+	const RefList = coral.list.Stack(?*RuntimeRef);
 
-	const RefStack = coral.list.Stack(?*RuntimeRef);
+	const RefTable = coral.map.Table(*RuntimeRef, *RuntimeRef, struct {
+		pub const hash = RuntimeRef.hash;
 
-	const RefSlab = coral.map.Slab(struct {
-		ref_count: usize,
-
-		object: union (enum) {
-			false,
-			true,
-			number: Float,
-			string: []coral.io.Byte,
-			dynamic: *DynamicObject,
-		},
+		pub const equals = RuntimeRef.equals;
 	});
 
-	pub const Syscall = struct {
-		name: []const coral.io.Byte,
-		caller: Caller,
-	};
+	const SymbolSet = coral.map.StringTable([:0]coral.io.Byte);
 
-	pub fn acquire(self: *RuntimeEnv, ref: ?*const RuntimeRef) ?*RuntimeRef {
-		const key = @intFromPtr(ref orelse return null);
-		var ref_data = self.ref_values.remove(key);
+	const Table = struct {
+		associative: RefTable,
+		contiguous: RefList,
 
-		coral.debug.assert(ref_data != null);
-
-		ref_data.?.ref_count += 1;
-
-		coral.debug.assert(self.ref_values.insert_at(key, ref_data.?));
-
-		return @ptrFromInt(key);
-	}
-
-	pub fn bind_syscalls(self: *RuntimeEnv, syscalls: []const Syscall) RuntimeError!void {
-		for (syscalls) |syscall| {
-			_ = try self.syscallers.replace(syscall.name, syscall.caller);
-		}
-	}
-
-	pub fn call(
-		self: *RuntimeEnv,
-		name: []const coral.io.Byte,
-		arg_count: u8,
-		caller: Caller,
-	) RuntimeError!?*RuntimeRef {
-		try self.frames.push_one(.{
-			.name = name,
-			.arg_count = arg_count,
-			.locals_top = self.local_refs.values.len,
-		});
-
-		defer {
-			const frame = self.frames.pop();
-
-			coral.debug.assert(frame != null);
+		fn typeinfo_destruct(method: Typeinfo.Method) void {
+			const table = @as(*Table, @ptrCast(@alignCast(method.userdata.ptr)));
 
 			{
-				var pops_remaining = (self.local_refs.values.len - frame.?.locals_top) + frame.?.arg_count;
+				var field_iterable = table.associative.as_iterable();
 
-				while (pops_remaining != 0) : (pops_remaining -= 1) {
-					const local = self.local_refs.pop();
-
-					coral.debug.assert(local != null);
-
-					self.discard(local.?);
+				while (field_iterable.next()) |entry| {
+					method.env.discard(entry.key);
+					method.env.discard(entry.value);
 				}
 			}
+
+			table.associative.free();
+
+			while (table.contiguous.pop()) |value| {
+				if (value) |ref| {
+					method.env.discard(ref);
+				}
+			}
+
+			table.contiguous.free();
+		}
+
+		fn typeinfo_get(method: Typeinfo.Method, index: *const RuntimeRef) RuntimeError!?*RuntimeRef {
+			const table = @as(*Table, @ptrCast(@alignCast(method.userdata.ptr)));
+			const acquired_index = try method.env.acquire(index);
+
+			defer method.env.discard(acquired_index);
+
+			if (acquired_index.is_fixed()) |fixed| {
+				if (fixed < 0) {
+					// TODO: Negative indexing.
+					unreachable;
+				}
+
+				if (fixed < table.contiguous.values.len) {
+					return method.env.acquire(table.contiguous.values[@intCast(fixed)] orelse return null);
+				}
+			}
+
+			if (table.associative.lookup(acquired_index)) |value_ref| {
+				return method.env.acquire(value_ref);
+			}
+
+			return null;
+		}
+
+		fn typeinfo_set(method: Typeinfo.Method, index: *const RuntimeRef, value: ?*const RuntimeRef) RuntimeError!void {
+			const table = @as(*Table, @ptrCast(@alignCast(method.userdata.ptr)));
+			const acquired_index = try method.env.acquire(index);
+
+			errdefer method.env.discard(acquired_index);
+
+			if (acquired_index.is_fixed()) |fixed| {
+				if (fixed < 0) {
+					// TODO: Negative indexing.
+					unreachable;
+				}
+
+				if (fixed < table.contiguous.values.len) {
+					const maybe_replacing = &table.contiguous.values[@intCast(fixed)];
+
+					if (maybe_replacing.*) |replacing| {
+						method.env.discard(replacing);
+					}
+
+					maybe_replacing.* = if (value) |ref| try method.env.acquire(ref) else null;
+
+					return;
+				}
+			}
+
+			const acquired_value = try method.env.acquire(value orelse {
+				if (table.associative.remove(acquired_index)) |removed| {
+					method.env.discard(removed.key);
+					method.env.discard(removed.value);
+				}
+
+				return;
+			});
+
+			errdefer method.env.discard(acquired_value);
+
+			if (try table.associative.replace(acquired_index, acquired_value)) |replaced| {
+				method.env.discard(replaced.key);
+				method.env.discard(replaced.value);
+			}
 		}
 
-		return caller.invoke(self);
+	};
+
+	pub fn acquire(self: *RuntimeEnv, value: *const RuntimeRef) RuntimeError!*RuntimeRef {
+		const object = value.object();
+
+		object.ref_count = coral.math.checked_add(object.ref_count, 1) orelse {
+			return self.raise(error.IllegalState, "reference overflow");
+		};
+
+		return @ptrCast(object);
 	}
 
-	pub fn discard(self: *RuntimeEnv, ref: ?*RuntimeRef) void {
-		const key = @intFromPtr(ref orelse return);
-		var ref_data = self.ref_values.remove(key) orelse unreachable;
+	pub fn arg(self: *RuntimeEnv, index: usize) RuntimeError!?*RuntimeRef {
+		const frame = self.frames.peek() orelse return self.raise(error.IllegalState, "stack underflow");
 
-		coral.debug.assert(ref_data.ref_count != 0);
+		if (index < frame.arg_count) {
+			if (self.locals.values[frame.locals_top - (1 + index)]) |local| {
+				return self.acquire(local);
+			}
+		}
 
-		ref_data.ref_count -= 1;
+		return null;
+	}
 
-		if (ref_data.ref_count == 0) {
-			switch (ref_data.object) {
-				.string => |string| self.allocator.deallocate(string),
+	pub fn bind_system(self: *RuntimeEnv, name: []const coral.io.Byte, value: *const RuntimeRef) RuntimeError!void {
+		const name_symbol = try self.new_symbol(name);
 
-				.dynamic => |dynamic| {
-					dynamic.typeinfo.clean(self, dynamic.userdata);
-					self.allocator.deallocate(dynamic.userdata);
-					self.allocator.deallocate(dynamic);
+		errdefer self.discard(name_symbol);
+
+		const acquired_value = try self.acquire(value);
+
+		errdefer self.discard(acquired_value);
+
+		if (try self.system_bindings.replace(name_symbol, acquired_value)) |replaced| {
+			self.discard(replaced.key);
+			self.discard(replaced.value);
+		}
+	}
+
+	pub fn call(self: *RuntimeEnv, callable: *RuntimeRef, args: []const *RuntimeRef) RuntimeError!?*RuntimeRef {
+		try self.locals.push_all(args);
+
+		defer coral.io.assert(self.locals.drop(args.len));
+
+		try self.frames.push_one(.{
+			.name = "<native>",
+			.arg_count = args.len,
+			.locals_top = self.locals.values.len,
+		});
+
+		defer coral.io.assert(self.frames.pop() != null);
+
+		return switch (callable.object().payload) {
+			.dynamic => |dynamic| dynamic.typeinfo.call(.{
+				.userdata = dynamic.userdata(),
+				.env = self,
+			}),
+
+			else => self.raise(error.TypeMismatch, "object is not callable"),
+		};
+	}
+
+	pub fn discard(self: *RuntimeEnv, value: *RuntimeRef) void {
+		var object = value.object();
+
+		coral.debug.assert(object.ref_count != 0);
+
+		object.ref_count -= 1;
+
+		if (object.ref_count == 0) {
+			switch (object.payload) {
+				.false, .true, .float, .fixed, .symbol => {},
+
+				.string => |string| {
+					coral.debug.assert(string.len >= 0);
+					self.allocator.deallocate(string.ptr[0 .. @intCast(string.len)]);
 				},
 
-				else => {},
+				.dynamic => |dynamic| {
+					if (dynamic.typeinfo().destruct) |destruct| {
+						destruct(.{
+							.userdata = dynamic.userdata(),
+							.env = self,
+						});
+					}
+
+					self.allocator.deallocate(dynamic.unpack());
+				},
 			}
-		} else {
-			coral.debug.assert(self.ref_values.insert_at(key, ref_data));
+
+			self.allocator.deallocate(object);
 		}
 	}
 
 	pub fn execute_file(self: *RuntimeEnv, file_access: file.Access, file_path: file.Path) RuntimeError!?*RuntimeRef {
-		if ((try file.allocate_and_load(self.allocator, file_access, file_path))) |file_data| {
-			defer self.allocator.deallocate(file_data);
+		const file_data = (try file.allocate_and_load(self.allocator, file_access, file_path)) orelse {
+			return self.raise(error.BadOperation, "failed to open or read file specified");
+		};
 
-			if (file_path.to_string()) |string| {
-				return self.execute_script(string, file_data);
-			}
-		}
+		defer self.allocator.deallocate(file_data);
 
-		return self.raise(error.BadOperation, "failed to load file");
-	}
-
-	pub fn execute_script(
-		self: *RuntimeEnv,
-		name: []const coral.io.Byte,
-		data: []const coral.io.Byte,
-	) RuntimeError!?*RuntimeRef {
-		var ast = Ast.make(self.allocator, name);
+		const file_name = file_path.to_string() orelse "<script>";
+		var ast = Ast.make(self.allocator, file_name);
 
 		defer ast.free();
 
-		ast.parse(data) catch |parse_error| switch (parse_error) {
-			error.BadSyntax => return self.raise(error.BadSyntax, ast.error_message()),
-			error.OutOfMemory => return error.OutOfMemory,
+		ast.parse(file_data) catch |parse_error| return switch (parse_error) {
+			error.BadSyntax => self.raise(error.BadSyntax, ast.error_message()),
+			error.OutOfMemory => error.OutOfMemory,
 		};
 
-		var chunk = Chunk.make(self);
+		var chunk = try Chunk.make(self, file_name);
 
 		defer chunk.free();
 
-		try chunk.compile_ast(ast);
+		try chunk.compile(ast);
 
-		return self.call(name, 0, chunk.as_caller());
+		return chunk.execute();
+	}
+
+	pub fn expect(self: *RuntimeEnv, value: ?*RuntimeRef) RuntimeError!*RuntimeRef {
+		return value orelse self.raise(error.TypeMismatch, "nil reference");
 	}
 
 	pub fn free(self: *RuntimeEnv) void {
-		for (self.local_refs.values) |ref| {
-			self.discard(ref);
+		while (self.locals.pop()) |local| {
+			if (local) |ref| {
+				self.discard(ref);
+			}
+		}
+
+		{
+			var iterable = self.interned_symbols.as_iterable();
+
+			while (iterable.next()) |entry| {
+				self.allocator.deallocate(entry.value);
+			}
+		}
+
+		{
+			var iterable = self.system_bindings.as_iterable();
+
+			while (iterable.next()) |entry| {
+				self.discard(entry.key);
+				self.discard(entry.value);
+			}
 		}
 
 		self.frames.free();
-		self.syscallers.free();
-		self.local_refs.free();
-		self.ref_values.free();
+		self.locals.free();
+		self.system_bindings.free();
+		self.interned_symbols.free();
 	}
 
-	pub fn get_local(self: *RuntimeEnv, local: u8) RuntimeError!?*RuntimeRef {
-		if (local >= self.local_refs.values.len) {
-			return self.raise(error.IllegalState, "out of bounds local get");
-		}
+	pub fn get(self: *RuntimeEnv, indexable: *RuntimeRef, index: *const RuntimeRef) RuntimeError!?*RuntimeRef {
+		return switch (indexable.object().payload) {
+			.dynamic => |dynamic| dynamic.typeinfo().get(.{
+				.userdata = dynamic.userdata(),
+				.env = self,
+			}, index),
 
-		return self.acquire(self.local_refs.values[local]);
+			else => self.raise(error.TypeMismatch, "object is not get-indexable"),
+		};
 	}
 
-	pub fn pop_local(self: *RuntimeEnv) RuntimeError!?*RuntimeRef {
-		return self.local_refs.pop() orelse self.raise(error.IllegalState, "stack underflow");
-	}
+	pub fn get_field(self: *RuntimeEnv, indexable: *RuntimeRef, field: []const coral.io.Byte) RuntimeError!?*RuntimeRef {
+		const field_symbol = try self.new_symbol(field);
 
-	pub fn push_boolean(self: *RuntimeEnv, boolean: bool) RuntimeError!void {
-		return self.local_refs.push_one(try self.new_boolean(boolean));
-	}
+		defer self.discard(field_symbol);
 
-	pub fn push_number(self: *RuntimeEnv, number: Float) RuntimeError!void {
-		return self.local_refs.push_one(try self.new_number(number));
-	}
-
-	pub fn push_ref(self: *RuntimeEnv, ref: ?*RuntimeRef) RuntimeError!void {
-		return self.local_refs.push_one(self.acquire(ref));
-	}
-
-	pub fn set_local(self: *RuntimeEnv, local: u8, value: ?*RuntimeRef) RuntimeError!void {
-		if (local >= self.local_refs.values.len) {
-			return self.raise(error.IllegalState, "out of bounds local set");
-		}
-
-		self.local_refs.values[local] = self.acquire(value);
+		return self.get(indexable, field_symbol);
 	}
 
 	pub fn make(allocator: coral.io.Allocator, error_handler: ErrorHandler) coral.io.AllocationError!RuntimeEnv {
 		return RuntimeEnv{
-			.local_refs = RefStack.make(allocator),
-			.ref_values = RefSlab.make(allocator),
+			.locals = RefList.make(allocator),
 			.frames = FrameStack.make(allocator),
-			.syscallers = SyscallerTable.make(allocator),
+			.system_bindings = RefTable.make(allocator, .{}),
+			.interned_symbols = SymbolSet.make(allocator, .{}),
 			.error_handler = error_handler,
 			.allocator = allocator,
 		};
 	}
 
-	pub fn new_boolean(self: *RuntimeEnv, value: bool) RuntimeError!?*RuntimeRef {
-		return @ptrFromInt(try self.ref_values.insert(.{
+	pub fn new_boolean(self: *RuntimeEnv, value: bool) RuntimeError!*RuntimeRef {
+		return RuntimeRef.allocate(self.allocator, .{
 			.ref_count = 1,
-			.object = if (value) .true else .false,
-		}));
+			.payload = if (value) .true else .false,
+		});
 	}
 
 	pub fn new_dynamic(
 		self: *RuntimeEnv,
-		userdata: []const coral.io.Byte,
+		userdata: [*]const coral.io.Byte,
 		typeinfo: *const Typeinfo,
 	) RuntimeError!*RuntimeRef {
-		const userdata_copy = try coral.io.allocate_copy(self.allocator, userdata);
+		const dynamic = try self.allocator.reallocate(null, @sizeOf(usize) + typeinfo.size);
 
-		errdefer self.allocator.deallocate(userdata_copy);
+		errdefer self.allocator.deallocate(dynamic);
 
-		const dynamic_object = try coral.io.allocate_one(self.allocator, DynamicObject{
-			.typeinfo = typeinfo,
-			.userdata = userdata_copy,
+		coral.io.copy(dynamic, coral.io.bytes_of(&typeinfo));
+		coral.io.copy(dynamic[@sizeOf(usize) ..], userdata[0 .. typeinfo.size]);
+
+		return RuntimeRef.allocate(self.allocator, .{
+			.ref_count = 1,
+			.payload = .{.dynamic = .{.ptr = dynamic.ptr}},
 		});
-
-		errdefer self.allocator.deallocate(dynamic_object);
-
-		return @ptrFromInt(try self.ref_values.insert(.{
-			.ref_count = 1,
-			.object = .{.dynamic = dynamic_object},
-		}));
 	}
 
-	pub fn new_number(self: *RuntimeEnv, value: Float) RuntimeError!?*RuntimeRef {
-		return @ptrFromInt(try self.ref_values.insert(.{
+	pub fn new_fixed(self: *RuntimeEnv, value: Fixed) RuntimeError!*RuntimeRef {
+		return RuntimeRef.allocate(self.allocator, .{
 			.ref_count = 1,
-			.object = .{.number = value},
-		}));
+			.payload = .{.fixed = value},
+		});
 	}
 
-	pub fn new_string(self: *RuntimeEnv, string_data: []const coral.io.Byte) RuntimeError!?*RuntimeRef {
-		const string_copy = try coral.io.allocate_copy(self.allocator, string_data);
-
-		errdefer self.allocator.deallocate(string_copy);
-
-		return @ptrFromInt(try self.ref_values.insert(.{
+	pub fn new_float(self: *RuntimeEnv, value: Float) RuntimeError!*RuntimeRef {
+		return RuntimeRef.allocate(self.allocator, .{
 			.ref_count = 1,
-			.object = .{.string = string_copy},
-		}));
+			.payload = .{.float = value},
+		});
+	}
+
+	pub fn new_string(self: *RuntimeEnv, value: []const coral.io.Byte) RuntimeError!*RuntimeRef {
+		if (value.len > coral.math.max_int(@typeInfo(Fixed).Int)) {
+			return error.OutOfMemory;
+		}
+
+		const string = try coral.io.allocate_copy(self.allocator, value);
+
+		errdefer self.allocator.deallocate(string);
+
+		return RuntimeRef.allocate(self.allocator, .{
+			.ref_count = 1,
+
+			.payload = .{
+				.string = .{
+					.ptr = string.ptr,
+					.len = @intCast(string.len),
+				},
+			},
+		});
+	}
+
+	pub fn new_symbol(self: *RuntimeEnv, value: []const coral.io.Byte) RuntimeError!*RuntimeRef {
+		return RuntimeRef.allocate(self.allocator, .{
+			.ref_count = 1,
+
+			.payload = .{
+				.symbol = self.interned_symbols.lookup(value) orelse create: {
+					const symbol_string = try coral.io.allocate_string(self.allocator, value);
+
+					errdefer self.allocator.deallocate(symbol_string);
+
+					coral.debug.assert(try self.interned_symbols.insert(symbol_string[0 .. value.len], symbol_string));
+
+					break: create symbol_string;
+				},
+			},
+		});
+	}
+
+	pub fn new_table(self: *RuntimeEnv) RuntimeError!*RuntimeRef {
+		var table = Table{
+			.associative = RefTable.make(self.allocator, .{}),
+			.contiguous = RefList.make(self.allocator),
+		};
+
+		errdefer {
+			table.associative.free();
+			table.contiguous.free();
+		}
+
+		return try self.new_dynamic(coral.io.bytes_of(&table).ptr, &.{
+			.name = "table",
+			.size = @sizeOf(Table),
+			.destruct = Table.typeinfo_destruct,
+			.get = Table.typeinfo_get,
+			.set = Table.typeinfo_set,
+		});
 	}
 
 	pub fn raise(self: *RuntimeEnv, error_value: RuntimeError, message: []const coral.io.Byte) RuntimeError {
@@ -326,36 +1182,53 @@ pub const RuntimeEnv = struct {
 		return error_value;
 	}
 
-	pub fn syscaller(self: *RuntimeEnv, name: []const coral.io.Byte) RuntimeError!Caller {
-		return self.syscallers.lookup(name) orelse self.raise(error.BadOperation, "attempt to call undefined syscall");
+	pub fn set(self: *RuntimeEnv, indexable: *RuntimeRef, index: *const RuntimeRef, value: ?*const RuntimeRef) RuntimeError!void {
+		return switch (indexable.object().payload) {
+			.dynamic => |dynamic| dynamic.typeinfo().set(.{
+				.userdata = dynamic.userdata(),
+				.env = self,
+			}, index, value),
+
+			else => self.raise(error.TypeMismatch, "object is not set-indexable"),
+		};
 	}
 
-	pub fn unbox(self: *RuntimeEnv, ref: ?*const RuntimeRef) Any {
-		if (ref) |live_ref| {
-			const ref_data = self.ref_values.lookup(@intFromPtr(live_ref));
-
-			coral.debug.assert(ref_data != null);
-
-			return switch (ref_data.?.object) {
-				.false => .{.boolean = false},
-				.true => .{.boolean = true},
-				.number => |number| .{.number = number},
-				.string => |string| .{.string = string},
-				.dynamic => |dynamic| .{.dynamic = dynamic},
-			};
-		}
-
-		return .nil;
+	pub fn unbox_dynamic(env: *RuntimeEnv, value: *const RuntimeRef) RuntimeError![]coral.io.Byte {
+		return switch (value.object().payload) {
+			.dynamic => |dynamic| dynamic.userdata(),
+			else => env.raise(error.TypeMismatch, "expected fixed object")
+		};
 	}
 
-	pub fn view_arg(self: *RuntimeEnv, index: usize) RuntimeError!?*const RuntimeRef {
-		const frame = self.frames.peek() orelse return self.raise(error.IllegalState, "stack underflow");
+	pub fn unbox_float(env: *RuntimeEnv, value: *const RuntimeRef) RuntimeError!Float {
+		return switch (value.object().payload) {
+			.fixed => |fixed| @floatFromInt(fixed),
+			.float => |float| float,
+			else => env.raise(error.TypeMismatch, "expected float object")
+		};
+	}
 
-		if (index >= frame.arg_count) {
-			return null;
-		}
+	pub fn unbox_fixed(env: *RuntimeEnv, value: *const RuntimeRef) RuntimeError!Fixed {
+		return value.is_fixed() orelse env.raise(error.TypeMismatch, "expected fixed object");
+	}
 
-		return self.local_refs.values[frame.locals_top - (1 + index)];
+	pub fn unbox_string(env: *RuntimeEnv, value: *const RuntimeRef) RuntimeError![]coral.io.Byte {
+		return switch (value.object().payload) {
+			.string => |string| extract: {
+				coral.debug.assert(string.len >= 0);
+
+				break: extract string.ptr[0 .. @intCast(string.len)];
+			},
+
+			else => env.raise(error.TypeMismatch, "expected string object")
+		};
+	}
+
+	pub fn unbox_symbol(env: *RuntimeEnv, value: *RuntimeRef) RuntimeError![*:0]const coral.io.Byte {
+		return switch (value.object().payload) {
+			.symbol => |symbol| symbol,
+			else => env.raise(error.TypeMismatch, "expected symbol object")
+		};
 	}
 };
 
@@ -366,184 +1239,178 @@ pub const RuntimeError = coral.io.AllocationError || error {
 	BadSyntax,
 };
 
-pub const RuntimeRef = opaque {};
+pub const RuntimeRef = opaque {
+	const Object = struct {
+		ref_count: u16,
 
-pub const TestContext = struct {
-	env: *RuntimeEnv,
-	userdata: []const coral.io.Byte,
-	other_ref: ?*const RuntimeRef,
-};
+		payload: union (enum) {
+			false,
+			true,
+			float: Float,
+			fixed: Fixed,
+			symbol: [*:0]const coral.io.Byte,
 
-pub const Typeinfo = struct {
-	name: []const coral.io.Byte,
-	call: *const fn (env: *RuntimeEnv) RuntimeError!?*RuntimeRef = default_call,
-	clean: *const fn (env: *RuntimeEnv, userdata: []coral.io.Byte) void = default_clean,
-	get: *const fn (context: IndexContext) RuntimeError!?*RuntimeRef = default_get,
-	set: *const fn (context: IndexContext, value: ?*const RuntimeRef) RuntimeError!void = default_set,
-	test_difference: *const fn (context: TestContext) RuntimeError!Float = default_test_difference,
-	test_equality: *const fn (context: TestContext) RuntimeError!bool = default_test_equality,
+			string: struct {
+				ptr: [*]coral.io.Byte,
+				len: Fixed,
 
-	fn default_call(env: *RuntimeEnv) RuntimeError!?*RuntimeRef {
-		return env.raise(error.TypeMismatch, "object is not callable");
+				const Self = @This();
+
+				fn unpack(self: Self) []coral.io.Byte {
+					coral.debug.assert(self.len >= 0);
+
+					return self.ptr[0 .. @intCast(self.len)];
+				}
+			},
+
+			dynamic: struct {
+				ptr: [*]coral.io.Byte,
+
+				const Self = @This();
+
+				fn typeinfo(self: Self) *const Typeinfo {
+					return @as(**const Typeinfo, @ptrCast(@alignCast(self.ptr))).*;
+				}
+
+				fn unpack(self: Self) []coral.io.Byte {
+					return self.ptr[0 .. (@sizeOf(usize) + self.typeinfo().size)];
+				}
+
+				fn userdata(self: Self) []coral.io.Byte {
+					const unpacked = self.unpack();
+					const address_size = @sizeOf(usize);
+
+					coral.debug.assert(unpacked.len >= address_size);
+
+					return unpacked[address_size ..];
+				}
+			},
+		},
+	};
+
+	fn allocate(allocator: coral.io.Allocator, data: Object) coral.io.AllocationError!*RuntimeRef {
+		return @ptrCast(try coral.io.allocate_one(allocator, data));
 	}
 
-	fn default_clean(_: *RuntimeEnv, _: []coral.io.Byte) void {
-		// Nothing to clean by default.
+	fn object(self: *const RuntimeRef) *Object {
+		return @constCast(@ptrCast(@alignCast(self)));
 	}
 
-	fn default_get(context: IndexContext) RuntimeError!?*RuntimeRef {
-		return context.env.raise(error.TypeMismatch, "object is not indexable");
+	pub fn equals(self: *const RuntimeRef, other: *const RuntimeRef) bool {
+		return switch (self.object().payload) {
+			.false => other.object().payload == .false,
+			.true => other.object().payload == .true,
+
+			.fixed => |self_fixed| switch (other.object().payload) {
+				.fixed => |other_fixed| other_fixed == self_fixed,
+				.float => |other_float| other_float == @as(Float, @floatFromInt(self_fixed)),
+				else => false,
+			},
+
+			.float => |self_float| switch (other.object().payload) {
+				.float => |other_float| other_float == self_float,
+				.fixed => |other_fixed| @as(Float, @floatFromInt(other_fixed)) == self_float,
+				else => false,
+			},
+
+			.symbol => |self_symbol| switch (other.object().payload) {
+				.symbol => |other_symbol| self_symbol == other_symbol,
+				else => false,
+			},
+
+			.string => |self_string| switch (other.object().payload) {
+				.string => |other_string| coral.io.equals(self_string.unpack(), other_string.unpack()),
+				else => false,
+			},
+
+			.dynamic => |self_dynamic| switch (other.object().payload) {
+				.dynamic => |other_dynamic|
+					self_dynamic.typeinfo() == other_dynamic.typeinfo() and
+					self_dynamic.userdata().ptr == other_dynamic.userdata().ptr,
+
+				else => false,
+			},
+		};
 	}
 
-	fn default_set(context: IndexContext, _: ?*const RuntimeRef) RuntimeError!void {
-		return context.env.raise(error.TypeMismatch, "object is not indexable");
+	pub fn hash(self: *const RuntimeRef) usize {
+		return switch (self.object().payload) {
+			.false => 1237,
+			.true => 1231,
+			.float => |float| @bitCast(float),
+			.fixed => |fixed| @intCast(@as(u32, @bitCast(fixed))),
+			.symbol => |symbol| @bitCast(@intFromPtr(symbol)),
+			.string => |string| coral.io.djb2_hash(@typeInfo(usize).Int, string.unpack()),
+			.dynamic => |dynamic| @intFromPtr(dynamic.typeinfo()) ^ @intFromPtr(dynamic.userdata().ptr),
+		};
 	}
 
-	fn default_test_difference(context: TestContext) RuntimeError!Float {
-		return context.env.raise(error.TypeMismatch, "object is not comparable");
+	pub fn is_fixed(self: *const RuntimeRef) ?Fixed {
+		return switch (self.object().payload) {
+			.fixed => |fixed| @intCast(@as(u32, @bitCast(fixed))),
+			else => null,
+		};
 	}
 
-	fn default_test_equality(context: TestContext) RuntimeError!bool {
-		return switch (context.env.unbox(context.other_ref)) {
-			.dynamic => |dynamic| context.userdata.ptr == dynamic.userdata.ptr,
-			else => false,
+	pub fn is_truthy(self: *const RuntimeRef) bool {
+		return switch (self.object().payload) {
+			.false => false,
+			.true => true,
+			.float => |float| float != 0,
+			.fixed => |fixed| fixed != 0,
+			.symbol => true,
+			.string => |string| string.len != 0,
+			.dynamic => true,
 		};
 	}
 };
 
-pub fn call(
-	env: *RuntimeEnv,
-	caller_ref: ?*const RuntimeRef,
-	callable_ref: ?*const RuntimeRef,
-	arg_refs: []const ?*const RuntimeRef,
-) RuntimeError!?*RuntimeRef {
-	for (arg_refs) |arg_ref| {
-		try env.local_push_ref(arg_ref);
+pub const Typeinfo = struct {
+	name: []const coral.io.Byte,
+	size: usize,
+	destruct: ?*const fn (method: Method) void = null,
+	call: *const fn (method: Method) RuntimeError!?*RuntimeRef = default_call,
+	get: *const fn (method: Method, index: *const RuntimeRef) RuntimeError!?*RuntimeRef = default_get,
+	set: *const fn (method: Method, value: *const RuntimeRef, value: ?*const RuntimeRef) RuntimeError!void = default_set,
+
+	pub const Method = struct {
+		env: *RuntimeEnv,
+		userdata: []coral.io.Byte,
+	};
+
+	fn default_call(method: Method) RuntimeError!?*RuntimeRef {
+		return method.env.raise(error.TypeMismatch, "object is not callable");
 	}
 
-	env.frame_push("", arg_refs.len);
+	fn default_get(method: Method, _: *const RuntimeRef) RuntimeError!?*RuntimeRef {
+		return method.env.raise(error.TypeMismatch, "object is not index-gettable");
+	}
 
-	defer env.frame_pop();
+	fn default_set(method: Method, _: *const RuntimeRef, _: ?*const RuntimeRef) RuntimeError!void {
+		return method.env.raise(error.TypeMismatch, "object is not index-settable");
+	}
+};
 
-	const dynamic = try env.unbox(callable_ref).expect_dynamic();
+pub fn bind_syscaller(env: *RuntimeEnv, name: []const coral.io.Byte, caller: Caller) RuntimeError!void {
+	const callable = try new_caller(env, caller);
 
-	return dynamic.type_info.call(.{
-		.env = env,
-		.caller = caller_ref,
-		.userdata = dynamic.userdata,
+	defer env.discard(callable);
+
+	try env.bind_system(name, callable);
+}
+
+pub fn new_caller(env: *RuntimeEnv, value: Caller) RuntimeError!*RuntimeRef {
+	const Callable = struct {
+		fn call(method: Typeinfo.Method) RuntimeError!?*RuntimeRef {
+			coral.debug.assert(method.userdata.len == @sizeOf(Caller));
+
+			return @as(*Caller, @ptrCast(@alignCast(method.userdata))).invoke(method.env);
+		}
+	};
+
+	return env.new_dynamic(coral.io.bytes_of(&value).ptr, &.{
+		.name = "<native>",
+		.size = @sizeOf(Caller),
+		.call = Callable.call,
 	});
 }
-
-pub fn get(
-	env: *RuntimeEnv,
-	indexable_ref: ?*const RuntimeRef,
-	index_ref: ?*const RuntimeRef,
-) RuntimeError!?*RuntimeRef {
-	const dynamic = try unbox_dynamic(env, indexable_ref);
-
-	return dynamic.typeinfo.get(.{
-		.userdata = dynamic.userdata,
-		.env = env,
-		.index_ref = index_ref,
-	});
-}
-
-pub fn get_field(
-	env: *RuntimeEnv,
-	indexable_ref: ?*const RuntimeRef,
-	field_name: []const coral.io.Byte,
-) RuntimeError!?*RuntimeRef {
-	const field_name_ref = try env.new_string(field_name);
-
-	defer env.discard(field_name_ref);
-
-	return get(env, indexable_ref, field_name_ref);
-}
-
-pub fn set(
-	env: *RuntimeEnv,
-	indexable_ref: ?*const RuntimeRef,
-	index_ref: ?*const RuntimeRef,
-	value_ref: ?*const RuntimeRef,
-) RuntimeError!void {
-	const dynamic = try unbox_dynamic(env, indexable_ref);
-
-	return dynamic.typeinfo.set(.{
-		.userdata = dynamic.userdata,
-		.env = env,
-		.index_ref = index_ref,
-	}, value_ref);
-}
-
-pub fn set_field(
-	env: *RuntimeEnv,
-	indexable_ref: ?*const RuntimeRef,
-	field_name: []const coral.io.Byte,
-	value_ref: ?*const RuntimeRef,
-) RuntimeError!void {
-	const field_name_ref = try env.new_string(field_name);
-
-	defer env.discard(field_name_ref);
-
-	return set(env, indexable_ref, field_name_ref, value_ref);
-}
-
-pub const new_table = Table.new;
-
-pub fn test_difference(env: *RuntimeEnv, lhs_ref: ?*const RuntimeRef, rhs_ref: ?*const RuntimeRef) RuntimeError!Float {
-	return switch (env.unbox(lhs_ref)) {
-		.nil => env.raise(error.TypeMismatch, "cannot compare nil objects"),
-		.boolean => env.raise(error.TypeMismatch, "cannot compare boolean objects"),
-
-		.number => |lhs_number| switch (env.unbox(rhs_ref)) {
-			.number => |rhs_number| rhs_number - lhs_number,
-			else => env.raise(error.TypeMismatch, "right-hand object is not comparable with number objects"),
-		},
-
-		.string => |lhs_string| switch (env.unbox(rhs_ref)) {
-			.string => |rhs_string| @floatFromInt(coral.io.compare(lhs_string, rhs_string)),
-			else => env.raise(error.TypeMismatch, "right-hand object is not comparable with string objects"),
-		},
-
-		.dynamic => |lhs_dynamic| lhs_dynamic.typeinfo.test_difference(.{
-			.env = env,
-			.userdata = lhs_dynamic.userdata,
-			.other_ref = rhs_ref,
-		}),
-	};
-}
-
-pub fn test_equality(env: *RuntimeEnv, lhs_ref: ?*const RuntimeRef, rhs_ref: ?*const RuntimeRef) RuntimeError!bool {
-	return switch (env.unbox(lhs_ref)) {
-		.nil => (rhs_ref == null),
-
-		.boolean => |lhs_boolean| switch (env.unbox(rhs_ref)) {
-			.boolean => |rhs_boolean| rhs_boolean == lhs_boolean,
-			else => false,
-		},
-
-		.number => |lhs_number| switch (env.unbox(rhs_ref)) {
-			.number => |rhs_number| lhs_number == rhs_number,
-			else => false,
-		},
-
-		.string => |lhs_string| switch (env.unbox(rhs_ref)) {
-			.string => |rhs_string| coral.io.equals(lhs_string, rhs_string),
-			else => false,
-		},
-
-		.dynamic => |lhs_dynamic| try lhs_dynamic.typeinfo.test_equality(.{
-			.env = env,
-			.userdata = lhs_dynamic.userdata,
-			.other_ref = rhs_ref,
-		}),
-	};
-}
-
-pub fn unbox_dynamic(env: *RuntimeEnv, ref: ?*const RuntimeRef) RuntimeError!*DynamicObject {
-	return env.unbox(ref).expect_dynamic() orelse env.raise(error.TypeMismatch, "expected dynamic object");
-}
-
-pub fn unbox_string(env: *RuntimeEnv, ref: ?*const RuntimeRef) RuntimeError![]const coral.io.Byte {
-	return env.unbox(ref).expect_string() orelse env.raise(error.TypeMismatch, "expected string object");
-}
diff --git a/source/ona/kym/Ast.zig b/source/ona/kym/Ast.zig
index 2580606..48f1346 100755
--- a/source/ona/kym/Ast.zig
+++ b/source/ona/kym/Ast.zig
@@ -15,13 +15,22 @@ pub const Expression = union (enum) {
 	false_literal,
 	number_literal: []const coral.io.Byte,
 	string_literal: []const coral.io.Byte,
-	table_literal: NamedList,
+	symbol_literal: []const coral.io.Byte,
+	table_literal: TableLiteral,
 	grouped_expression: *Expression,
-	get_local: []const coral.io.Byte,
+	get_system: []const coral.io.Byte,
+	local_get: []const coral.io.Byte,
+	local_set: []const coral.io.Byte,
 
-	call_system: struct {
+	field_get: struct {
+		object_expression: *Expression,
 		identifier: []const coral.io.Byte,
-		argument_expressions: List,
+	},
+
+	field_set: struct {
+		object_expression: *Expression,
+		identifier: []const coral.io.Byte,
+		value_expression: *Expression,
 	},
 
 	binary_operation: struct {
@@ -35,6 +44,11 @@ pub const Expression = union (enum) {
 		expression: *Expression,
 	},
 
+	invoke: struct {
+		object_expression: *Expression,
+		argument_expressions: List,
+	},
+
 	pub const BinaryOperator = enum {
 		addition,
 		subtraction,
@@ -61,9 +75,9 @@ pub const Expression = union (enum) {
 		}
 	};
 
-	pub const NamedList = coral.list.Stack(struct {
-		identifier: []const coral.io.Byte,
-		expression: Expression,
+	pub const TableLiteral = coral.list.Stack(struct {
+		key_expression: Expression,
+		value_expression: Expression,
 	});
 
 	pub const List = coral.list.Stack(Expression);
@@ -79,18 +93,11 @@ pub const ParseError = error {
 const Self = @This();
 
 pub const Statement = union (enum) {
-	return_expression: Expression,
-	return_nothing,
-
-	set_local: struct {
-		identifier: []const coral.io.Byte,
-		expression: Expression,
+	@"return": struct {
+		expression: ?Expression,
 	},
 
-	call_system: struct {
-		identifier: []const coral.io.Byte,
-		argument_expressions: Expression.List,
-	},
+	expression: Expression,
 
 	const List = coral.list.Stack(Statement);
 };
@@ -112,10 +119,10 @@ fn binary_operation_parser(
 			inline for (operators) |operator| {
 				const token = comptime operator.token();
 
-				if (self.tokenizer.is_token(coral.io.tag_of(token))) {
+				if (self.tokenizer.token == coral.io.tag_of(token)) {
 					self.tokenizer.step();
 
-					if (self.tokenizer.token == null) {
+					if (self.tokenizer.token == .end) {
 						return self.report("expected other half of expression after `" ++ comptime token.text() ++ "`");
 					}
 
@@ -174,112 +181,58 @@ pub fn list_statements(self: Self) []const Statement {
 pub fn parse(self: *Self, data: []const coral.io.Byte) ParseError!void {
 	self.tokenizer = .{.source = data};
 
-	const allocator = self.arena.as_allocator();
 	var has_returned = false;
 
+	self.tokenizer.skip_newlines();
+
 	while (true) {
-		self.tokenizer.skip(.newline);
+		try self.statements.push_one(parse_statement: {
+			switch (self.tokenizer.token) {
+				.end => return,
 
-		switch (self.tokenizer.token orelse return) {
-			.keyword_return => {
-				if (has_returned) {
-					return self.report("multiple returns in function scope but expected only one");
-				}
+				.keyword_return => {
+					if (has_returned) {
+						return self.report("multiple returns in function scope but expected only one");
+					}
 
-				try self.statements.push_one(get_statement: {
 					self.tokenizer.step();
 
-					if (!self.tokenizer.is_token_null_or(.newline)) {
-						break: get_statement .{.return_expression = try self.parse_expression()};
-					}
-
-					if (!self.tokenizer.is_token_null_or(.newline)) {
-						return self.report("unexpected token after return");
-					}
-
-					break: get_statement .return_nothing;
-				});
-
-				has_returned = true;
-			},
-
-			.identifier => |identifier| {
-				self.tokenizer.step();
-
-				const no_effect_message = "statement has no effect";
-
-				switch (self.tokenizer.token orelse return self.report(no_effect_message)) {
-					.newline => return self.report(no_effect_message),
-
-					.symbol_equals => {
-						self.tokenizer.step();
-
-						if (self.tokenizer.token == null) {
-							return self.report("expected expression after `=`");
-						}
-
-						try self.statements.push_one(.{
-							.set_local = .{
+					if (self.tokenizer.token != .end and self.tokenizer.token != .newline) {
+						break: parse_statement .{
+							.@"return" = .{
 								.expression = try self.parse_expression(),
-								.identifier = identifier,
 							},
-						});
+						};
+					}
 
-						if (!self.tokenizer.is_token_null_or(.newline)) {
-							return self.report("unexpected token after assignment");
-						}
-					},
+					if (self.tokenizer.token != .end and self.tokenizer.token != .newline) {
+						return self.report("expected end or newline after return statement");
+					}
 
-					else => return self.report("expected `=` after local"),
-				}
-			},
+					has_returned = true;
 
-			.special_identifier => |identifier| {
-				self.tokenizer.step();
+					break: parse_statement .{
+						.@"return" = .{
+							.expression = null,
+						},
+					};
+				},
 
-				const missing_arguments_message = "system call is missing arguments";
-
-				switch (self.tokenizer.token orelse return self.report(missing_arguments_message)) {
-					.newline => return self.report(missing_arguments_message),
-
-					.symbol_paren_left => {
-						self.tokenizer.step();
-
-						var expressions_list = Expression.List.make(allocator);
-
-						while (true) {
-							if (self.tokenizer.is_token(.symbol_paren_right)) {
-								break;
-							}
-
-							try expressions_list.push_one(try self.parse_expression());
-
-							switch (self.tokenizer.token orelse return self.report("unexpected end after after `(`")) {
-								.symbol_comma => continue,
-								.symbol_paren_right => break,
-								else => return self.report("expected `)` or argument after `(`"),
-							}
-						}
-
-						self.tokenizer.step();
-
-						try self.statements.push_one(.{
-							.call_system = .{
-								.argument_expressions = expressions_list,
-								.identifier = identifier,
-							},
-						});
-					},
-
-					else => return self.report("expected `=` after local"),
-				}
-			},
-
-			else => return self.report("invalid statement"),
-		}
+				else => {
+					break: parse_statement .{
+						.expression = try self.parse_expression()
+					};
+				},
+			}
+		});
 	}
 }
 
+const parse_additive = binary_operation_parser(parse_equality, &.{
+	.addition,
+	.subtraction,
+});
+
 const parse_comparison = binary_operation_parser(parse_term, &.{
 	.greater_than_comparison,
 	.greater_equals_comparison,
@@ -291,192 +244,259 @@ const parse_equality = binary_operation_parser(parse_comparison, &.{
 	.equals_comparison,
 });
 
-const parse_expression = binary_operation_parser(parse_equality, &.{
-	.addition,
-	.subtraction,
-});
+pub fn parse_expression(self: *Self) ParseError!Expression {
+	const allocator = self.arena.as_allocator();
+	const expression = try parse_additive(self);
+
+	if (self.tokenizer.token == .symbol_equals) {
+		self.tokenizer.skip_newlines();
+
+		if (self.tokenizer.token == .end) {
+			return self.report("expected assignment after `=`");
+		}
+
+		return switch (expression) {
+			.local_get => |local_get| .{.local_set = local_get},
+
+			.field_get => |field_get| .{
+				.field_set = .{
+					.object_expression = field_get.object_expression,
+					.identifier = field_get.identifier,
+					.value_expression = try coral.io.allocate_one(allocator, try self.parse_expression()),
+				},
+			},
+
+			else => self.report("expected local or field on left-hand side of expression"),
+		};
+	}
+
+	return expression;
+}
 
 fn parse_factor(self: *Self) ParseError!Expression {
 	const allocator = self.arena.as_allocator();
 
-	switch (self.tokenizer.token orelse return self.report("expected operand after operator")) {
-		.symbol_paren_left => {
-			self.tokenizer.skip(.newline);
+	var expression = @as(Expression, parse: {
+		switch (self.tokenizer.token) {
+			.symbol_paren_left => {
+				self.tokenizer.skip_newlines();
 
-			if (self.tokenizer.token == null) {
-				return self.report("expected an expression after `(`");
-			}
-
-			const expression = try self.parse_expression();
-
-			if (!self.tokenizer.is_token(.symbol_paren_right)) {
-				return self.report("expected a closing `)` after expression");
-			}
-
-			self.tokenizer.step();
-
-			return Expression{.grouped_expression = try coral.io.allocate_one(allocator, expression)};
-		},
-
-		.keyword_nil => {
-			self.tokenizer.step();
-
-			return .nil_literal;
-		},
-
-		.keyword_true => {
-			self.tokenizer.step();
-
-			return .true_literal;
-		},
-
-		.keyword_false => {
-			self.tokenizer.step();
-
-			return .false_literal;
-		},
-
-		.number => |value| {
-			self.tokenizer.step();
-
-			return Expression{.number_literal = value};
-		},
-
-		.string => |value| {
-			self.tokenizer.step();
-
-			return Expression{.string_literal = value};
-		},
-
-		.special_identifier => |identifier| {
-			self.tokenizer.skip(.newline);
-
-			var expression_list = Expression.List.make(allocator);
-
-			while (true) {
-				switch (self.tokenizer.token orelse return self.report("expected expression or `)` after `(`")) {
-					.symbol_paren_right => {
-						self.tokenizer.step();
-
-						return Expression{
-							.call_system = .{
-								.identifier = identifier,
-								.argument_expressions = expression_list,
-							},
-						};
-					},
-
-					else => {
-						try expression_list.push_one(try self.parse_expression());
-
-						switch (self.tokenizer.token orelse return self.report("expected `,` or `)` after argument")) {
-							.symbol_comma => continue,
-
-							.symbol_paren_right => {
-								self.tokenizer.step();
-
-								return Expression{
-									.call_system = .{
-										.identifier = identifier,
-										.argument_expressions = expression_list,
-									},
-								};
-							},
-
-							else => return self.report("expected `,` or `)` after argument"),
-						}
-					},
+				if (self.tokenizer.token == .end) {
+					return self.report("expected an expression after `(`");
 				}
-			}
-		},
 
-		.identifier => |identifier| {
-			self.tokenizer.step();
+				const expression = try self.parse_expression();
 
-			return Expression{.get_local = identifier};
-		},
-
-		.symbol_brace_left => {
-			var table_fields = Expression.NamedList.make(allocator);
-
-			self.tokenizer.skip(.newline);
-
-			while (true) {
-				switch (self.tokenizer.token orelse return self.report("unexpected end of table literal")) {
-					.symbol_brace_right => {
-						self.tokenizer.step();
-
-						return Expression{.table_literal = table_fields};
-					},
-
-					.identifier => |identifier| {
-						self.tokenizer.skip(.newline);
-
-						if (!self.tokenizer.is_token(.symbol_equals)) {
-							return self.report("expected `=` after identifier");
-						}
-
-						self.tokenizer.skip(.newline);
-
-						if (self.tokenizer.token == null) {
-							return self.report("unexpected end after `=`");
-						}
-
-						try table_fields.push_one(.{
-							.expression = try self.parse_expression(),
-							.identifier = identifier,
-						});
-
-						switch (self.tokenizer.token orelse return self.report("unexpected end of table")) {
-							.symbol_comma => self.tokenizer.skip(.newline),
-
-							.symbol_brace_right => {
-								self.tokenizer.step();
-
-								return Expression{.table_literal = table_fields};
-							},
-
-							else => return self.report("expected `,` or `}` after expression"),
-						}
-					},
-
-					else => return self.report("expected `}` or fields in table literal"),
+				if (self.tokenizer.token != .symbol_paren_right) {
+					return self.report("expected a closing `)` after expression");
 				}
-			}
-		},
 
-		.symbol_minus => {
-			self.tokenizer.skip(.newline);
+				self.tokenizer.skip_newlines();
 
-			if (self.tokenizer.token == null) {
-				return self.report("expected expression after numeric negation (`-`)");
-			}
+				break: parse .{.grouped_expression = try coral.io.allocate_one(allocator, expression)};
+			},
 
-			return Expression{
-				.unary_operation = .{
-					.expression = try coral.io.allocate_one(allocator, try self.parse_factor()),
-					.operator = .numeric_negation,
-				},
-			};
-		},
+			.keyword_nil => {
+				self.tokenizer.skip_newlines();
 
-		.symbol_bang => {
-			self.tokenizer.skip(.newline);
+				break: parse .nil_literal;
+			},
 
-			if (self.tokenizer.token == null) {
-				return self.report("expected expression after boolean negation (`!`)");
-			}
+			.keyword_true => {
+				self.tokenizer.skip_newlines();
 
-			return Expression{
-				.unary_operation = .{
-					.expression = try coral.io.allocate_one(allocator, try self.parse_factor()),
-					.operator = .boolean_negation,
-				},
-			};
-		},
+				break: parse .true_literal;
+			},
 
-		else => return self.report("unexpected token in expression"),
+			.keyword_false => {
+				self.tokenizer.skip_newlines();
+
+				break: parse .false_literal;
+			},
+
+			.number => |value| {
+				self.tokenizer.skip_newlines();
+
+				break: parse .{.number_literal = value};
+			},
+
+			.string => |value| {
+				self.tokenizer.skip_newlines();
+
+				break: parse .{.string_literal = value};
+			},
+
+			.identifier => |identifier| {
+				self.tokenizer.skip_newlines();
+
+				break: parse .{.local_get = identifier};
+			},
+
+			.system_identifier => |system_identifier| {
+				self.tokenizer.skip_newlines();
+
+				break: parse .{.get_system = system_identifier};
+			},
+
+			.symbol_brace_left => {
+				var table_literal = Expression.TableLiteral.make(allocator);
+
+				self.tokenizer.skip_newlines();
+
+				while (true) {
+					switch (self.tokenizer.token) {
+						.symbol_brace_right => {
+							self.tokenizer.skip_newlines();
+
+							break: parse .{.table_literal = table_literal};
+						},
+
+						.symbol_bracket_left => {
+							self.tokenizer.skip_newlines();
+
+							if (self.tokenizer.token != .symbol_equals) {
+								return self.report("expected expression after identifier");
+							}
+						},
+
+						.symbol_period => {
+							self.tokenizer.step();
+
+							const identifier = switch (self.tokenizer.token) {
+								.identifier => |identifier| identifier,
+								else => return self.report("expected identifier after `.`"),
+							};
+
+							self.tokenizer.skip_newlines();
+
+							if (self.tokenizer.token != .symbol_equals) {
+								return self.report("expected `=` after key");
+							}
+
+							self.tokenizer.skip_newlines();
+
+							if (self.tokenizer.token == .end) {
+								return self.report("unexpected end after `=`");
+							}
+
+							try table_literal.push_one(.{
+								.value_expression = try self.parse_expression(),
+								.key_expression = .{.symbol_literal = identifier},
+							});
+
+							switch (self.tokenizer.token) {
+								.symbol_comma => self.tokenizer.skip_newlines(),
+
+								.symbol_brace_right => {
+									self.tokenizer.skip_newlines();
+
+									break: parse .{.table_literal = table_literal};
+								},
+
+								else => return self.report("expected `,` or `}` after expression"),
+							}
+						},
+
+						else => return self.report("expected `}` or fields in table literal"),
+					}
+				}
+			},
+
+			.symbol_minus => {
+				self.tokenizer.skip_newlines();
+
+				if (self.tokenizer.token == .end) {
+					return self.report("expected expression after numeric negation (`-`)");
+				}
+
+				break: parse .{
+					.unary_operation = .{
+						.expression = try coral.io.allocate_one(allocator, try self.parse_factor()),
+						.operator = .numeric_negation,
+					},
+				};
+			},
+
+			.symbol_bang => {
+				self.tokenizer.skip_newlines();
+
+				if (self.tokenizer.token == .end) {
+					return self.report("expected expression after boolean negation (`!`)");
+				}
+
+				break: parse .{
+					.unary_operation = .{
+						.expression = try coral.io.allocate_one(allocator, try self.parse_factor()),
+						.operator = .boolean_negation,
+					},
+				};
+			},
+
+			else => return self.report("unexpected token in expression"),
+		}
+	});
+
+	while (true) {
+		switch (self.tokenizer.token) {
+			.symbol_period => {
+				self.tokenizer.skip_newlines();
+
+				// TODO: Remove when Zig fixes miscompilation with in-place struct re-assignment.
+				const unnecessary_temp = try coral.io.allocate_one(allocator, expression);
+
+				expression = .{
+					.field_get = .{
+						.identifier = switch (self.tokenizer.token) {
+							.identifier => |field_identifier| field_identifier,
+							else => return self.report("expected identifier after `.`"),
+						},
+
+						.object_expression = unnecessary_temp,
+					},
+				};
+
+				self.tokenizer.skip_newlines();
+			},
+
+			.symbol_paren_left => {
+				var argument_expressions = Expression.List.make(allocator);
+
+				while (true) {
+					self.tokenizer.skip_newlines();
+
+					switch (self.tokenizer.token) {
+						.symbol_paren_right => break,
+
+						else => {
+							try argument_expressions.push_one(try self.parse_expression());
+
+							switch (self.tokenizer.token) {
+								.symbol_comma => continue,
+								.symbol_paren_right => break,
+								else => return self.report("expected `,` or `)` after function argument expression"),
+							}
+						},
+					}
+				}
+
+				self.tokenizer.skip_newlines();
+
+				// TODO: Remove when Zig fixes miscompilation with in-place struct re-assignment.
+				const unnecessary_temp = try coral.io.allocate_one(allocator, expression);
+
+				expression = .{
+					.invoke = .{
+						.argument_expressions = argument_expressions,
+						.object_expression = unnecessary_temp,
+					},
+				};
+			},
+
+			else => break,
+		}
 	}
+
+	return expression;
 }
 
 const parse_term = binary_operation_parser(parse_factor, &.{
diff --git a/source/ona/kym/Chunk.zig b/source/ona/kym/Chunk.zig
deleted file mode 100644
index c58346f..0000000
--- a/source/ona/kym/Chunk.zig
+++ /dev/null
@@ -1,512 +0,0 @@
-const Ast = @import("./Ast.zig");
-
-const coral = @import("coral");
-
-const kym = @import("../kym.zig");
-
-env: *kym.RuntimeEnv,
-constant_refs: RefList,
-opcodes: OpcodeList,
-
-const AstCompiler = struct {
-	chunk: *Self,
-	local_identifiers_buffer: [255][]const coral.io.Byte = [_][]const coral.io.Byte{""} ** 255,
-	local_identifiers_count: u8 = 0,
-
-	fn compile_expression(self: *AstCompiler, expression: Ast.Expression) kym.RuntimeError!void {
-		const number_format = coral.utf8.DecimalFormat{
-			.delimiter = "_",
-			.positive_prefix = .none,
-		};
-
-		switch (expression) {
-			.nil_literal => try self.chunk.append_opcode(.push_nil),
-			.true_literal => try self.chunk.append_opcode(.push_true),
-			.false_literal => try self.chunk.append_opcode(.push_false),
-
-			.number_literal => |literal| {
-				const parsed_number = number_format.parse(literal, kym.Float);
-
-				coral.debug.assert(parsed_number != null);
-
-				try self.chunk.append_opcode(.{
-					.push_const = try self.chunk.declare_constant_number(parsed_number.?),
-				});
-			},
-
-			.string_literal => |literal| {
-				try self.chunk.append_opcode(.{.push_const = try self.chunk.declare_constant_string(literal)});
-			},
-
-			.table_literal => |fields| {
-				if (fields.values.len > coral.math.max_int(@typeInfo(u32).Int)) {
-					return error.OutOfMemory;
-				}
-
-				for (fields.values) |field| {
-					try self.compile_expression(field.expression);
-
-					try self.chunk.append_opcode(.{
-						.push_const = try self.chunk.declare_constant_string(field.identifier),
-					});
-				}
-
-				try self.chunk.append_opcode(.{.push_table = @intCast(fields.values.len)});
-			},
-
-			.binary_operation => |operation| {
-				try self.compile_expression(operation.lhs_expression.*);
-				try self.compile_expression(operation.rhs_expression.*);
-
-				try self.chunk.append_opcode(switch (operation.operator) {
-					.addition => .add,
-					.subtraction => .sub,
-					.multiplication => .mul,
-					.divsion => .div,
-					.greater_equals_comparison => .eql,
-					.greater_than_comparison => .cgt,
-					.equals_comparison => .cge,
-					.less_than_comparison => .clt,
-					.less_equals_comparison => .cle,
-				});
-			},
-
-			.unary_operation => |operation| {
-				try self.compile_expression(operation.expression.*);
-
-				try self.chunk.append_opcode(switch (operation.operator) {
-					.boolean_negation => .not,
-					.numeric_negation => .neg,
-				});
-			},
-
-			.grouped_expression => |grouped_expression| {
-				try self.compile_expression(grouped_expression.*);
-			},
-
-			.get_local => |local| {
-				try self.chunk.append_opcode(.{
-					.push_local = self.resolve_local(local) orelse return self.chunk.env.raise(error.OutOfMemory, "undefined local"),
-				});
-			},
-
-			.call_system => |call| {
-				if (call.argument_expressions.values.len > coral.math.max_int(@typeInfo(u8).Int)) {
-					return self.chunk.env.raise(error.OutOfMemory, "functions may receive a maximum of 255 locals");
-				}
-
-				for (call.argument_expressions.values) |argument_expression| {
-					try self.compile_expression(argument_expression);
-				}
-
-				try self.chunk.append_opcode(.{.push_const = try self.chunk.declare_constant_string(call.identifier)});
-				try self.chunk.append_opcode(.{.syscall = @intCast(call.argument_expressions.values.len)});
-				try self.chunk.append_opcode(.pop);
-			},
-		}
-	}
-
-	fn compile_statement(self: *AstCompiler, statement: Ast.Statement) kym.RuntimeError!void {
-		switch (statement) {
-			.return_expression => |return_expression| try self.compile_expression(return_expression),
-			.return_nothing => try self.chunk.append_opcode(.push_nil),
-
-			.set_local => |local| {
-				try self.compile_expression(local.expression);
-
-				if (self.resolve_local(local.identifier)) |index| {
-					try self.chunk.append_opcode(.{.set_local = index});
-				} else {
-					try self.declare_local(local.identifier);
-				}
-			},
-
-			.call_system => |call| {
-				if (call.argument_expressions.values.len > coral.math.max_int(@typeInfo(u8).Int)) {
-					return self.chunk.env.raise(error.OutOfMemory, "functions may receive a maximum of 255 locals");
-				}
-
-				for (call.argument_expressions.values) |argument_expression| {
-					try self.compile_expression(argument_expression);
-				}
-
-				try self.chunk.append_opcode(.{.push_const = try self.chunk.declare_constant_string(call.identifier)});
-				try self.chunk.append_opcode(.{.syscall = @intCast(call.argument_expressions.values.len)});
-				try self.chunk.append_opcode(.pop);
-			}
-		}
-	}
-
-	fn declare_local(self: *AstCompiler, identifier: []const u8) kym.RuntimeError!void {
-		if (self.local_identifiers_count == self.local_identifiers_buffer.len) {
-			return self.chunk.env.raise(error.OutOfMemory, "functions may contain a maximum of 255 locals");
-		}
-
-		self.local_identifiers_buffer[self.local_identifiers_count] = identifier;
-		self.local_identifiers_count += 1;
-	}
-
-	fn resolve_local(self: *AstCompiler, local_identifier: []const coral.io.Byte) ?u8 {
-		if (self.local_identifiers_count == 0) {
-			return null;
-		}
-
-		var index = @as(u8, self.local_identifiers_count - 1);
-
-		while (true) : (index -= 1) {
-			if (coral.io.equals(local_identifier, self.local_identifiers_buffer[index])) {
-				return index;
-			}
-
-			if (index == 0) {
-				return null;
-			}
-		}
-	}
-};
-
-pub const Constant = u16;
-
-const RefList = coral.list.Stack(?*kym.RuntimeRef);
-
-const LocalsList = coral.list.Stack([]const u8);
-
-pub const Opcode = union (enum) {
-	pop,
-	push_nil,
-	push_true,
-	push_false,
-	push_const: Constant,
-	push_local: u8,
-	push_table: u32,
-	set_local: u8,
-	call: u8,
-	syscall: u8,
-
-	not,
-	neg,
-
-	add,
-	sub,
-	mul,
-	div,
-
-	eql,
-	cgt,
-	clt,
-	cge,
-	cle,
-};
-
-const OpcodeList = coral.list.Stack(Opcode);
-
-const Self = @This();
-
-pub fn append_opcode(self: *Self, opcode: Opcode) kym.RuntimeError!void {
-	return self.opcodes.push_one(opcode);
-}
-
-pub fn as_caller(self: *Self) kym.Caller {
-	return kym.Caller.bind(Self, self, execute);
-}
-
-pub fn compile_ast(self: *Self, ast: Ast) kym.RuntimeError!void {
-	try self.constant_refs.grow(coral.math.max_int(@typeInfo(u16).Int));
-
-	var compiler = AstCompiler{.chunk = self};
-
-	for (ast.list_statements()) |statement| {
-		try compiler.compile_statement(statement);
-	}
-
-	try self.constant_refs.pack();
-	try self.opcodes.pack();
-}
-
-pub fn declare_constant_number(self: *Self, constant: kym.Float) kym.RuntimeError!Constant {
-	const tail = self.constant_refs.values.len;
-
-	if (tail == coral.math.max_int(@typeInfo(u16).Int)) {
-		return self.env.raise(error.BadSyntax, "functions may contain a maximum of 65,535 constants");
-	}
-
-	const constant_ref = try self.env.new_number(constant);
-
-	errdefer self.env.discard(constant_ref);
-
-	try self.constant_refs.push_one(constant_ref);
-
-	return @intCast(tail);
-}
-
-pub fn declare_constant_string(self: *Self, constant: []const coral.io.Byte) kym.RuntimeError!Constant {
-	const tail = self.constant_refs.values.len;
-
-	if (tail == coral.math.max_int(@typeInfo(u16).Int)) {
-		return self.env.raise(error.BadSyntax, "functions may contain a maximum of 65,535 constants");
-	}
-
-	const constant_ref = try self.env.new_string(constant);
-
-	errdefer self.env.discard(constant_ref);
-
-	try self.constant_refs.push_one(constant_ref);
-
-	return @intCast(tail);
-}
-
-fn execute(self: *Self, env: *kym.RuntimeEnv) kym.RuntimeError!?*kym.RuntimeRef {
-	for (self.opcodes.values) |opcode| {
-		switch (opcode) {
-			.pop => env.discard(try env.pop_local()),
-			.push_nil => try env.push_ref(null),
-			.push_true => try env.push_boolean(true),
-			.push_false => try env.push_boolean(false),
-			.push_const => |constant| try env.push_ref(self.constant_refs.values[constant]),
-
-			.push_table => |field_count| {
-				const table_ref = try kym.new_table(env);
-
-				defer env.discard(table_ref);
-
-				{
-					const dynamic = try kym.unbox_dynamic(env, table_ref);
-					var popped = @as(usize, 0);
-
-					while (popped < field_count) : (popped += 1) {
-						const index_ref = try env.pop_local();
-
-						defer env.discard(index_ref);
-
-						const value_ref = try env.pop_local();
-
-						defer env.discard(value_ref);
-
-						try dynamic.typeinfo.set(.{
-							.userdata = dynamic.userdata,
-							.env = env,
-							.index_ref = index_ref,
-						}, value_ref);
-					}
-				}
-
-				try env.push_ref(table_ref);
-			},
-
-			.push_local => |local| {
-				const ref = try env.get_local(local);
-
-				defer env.discard(ref);
-
-				try env.push_ref(ref);
-			},
-
-			.set_local => |local| {
-				const ref = try env.pop_local();
-
-				defer env.discard(ref);
-
-				try env.set_local(local, ref);
-			},
-
-			.call => |arg_count| {
-				const result_ref = call: {
-					const callable_ref = try env.pop_local();
-
-					defer env.discard(callable_ref);
-
-					break: call try env.call("", arg_count, (try kym.unbox_dynamic(env, callable_ref)).as_caller());
-				};
-
-				defer env.discard(result_ref);
-
-				try env.push_ref(result_ref);
-			},
-
-			.syscall => |arg_count| {
-				const result_ref = call: {
-					const identifier_ref = try env.pop_local();
-
-					defer env.discard(identifier_ref);
-
-					const identifier = try kym.unbox_string(env, identifier_ref);
-
-					break: call try env.call(identifier, arg_count, try env.syscaller(identifier));
-				};
-
-				defer env.discard(result_ref);
-
-				try env.push_ref(result_ref);
-			},
-
-			.neg => try env.push_number(switch (env.unbox(try env.pop_local())) {
-				.number => |number| -number,
-				else => return env.raise(error.TypeMismatch, "object is not scalar negatable"),
-			}),
-
-			.not => try env.push_boolean(switch (env.unbox(try env.pop_local())) {
-				.boolean => |boolean| !boolean,
-				else => return env.raise(error.TypeMismatch, "object is not boolean negatable"),
-			}),
-
-			.add => {
-				const rhs_ref = try env.pop_local();
-
-				defer env.discard(rhs_ref);
-
-				const lhs_ref = try env.pop_local();
-
-				defer env.discard(lhs_ref);
-
-				try env.push_ref(try switch (env.unbox(lhs_ref)) {
-					.number => |lhs_number| switch (env.unbox(rhs_ref)) {
-						.number => |rhs_number| env.new_number(lhs_number + rhs_number),
-						else => return env.raise(error.TypeMismatch, "right-hand object is not addable"),
-					},
-
-					else => return env.raise(error.TypeMismatch, "left-hand object is not addable"),
-				});
-			},
-
-			.sub => {
-				const rhs_ref = try env.pop_local();
-
-				defer env.discard(rhs_ref);
-
-				const lhs_ref = try env.pop_local();
-
-				defer env.discard(lhs_ref);
-
-				try env.push_ref(try switch (env.unbox(lhs_ref)) {
-					.number => |lhs_number| switch (env.unbox(rhs_ref)) {
-						.number => |rhs_number| env.new_number(lhs_number - rhs_number),
-						else => return env.raise(error.TypeMismatch, "right-hand object is not subtractable"),
-					},
-
-					else => return env.raise(error.TypeMismatch, "left-hand object is not subtractable"),
-				});
-			},
-
-			.mul => {
-				const rhs_ref = try env.pop_local();
-
-				defer env.discard(rhs_ref);
-
-				const lhs_ref = try env.pop_local();
-
-				defer env.discard(lhs_ref);
-
-				try env.push_ref(try switch (env.unbox(lhs_ref)) {
-					.number => |lhs_number| switch (env.unbox(rhs_ref)) {
-						.number => |rhs_number| env.new_number(lhs_number * rhs_number),
-						else => return env.raise(error.TypeMismatch, "right-hand object is not multiplyable"),
-					},
-
-					else => return env.raise(error.TypeMismatch, "left-hand object is not multiplyable"),
-				});
-			},
-
-			.div => {
-				const rhs_ref = try env.pop_local();
-
-				defer env.discard(rhs_ref);
-
-				const lhs_ref = try env.pop_local();
-
-				defer env.discard(lhs_ref);
-
-				try env.push_ref(try switch (env.unbox(lhs_ref)) {
-					.number => |lhs_number| switch (env.unbox(rhs_ref)) {
-						.number => |rhs_number| env.new_number(lhs_number / rhs_number),
-						else => return env.raise(error.TypeMismatch, "right-hand object is not divisable"),
-					},
-
-					else => return env.raise(error.TypeMismatch, "left-hand object is not divisable"),
-				});
-			},
-
-			.eql => {
-				const rhs_ref = try env.pop_local();
-
-				defer env.discard(rhs_ref);
-
-				const lhs_ref = try env.pop_local();
-
-				defer env.discard(lhs_ref);
-
-				try env.push_boolean(try kym.test_equality(env, lhs_ref, rhs_ref));
-			},
-
-			.cgt => {
-				const rhs_ref = try env.pop_local();
-
-				defer env.discard(rhs_ref);
-
-				const lhs_ref = try env.pop_local();
-
-				defer env.discard(lhs_ref);
-
-				try env.push_boolean(try kym.test_difference(env, lhs_ref, rhs_ref) > 0);
-			},
-
-			.clt => {
-				const rhs_ref = try env.pop_local();
-
-				defer env.discard(rhs_ref);
-
-				const lhs_ref = try env.pop_local();
-
-				defer env.discard(lhs_ref);
-
-				try env.push_boolean(try kym.test_difference(env, lhs_ref, rhs_ref) < 0);
-			},
-
-			.cge => {
-				const rhs_ref = try env.pop_local();
-
-				defer env.discard(rhs_ref);
-
-				const lhs_ref = try env.pop_local();
-
-				defer env.discard(lhs_ref);
-
-				try env.push_boolean(try kym.test_difference(env, lhs_ref, rhs_ref) >= 0);
-			},
-
-			.cle => {
-				const rhs_ref = try env.pop_local();
-
-				defer env.discard(rhs_ref);
-
-				const lhs_ref = try env.pop_local();
-
-				defer env.discard(lhs_ref);
-
-				try env.push_boolean(try kym.test_difference(env, lhs_ref, rhs_ref) <= 0);
-			},
-		}
-	}
-
-	return env.pop_local();
-}
-
-pub fn free(self: *Self) void {
-	for (self.constant_refs.values) |constant| {
-		self.env.discard(constant);
-	}
-
-	self.opcodes.free();
-	self.constant_refs.free();
-}
-
-fn is_zero(utf8: []const u8) bool {
-	return coral.io.equals(utf8, "0") or coral.io.equals(utf8, "0.0");
-}
-
-pub fn make(env: *kym.RuntimeEnv) Self {
-	return Self{
-		.opcodes = OpcodeList.make(env.allocator),
-		.constant_refs = RefList.make(env.allocator),
-		.env = env,
-	};
-}
diff --git a/source/ona/kym/Table.zig b/source/ona/kym/Table.zig
deleted file mode 100644
index 11506ed..0000000
--- a/source/ona/kym/Table.zig
+++ /dev/null
@@ -1,91 +0,0 @@
-const coral = @import("coral");
-
-const kym = @import("../kym.zig");
-
-fields: FieldTable,
-
-const FieldTable = coral.map.StringTable(struct {
-	key_ref: ?*kym.RuntimeRef,
-	value_ref: ?*kym.RuntimeRef,
-});
-
-const Self = @This();
-
-pub fn new(env: *kym.RuntimeEnv) kym.RuntimeError!?*kym.RuntimeRef {
-	var self = Self{
-		.fields = FieldTable.make(env.allocator),
-	};
-
-	errdefer {
-		self.fields.free();
-	}
-
-	return try env.new_dynamic(coral.io.bytes_of(&self), &typeinfo);
-}
-
-const typeinfo = kym.Typeinfo{
-	.name = "table",
-	.clean = typeinfo_clean,
-	.get = typeinfo_get,
-	.set = typeinfo_set,
-};
-
-fn typeinfo_clean(env: *kym.RuntimeEnv, userdata: []coral.io.Byte) void {
-	const table = @as(*Self, @ptrCast(@alignCast(userdata.ptr)));
-
-	{
-		var field_iterable = table.fields.as_iterable();
-
-		while (field_iterable.next()) |entry| {
-			env.discard(entry.value.key_ref);
-			env.discard(entry.value.value_ref);
-		}
-	}
-
-	table.fields.free();
-}
-
-fn typeinfo_get(context: kym.IndexContext) kym.RuntimeError!?*kym.RuntimeRef {
-	const table = @as(*Self, @ptrCast(@alignCast(context.userdata.ptr)));
-
-	return switch (context.env.unbox(context.index_ref)) {
-		.string => |string| context.env.acquire((table.fields.lookup(string) orelse return null).value_ref),
-		// TODO: Implement number indices in tables.
-		.number => |_| unreachable,
-		else => context.env.raise(error.TypeMismatch, "table objects may only be indexed with strings or numbers"),
-	};
-}
-
-fn typeinfo_set(context: kym.IndexContext, value_ref: ?*const kym.RuntimeRef) kym.RuntimeError!void {
-	const table = @as(*Self, @ptrCast(@alignCast(context.userdata.ptr)));
-	const acquired_value_ref = context.env.acquire(value_ref);
-
-	errdefer context.env.discard(acquired_value_ref);
-
-	switch (context.env.unbox(context.index_ref)) {
-		.string => |string| {
-			const acquired_index_ref = context.env.acquire(context.index_ref);
-
-			errdefer context.env.discard(acquired_index_ref);
-
-			var displaced_table_entry = if (acquired_value_ref) |ref| try table.fields.replace(string, .{
-				.key_ref = acquired_index_ref,
-				.value_ref = ref,
-			}) else table.fields.remove(string);
-
-			if (displaced_table_entry) |*entry| {
-				context.env.discard(entry.value.key_ref);
-				context.env.discard(entry.value.value_ref);
-			}
-		},
-
-		.number => |_| {
-			// TODO: Implement number indices in tables.
-			unreachable;
-		},
-
-		else => {
-			return context.env.raise(error.TypeMismatch, "table objects may only be indexed with strings or numbers");
-		},
-	}
-}
diff --git a/source/ona/kym/tokens.zig b/source/ona/kym/tokens.zig
index 76fac23..bc916d4 100755
--- a/source/ona/kym/tokens.zig
+++ b/source/ona/kym/tokens.zig
@@ -1,10 +1,11 @@
 const coral = @import("coral");
 
 pub const Token = union(enum) {
+	end,
 	unknown: coral.io.Byte,
 	newline,
 
-	special_identifier: []const coral.io.Byte,
+	system_identifier: []const coral.io.Byte,
 	identifier: []const coral.io.Byte,
 
 	symbol_plus,
@@ -41,10 +42,11 @@ pub const Token = union(enum) {
 
 	pub fn text(self: Token) []const coral.io.Byte {
 		return switch (self) {
+			.end => "end",
 			.unknown => |unknown| @as([*]const coral.io.Byte, @ptrCast(&unknown))[0 .. 1],
 			.newline => "newline",
 
-			.special_identifier => |identifier| identifier,
+			.system_identifier => |identifier| identifier,
 			.identifier => |identifier| identifier,
 
 			.symbol_plus => "+",
@@ -85,26 +87,12 @@ pub const Token = union(enum) {
 pub const Tokenizer = struct {
 	source: []const coral.io.Byte,
 	lines_stepped: usize = 1,
-	token: ?Token = null,
+	token: Token = .end,
 
-	const TokenTag = coral.io.Tag(Token);
-
-	pub fn is_token(self: *Tokenizer, token_tag: TokenTag) bool {
-		return if (self.token) |token| token == token_tag else false;
-	}
-
-	pub fn is_token_null_or(self: *Tokenizer, token_tag: TokenTag) bool {
-		return if (self.token) |token| token == token_tag else true;
-	}
-
-	pub fn skip(self: *Tokenizer, skip_token_tag: TokenTag) void {
+	pub fn skip_newlines(self: *Tokenizer) void {
 		self.step();
 
-		while (self.token) |token| {
-			if (token != skip_token_tag) {
-				return;
-			}
-
+		while (self.token == .newline) {
 			self.step();
 		}
 	}
@@ -236,7 +224,7 @@ pub const Tokenizer = struct {
 								else => break,
 							};
 
-							self.token = .{.special_identifier = self.source[begin .. cursor]};
+							self.token = .{.system_identifier = self.source[begin .. cursor]};
 
 							return;
 						},
@@ -253,7 +241,7 @@ pub const Tokenizer = struct {
 								else => cursor += 1,
 							};
 
-							self.token = .{.special_identifier = self.source[begin .. cursor]};
+							self.token = .{.system_identifier = self.source[begin .. cursor]};
 							cursor += 1;
 
 							return;
@@ -429,7 +417,7 @@ pub const Tokenizer = struct {
 			}
 		}
 
-		self.token = null;
+		self.token = .end;
 
 		return;
 	}
diff --git a/source/ona/ona.zig b/source/ona/ona.zig
index 35a0445..ee81b03 100644
--- a/source/ona/ona.zig
+++ b/source/ona/ona.zig
@@ -27,19 +27,31 @@ fn kym_handle_errors(info: kym.ErrorInfo) void {
 }
 
 fn kym_log_info(env: *kym.RuntimeEnv) kym.RuntimeError!?*kym.RuntimeRef {
-	app.log_info(try kym.unbox_string(env, try env.view_arg(0)));
+	const argument = try env.expect(try env.arg(0));
+
+	defer env.discard(argument);
+
+	app.log_info(try env.unbox_string(argument));
 
 	return null;
 }
 
 fn kym_log_warn(env: *kym.RuntimeEnv) kym.RuntimeError!?*kym.RuntimeRef {
-	app.log_warn(try kym.unbox_string(env, try env.view_arg(0)));
+	const argument = try env.expect(try env.arg(0));
+
+	defer env.discard(argument);
+
+	app.log_warn(try env.unbox_string(argument));
 
 	return null;
 }
 
 fn kym_log_fail(env: *kym.RuntimeEnv) kym.RuntimeError!?*kym.RuntimeRef {
-	app.log_fail(try kym.unbox_string(env, try env.view_arg(0)));
+	const argument = try env.expect(try env.arg(0));
+
+	defer env.discard(argument);
+
+	app.log_fail(try env.unbox_string(argument));
 
 	return null;
 }
@@ -63,21 +75,16 @@ pub fn run_app(file_access: file.Access) void {
 
 	defer script_env.free();
 
-	script_env.bind_syscalls(&.{
-		.{
-			.name = "log_info",
-			.caller = kym.Caller.from(kym_log_info),
-		},
-		.{
-			.name = "log_warn",
-			.caller = kym.Caller.from(kym_log_warn),
-		},
-		.{
-			.name = "log_fail",
-			.caller = kym.Caller.from(kym_log_fail),
-		},
-	}) catch {
-		return app.log_fail("failed to bind syscalls to script runtime");
+	kym.bind_syscaller(&script_env, "log_info", kym.Caller.from(kym_log_info)) catch {
+		return app.log_fail("failed to bind `log_info` syscall");
+	};
+
+	kym.bind_syscaller(&script_env, "log_warn", kym.Caller.from(kym_log_warn)) catch {
+		return app.log_fail("failed to bind `log_warn` syscall");
+	};
+
+	kym.bind_syscaller(&script_env, "log_fail", kym.Caller.from(kym_log_fail)) catch {
+		return app.log_fail("failed to bind `log_fail` syscall");
 	};
 
 	var manifest = app.Manifest{};