diff --git a/src/lang.zig b/src/lang.zig
index c45aff8..1a747b9 100644
--- a/src/lang.zig
+++ b/src/lang.zig
@@ -116,7 +116,7 @@ pub const NewCommand = struct {
         };
     }
 
-    pub fn cast(base: *const @This(), comptime T: type) ?*const T {
+    pub fn cast(base: *@This(), comptime T: type) ?*T {
         if (base.tag != T.base_tag)
             return null;
 
@@ -124,7 +124,7 @@ pub const NewCommand = struct {
     }
 
     pub fn print(base: *const @This()) void {
-        std.debug.warn("tag: {}\n", .{base.tag});
+        std.debug.warn("{}\n", .{base.tag});
     }
 
     pub const Noop = struct {
@@ -268,7 +268,7 @@ pub const Command = struct {
     }
 };
 
-pub const CommandList = std.ArrayList(*NewCommand);
+pub const CommandList = std.ArrayList(NewCommand);
 pub const ArgList = std.ArrayList([]const u8);
 
 pub const KeywordMap = std.StringHashMap(CommandType);
@@ -413,24 +413,21 @@ pub const Lang = struct {
                 usize => try std.fmt.parseInt(usize, arg, 10),
                 i32 => try std.fmt.parseInt(i32, arg, 10),
                 f32 => try std.fmt.parseFloat(f32, arg),
-                []const u8 => try self.allocator.dupe(u8, arg),
+                []const u8 => arg,
                 else => @panic("Invalid parameter type (" ++ @typeName(cmd_field.field_type) ++ ") left on command struct " ++ @typeName(command_struct) ++ "."),
             };
 
-            std.debug.warn("parsing {}, arg of type {} => {}\n", .{ @typeName(command_struct), @typeName(@TypeOf(argument_value)), argument_value });
-
             @field(cmd, cmd_field.name) = argument_value;
         }
 
         cmd.base.tag = command_struct.base_tag;
-        const command = cmd.base.cast(command_struct).?;
-        std.debug.warn("cmd: {}\n", .{command});
 
-        try commands.append(&cmd.base);
+        try commands.append(cmd.base);
     }
 
     pub fn parse(self: *Lang, data: []const u8) !CommandList {
         var splitted_it = std.mem.split(data, ";");
+        // try self.fillKeywords();
         var cmds = CommandList.init(self.allocator);
 
         while (splitted_it.next()) |stmt_orig| {
diff --git a/src/runner.zig b/src/runner.zig
index a27c945..eacc3c7 100644
--- a/src/runner.zig
+++ b/src/runner.zig
@@ -374,24 +374,7 @@ pub const Runner = struct {
         try image.runPlugin("http://calf.sourceforge.net/plugins/VintageDelay", pos, params);
     }
 
-    fn newRunCommandSingle(
-        self: *@This(),
-        cmd: lang.NewCommand,
-        comptime tag: lang.NewCommand.Tag,
-    ) !void {
-        comptime const typ = lang.NewCommand.tagToType(tag);
-        const command = cmd.cast(typ).?;
-        std.debug.warn("{} {}\n", .{ command.path.ptr, command.path.len });
-
-        std.debug.warn("{}\n", .{command});
-    }
-
-    fn newRunCommand(self: *@This(), cmd: lang.NewCommand) !void {
-        switch (cmd.tag) {
-            .load => try self.newRunCommandSingle(cmd, .load),
-            else => @panic("TODO"),
-        }
-    }
+    fn newRunCommand(self: *@This(), cmd: lang.NewCommand) !void {}
 
     fn runCommand(self: *Runner, cmd: *lang.Command) !void {
         var params = ParamList.init(self.allocator);
@@ -796,15 +779,7 @@ pub const Runner = struct {
     ) !void {
         for (cmds.items) |cmd| {
             cmd.print();
-
-            switch (cmd.tag) {
-                .load => {
-                    const proper_cmd = cmd.cast(lang.NewCommand.Load).?;
-                    std.debug.warn("got load! {}\n", .{proper_cmd});
-                },
-                else => @panic("TODO"),
-            }
-            try self.newRunCommand(cmd.*);
+            try self.newRunCommand(cmd);
         }
     }
 };