diff --git a/base/sources/libs/minic.c b/base/sources/libs/minic.c
index 4004f173..d483ddfe 100644
--- a/base/sources/libs/minic.c
+++ b/base/sources/libs/minic.c
@@ -516,7 +516,9 @@ typedef struct {
 typedef struct {
 	char         name[64];
 	char         fields[MINIC_MAX_STRUCT_FIELDS][64];
+	char         field_struct_names[MINIC_MAX_STRUCT_FIELDS][64]; // struct type name for PTR fields, or ""
 	int          field_count;
+	int          size; // sizeof the native C struct, 0 if unknown
 	bool         has_native_layout;
 	int          field_offsets[MINIC_MAX_STRUCT_FIELDS];
 	minic_type_t field_native_types[MINIC_MAX_STRUCT_FIELDS];
@@ -531,6 +533,7 @@ typedef struct {
 
 typedef struct minic_env_s {
 	minic_lexer_t       lex;
+	const char         *filename;
 	minic_var_t        *vars;
 	int                 var_count;
 	int                 var_cap;
@@ -678,9 +681,17 @@ static const char *minic_tok_name(minic_tok_type_t t) {
 	}
 }
 
+static int minic_current_line(minic_env_t *e) {
+	int line = 1;
+	for (int i = 0; i < e->lex.pos; i++) {
+		if (e->lex.src[i] == '\n') line++;
+	}
+	return line;
+}
+
 static void minic_error(minic_env_t *e, const char *msg) {
 	if (!e->error) {
-		fprintf(stderr, "minic error: %s (got %s)\n", msg, minic_tok_name(e->lex.cur.type));
+		fprintf(stderr, "%s:%d: error: %s (got %s)\n", e->filename, minic_current_line(e), msg, minic_tok_name(e->lex.cur.type));
 		e->error     = true;
 		e->returning = true;
 	}
@@ -928,7 +939,7 @@ static int minic_struct_field_idx(minic_struct_def_t *def, const char *field) {
 static minic_val_t minic_struct_field_get_base(minic_env_t *e, void *base, minic_struct_def_t *def, const char *field) {
 	int idx = minic_struct_field_idx(def, field);
 	if (idx < 0) {
-		fprintf(stderr, "minic error: struct '%s' has no field '%s'\n", def->name, field);
+		fprintf(stderr, "%s:%d: error: struct '%s' has no field '%s'\n", e->filename, minic_current_line(e), def->name, field);
 		e->error = e->returning = true;
 		return minic_val_int(0);
 	}
@@ -952,7 +963,7 @@ static minic_val_t minic_struct_field_get_base(minic_env_t *e, void *base, minic
 static void minic_struct_field_set_base(minic_env_t *e, void *base, minic_struct_def_t *def, const char *field, minic_val_t val) {
 	int idx = minic_struct_field_idx(def, field);
 	if (idx < 0) {
-		fprintf(stderr, "minic error: struct '%s' has no field '%s'\n", def->name, field);
+		fprintf(stderr, "%s:%d: error: struct '%s' has no field '%s'\n", e->filename, minic_current_line(e), def->name, field);
 		e->error = e->returning = true;
 		return;
 	}
@@ -991,6 +1002,7 @@ static minic_val_t minic_call(minic_env_t *e, minic_func_t *fn, minic_val_t *arg
 	minic_env_t child   = {0};
 	child.lex.src       = e->lex.src;
 	child.lex.pos       = fn->body_pos;
+	child.filename      = e->filename;
 	child.var_cap       = 64;
 	child.vars          = minic_alloc(child.var_cap * sizeof(minic_var_t));
 	child.global_env    = e->global_env != NULL ? e->global_env : e;
@@ -1155,6 +1167,16 @@ static minic_val_t minic_parse_primary(minic_env_t *e) {
 		strncpy(name, e->lex.cur.text, 63);
 		minic_lex_next(&e->lex);
 
+		if (strcmp(name, "sizeof") == 0) {
+			minic_expect(e, TOK_LPAREN); // checks and consumes '('
+			char type_name[64];
+			strncpy(type_name, e->lex.cur.text, 63);
+			minic_lex_next(&e->lex); // Consume type name
+			minic_expect(e, TOK_RPAREN); // checks and consumes ')'
+			minic_struct_def_t *def = minic_struct_get(e, type_name);
+			return minic_val_int(def != NULL ? def->size : 0);
+		}
+
 		if (e->lex.cur.type == TOK_LBRACKET) {
 			minic_lex_next(&e->lex); // Consume '['
 			int idx = (int)minic_val_to_d(minic_parse_expr(e));
@@ -1181,7 +1203,7 @@ static minic_val_t minic_parse_primary(minic_env_t *e) {
 			if (ext != NULL) {
 				return minic_dispatch(ext, args, argc);
 			}
-			fprintf(stderr, "minic error: unknown function '%s'\n", name);
+			fprintf(stderr, "%s:%d: error: unknown function '%s'\n", e->filename, minic_current_line(e), name);
 			e->error     = true;
 			e->returning = true;
 			return minic_val_int(0);
@@ -1194,7 +1216,7 @@ static minic_val_t minic_parse_primary(minic_env_t *e) {
 			minic_lex_next(&e->lex);
 			minic_struct_def_t *def = minic_var_struct(e, name);
 			if (def == NULL) {
-				fprintf(stderr, "minic error: '%s' is not a struct\n", name);
+				fprintf(stderr, "%s:%d: error: '%s' is not a struct\n", e->filename, minic_current_line(e), name);
 				e->error = e->returning = true;
 				return minic_val_int(0);
 			}
@@ -1208,13 +1230,26 @@ static minic_val_t minic_parse_primary(minic_env_t *e) {
 			minic_lex_next(&e->lex);
 			minic_struct_def_t *def = minic_var_struct(e, name);
 			if (def == NULL) {
-				fprintf(stderr, "minic error: '%s' is not a struct pointer\n", name);
+				fprintf(stderr, "%s:%d: error: '%s' is not a struct pointer\n", e->filename, minic_current_line(e), name);
 				e->error = e->returning = true;
 				return minic_val_int(0);
 			}
 			minic_val_t base_val  = minic_var_get(e, name);
 			void       *base      = minic_val_to_ptr(base_val);
 			minic_val_t field_val = minic_struct_field_get_base(e, base, def, field);
+			// Handle chained -> or . access (e.g. node->inputs->buffer)
+			while ((e->lex.cur.type == TOK_ARROW || e->lex.cur.type == TOK_DOT) && !e->error) {
+				int fidx = minic_struct_field_idx(def, field);
+				if (fidx < 0 || def->field_struct_names[fidx][0] == '\0') break;
+				minic_struct_def_t *next_def = minic_struct_get(e, def->field_struct_names[fidx]);
+				if (next_def == NULL) break;
+				minic_lex_next(&e->lex); // Consume '->' or '.'
+				strncpy(field, e->lex.cur.text, 63);
+				minic_lex_next(&e->lex);
+				base      = minic_val_to_ptr(field_val);
+				def       = next_def;
+				field_val = minic_struct_field_get_base(e, base, def, field);
+			}
 			if (e->lex.cur.type == TOK_LBRACKET) {
 				minic_lex_next(&e->lex); // Consume '['
 				int idx = (int)minic_val_to_d(minic_parse_expr(e));
@@ -1383,7 +1418,7 @@ static void minic_parse_stmt(minic_env_t *e) {
 
 		minic_struct_def_t *def = minic_struct_get(e, sname);
 		if (def == NULL) {
-			fprintf(stderr, "minic error: unknown struct '%s'\n", sname);
+			fprintf(stderr, "%s:%d: error: unknown struct '%s'\n", e->filename, minic_current_line(e), sname);
 			e->error = e->returning = true;
 			return;
 		}
@@ -1550,7 +1585,7 @@ static void minic_parse_stmt(minic_env_t *e) {
 			minic_lex_next(&e->lex);
 			minic_struct_def_t *def = minic_var_struct(e, name);
 			if (def == NULL) {
-				fprintf(stderr, "minic error: '%s' is not a struct%s\n", name, is_arrow ? " pointer" : "");
+				fprintf(stderr, "%s:%d: error: '%s' is not a struct%s\n", e->filename, minic_current_line(e), name, is_arrow ? " pointer" : "");
 				e->error = e->returning = true;
 				return;
 			}
@@ -1614,7 +1649,7 @@ static void minic_parse_stmt(minic_env_t *e) {
 					minic_dispatch(ext, args, argc);
 				}
 				else {
-					fprintf(stderr, "minic error: unknown function '%s'\n", name);
+					fprintf(stderr, "%s:%d: error: unknown function '%s'\n", e->filename, minic_current_line(e), name);
 					e->error     = true;
 					e->returning = true;
 				}
@@ -2266,7 +2301,7 @@ static void minic_register_funcs(minic_env_t *e) {
 	}
 }
 
-minic_ctx_t *minic_eval(const char *src) {
+minic_ctx_t *minic_eval_named(const char *src, const char *filename) {
 	minic_register_builtins();
 
 	minic_ctx_t *ctx = (minic_ctx_t *)malloc(sizeof(minic_ctx_t));
@@ -2293,6 +2328,7 @@ minic_ctx_t *minic_eval(const char *src) {
 	minic_env_t *e    = &ctx->e;
 	e->lex.src        = ctx->src_copy;
 	e->lex.pos        = 0;
+	e->filename       = filename;
 	e->var_cap        = var_cap;
 	e->vars           = minic_alloc(var_cap * sizeof(minic_var_t));
 	e->arr_cap        = arr_cap;
@@ -2312,9 +2348,11 @@ minic_ctx_t *minic_eval(const char *src) {
 		minic_struct_def_t *dst = &e->structs[e->struct_count++];
 		strncpy(dst->name, minic_global_structs[i].name, 63);
 		dst->field_count       = minic_global_structs[i].field_count;
+		dst->size              = minic_global_structs[i].size;
 		dst->has_native_layout = minic_global_structs[i].has_native_layout;
 		for (int j = 0; j < dst->field_count; ++j) {
 			strncpy(dst->fields[j], minic_global_structs[i].fields[j], 63);
+			strncpy(dst->field_struct_names[j], minic_global_structs[i].field_struct_names[j], 63);
 			dst->field_offsets[j]      = minic_global_structs[i].field_offsets[j];
 			dst->field_native_types[j] = minic_global_structs[i].field_native_types[j];
 			dst->field_deref_types[j]  = minic_global_structs[i].field_deref_types[j];
@@ -2343,6 +2381,10 @@ minic_ctx_t *minic_eval(const char *src) {
 	return ctx;
 }
 
+minic_ctx_t *minic_eval(const char *src) {
+	return minic_eval_named(src, "<script>");
+}
+
 void minic_ctx_free(minic_ctx_t *ctx) {
 	if (ctx) {
 		free(ctx->mem);
diff --git a/base/sources/libs/minic.h b/base/sources/libs/minic.h
index 07893c91..5eb15975 100644
--- a/base/sources/libs/minic.h
+++ b/base/sources/libs/minic.h
@@ -43,7 +43,9 @@ typedef struct {
 typedef struct {
 	char         name[64];
 	char         fields[MINIC_MAX_STRUCT_FIELDS][64];
+	char         field_struct_names[MINIC_MAX_STRUCT_FIELDS][64]; // struct type name for PTR fields, or ""
 	int          field_count;
+	int          size; // sizeof the native C struct, 0 if unknown
 	bool         has_native_layout;
 	int          field_offsets[MINIC_MAX_STRUCT_FIELDS]; // byte offset of each field in the native C struct
 	minic_type_t field_native_types[MINIC_MAX_STRUCT_FIELDS];
@@ -82,6 +84,9 @@ void minic_register_struct_native(const char *name, const char **fields, const i
 
 void        *minic_alloc(int size);
 minic_ctx_t *minic_eval(const char *src);
+minic_ctx_t *minic_eval_named(const char *src, const char *filename);
+void         minic_struct_field_set_type(const char *struct_name, const char *field_name, const char *field_struct_name);
+void         minic_struct_set_size(const char *struct_name, int size);
 void         minic_ctx_free(minic_ctx_t *ctx);
 float        minic_ctx_result(minic_ctx_t *ctx);
 minic_val_t  minic_ctx_call_fn(minic_ctx_t *ctx, void *fn_ptr, minic_val_t *args, int argc);
diff --git a/base/sources/libs/minic_api.c b/base/sources/libs/minic_api.c
index 48349ef8..1c8cb44d 100644
--- a/base/sources/libs/minic_api.c
+++ b/base/sources/libs/minic_api.c
@@ -1,6 +1,7 @@
 #include "iron_array.h"
 #include "iron_string.h"
 #include "minic.h"
+#include <math.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
@@ -14,7 +15,6 @@ static const char *minic_read_str(minic_val_t v) {
 	return "";
 }
 
-// Returns number of chars written (excl. NUL). buf=NULL does a measure-only pass.
 static int minic_vformat(const char *fmt, minic_val_t *args, int argc, char *buf, int bufsize) {
 	int pos = 0;
 	int arg = 0;
@@ -138,9 +138,7 @@ static minic_val_t minic_string_native(minic_val_t *args, int argc) {
 
 #define R(name, sig) minic_register(#name, sig, (minic_ext_fn_raw_t)name)
 
-// ─── iron_math.h struct layout helpers ───────────────────────────────────────
-// Minic struct vars use one minic_val_t slot per field; native C structs use
-// packed floats.  These helpers convert between the two layouts.
+// iron_math.h struct layout helpers
 
 static vec2_t minic_get_vec2(void *p) {
 	minic_val_t *f = (minic_val_t *)p;
@@ -779,6 +777,16 @@ void minic_register_builtins() {
 	minic_register_struct_native("any_array_t", array_fields, array_offsets, array_types, array_ptr_derefs, 3);
 	minic_register_struct_native("string_array_t", array_fields, array_offsets, array_types, array_ptr_derefs, 3);
 	minic_register_struct_native("buffer_t", array_fields, array_offsets, array_types, array_int_derefs, 3);
+	minic_struct_set_size("i8_array_t",     (int)sizeof(i8_array_t));
+	minic_struct_set_size("u8_array_t",     (int)sizeof(u8_array_t));
+	minic_struct_set_size("i16_array_t",    (int)sizeof(i16_array_t));
+	minic_struct_set_size("u16_array_t",    (int)sizeof(u16_array_t));
+	minic_struct_set_size("i32_array_t",    (int)sizeof(i32_array_t));
+	minic_struct_set_size("u32_array_t",    (int)sizeof(u32_array_t));
+	minic_struct_set_size("f32_array_t",    (int)sizeof(f32_array_t));
+	minic_struct_set_size("any_array_t",    (int)sizeof(any_array_t));
+	minic_struct_set_size("string_array_t", (int)sizeof(string_array_t));
+	minic_struct_set_size("buffer_t",       (int)sizeof(buffer_t));
 
 	// iron_math
 	static const char *vec2_fields[] = {"x", "y"};
@@ -838,6 +846,8 @@ void minic_register_builtins() {
 	static const minic_type_t ui_handle_deref_types[] = {MINIC_T_INT,  MINIC_T_FLOAT, MINIC_T_INT, MINIC_T_INT, MINIC_T_FLOAT, MINIC_T_INT, MINIC_T_INT,
 	                                                     MINIC_T_CHAR, MINIC_T_INT,   MINIC_T_INT, MINIC_T_INT, MINIC_T_INT,   MINIC_T_PTR};
 	minic_register_struct_native("ui_handle_t", ui_handle_fields, ui_handle_offsets, ui_handle_types, ui_handle_deref_types, 13);
+	minic_struct_set_size("ui_handle_t", (int)sizeof(ui_handle_t));
+	minic_struct_field_set_type("ui_handle_t", "children", "any_array_t");
 
 	static const char *ui_node_socket_fields[]  = {"id", "node_id", "name", "type", "color", "default_value", "min", "max", "precision", "display"};
 	static const int   ui_node_socket_offsets[] = {
@@ -851,6 +861,8 @@ void minic_register_builtins() {
 	static const minic_type_t ui_node_socket_deref_types[] = {MINIC_T_INT, MINIC_T_INT,   MINIC_T_CHAR,  MINIC_T_CHAR,  MINIC_T_INT,
 	                                                          MINIC_T_PTR, MINIC_T_FLOAT, MINIC_T_FLOAT, MINIC_T_FLOAT, MINIC_T_INT};
 	minic_register_struct_native("ui_node_socket_t", ui_node_socket_fields, ui_node_socket_offsets, ui_node_socket_types, ui_node_socket_deref_types, 10);
+	minic_struct_set_size("ui_node_socket_t", (int)sizeof(ui_node_socket_t));
+	minic_struct_field_set_type("ui_node_socket_t", "default_value", "f32_array_t");
 
 	static const char *ui_node_button_fields[]  = {"name", "type", "output", "default_value", "data", "min", "max", "precision", "height"};
 	static const int   ui_node_button_offsets[] = {
@@ -863,6 +875,9 @@ void minic_register_builtins() {
 	static const minic_type_t ui_node_button_deref_types[] = {MINIC_T_CHAR,  MINIC_T_CHAR,  MINIC_T_INT,   MINIC_T_PTR,  MINIC_T_PTR,
 	                                                          MINIC_T_FLOAT, MINIC_T_FLOAT, MINIC_T_FLOAT, MINIC_T_FLOAT};
 	minic_register_struct_native("ui_node_button_t", ui_node_button_fields, ui_node_button_offsets, ui_node_button_types, ui_node_button_deref_types, 9);
+	minic_struct_set_size("ui_node_button_t", (int)sizeof(ui_node_button_t));
+	minic_struct_field_set_type("ui_node_button_t", "default_value", "f32_array_t");
+	minic_struct_field_set_type("ui_node_button_t", "data",          "u8_array_t");
 
 	static const char *ui_node_link_fields[]  = {"id", "from_id", "from_socket", "to_id", "to_socket"};
 	static const int   ui_node_link_offsets[] = {
@@ -872,6 +887,7 @@ void minic_register_builtins() {
 	static const minic_type_t ui_node_link_types[]       = {MINIC_T_INT, MINIC_T_INT, MINIC_T_INT, MINIC_T_INT, MINIC_T_INT};
 	static const minic_type_t ui_node_link_deref_types[] = {MINIC_T_INT, MINIC_T_INT, MINIC_T_INT, MINIC_T_INT, MINIC_T_INT};
 	minic_register_struct_native("ui_node_link_t", ui_node_link_fields, ui_node_link_offsets, ui_node_link_types, ui_node_link_deref_types, 5);
+	minic_struct_set_size("ui_node_link_t", (int)sizeof(ui_node_link_t));
 
 	static const char *ui_node_fields[]  = {"id", "name", "type", "x", "y", "color", "inputs", "outputs", "buttons", "width", "flags"};
 	static const int   ui_node_offsets[] = {
@@ -884,6 +900,10 @@ void minic_register_builtins() {
 	static const minic_type_t ui_node_deref_types[] = {MINIC_T_INT, MINIC_T_CHAR, MINIC_T_CHAR, MINIC_T_FLOAT, MINIC_T_FLOAT, MINIC_T_INT,
 	                                                   MINIC_T_PTR, MINIC_T_PTR,  MINIC_T_PTR,  MINIC_T_FLOAT, MINIC_T_INT};
 	minic_register_struct_native("ui_node_t", ui_node_fields, ui_node_offsets, ui_node_types, ui_node_deref_types, 11);
+	minic_struct_set_size("ui_node_t", (int)sizeof(ui_node_t));
+	minic_struct_field_set_type("ui_node_t", "inputs",  "any_array_t");
+	minic_struct_field_set_type("ui_node_t", "outputs", "any_array_t");
+	minic_struct_field_set_type("ui_node_t", "buttons", "any_array_t");
 
 	// iron_math
 	R(iron_random_init, "v(i)");
@@ -893,6 +913,8 @@ void minic_register_builtins() {
 	R(iron_hash_djb2, "i(p)");
 	R(vec4_fdist, "f(f,f,f,f,f,f)");
 	R(mat4_cofactor, "f(f,f,f,f,f,f,f,f,f)");
+	R(cosf, "f(f)");
+	R(sinf, "f(f)");
 
 	// iron_math
 #define MR(sym) minic_register_native(#sym, mn_##sym)
diff --git a/base/sources/libs/minic_ext.c b/base/sources/libs/minic_ext.c
index 99b883b9..28888e7c 100644
--- a/base/sources/libs/minic_ext.c
+++ b/base/sources/libs/minic_ext.c
@@ -62,6 +62,30 @@ void minic_register_struct(const char *name, const char **fields, int field_coun
 	}
 }
 
+void minic_struct_set_size(const char *struct_name, int size) {
+	for (int i = 0; i < minic_global_struct_count; ++i) {
+		if (strcmp(minic_global_structs[i].name, struct_name) == 0) {
+			minic_global_structs[i].size = size;
+			return;
+		}
+	}
+}
+
+void minic_struct_field_set_type(const char *struct_name, const char *field_name, const char *field_struct_name) {
+	for (int i = 0; i < minic_global_struct_count; ++i) {
+		if (strcmp(minic_global_structs[i].name, struct_name) == 0) {
+			minic_global_struct_t *def = &minic_global_structs[i];
+			for (int j = 0; j < def->field_count; ++j) {
+				if (strcmp(def->fields[j], field_name) == 0) {
+					strncpy(def->field_struct_names[j], field_struct_name, 63);
+					return;
+				}
+			}
+			return;
+		}
+	}
+}
+
 void minic_register_enum(const char *typedef_name, const char **names, const int *values, int count) {
 	if (typedef_name != NULL) {
 		bool found = false;
diff --git a/paint/assets/plugins/hello_node.c b/paint/assets/plugins/hello_node.c
index 96fccbe9..8a8f471a 100644
--- a/paint/assets/plugins/hello_node.c
+++ b/paint/assets/plugins/hello_node.c
@@ -7,11 +7,7 @@ char *node_type = "HELLO_WORLD";
 
 char *custom_node(ui_node_t *node, char *socket_name) {
 	void *kong = plugin_material_kong_get();
-	any_array_t *ar = node->inputs;
-	ui_node_socket_t *soc = ar->buffer[0];
-	// ui_node_socket_t *soc = node->inputs->buffer[0];
-	char *scale = parser_material_parse_value_input(soc, false);
-	// char *scale = parser_material_parse_value_input(node->inputs->buffer[0], false);
+	char *scale = parser_material_parse_value_input(node->inputs->buffer[0], false);
 	char *my_out = "my_out";
 
 	node_shader_write_frag(kong,
@@ -37,8 +33,7 @@ void main() {
 
 	// Create new node category
 	any_array_t *node_list = any_array_create(0);
-	// ui_node_t *n = gc_alloc(sizeof(ui_node_t));
-	ui_node_t *n = gc_alloc(72);
+	ui_node_t *n = gc_alloc(sizeof(ui_node_t));
 	any_array_push(node_list, n);
 
 	n->id = 0;
@@ -49,8 +44,7 @@ void main() {
 	n->color = 0xffb34f5a;
 
 	n->inputs = any_array_create(0);
-	// ui_node_socket_t *s = gc_alloc(sizeof(ui_node_socket_t));
-	ui_node_socket_t *s = gc_alloc(56);
+	ui_node_socket_t *s = gc_alloc(sizeof(ui_node_socket_t));
 	any_array_push(n->inputs, s);
 	s->id = 0;
 	s->node_id = 0;
@@ -64,8 +58,7 @@ void main() {
 	s->display = 0;
 
 	n->outputs = any_array_create(0);
-	// s = gc_alloc(sizeof(ui_node_socket_t));
-	s = gc_alloc(56);
+	s = gc_alloc(sizeof(ui_node_socket_t));
 	any_array_push(n->outputs, s);
 	s->id = 0;
 	s->node_id = 0;
@@ -78,8 +71,7 @@ void main() {
 	s->precision = 100.0;
 	s->display = 0;
 
-	// s = gc_alloc(sizeof(ui_node_socket_t));
-	s = gc_alloc(56);
+	s = gc_alloc(sizeof(ui_node_socket_t));
 	any_array_push(n->outputs, s);
 	s->id = 1;
 	s->node_id = 0;
diff --git a/paint/assets/plugins/hello_node_brush.c b/paint/assets/plugins/hello_node_brush.c
index 06a2ac76..ebbb02b5 100644
--- a/paint/assets/plugins/hello_node_brush.c
+++ b/paint/assets/plugins/hello_node_brush.c
@@ -6,7 +6,9 @@ char *node_name = "Hello World";
 char *node_type = "HELLO_WORLD";
 
 float custom_node(logic_node_t *node, int from) {
-	return sin(sys_time() * node->inputs->buffer[0]->get(0));
+	// float f = node->inputs->buffer[0]->get(0);
+	float f = 1.0;
+	return sinf(sys_time() * f);
 }
 
 void on_delete() {
@@ -20,8 +22,7 @@ void main() {
 
 	// Create new node category
 	any_array_t *node_list = any_array_create(0);
-	// ui_node_t *n = gc_alloc(sizeof(ui_node_t));
-	ui_node_t *n = gc_alloc(72);
+	ui_node_t *n = gc_alloc(sizeof(ui_node_t));
 	any_array_push(node_list, n);
 
 	n->id = 0;
@@ -32,8 +33,7 @@ void main() {
 	n->color = 0xffb34f5a;
 
 	n->inputs = any_array_create(0);
-	// ui_node_socket_t *s = gc_alloc(sizeof(ui_node_socket_t));
-	ui_node_socket_t *s = gc_alloc(56);
+	ui_node_socket_t *s = gc_alloc(sizeof(ui_node_socket_t));
 	any_array_push(n->inputs, s);
 	s->id = 0;
 	s->node_id = 0;
@@ -47,8 +47,7 @@ void main() {
 	s->display = 0;
 
 	n->outputs = any_array_create(0);
-	// s = gc_alloc(sizeof(ui_node_socket_t));
-	s = gc_alloc(56);
+	s = gc_alloc(sizeof(ui_node_socket_t));
 	any_array_push(n->outputs, s);
 	s->id = 0;
 	s->node_id = 0;
diff --git a/paint/sources/plugin.c b/paint/sources/plugin.c
index de35cba1..99aebb77 100644
--- a/paint/sources/plugin.c
+++ b/paint/sources/plugin.c
@@ -13,7 +13,7 @@ void plugin_start(char *plugin) {
 	gc_unroot(_plugin_name);
 	_plugin_name = string_copy(plugin);
 	gc_root(_plugin_name);
-	minic_ctx_t *ctx = minic_eval(sys_buffer_to_string(blob));
+	minic_ctx_t *ctx = minic_eval_named(sys_buffer_to_string(blob), plugin);
 	data_delete_blob(string("plugins/%s", plugin));
 	// Store context on the plugin so callbacks can use it and it can be freed on stop
 	plugin_t *p = any_map_get(plugin_map, plugin);