diff --git a/debug/app.ona b/debug/app.ona
index 19d8065..1cdb540 100644
--- a/debug/app.ona
+++ b/debug/app.ona
@@ -1,17 +1,13 @@
 
 # Test comment.
 
-test = {
-	.message = "don't you lecture me with your 30 dollar scripting language"
-}
-
-test.message = "game is loading"
-
-@log_info(test.message)
-
-return {
+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 8da89fe..39025ee 100644
--- a/source/coral/io.zig
+++ b/source/coral/io.zig
@@ -255,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;
 
@@ -330,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/map.zig b/source/coral/map.zig
index 81c11d4..30a8bdb 100644
--- a/source/coral/map.zig
+++ b/source/coral/map.zig
@@ -6,112 +6,15 @@ 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,
-		});
-
-		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,
-			};
-		}
-
-		pub fn free(self: *Self) void {
-			self.entries.free();
-
-			self.next_index = 0;
-		}
-
-		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, struct {
 		const Self = @This();
 
-		fn equals(_: Self, key_a: []const io.Byte, key_b: []const io.Byte) bool {
+		fn equals(key_a: []const io.Byte, key_b: []const io.Byte) bool {
 			return io.equals(key_a, key_b);
 		}
 
-		fn hash(_: Self, key: []const io.Byte) usize {
+		fn hash(key: []const io.Byte) usize {
 			return io.djb2_hash(@typeInfo(usize).Int, key);
 		}
 	});
@@ -119,9 +22,7 @@ pub fn StringTable(comptime Value: type) 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,
@@ -135,7 +36,7 @@ pub fn Table(comptime Key: type, comptime Value: type, comptime Traits: type) ty
 
 			fn write_into(self: Entry, table: *Self) bool {
 				const hash_max = @min(max_int, table.entries.len);
-				var hashed_key = math.wrap(table.traits.hash(self.key), min_int, hash_max);
+				var hashed_key = table.hash_key(self.key) % hash_max;
 				var iterations = @as(usize, 0);
 
 				while (true) : (iterations += 1) {
@@ -152,7 +53,7 @@ pub fn Table(comptime Key: type, comptime Value: type, comptime Traits: type) ty
 						return true;
 					});
 
-					if (table.traits.equals(table_entry.key, self.key)) {
+					if (table.keys_equal(table_entry.key, self.key)) {
 						return false;
 					}
 
@@ -187,14 +88,18 @@ pub fn Table(comptime Key: type, comptime Value: type, comptime Traits: type) ty
 			};
 		}
 
+		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(self.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 (self.traits.equals(entry.key, key)) {
+				if (self.keys_equal(entry.key, key)) {
 					const original_entry = entry.*;
 
 					self.entries[hashed_key] = null;
@@ -213,7 +118,8 @@ pub fn Table(comptime Key: type, comptime Value: type, comptime Traits: type) ty
 
 			{
 				const hash_max = @min(max_int, self.entries.len);
-				var hashed_key = math.wrap(self.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 {
@@ -227,15 +133,28 @@ pub fn Table(comptime Key: type, comptime Value: type, comptime Traits: type) ty
 						return null;
 					});
 
-					if (self.traits.equals(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;
@@ -279,20 +198,35 @@ pub fn Table(comptime Key: type, comptime Value: type, comptime Traits: type) ty
 			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 {
 			if (self.count == 0) {
 				return null;
 			}
 
 			const hash_max = @min(max_int, self.entries.len);
-			var hashed_key = math.wrap(self.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 (self.traits.equals(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;
diff --git a/source/coral/math.zig b/source/coral/math.zig
index 3f0de17..360da13 100644
--- a/source/coral/math.zig
+++ b/source/coral/math.zig
@@ -60,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/ona/app.zig b/source/ona/app.zig
index a7d49ba..81d51f5 100644
--- a/source/ona/app.zig
+++ b/source/ona/app.zig
@@ -13,20 +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"})) orelse return;
+		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 (ref) |live_ref| {
-				if (env.unbox(live_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);
 				}
 			}
 
@@ -34,15 +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 (ref) |live_ref| {
-				if (env.unbox(live_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);
 				}
 			}
 
@@ -50,38 +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 (ref) |live_ref| {
-				if (env.unbox(live_ref).expect_number()) |number| {
-					break: get @floatCast(number);
-				}
+				break: get @floatCast(try env.unbox_float(ref));
 			}
 
 			break: get self.tick_rate;
 		});
 
-		{
-			const ref = try kym.get_field(env, manifest_ref, "title");
-
+		if (try env.get_field(manifest, "title")) |ref| {
 			defer env.discard(ref);
 
-			const title_string = unbox: {
-				if (ref) |live_ref| {
-					if (env.unbox(live_ref).expect_string()) |string| {
-						break: unbox string;
-					}
-				}
-
-				break: unbox "";
-			};
-
+			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/kym.zig b/source/ona/kym.zig
index 42758c9..1b424e4 100644
--- a/source/ona/kym.zig
+++ b/source/ona/kym.zig
@@ -1,59 +1,13 @@
 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) {
-	boolean: bool,
-	fixed: Fixed,
-	float: Float,
-	string: []const coral.io.Byte,
-	symbol: []const coral.io.Byte,
-	lambda,
-	dynamic: *const DynamicObject,
-
-	pub fn expect_dynamic(self: Any) ?*const DynamicObject {
-		return switch (self) {
-			.dynamic => |dynamic| dynamic,
-			else => null,
-		};
-	}
-
-	pub fn expect_number(self: Any) ?Float {
-		return switch (self) {
-			.fixed => |fixed| @floatFromInt(fixed),
-			.float => |float| float,
-			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,
-
-	fn call(self: *DynamicObject, env: *RuntimeEnv) RuntimeError!?*RuntimeRef {
-		return self.typeinfo.call(.{
-			.env = env,
-			.userdata = self.userdata,
-		});
-	}
-};
-
 pub const ErrorHandler = coral.io.Generator(void, ErrorInfo);
 
 pub const ErrorInfo = struct {
@@ -71,176 +25,890 @@ pub const Frame = struct {
 	locals_top: usize,
 };
 
-pub const Method = struct {
-	env: *RuntimeEnv,
-	userdata: []coral.io.Byte,
-};
-
 pub const RuntimeEnv = struct {
-	interned_symbols: RefTable,
+	interned_symbols: SymbolSet,
 	allocator: coral.io.Allocator,
 	error_handler: ErrorHandler,
 	syscallables: RefTable,
-	local_refs: RefStack,
+	locals: RefList,
 	frames: FrameStack,
-	ref_values: RefSlab,
 
-	const FrameStack = coral.list.Stack(Frame);
+	const Chunk = struct {
+		env: *RuntimeEnv,
+		name: []coral.io.Byte,
+		opcodes: OpcodeList,
+		constants: ConstList,
 
-	const RefStack = coral.list.Stack(?*RuntimeRef);
-
-	const RefTable = coral.map.StringTable(*RuntimeRef);
-
-	const RefSlab = coral.map.Slab(struct {
-		ref_count: usize,
-
-		object: union (enum) {
-			false,
-			true,
-			float: Float,
+		const Constant = union (enum) {
 			fixed: Fixed,
-			string: []coral.io.Byte,
-			symbol: []coral.io.Byte,
-			lambda: Caller,
-			dynamic: *DynamicObject,
-		},
-	});
+			float: Float,
+			string: []const coral.io.Byte,
+			symbol: []const coral.io.Byte,
+		};
 
-	pub fn acquire(self: *RuntimeEnv, ref: *const RuntimeRef) *RuntimeRef {
-		const key = @intFromPtr(ref);
-		var ref_data = self.ref_values.remove(key);
+		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,
 
-		coral.debug.assert(ref_data != null);
+			not,
+			neg,
 
-		ref_data.?.ref_count += 1;
+			add,
+			sub,
+			mul,
+			div,
 
-		coral.debug.assert(self.ref_values.insert_at(key, ref_data.?));
+			eql,
+			cgt,
+			clt,
+			cge,
+			cle,
+		};
 
-		return @ptrFromInt(key);
-	}
+		const OpcodeList = coral.list.Stack(Opcode);
 
-	pub fn call(
-		self: *RuntimeEnv,
-		callable_ref: *const RuntimeRef,
-		arg_count: u8,
-		name: []const coral.io.Byte,
-	) RuntimeError!?*RuntimeRef {
-		try self.frames.push_one(.{
-			.name = name,
-			.arg_count = arg_count,
-			.locals_top = self.local_refs.values.len,
-		});
+		const CompilationUnit = struct {
+			local_identifiers_buffer: [255][]const coral.io.Byte = [_][]const coral.io.Byte{""} ** 255,
+			local_identifiers_count: u8 = 0,
 
-		defer {
-			const frame = self.frames.pop() orelse unreachable;
+			fn compile_expression(self: *CompilationUnit, chunk: *Chunk, expression: Ast.Expression) RuntimeError!void {
+				const number_format = coral.utf8.DecimalFormat{
+					.delimiter = "_",
+					.positive_prefix = .none,
+				};
 
-			{
-				var pops_remaining = (self.local_refs.values.len - frame.locals_top) + frame.arg_count;
+				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),
 
-				while (pops_remaining != 0) : (pops_remaining -= 1) {
-					self.discard(self.local_refs.pop() orelse unreachable);
+					.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);
+			}
 		}
 
-		return switch ((self.ref_values.lookup(@intFromPtr(callable_ref)) orelse unreachable).object) {
-			.lambda => |lambda| lambda.invoke(self),
+		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.syscallables.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 => {
+						const result = call: {
+							const callable = try self.env.expect(try self.pop_local());
+
+							defer self.env.discard(callable);
+
+							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"),
+							};
+						};
+
+						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 RefList = coral.list.Stack(?*RuntimeRef);
+
+	const RefTable = coral.map.Table(*RuntimeRef, *RuntimeRef, struct {
+		pub const hash = RuntimeRef.hash;
+
+		pub const equals = RuntimeRef.equals;
+	});
+
+	const SymbolSet = coral.map.StringTable([:0]coral.io.Byte);
+
+	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 arg(self: *RuntimeEnv, index: usize) RuntimeError!?*RuntimeRef {
+		const frame = self.frames.peek() orelse return self.raise(error.IllegalState, "stack underflow");
+
+		if (index < frame.arg_count) {
+			if (self.locals.values[frame.locals_top - (1 + index)]) |local| {
+				return self.acquire(local);
+			}
+		}
+
+		return null;
+	}
+
+	pub fn bind_syscaller(_: *RuntimeEnv, comptime _: []const coral.io.Byte, _: Caller) RuntimeError!void {
+
+	}
+
+	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,
-				.userdata = dynamic.userdata,
 			}),
 
 			else => self.raise(error.TypeMismatch, "object is not callable"),
 		};
 	}
 
-	pub fn bind_syscaller(self: *RuntimeEnv, comptime name: []const coral.io.Byte, caller: Caller) RuntimeError!void {
-		const lambda_ref = try self.new_lambda(caller);
+	pub fn discard(self: *RuntimeEnv, value: *RuntimeRef) void {
+		var object = value.object();
 
-		if (try self.syscallables.replace(name, self.acquire(lambda_ref))) |replaced_entry| {
-			self.discard(replaced_entry.value);
-		}
-	}
+		coral.debug.assert(object.ref_count != 0);
 
-	pub fn discard(self: *RuntimeEnv, ref: ?*RuntimeRef) void {
-		const key = @intFromPtr(ref orelse return);
-		var ref_data = self.ref_values.remove(key) orelse unreachable;
+		object.ref_count -= 1;
 
-		coral.debug.assert(ref_data.ref_count != 0);
+		if (object.ref_count == 0) {
+			switch (object.payload) {
+				.false, .true, .float, .fixed, .symbol => {},
 
-		ref_data.ref_count -= 1;
-
-		if (ref_data.ref_count == 0) {
-			switch (ref_data.object) {
-				.false, .true, .float, .fixed, .lambda => {},
-				.string => |string| self.allocator.deallocate(string),
-				.symbol => |symbol| self.allocator.deallocate(symbol),
+				.string => |string| {
+					coral.debug.assert(string.len >= 0);
+					self.allocator.deallocate(string.ptr[0 .. @intCast(string.len)]);
+				},
 
 				.dynamic => |dynamic| {
-					dynamic.typeinfo.clean(.{
-						.env = self,
-						.userdata = dynamic.userdata,
-					});
+					if (dynamic.typeinfo().destruct) |destruct| {
+						destruct(.{
+							.userdata = dynamic.userdata(),
+							.env = self,
+						});
+					}
 
-					self.allocator.deallocate(dynamic.userdata);
-					self.allocator.deallocate(dynamic);
+					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);
 
-		const chunk_ref = try self.new_lambda(chunk.as_caller());
+		return chunk.execute();
+	}
 
-		defer self.discard(chunk_ref);
-
-		return self.call(chunk_ref, 0, name);
+	pub fn expect(self: *RuntimeEnv, value: ?*RuntimeRef) RuntimeError!*RuntimeRef {
+		return value orelse self.raise(error.TypeMismatch, "nil reference");
 	}
 
 	pub fn free(self: *RuntimeEnv) void {
-		while (self.local_refs.pop()) |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.discard(entry.value);
+				self.allocator.deallocate(entry.value);
 			}
 		}
 
@@ -253,161 +921,118 @@ pub const RuntimeEnv = struct {
 		}
 
 		self.frames.free();
-		self.local_refs.free();
+		self.locals.free();
 		self.syscallables.free();
-		self.ref_values.free();
 		self.interned_symbols.free();
 	}
 
-	pub fn get_dynamic(
-		self: *RuntimeEnv,
-		indexable: *const DynamicObject,
-		index_ref: *const RuntimeRef,
-	) RuntimeError!?*RuntimeRef {
-		return indexable.typeinfo.get(.{
-			.env = self,
-			.userdata = indexable.userdata,
-		}, index_ref);
+	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),
+
+			else => self.raise(error.TypeMismatch, "object is not get-indexable"),
+		};
 	}
 
-	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_field(self: *RuntimeEnv, indexable: *RuntimeRef, field: []const coral.io.Byte) RuntimeError!?*RuntimeRef {
+		const field_symbol = try self.new_symbol(field);
 
-		return self.acquire(self.local_refs.values[local] orelse return null);
-	}
+		defer self.discard(field_symbol);
 
-	pub fn get_syscallable(self: *RuntimeEnv, name: []const coral.io.Byte) ?*RuntimeRef {
-		if (self.syscallables.lookup(name)) |system_ref| {
-			return self.acquire(system_ref);
-		}
-
-		return null;
-	}
-
-	pub fn pop_local(self: *RuntimeEnv) RuntimeError!?*RuntimeRef {
-		return self.local_refs.pop() orelse self.raise(error.IllegalState, "stack underflow");
-	}
-
-	pub fn push_boolean(self: *RuntimeEnv, boolean: bool) RuntimeError!void {
-		return self.local_refs.push_one(try self.new_boolean(boolean));
-	}
-
-	pub fn push_fixed(self: *RuntimeEnv, fixed: Fixed) RuntimeError!void {
-		return self.local_refs.push_one(try self.new_fixed(fixed));
-	}
-
-	pub fn push_float(self: *RuntimeEnv, float: Float) RuntimeError!void {
-		return self.local_refs.push_one(try self.new_float(float));
-	}
-
-	pub fn push_ref(self: *RuntimeEnv, ref: ?*RuntimeRef) RuntimeError!void {
-		return self.local_refs.push_one(if (ref) |live_ref| self.acquire(live_ref) else null);
-	}
-
-	pub fn set_local(self: *RuntimeEnv, local: u8, ref: ?*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] = if (ref) |live_ref| self.acquire(live_ref) else null;
+		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),
 			.syscallables = RefTable.make(allocator, .{}),
-			.interned_symbols = 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(.{
+		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,
-		typeinfo: *const Typeinfo,
-	) RuntimeError!*RuntimeRef {
-		const userdata_copy = try coral.io.allocate_copy(self.allocator, userdata);
+	pub fn new_dynamic(self: *RuntimeEnv, typeinfo: *const Typeinfo) RuntimeError!*RuntimeRef {
+		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.zero(dynamic[@sizeOf(usize) ..]);
 
-		errdefer self.allocator.deallocate(dynamic_object);
-
-		return @ptrFromInt(try self.ref_values.insert(.{
+		return RuntimeRef.allocate(self.allocator, .{
 			.ref_count = 1,
-			.object = .{.dynamic = dynamic_object},
-		}));
+			.payload = .{.dynamic = .{.ptr = dynamic.ptr}},
+		});
 	}
 
 	pub fn new_fixed(self: *RuntimeEnv, value: Fixed) RuntimeError!*RuntimeRef {
-		return @ptrFromInt(try self.ref_values.insert(.{
+		return RuntimeRef.allocate(self.allocator, .{
 			.ref_count = 1,
-			.object = .{.fixed = value},
-		}));
+			.payload = .{.fixed = value},
+		});
 	}
 
 	pub fn new_float(self: *RuntimeEnv, value: Float) RuntimeError!*RuntimeRef {
-		return @ptrFromInt(try self.ref_values.insert(.{
+		return RuntimeRef.allocate(self.allocator, .{
 			.ref_count = 1,
-			.object = .{.float = value},
-		}));
+			.payload = .{.float = value},
+		});
 	}
 
-	pub fn new_lambda(self: *RuntimeEnv, caller: Caller) RuntimeError!*RuntimeRef {
-		return @ptrFromInt(try self.ref_values.insert(.{
-			.ref_count = 1,
-			.object = .{.lambda = caller},
-		}));
-	}
-
-	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(.{
-			.ref_count = 1,
-			.object = .{.string = string_copy},
-		}));
-	}
-
-	pub fn new_symbol(self: *RuntimeEnv, symbol_data: []const coral.io.Byte) RuntimeError!*RuntimeRef {
-		if (self.interned_symbols.lookup(symbol_data)) |symbol_ref| {
-			return self.acquire(symbol_ref);
-		} else {
-			const symbol_copy = try coral.io.allocate_copy(self.allocator, symbol_data);
-
-			const symbol_ref = @as(*RuntimeRef, new: {
-				errdefer self.allocator.deallocate(symbol_copy);
-
-				break: new @ptrFromInt(try self.ref_values.insert(.{
-					.ref_count = 1,
-					.object = .{.symbol = symbol_copy},
-				}));
-			});
-
-			errdefer self.discard(symbol_ref);
-
-			coral.debug.assert(try self.interned_symbols.insert(symbol_copy, symbol_ref));
-
-			return self.acquire(symbol_ref);
+	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 {
+		// TODO: Unroll this call logic into the environment.
+		return Table.new(self);
 	}
 
 	pub fn raise(self: *RuntimeEnv, error_value: RuntimeError, message: []const coral.io.Byte) RuntimeError {
@@ -419,39 +1044,53 @@ pub const RuntimeEnv = struct {
 		return error_value;
 	}
 
-	pub fn set_dynamic(
-		self: *RuntimeEnv,
-		indexable: *const DynamicObject,
-		index_ref: *const RuntimeRef,
-		value_ref: ?*const RuntimeRef,
-	) RuntimeError!void {
-		return indexable.typeinfo.set(.{
-			.env = self,
-			.userdata = indexable.userdata,
-		}, index_ref, value_ref);
-	}
+	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),
 
-	pub fn unbox(self: *RuntimeEnv, ref: *const RuntimeRef) Any {
-		return switch ((self.ref_values.lookup(@intFromPtr(ref)) orelse unreachable).object) {
-			.false => .{.boolean = false},
-			.true => .{.boolean = true},
-			.fixed => |fixed| .{.fixed = fixed},
-			.float => |float| .{.float = float},
-			.string => |string| .{.string = string},
-			.symbol => |symbol| .{.symbol = symbol},
-			.lambda => .lambda,
-			.dynamic => |dynamic| .{.dynamic = dynamic},
+			else => self.raise(error.TypeMismatch, "object is not set-indexable"),
 		};
 	}
 
-	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_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")
+		};
+	}
 
-		if (index >= frame.arg_count) {
-			return null;
-		}
+	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")
+		};
+	}
 
-		return self.local_refs.values[frame.locals_top - (1 + index)];
+	pub fn unbox_fixed(env: *RuntimeEnv, value: *const RuntimeRef) RuntimeError!Fixed {
+		return value.is_fixed() orelse env.raise(error.TypeMismatch, "expected fixed object");
+	}
+
+	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")
+		};
 	}
 };
 
@@ -462,132 +1101,154 @@ pub const RuntimeError = coral.io.AllocationError || error {
 	BadSyntax,
 };
 
-pub const RuntimeRef = opaque {};
+pub const RuntimeRef = opaque {
+	const Object = struct {
+		ref_count: u16,
+
+		payload: union (enum) {
+			false,
+			true,
+			float: Float,
+			fixed: Fixed,
+			symbol: [*:0]const coral.io.Byte,
+
+			string: struct {
+				ptr: [*]coral.io.Byte,
+				len: Fixed,
+
+				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 object(self: *const RuntimeRef) *Object {
+		return @constCast(@ptrCast(@alignCast(self)));
+	}
+
+	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,
+			},
+		};
+	}
+
+	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),
+		};
+	}
+
+	pub fn is_fixed(self: *const RuntimeRef) ?Fixed {
+		return switch (self.object().payload) {
+			.fixed => |fixed| @intCast(@as(u32, @bitCast(fixed))),
+			else => null,
+		};
+	}
+
+	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 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,
-	clean: *const fn (method: Method) void = default_clean,
 	get: *const fn (method: Method, index: *const RuntimeRef) RuntimeError!?*RuntimeRef = default_get,
-	set: *const fn (method: Method, index: *const RuntimeRef, value: ?*const RuntimeRef) RuntimeError!void = default_set,
+	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");
 	}
 
-	fn default_clean(_: Method) void {
-		// Nothing to clean by default.
-	}
-
 	fn default_get(method: Method, _: *const RuntimeRef) RuntimeError!?*RuntimeRef {
-		return method.env.raise(error.TypeMismatch, "object is not indexable");
+		return method.env.raise(error.TypeMismatch, "object is not index-gettable");
 	}
 
 	fn default_set(method: Method, _: *const RuntimeRef, _: ?*const RuntimeRef) RuntimeError!void {
-		return method.env.raise(error.TypeMismatch, "object is not indexable");
+		return method.env.raise(error.TypeMismatch, "object is not index-settable");
 	}
 };
-
-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_symbol(field_name);
-
-	defer env.discard(field_name_ref);
-
-	return env.get_dynamic(try unbox_dynamic(env, indexable_ref), field_name_ref);
-}
-
-pub fn hash(env: *RuntimeEnv, ref: *const RuntimeRef) usize {
-	return switch (env.unbox(ref)) {
-		.boolean => 0,
-		.float => 0,
-		.fixed => 0,
-		.string => |string| coral.io.djb2_hash(@typeInfo(usize).Int, string),
-		.symbol => 0,
-		.lambda => 0,
-		.dynamic => 0,
-	};
-}
-
-pub const new_table = Table.new;
-
-pub fn test_difference(
-	env: *RuntimeEnv,
-	lhs_comparable_ref: *const RuntimeRef,
-	rhs_comparable_ref: *const RuntimeRef,
-) RuntimeError!Float {
-	return switch (env.unbox(lhs_comparable_ref)) {
-		.boolean => env.raise(error.TypeMismatch, "boolean objects are not comparable"),
-
-		.fixed => |lhs_fixed| switch (env.unbox(rhs_comparable_ref)) {
-			.fixed => |rhs_fixed| @as(Float, @floatFromInt(rhs_fixed)) - @as(Float, @floatFromInt(lhs_fixed)),
-			else => env.raise(error.TypeMismatch, "right-hand object is not comparable with fixed objects"),
-		},
-
-		.float => |lhs_float| switch (env.unbox(rhs_comparable_ref)) {
-			.float => |rhs_float| rhs_float - lhs_float,
-			else => env.raise(error.TypeMismatch, "right-hand object is not comparable with float objects"),
-		},
-
-		.string => |lhs_string| switch (env.unbox(rhs_comparable_ref)) {
-			.string => |rhs_string| @floatFromInt(coral.io.compare(lhs_string, rhs_string)),
-			.symbol => |rhs_symbol| @floatFromInt(coral.io.compare(lhs_string, rhs_symbol)),
-			else => env.raise(error.TypeMismatch, "right-hand object is not comparable with string objects"),
-		},
-
-		.symbol => |lhs_symbol| switch (env.unbox(rhs_comparable_ref)) {
-			.symbol => env.raise(error.TypeMismatch, "cannot compare symbol objects"),
-			.string => |rhs_string| @floatFromInt(coral.io.compare(lhs_symbol, rhs_string)),
-			else => env.raise(error.TypeMismatch, "right-hand object is not comparable with symbol objects"),
-		},
-
-		.lambda => env.raise(error.TypeMismatch, "lambda objects are not comparable"),
-		.dynamic => env.raise(error.TypeMismatch, "dynamic objects are not comparable"),
-	};
-}
-
-pub fn test_equality(env: *RuntimeEnv, lhs_ref: *const RuntimeRef, rhs_ref: *const RuntimeRef) bool {
-	return switch (env.unbox(lhs_ref)) {
-		.boolean => |lhs_boolean| switch (env.unbox(rhs_ref)) {
-			.boolean => |rhs_boolean| rhs_boolean == lhs_boolean,
-			else => false,
-		},
-
-		.fixed => |lhs_fixed| switch (env.unbox(rhs_ref)) {
-			.fixed => |rhs_fixed| rhs_fixed == lhs_fixed,
-			.float => |rhs_float| rhs_float == @as(Float, @floatFromInt(lhs_fixed)),
-			else => false,
-		},
-
-		.float => |lhs_float| switch (env.unbox(rhs_ref)) {
-			.float => |rhs_float| rhs_float == lhs_float,
-			.fixed => |rhs_fixed| @as(Float, @floatFromInt(rhs_fixed)) == lhs_float,
-			else => false,
-		},
-
-		.string => |lhs_string| switch (env.unbox(rhs_ref)) {
-			.string => |rhs_string| coral.io.equals(lhs_string, rhs_string),
-			.symbol => |rhs_symbol| coral.io.equals(lhs_string, rhs_symbol),
-			else => false,
-		},
-
-		.symbol => |lhs_symbol| switch (env.unbox(rhs_ref)) {
-			.symbol => |rhs_symbol| lhs_symbol.ptr == rhs_symbol.ptr,
-			.string => |rhs_string| coral.io.equals(lhs_symbol, rhs_string),
-			else => false,
-		},
-
-		else => lhs_ref == rhs_ref,
-	};
-}
-
-pub fn unbox_dynamic(env: *RuntimeEnv, ref: *const RuntimeRef) RuntimeError!*const 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 2815216..48f1346 100755
--- a/source/ona/kym/Ast.zig
+++ b/source/ona/kym/Ast.zig
@@ -19,15 +19,15 @@ pub const Expression = union (enum) {
 	table_literal: TableLiteral,
 	grouped_expression: *Expression,
 	get_system: []const coral.io.Byte,
-	get_local: []const coral.io.Byte,
-	set_local: []const coral.io.Byte,
+	local_get: []const coral.io.Byte,
+	local_set: []const coral.io.Byte,
 
-	get_field: struct {
+	field_get: struct {
 		object_expression: *Expression,
 		identifier: []const coral.io.Byte,
 	},
 
-	set_field: struct {
+	field_set: struct {
 		object_expression: *Expression,
 		identifier: []const coral.io.Byte,
 		value_expression: *Expression,
@@ -44,7 +44,7 @@ pub const Expression = union (enum) {
 		expression: *Expression,
 	},
 
-	call: struct {
+	invoke: struct {
 		object_expression: *Expression,
 		argument_expressions: List,
 	},
@@ -256,12 +256,12 @@ pub fn parse_expression(self: *Self) ParseError!Expression {
 		}
 
 		return switch (expression) {
-			.get_local => |get_local| .{.set_local = get_local},
+			.local_get => |local_get| .{.local_set = local_get},
 
-			.get_field => |get_field| .{
-				.set_field = .{
-					.object_expression = get_field.object_expression,
-					.identifier = get_field.identifier,
+			.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()),
 				},
 			},
@@ -329,7 +329,7 @@ fn parse_factor(self: *Self) ParseError!Expression {
 			.identifier => |identifier| {
 				self.tokenizer.skip_newlines();
 
-				break: parse .{.get_local = identifier};
+				break: parse .{.local_get = identifier};
 			},
 
 			.system_identifier => |system_identifier| {
@@ -445,7 +445,7 @@ fn parse_factor(self: *Self) ParseError!Expression {
 				const unnecessary_temp = try coral.io.allocate_one(allocator, expression);
 
 				expression = .{
-					.get_field = .{
+					.field_get = .{
 						.identifier = switch (self.tokenizer.token) {
 							.identifier => |field_identifier| field_identifier,
 							else => return self.report("expected identifier after `.`"),
@@ -485,7 +485,7 @@ fn parse_factor(self: *Self) ParseError!Expression {
 				const unnecessary_temp = try coral.io.allocate_one(allocator, expression);
 
 				expression = .{
-					.call = .{
+					.invoke = .{
 						.argument_expressions = argument_expressions,
 						.object_expression = unnecessary_temp,
 					},
diff --git a/source/ona/kym/Chunk.zig b/source/ona/kym/Chunk.zig
deleted file mode 100644
index 899075b..0000000
--- a/source/ona/kym/Chunk.zig
+++ /dev/null
@@ -1,663 +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| {
-				for (literal) |codepoint| {
-					if (codepoint == '.') {
-						const parsed = number_format.parse(literal, kym.Float);
-
-						coral.debug.assert(parsed != null);
-
-						try self.chunk.append_opcode(.{
-							.push_const = try self.chunk.declare_constant_float(parsed.?),
-						});
-
-						return;
-					}
-				}
-
-				const parsed = number_format.parse(literal, kym.Fixed);
-
-				coral.debug.assert(parsed != null);
-
-				try self.chunk.append_opcode(.{
-					.push_const = try self.chunk.declare_constant_fixed(parsed.?),
-				});
-			},
-
-			.string_literal => |literal| {
-				try self.chunk.append_opcode(.{.push_const = try self.chunk.declare_constant_string(literal)});
-			},
-
-			.symbol_literal => |literal| {
-				try self.chunk.append_opcode(.{.push_const = try self.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(field.value_expression);
-					try self.compile_expression(field.key_expression);
-				}
-
-				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,
-				});
-			},
-
-			.call => |call| {
-				if (call.argument_expressions.values.len > coral.math.max_int(@typeInfo(u8).Int)) {
-					return self.chunk.env.raise(error.BadSyntax, "lambdas may contain a maximum of 255 arguments");
-				}
-
-				for (call.argument_expressions.values) |argument_expression| {
-					try self.compile_expression(argument_expression);
-				}
-
-				try self.compile_expression(call.object_expression.*);
-				try self.chunk.append_opcode(.{.call = @intCast(call.argument_expressions.values.len)});
-			},
-
-			.grouped_expression => |grouped_expression| {
-				try self.compile_expression(grouped_expression.*);
-			},
-
-			.get_system => |get_system| {
-				try self.chunk.append_opcode(.{.push_system = try self.chunk.declare_constant_string(get_system)});
-			},
-
-			.get_local => |get_local| {
-				try self.chunk.append_opcode(.{
-					.push_local = self.resolve_local(get_local) orelse {
-						return self.chunk.env.raise(error.OutOfMemory, "undefined local");
-					},
-				});
-			},
-
-			.set_local => |set_local| {
-				if (self.resolve_local(set_local)) |index| {
-					try self.chunk.append_opcode(.{.set_local = index});
-				} else {
-					try self.declare_local(set_local);
-				}
-			},
-
-			.get_field => |get_field| {
-				try self.compile_expression(get_field.object_expression.*);
-
-				try self.chunk.append_opcode(.{
-					.push_const = try self.chunk.declare_constant_symbol(get_field.identifier),
-				});
-
-				try self.chunk.append_opcode(.get_dynamic);
-			},
-
-			.set_field => |set_field| {
-				try self.compile_expression(set_field.object_expression.*);
-
-				try self.chunk.append_opcode(.{
-					.push_const = try self.chunk.declare_constant_symbol(set_field.identifier),
-				});
-
-				try self.compile_expression(set_field.value_expression.*);
-				try self.chunk.append_opcode(.set_dynamic);
-			},
-		}
-	}
-
-	fn compile_statement(self: *AstCompiler, statement: Ast.Statement) kym.RuntimeError!void {
-		switch (statement) {
-			.@"return" => |@"return"| {
-				if (@"return".expression) |expression| {
-					try self.compile_expression(expression);
-				} else {
-					try self.chunk.append_opcode(.push_nil);
-				}
-			},
-
-			.expression => |expression| try self.compile_expression(expression),
-		}
-	}
-
-	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, "lambdas 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;
-			}
-		}
-	}
-};
-
-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: u16,
-	push_local: u8,
-	push_table: u32,
-	push_system: u16,
-	set_local: u8,
-	get_dynamic,
-	set_dynamic,
-	call: 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_fixed(self: *Self, constant: kym.Fixed) kym.RuntimeError!u16 {
-	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_fixed(constant);
-
-	errdefer self.env.discard(constant_ref);
-
-	try self.constant_refs.push_one(constant_ref);
-
-	return @intCast(tail);
-}
-
-pub fn declare_constant_float(self: *Self, constant: kym.Float) kym.RuntimeError!u16 {
-	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_float(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!u16 {
-	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);
-}
-
-pub fn declare_constant_symbol(self: *Self, constant: []const coral.io.Byte) kym.RuntimeError!u16 {
-	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_symbol(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() orelse {
-							return env.raise(error.TypeMismatch, "nil is not a valid index");
-						};
-
-						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, value_ref);
-					}
-				}
-
-				try env.push_ref(table_ref);
-			},
-
-			.push_system => |push_system| {
-				const system_ref = self.env.get_syscallable(try kym.unbox_string(
-					self.env,
-					self.constant_refs.values[push_system],
-				));
-
-				defer self.env.discard(system_ref);
-
-				try self.env.push_ref(system_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);
-			},
-
-			.get_dynamic => {
-				const index_ref = try env.pop_local() orelse {
-					return env.raise(error.TypeMismatch, "nil is not a valid index");
-				};
-
-				defer env.discard(index_ref);
-
-				const indexable_ref = try env.pop_local() orelse {
-					return env.raise(error.TypeMismatch, "nil is not a valid indexable");
-				};
-
-				defer env.discard(indexable_ref);
-
-				const value_ref = try env.get_dynamic(try kym.unbox_dynamic(env, indexable_ref), index_ref);
-
-				defer env.discard(value_ref);
-
-				try env.push_ref(value_ref);
-			},
-
-			.set_dynamic => {
-				const value_ref = try env.pop_local();
-
-				defer env.discard(value_ref);
-
-				const index_ref = try env.pop_local() orelse {
-					return env.raise(error.TypeMismatch, "nil is not a valid index");
-				};
-
-				defer env.discard(index_ref);
-
-				const indexable_ref = try env.pop_local() orelse {
-					return env.raise(error.TypeMismatch, "nil is not a valid indexable");
-				};
-
-				defer env.discard(indexable_ref);
-
-				try env.set_dynamic(try kym.unbox_dynamic(env, indexable_ref), index_ref, value_ref);
-			},
-
-			.call => |arg_count| {
-				const result_ref = call: {
-					const callable_ref = try env.pop_local() orelse {
-						return env.raise(error.TypeMismatch, "nil is not callable");
-					};
-
-					defer env.discard(callable_ref);
-
-					break: call try env.call(callable_ref, arg_count, "");
-				};
-
-				defer env.discard(result_ref);
-
-				try env.push_ref(result_ref);
-			},
-
-			.neg => {
-				const ref = (try env.pop_local()) orelse {
-					return env.raise(error.TypeMismatch, "null is not scalar negatable");
-				};
-
-				defer env.discard(ref);
-
-				switch (env.unbox(ref)) {
-					.fixed => |fixed| try env.push_fixed(-fixed),
-					.float => |float| try env.push_float(-float),
-					else => return env.raise(error.TypeMismatch, "object is not scalar negatable"),
-				}
-			},
-
-			.not => {
-				const ref = (try env.pop_local()) orelse {
-					return env.raise(error.TypeMismatch, "null is not boolean negatable");
-				};
-
-				defer env.discard(ref);
-
-				try env.push_boolean(switch (env.unbox(ref)) {
-					.boolean => |boolean| !boolean,
-					else => return env.raise(error.TypeMismatch, "object is not boolean negatable"),
-				});
-			},
-
-			.add => {
-				const rhs_ref = (try env.pop_local()) orelse {
-					return env.raise(error.TypeMismatch, "nil is not addable");
-				};
-
-				defer env.discard(rhs_ref);
-
-				const lhs_ref = (try env.pop_local()) orelse {
-					return env.raise(error.TypeMismatch, "nil is not addable");
-				};
-
-				defer env.discard(lhs_ref);
-
-				try switch (env.unbox(lhs_ref)) {
-					.float => |lhs_float| switch (env.unbox(rhs_ref)) {
-						.float => |rhs_float| env.push_float(lhs_float + rhs_float),
-						else => env.raise(error.TypeMismatch, "right-hand object is not addable"),
-					},
-
-					else => env.raise(error.TypeMismatch, "left-hand object is not addable"),
-				};
-			},
-
-			.sub => {
-				const rhs_ref = (try env.pop_local()) orelse {
-					return env.raise(error.TypeMismatch, "nil is not subtractable");
-				};
-
-				defer env.discard(rhs_ref);
-
-				const lhs_ref = (try env.pop_local()) orelse {
-					return env.raise(error.TypeMismatch, "nil is not subtractable");
-				};
-
-				defer env.discard(lhs_ref);
-
-				try switch (env.unbox(lhs_ref)) {
-					.float => |lhs_float| switch (env.unbox(rhs_ref)) {
-						.float => |rhs_float| env.push_float(lhs_float - rhs_float),
-						else => env.raise(error.TypeMismatch, "right-hand object is not subtractable"),
-					},
-
-					else => env.raise(error.TypeMismatch, "left-hand object is not subtractable"),
-				};
-			},
-
-			.mul => {
-				const rhs_ref = (try env.pop_local()) orelse {
-					return env.raise(error.TypeMismatch, "nil is not multiplicable");
-				};
-
-				defer env.discard(rhs_ref);
-
-				const lhs_ref = (try env.pop_local()) orelse {
-					return env.raise(error.TypeMismatch, "nil is not multiplicable");
-				};
-
-				defer env.discard(lhs_ref);
-
-				try switch (env.unbox(lhs_ref)) {
-					.float => |lhs_float| switch (env.unbox(rhs_ref)) {
-						.float => |rhs_float| env.push_float(lhs_float * rhs_float),
-						else => env.raise(error.TypeMismatch, "right-hand object is not multipliable"),
-					},
-
-					else => env.raise(error.TypeMismatch, "left-hand object is not multipliable"),
-				};
-			},
-
-			.div => {
-				const rhs_ref = (try env.pop_local()) orelse {
-					return env.raise(error.TypeMismatch, "nil is not divisible");
-				};
-
-				defer env.discard(rhs_ref);
-
-				const lhs_ref = (try env.pop_local()) orelse {
-					return env.raise(error.TypeMismatch, "nil is not divisible");
-				};
-
-				defer env.discard(lhs_ref);
-
-				try switch (env.unbox(lhs_ref)) {
-					.float => |lhs_float| switch (env.unbox(rhs_ref)) {
-						.float => |rhs_float| env.push_float(lhs_float / rhs_float),
-						else => env.raise(error.TypeMismatch, "right-hand object is not divisible"),
-					},
-
-					else => env.raise(error.TypeMismatch, "left-hand object is not divisible"),
-				};
-			},
-
-			.eql => {
-				const rhs_ref = try env.pop_local() orelse {
-					return env.raise(error.TypeMismatch, "nil is not equatable");
-				};
-
-				defer env.discard(rhs_ref);
-
-				const lhs_ref = try env.pop_local() orelse {
-					return env.raise(error.TypeMismatch, "nil is not equatable");
-				};
-
-				defer env.discard(lhs_ref);
-
-				try env.push_boolean(kym.test_equality(env, lhs_ref, rhs_ref));
-			},
-
-			.cgt => {
-				const rhs_ref = try env.pop_local() orelse {
-					return env.raise(error.TypeMismatch, "nil is not comparable");
-				};
-
-				defer env.discard(rhs_ref);
-
-				const lhs_ref = try env.pop_local() orelse {
-					return env.raise(error.TypeMismatch, "nil is not comparable");
-				};
-
-				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() orelse {
-					return env.raise(error.TypeMismatch, "nil is not comparable");
-				};
-
-				defer env.discard(rhs_ref);
-
-				const lhs_ref = try env.pop_local() orelse {
-					return env.raise(error.TypeMismatch, "nil is not comparable");
-				};
-
-				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() orelse {
-					return env.raise(error.TypeMismatch, "nil is not comparable");
-				};
-
-				defer env.discard(rhs_ref);
-
-				const lhs_ref = try env.pop_local() orelse {
-					return env.raise(error.TypeMismatch, "nil is not comparable");
-				};
-
-				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() orelse {
-					return env.raise(error.TypeMismatch, "nil is not comparable");
-				};
-
-				defer env.discard(rhs_ref);
-
-				const lhs_ref = try env.pop_local() orelse {
-					return env.raise(error.TypeMismatch, "nil is not comparable");
-				};
-
-				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();
-}
-
-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
index 28ab78b..c2d54e4 100644
--- a/source/ona/kym/Table.zig
+++ b/source/ona/kym/Table.zig
@@ -6,14 +6,12 @@ associative: AssociativeTable,
 contiguous: ContiguousList,
 
 const AssociativeTable = coral.map.Table(*kym.RuntimeRef, *kym.RuntimeRef, struct {
-	env: *kym.RuntimeEnv,
-
-	pub fn hash(self: @This(), key_ref: *kym.RuntimeRef) usize {
-		return kym.hash(self.env, key_ref);
+	pub fn hash(key: *kym.RuntimeRef) usize {
+		return key.hash();
 	}
 
-	pub fn equals(self: @This(), key_ref_a: *kym.RuntimeRef, key_ref_b: *kym.RuntimeRef) bool {
-		return kym.test_equality(self.env, key_ref_a, key_ref_b);
+	pub fn equals(key_a: *kym.RuntimeRef, key_b: *kym.RuntimeRef) bool {
+		return key_a.equals(key_b);
 	}
 });
 
@@ -23,10 +21,7 @@ const Self = @This();
 
 pub fn new(env: *kym.RuntimeEnv) kym.RuntimeError!*kym.RuntimeRef {
 	var self = Self{
-		.associative = AssociativeTable.make(env.allocator, .{
-			.env = env,
-		}),
-
+		.associative = AssociativeTable.make(env.allocator, .{}),
 		.contiguous = ContiguousList.make(env.allocator),
 	};
 
@@ -35,17 +30,20 @@ pub fn new(env: *kym.RuntimeEnv) kym.RuntimeError!*kym.RuntimeRef {
 		self.contiguous.free();
 	}
 
-	return try env.new_dynamic(coral.io.bytes_of(&self), &typeinfo);
+	const table = try env.new_dynamic(&.{
+		.name = "table",
+		.size = @sizeOf(Self),
+		.destruct = typeinfo_destruct,
+		.get = typeinfo_get,
+		.set = typeinfo_set,
+	});
+
+	coral.io.copy(env.unbox_dynamic(table) catch unreachable, coral.io.bytes_of(&self));
+
+	return table;
 }
 
-const typeinfo = kym.Typeinfo{
-	.name = "table",
-	.clean = typeinfo_clean,
-	.get = typeinfo_get,
-	.set = typeinfo_set,
-};
-
-fn typeinfo_clean(method: kym.Method) void {
+fn typeinfo_destruct(method: kym.Typeinfo.Method) void {
 	const table = @as(*Self, @ptrCast(@alignCast(method.userdata.ptr)));
 
 	{
@@ -59,125 +57,77 @@ fn typeinfo_clean(method: kym.Method) void {
 
 	table.associative.free();
 
-	while (table.contiguous.pop()) |ref| {
-		method.env.discard(ref);
+	while (table.contiguous.pop()) |value| {
+		if (value) |ref| {
+			method.env.discard(ref);
+		}
 	}
 
 	table.contiguous.free();
 }
 
-fn typeinfo_get(method: kym.Method, index_ref: *const kym.RuntimeRef) kym.RuntimeError!?*kym.RuntimeRef {
+fn typeinfo_get(method: kym.Typeinfo.Method, index: *const kym.RuntimeRef) kym.RuntimeError!?*kym.RuntimeRef {
 	const table = @as(*Self, @ptrCast(@alignCast(method.userdata.ptr)));
+	const acquired_index = try method.env.acquire(index);
 
-	switch (method.env.unbox(index_ref)) {
-		.symbol, .string, .float => {
-			const mutable_index_ref = method.env.acquire(index_ref);
+	defer method.env.discard(acquired_index);
 
-			defer method.env.discard(mutable_index_ref);
+	if (acquired_index.is_fixed()) |fixed| {
+		if (fixed < 0) {
+			// TODO: Negative indexing.
+			unreachable;
+		}
 
-			if (table.associative.lookup(mutable_index_ref)) |value_ref| {
-				return method.env.acquire(value_ref);
-			}
-		},
+		if (fixed < table.contiguous.values.len) {
+			return method.env.acquire(table.contiguous.values[@intCast(fixed)] orelse return null);
+		}
+	}
 
-		.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);
-			}
-
-			const mutable_index_ref = method.env.acquire(index_ref);
-
-			defer method.env.discard(mutable_index_ref);
-
-			if (table.associative.lookup(mutable_index_ref)) |value_ref| {
-				return method.env.acquire(value_ref);
-			}
-		},
-
-		else => return method.env.raise(error.TypeMismatch, "expected symbol, string, or number index"),
+	if (table.associative.lookup(acquired_index)) |value_ref| {
+		return method.env.acquire(value_ref);
 	}
 
 	return null;
 }
 
-fn typeinfo_set(method: kym.Method, index_ref: *const kym.RuntimeRef, value_ref: ?*const kym.RuntimeRef) kym.RuntimeError!void {
+fn typeinfo_set(method: kym.Typeinfo.Method, index: *const kym.RuntimeRef, value: ?*const kym.RuntimeRef) kym.RuntimeError!void {
 	const table = @as(*Self, @ptrCast(@alignCast(method.userdata.ptr)));
+	const acquired_index = try method.env.acquire(index);
 
-	switch (method.env.unbox(index_ref)) {
-		.symbol, .string, .float => {
-			const acquired_index_ref = method.env.acquire(index_ref);
+	errdefer method.env.discard(acquired_index);
 
-			errdefer method.env.discard(acquired_index_ref);
+	if (acquired_index.is_fixed()) |fixed| {
+		if (fixed < 0) {
+			// TODO: Negative indexing.
+			unreachable;
+		}
 
-			if (value_ref) |ref| {
-				const acquired_ref = method.env.acquire(ref);
+		if (fixed < table.contiguous.values.len) {
+			const maybe_replacing = &table.contiguous.values[@intCast(fixed)];
 
-				errdefer method.env.discard(acquired_ref);
-
-				if (try table.associative.replace(acquired_index_ref, acquired_ref)) |replaced| {
-					method.env.discard(replaced.key);
-					method.env.discard(replaced.value);
-				}
-			} else if (table.associative.remove(acquired_index_ref)) |removed| {
-				method.env.discard(removed.key);
-				method.env.discard(removed.value);
-			}
-		},
-
-		.fixed => |fixed| {
-			if (fixed < 0) {
-				// TODO: Negative indexing.
-				unreachable;
+			if (maybe_replacing.*) |replacing| {
+				method.env.discard(replacing);
 			}
 
-			if (fixed < table.contiguous.values.len) {
-				const contiguous_value = &table.contiguous.values[@intCast(fixed)];
+			maybe_replacing.* = if (value) |ref| try method.env.acquire(ref) else null;
 
-				method.env.discard(contiguous_value.*);
+			return;
+		}
+	}
 
-				contiguous_value.* = if (value_ref) |ref| method.env.acquire(ref) else null;
+	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;
-			}
+		return;
+	});
 
-			if (fixed == table.contiguous.values.len) {
-				if (value_ref) |ref| {
-					const acquired_ref = method.env.acquire(ref);
+	errdefer method.env.discard(acquired_value);
 
-					errdefer method.env.discard(acquired_ref);
-
-					try table.contiguous.push_one(acquired_ref);
-				} else {
-					try table.contiguous.push_one(null);
-				}
-
-				return;
-			}
-
-			const acquired_index_ref = method.env.acquire(index_ref);
-
-			errdefer method.env.discard(acquired_index_ref);
-
-			if (value_ref) |ref| {
-				const acquired_ref = method.env.acquire(ref);
-
-				errdefer method.env.discard(acquired_ref);
-
-				if (try table.associative.replace(acquired_index_ref, acquired_ref)) |replaced| {
-					method.env.discard(replaced.key);
-					method.env.discard(replaced.value);
-				}
-			} else if (table.associative.remove(acquired_index_ref)) |removed| {
-				method.env.discard(removed.key);
-				method.env.discard(removed.value);
-			}
-		},
-
-		else => return method.env.raise(error.TypeMismatch, "expected symbol, string, or number index"),
+	if (try table.associative.replace(acquired_index, acquired_value)) |replaced| {
+		method.env.discard(replaced.key);
+		method.env.discard(replaced.value);
 	}
 }
diff --git a/source/ona/ona.zig b/source/ona/ona.zig
index 212ef85..28807b4 100644
--- a/source/ona/ona.zig
+++ b/source/ona/ona.zig
@@ -27,25 +27,31 @@ fn kym_handle_errors(info: kym.ErrorInfo) void {
 }
 
 fn kym_log_info(env: *kym.RuntimeEnv) kym.RuntimeError!?*kym.RuntimeRef {
-	if (try env.view_arg(0)) |arg| {
-		app.log_info(try kym.unbox_string(env, arg));
-	}
+	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 {
-	if (try env.view_arg(0)) |arg| {
-		app.log_warn(try kym.unbox_string(env, arg));
-	}
+	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 {
-	if (try env.view_arg(0)) |arg| {
-		app.log_fail(try kym.unbox_string(env, arg));
-	}
+	const argument = try env.expect(try env.arg(0));
+
+	defer env.discard(argument);
+
+	app.log_fail(try env.unbox_string(argument));
 
 	return null;
 }