diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index c5355dcc6..832f00994 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -184,7 +184,7 @@ jobs:
       fail-fast: false
       matrix:
         build_type: [Release, Debug]
-        llvm_version: [16]
+        llvm_version: [16, 17]
 
     steps:
       - uses: actions/checkout@v3
diff --git a/lib/std/collections/list.c3 b/lib/std/collections/list.c3
index 6eac30d9d..06fdda514 100644
--- a/lib/std/collections/list.c3
+++ b/lib/std/collections/list.c3
@@ -38,6 +38,26 @@ fn void List.tinit(List* list, usz initial_capacity = 16)
 	list.init(initial_capacity, mem::temp()) @inline;
 }
 
+fn String List.to_string(List* list, Allocator* using = mem::heap()) @dynamic
+{
+	if (!list.size) return "[]".copy(using);
+	if (list.size == 1) return string::printf("[%s]", list.entries[0], .using = using);
+
+	@stack_mem(512 + 128; Allocator* mem)
+	{
+		DString str;
+		str.init(512, mem);
+		str.append("[");
+		foreach (i, element : list.entries[:list.size])
+		{
+			if (i != 0) str.append(", ");
+			str.printf("%s", element);
+		}
+		str.printf("]");
+		return str.copy_str(using);
+	};
+}
+
 fn void List.push(List* list, Type element) @inline
 {
     list.append(element);
diff --git a/lib/std/io/io_printf.c3 b/lib/std/io/io_printf.c3
index fcaa7a256..c2c1a3356 100644
--- a/lib/std/io/io_printf.c3
+++ b/lib/std/io/io_printf.c3
@@ -135,9 +135,9 @@ macro bool! Formatter.print_with_function(Formatter* this, any arg)
 			this.width = old_width;
 			this.prec = old_prec;
 		}
-		@pool()
+		@stack_mem(512; Allocator* mem)
 		{
-			this.out_substr(arg.to_string(mem::temp()))!;
+			this.out_substr(arg.to_string(mem))!;
 			return true;
 		};
     }
diff --git a/lib/std/net/inetaddr.c3 b/lib/std/net/inetaddr.c3
index ded894cd5..2a20d597d 100644
--- a/lib/std/net/inetaddr.c3
+++ b/lib/std/net/inetaddr.c3
@@ -50,18 +50,18 @@ fn void! InetAddress.to_format(InetAddress* addr, Formatter* formatter) @dynamic
 	formatter.printf("%d.%d.%d.%d", addr.ipv4.a, addr.ipv4.b, addr.ipv4.c, addr.ipv4.d)!;
 }
 
-fn String! InetAddress.to_string(InetAddress* addr, Allocator* using = mem::heap()) @dynamic
+fn String InetAddress.to_string(InetAddress* addr, Allocator* using = mem::heap()) @dynamic
 {
 	if (addr.is_ipv6)
 	{
 		char[8 * 5 + 1] buffer;
 		String res = (String)io::bprintf(&buffer, "%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x",
 			addr.ipv6.a, addr.ipv6.b, addr.ipv6.c, addr.ipv6.d,
-			addr.ipv6.e, addr.ipv6.f, addr.ipv6.g, addr.ipv6.h)!;
+			addr.ipv6.e, addr.ipv6.f, addr.ipv6.g, addr.ipv6.h)!!;
 		return res.copy(using);
 	}
 	char[3 * 4 + 3 + 1] buffer;
-	String res = (String)io::bprintf(&buffer, "%d.%d.%d.%d", addr.ipv4.a, addr.ipv4.b, addr.ipv4.c, addr.ipv4.d)!;
+	String res = (String)io::bprintf(&buffer, "%d.%d.%d.%d", addr.ipv4.a, addr.ipv4.b, addr.ipv4.c, addr.ipv4.d)!!;
 	return res.copy(using);
 }
 
diff --git a/src/build/build_options.c b/src/build/build_options.c
index 2b12fdba7..cdd8a4794 100644
--- a/src/build/build_options.c
+++ b/src/build/build_options.c
@@ -134,7 +134,7 @@ static void usage(void)
 	OUTPUT("  --x86vec=<option>         - Set max type of vector use: none, mmx, sse, avx, avx512, native.");
 	OUTPUT("  --riscvfloat=<option>     - Set type of RISC-V float support: none, float, double");
 	OUTPUT("  --memory-env=<option>     - Set the memory environment: normal, small, tiny, none.");
-	OUTPUT("  --strip-unused            - Strip unused code and globals from the output (experimental)");
+	OUTPUT("  --no-strip-unused         - Do not strip unused code and globals from the output.");
 	OUTPUT("");
 	OUTPUT("  --debug-stats             - Print debug statistics.");
 #ifndef NDEBUG
@@ -549,9 +549,9 @@ static void parse_option(BuildOptions *options)
 				print_version();
 				exit_compiler(COMPILER_SUCCESS_EXIT);
 			}
-			if (match_longopt("strip-unused"))
+			if (match_longopt("no-strip-unused"))
 			{
-				options->strip_unused = true;
+				options->no_strip_unused = true;
 				return;
 			}
 			if ((argopt = match_argopt("x86vec")))
diff --git a/src/build/build_options.h b/src/build/build_options.h
index 94a0c24f6..80812c16d 100644
--- a/src/build/build_options.h
+++ b/src/build/build_options.h
@@ -340,7 +340,7 @@ typedef struct BuildOptions_
 	X86CpuSet x86_cpu_set;
 	RiscvFloatCapability riscv_float_capability;
 	MemoryEnvironment memory_environment;
-	bool strip_unused;
+	bool no_strip_unused;
 	bool print_keywords;
 	bool print_attributes;
 	bool print_builtins;
@@ -414,7 +414,7 @@ typedef struct
 	bool emit_asm;
 	bool no_stdlib;
 	bool no_libc;
-	bool strip_unused;
+	bool no_strip_unused;
 	bool emit_object_files;
 	bool force_linker;
 	bool benchmarking;
diff --git a/src/build/builder.c b/src/build/builder.c
index 1abe8352a..7d2ce7836 100644
--- a/src/build/builder.c
+++ b/src/build/builder.c
@@ -199,7 +199,7 @@ static void update_build_target_from_options(BuildTarget *target, BuildOptions *
 	{
 		target->feature.safe_mode = options->safe_mode == 1;
 	}
-	if (options->strip_unused) target->strip_unused = true;
+	if (options->no_strip_unused || options->test_mode) target->no_strip_unused = true;
 
 	if (options->memory_environment != MEMORY_ENV_NOT_SET)
 	{
diff --git a/src/compiler/linker.c b/src/compiler/linker.c
index c51a23a1f..a3fba616d 100644
--- a/src/compiler/linker.c
+++ b/src/compiler/linker.c
@@ -286,7 +286,7 @@ static void linker_setup_macos(const char ***args_ref, LinkerType linker_type)
 	}
 	add_arg("-arch");
 	add_arg(arch_to_linker_arch(platform_target.arch));
-	if (active_target.strip_unused && active_target.type == TARGET_TYPE_EXECUTABLE)
+	if (!active_target.no_strip_unused && active_target.type == TARGET_TYPE_EXECUTABLE)
 	{
 		add_arg("-no_exported_symbols");
 		add_arg("-dead_strip");
@@ -398,9 +398,9 @@ static void linker_setup_linux(const char ***args_ref, LinkerType linker_type)
 	const char *crt_begin_dir = find_linux_crt_begin();
 	const char *crt_dir = find_linux_crt();
 
-	if (active_target.strip_unused && active_target.type == TARGET_TYPE_EXECUTABLE)
+	if (!active_target.no_strip_unused && active_target.type == TARGET_TYPE_EXECUTABLE)
 	{
-		add_arg("-dead_strip");
+		add_arg("--gc-sections");
 	}
 
 	if (!crt_begin_dir || !crt_dir)
@@ -448,9 +448,9 @@ static void linker_setup_freebsd(const char ***args_ref, LinkerType linker_type)
 	{
 		error_exit("Failed to find the C runtime at link time.");
 	}
-	if (active_target.strip_unused && active_target.type == TARGET_TYPE_EXECUTABLE)
+	if (!active_target.no_strip_unused && active_target.type == TARGET_TYPE_EXECUTABLE)
 	{
-		add_arg("-dead_strip");
+		add_arg("--gc-sections");
 	}
 
 	if (is_pie_pic(platform_target.reloc_model))
diff --git a/src/compiler/llvm_codegen.c b/src/compiler/llvm_codegen.c
index d81864320..e23e6a497 100644
--- a/src/compiler/llvm_codegen.c
+++ b/src/compiler/llvm_codegen.c
@@ -1275,7 +1275,7 @@ static GenContext *llvm_gen_module(Module *module, LLVMContextRef shared_context
 	gencontext_init(gen_context, module, shared_context);
 	gencontext_begin_module(gen_context);
 
-	bool only_used = active_target.strip_unused && !active_target.testing;
+	bool only_used = !active_target.no_strip_unused;
 
 	FOREACH_BEGIN(CompilationUnit *unit, module->units)
 
@@ -1296,10 +1296,12 @@ static GenContext *llvm_gen_module(Module *module, LLVMContextRef shared_context
 		FOREACH_END();
 
 		FOREACH_BEGIN(Decl *type_decl, unit->types)
+			if (only_used && !type_decl->is_live) continue;
 			llvm_emit_type_decls(gen_context, type_decl);
 		FOREACH_END();
 
 		FOREACH_BEGIN(Decl *enum_decl, unit->enums)
+			if (only_used && !enum_decl->is_live) continue;
 			llvm_emit_type_decls(gen_context, enum_decl);
 		FOREACH_END();
 
diff --git a/src/compiler/sema_decls.c b/src/compiler/sema_decls.c
index 59a7ca5ca..7b8563273 100644
--- a/src/compiler/sema_decls.c
+++ b/src/compiler/sema_decls.c
@@ -2332,6 +2332,7 @@ static inline bool sema_analyse_func(SemaContext *context, Decl *decl)
 			return false;
 		}
 		global_context.test_func = decl;
+		if (active_target.testing) decl->no_strip = true;
 	}
 	bool is_test = decl->func_decl.attr_test;
 	Signature *sig = &decl->func_decl.signature;
diff --git a/src/compiler/sema_liveness.c b/src/compiler/sema_liveness.c
index ed757d488..81d3b69f0 100644
--- a/src/compiler/sema_liveness.c
+++ b/src/compiler/sema_liveness.c
@@ -178,12 +178,14 @@ static void sema_trace_stmt_liveness(Ast *ast)
 
 static void sema_trace_const_initializer_liveness(ConstInitializer *const_init)
 {
+	RETRY:
 	switch (const_init->kind)
 	{
 		case CONST_INIT_ZERO:
 			return;
 		case CONST_INIT_ARRAY_VALUE:
-			UNREACHABLE
+			const_init = const_init->init_array_value.element;
+			goto RETRY;
 		case CONST_INIT_ARRAY_FULL:
 		{
 			bool was_modified = false;
@@ -204,8 +206,8 @@ static void sema_trace_const_initializer_liveness(ConstInitializer *const_init)
 			return;
 		}
 		case CONST_INIT_UNION:
-			sema_trace_const_initializer_liveness(const_init->init_union.element);
-			return;
+			const_init = const_init->init_union.element;
+			goto RETRY;
 		case CONST_INIT_STRUCT:
 		{
 			Decl *decl = const_init->type->decl;
@@ -353,8 +355,16 @@ RETRY:
 			sema_trace_expr_list_liveness(expr->designated_init_list);
 			return;
 		case EXPR_EXPR_BLOCK:
-			sema_trace_stmt_liveness(astptr(expr->expr_block.first_stmt));
+		{
+			AstId current = expr->expr_block.first_stmt;
+			if (!current) return;
+			do
+			{
+				Ast *value = ast_next(&current);
+				sema_trace_stmt_liveness(value);
+			} while (current);
 			return;
+		}
 		case EXPR_IDENTIFIER:
 			sema_trace_decl_liveness(expr->identifier_expr.decl);
 			return;
@@ -452,10 +462,15 @@ void sema_trace_liveness(void)
 	{
 		sema_trace_decl_liveness(global_context.main);
 	}
+	bool keep_tests = active_target.testing;
+	FOREACH_BEGIN(Decl *function, global_context.method_extensions)
+		if (function->func_decl.attr_dynamic) function->no_strip = true;
+		if (function->is_export || function->no_strip) sema_trace_decl_liveness(function);
+	FOREACH_END();
 	FOREACH_BEGIN(Module *module, global_context.module_list)
 		FOREACH_BEGIN(CompilationUnit *unit, module->units)
 			FOREACH_BEGIN(Decl *function, unit->functions)
-				if (function->is_export || function->no_strip) sema_trace_decl_liveness(function);
+				if (function->is_export || function->no_strip || (function->func_decl.attr_test && keep_tests)) sema_trace_decl_liveness(function);
 			FOREACH_END();
 			FOREACH_BEGIN(Decl *method, unit->methods)
 				if (method->is_export || method->no_strip) sema_trace_decl_liveness(method);
@@ -463,26 +478,67 @@ void sema_trace_liveness(void)
 			FOREACH_BEGIN(Decl *var, unit->vars)
 				if (var->is_export || var->no_strip) sema_trace_decl_liveness(var);
 			FOREACH_END();
+			FOREACH_BEGIN(Decl *method, unit->local_method_extensions)
+				if (method->is_export || method->no_strip) sema_trace_decl_liveness(method);
+			FOREACH_END();
 			FOREACH_BEGIN(Decl *xxlizer, unit->xxlizers)
 				sema_trace_decl_liveness(xxlizer);
 			FOREACH_END();
 		FOREACH_END();
 	FOREACH_END();
 }
+
+INLINE void sema_trace_type_liveness(Type *type)
+{
+	if (!type || !type_is_user_defined(type)) return;
+	sema_trace_decl_liveness(type->decl);
+}
+
+INLINE void sema_trace_decl_dynamic_methods(Decl *decl)
+{
+	Decl **methods = decl->methods;
+	unsigned method_count = vec_size(methods);
+	if (!method_count) return;
+	for (unsigned i = 0; i < method_count; i++)
+	{
+		Decl *method = methods[i];
+		if (!method->func_decl.attr_dynamic) continue;
+		sema_trace_decl_liveness(method);
+	}
+}
+
 static void sema_trace_decl_liveness(Decl *decl)
 {
+RETRY:
 	if (!decl || decl->is_live) return;
 	decl->is_live = true;
 	switch (decl->decl_kind)
 	{
-		case DECL_POISONED:
-		case DECL_ATTRIBUTE:
-		case DECL_BITSTRUCT:
+		case DECL_TYPEDEF:
+			if (!decl->typedef_decl.is_func)
+			{
+				sema_trace_type_liveness(decl->typedef_decl.type_info->type);
+				return;
+			}
+			FOREACH_BEGIN(Decl *param, decl->typedef_decl.function_signature.params)
+				sema_trace_decl_liveness(param);
+			FOREACH_END();
+			sema_trace_type_liveness(typeinfotype(decl->typedef_decl.function_signature.rtype));
+			return;
 		case DECL_DEFINE:
+			decl = decl->define_decl.alias;
+			goto RETRY;
 		case DECL_DISTINCT:
 		case DECL_ENUM:
-		case DECL_ENUM_CONSTANT:
+		case DECL_BITSTRUCT:
 		case DECL_FAULT:
+		case DECL_STRUCT:
+		case DECL_UNION:
+			sema_trace_decl_dynamic_methods(decl);
+			return;
+		case DECL_POISONED:
+		case DECL_ATTRIBUTE:
+		case DECL_ENUM_CONSTANT:
 		case DECL_FAULTVALUE:
 			return;
 		case DECL_CT_CASE:
@@ -508,20 +564,27 @@ static void sema_trace_decl_liveness(Decl *decl)
 			{
 				case VARDECL_REWRAPPED:
 				case VARDECL_UNWRAPPED:
-					return;
+					break;
+				case VARDECL_PARAM_EXPR:
+				case VARDECL_PARAM_CT:
+				case VARDECL_PARAM_REF:
+				case VARDECL_PARAM:
+					sema_trace_type_liveness(decl->type);
+					if (decl->var.init_expr && decl->var.init_expr->resolve_status == RESOLVE_DONE)
+					{
+						sema_trace_expr_liveness(decl->var.init_expr);
+					}
+					break;
 				default:
+					sema_trace_type_liveness(decl->type);
+					sema_trace_expr_liveness(decl->var.init_expr);
 					break;
 			}
-			sema_trace_expr_liveness(decl->var.init_expr);
 			return;
 		case DECL_INITIALIZE:
 		case DECL_FINALIZE:
 			sema_trace_stmt_liveness(astptrzero(decl->xxlizer.init));
 			return;
-		case DECL_STRUCT:
-		case DECL_TYPEDEF:
-		case DECL_UNION:
-			return;
 		case DECL_DECLARRAY:
 			UNREACHABLE
 	}
diff --git a/src/compiler/sema_stmts.c b/src/compiler/sema_stmts.c
index 5c8781a2a..d641d974b 100644
--- a/src/compiler/sema_stmts.c
+++ b/src/compiler/sema_stmts.c
@@ -2927,6 +2927,49 @@ bool sema_analyse_function_body(SemaContext *context, Decl *func)
 			           func->name);
 			return false;
 		}
+
+		Signature any_sig = any->func_decl.signature;
+		Signature this_sig = func->func_decl.signature;
+		Type *any_rtype = typeinfotype(any_sig.rtype);
+		Type *this_rtype = typeinfotype(this_sig.rtype);
+		if (any_rtype->canonical != this_rtype->canonical)
+		{
+			SEMA_ERROR(type_infoptr(this_sig.rtype), "The prototype method has a return type %s, but this function returns %s, they need to match.",
+			           type_quoted_error_string(any_rtype), type_quoted_error_string(this_rtype));
+			SEMA_NOTE(type_infoptr(any_sig.rtype), "The interface definition is here.");
+			return false;
+		}
+		Decl **any_params = any_sig.params;
+		Decl **this_params = this_sig.params;
+		unsigned any_param_count = vec_size(any_params);
+		unsigned this_param_count = vec_size(this_params);
+		if (any_param_count != this_param_count)
+		{
+			if (any_param_count > this_param_count)
+			{
+				SEMA_ERROR(func, "This function is missing parameters, %d parameters were expected.", any_param_count);
+				SEMA_NOTE(any_params[this_param_count], "Compare with the interface definition.");
+				return false;
+			}
+			else
+			{
+				SEMA_ERROR(this_params[any_param_count], "This function has too many parameters (%d).", this_param_count);
+				SEMA_NOTE(any, "Compare with the interface, which has only %d parameter%s.",
+						  any_param_count, any_param_count == 1 ? "" : "s");
+			}
+			return false;
+		}
+		FOREACH_BEGIN_IDX(i, Decl *param, this_params)
+			if (i == 0) continue;
+			if (param->type->canonical != any_params[i]->type->canonical)
+			{
+				SEMA_ERROR(param->var.type_info, "The prototype argument has type %s, but in this function it has type %s. Please make them match.",
+				           type_quoted_error_string(any_params[i]->type), type_quoted_error_string(param->type));
+				SEMA_NOTE(any_params[i]->var.type_info, "The interface definition is here.");
+				return false;
+			}
+
+		FOREACH_END();
 		func->func_decl.any_prototype = declid(any);
 	}
 	Signature *signature = &func->func_decl.signature;
diff --git a/src/compiler/semantic_analyser.c b/src/compiler/semantic_analyser.c
index 0abf1e60c..f4907c11e 100644
--- a/src/compiler/semantic_analyser.c
+++ b/src/compiler/semantic_analyser.c
@@ -373,12 +373,13 @@ RESOLVE_LAMBDA:;
 	if (found_lambda) goto RESOLVE_LAMBDA;
 	halt_on_error();
 
-	if (active_target.strip_unused && !active_target.testing)
+	assign_panicfn();
+
+	if (!active_target.no_strip_unused)
 	{
 		sema_trace_liveness();
 	}
 
-	assign_panicfn();
 
 	compiler_sema_time = bench_mark();
 
diff --git a/src/main.c b/src/main.c
index ee7317e49..5bb83e789 100644
--- a/src/main.c
+++ b/src/main.c
@@ -25,6 +25,15 @@ static void cleanup()
 
 int main_real(int argc, const char *argv[])
 {
+	printf("------------------------------------------------------------\n"
+		   " PLEASE NOTE, this version of the compiler has enabled dead\n"
+		   " code stripping by default. This functionality has not been\n"
+		   " completely audited, so if you run into any linking error, \n"
+		   " please use --no-strip-unused to disable the feature.      \n"
+		   " If possible, file an error here: \n"
+		   " https://github.com/c3lang/c3c/issues\n"
+		   " Thank you!\n"
+		   "------------------------------------------------------------\n");
 	bench_begin();
 
 	// Setjmp will allow us to add things like fuzzing with
diff --git a/src/version.h b/src/version.h
index 1f910107e..4346e2e67 100644
--- a/src/version.h
+++ b/src/version.h
@@ -1 +1 @@
-#define COMPILER_VERSION "0.4.522"
\ No newline at end of file
+#define COMPILER_VERSION "0.4.523"
\ No newline at end of file
diff --git a/test/test_suite/dynamic/dynamic_mismatch.c3 b/test/test_suite/dynamic/dynamic_mismatch.c3
new file mode 100644
index 000000000..e9ad10784
--- /dev/null
+++ b/test/test_suite/dynamic/dynamic_mismatch.c3
@@ -0,0 +1,21 @@
+fn int any.test(void* a, int ag) @interface;
+
+struct Foo { int a; }
+
+fn int! Foo.test(Foo* f) @dynamic { return 1; } // #error: The prototype method has a return type 'int'
+
+struct Foo1 { int a; }
+
+fn int Foo1.test(Foo1* f, int a) @dynamic { return 1; }
+
+struct Foo2 { int a; }
+
+fn int Foo2.test(Foo2* f) @dynamic { return 1; } // #error: This function is missing parameters, 2
+
+struct Foo3 { int a; }
+
+fn int Foo3.test(Foo3* f, double a) @dynamic { return 1; } // #error: The prototype argument has type 'int'
+
+struct Foo4 { int a; }
+
+fn int Foo4.test(Foo4* f, double a, int x) @dynamic { return 1; } // #error: This function has too many parameters
diff --git a/test/unit/stdlib/net/inetaddr.c3 b/test/unit/stdlib/net/inetaddr.c3
index d90dbbae9..ecdbf5520 100644
--- a/test/unit/stdlib/net/inetaddr.c3
+++ b/test/unit/stdlib/net/inetaddr.c3
@@ -12,14 +12,14 @@ fn void test_ipv4()
 fn void! test_ipv4_to_string()
 {
 	InetAddress a = net::ipv4_from_str("127.0.0.1")!;
-	assert(a.to_string()! == "127.0.0.1");
+	assert(a.to_string() == "127.0.0.1");
 }
 
 fn void! test_ipv6_to_string()
 {
 	InetAddress a = net::ipv6_from_str("2001:db8::2:1")!;
-	a.to_string()!;
-	assert(a.to_string()! == "2001:0db8:0000:0000:0000:0000:0002:0001");
+	a.to_string();
+	assert(a.to_string() == "2001:0db8:0000:0000:0000:0000:0002:0001");
 	assert(net::ipv6_from_str("2001:db8::1").to_string()! == "2001:0db8:0000:0000:0000:0000:0000:0001");
 	assert(net::ipv6_from_str("::1").to_string()! == "0000:0000:0000:0000:0000:0000:0000:0001");
 	assert(net::ipv6_from_str("2001::1").to_string()! == "2001:0000:0000:0000:0000:0000:0000:0001");