fix: missing freeing and type (in CIF prepare)

- Feat: finish FFI CIF prepare

.clangd

@@ -0,0 +1,4 @@
+Style:
+  AngledHeaders: [".*"]
+  QuotedHeaders: []
+

.gitignore

@@ -11,6 +11,7 @@
 
 # Files
 !/.clang-format
+!/.clangd
 !/.gdbinit
 !/.gitignore
 !/CMakeLists.txt

CMakeLists.txt

@@ -8,6 +8,7 @@ add_compile_options(-Wall -Wextra -Werror=implicit-function-declaration)
 if (CMAKE_BUILD_TYPE STREQUAL "Debug")
 	add_compile_options(-fsanitize=address,undefined -g)
 	add_link_options(-fsanitize=address,undefined)
+	set(FZL_TESTS TRUE)
 endif()
 
 include_directories(include)
@@ -29,7 +30,8 @@ set(CMAKE_SUPPRESS_DEVELOPER_WARNINGS ${PREV_SUPPRESS_DEV} CACHE INTERNAL "")
 # --------------
 
 # Compiler
-add_executable(fzc
+if (NOT FZL_SKIP_C)
+	add_executable(fzc
 		src/compiler/utils/fzl_const_pool.c
 		src/compiler/utils/fzl_symtable.c
 		src/compiler/utils/fzl_linked.c
@@ -48,14 +50,51 @@ add_executable(fzc
 		src/compiler/analyzer/an_conditional.c
 		src/compiler/analyzer/an_construct.c
 		src/compiler/analyzer/an_declaration.c
+		src/compiler/analyzer/an_extern.c
+		src/compiler/analyzer/an_externfn.c
 		src/compiler/analyzer/an_field.c
 		src/compiler/analyzer/an_function.c
 		src/compiler/analyzer/an_identifier.c
 		src/compiler/analyzer/an_loop.c
+		src/compiler/analyzer/an_ref.c
 		src/compiler/analyzer/an_return.c
 		src/compiler/analyzer/an_strfmt.c
+		src/compiler/analyzer/an_struct.c
+		src/compiler/analyzer/an_typedef.c
 		src/compiler/analyzer/an_unarycond.c
 		src/compiler/analyzer/an_unarymath.c
+		src/compiler/generator/context.c
+		src/compiler/generator/op.c
+		src/compiler/generator/utility.c
+		src/compiler/generator/gen_alias.c
+		src/compiler/generator/gen_assign.c
+		src/compiler/generator/gen_block.c
+		src/compiler/generator/gen_break.c
+		src/compiler/generator/gen_call.c
+		src/compiler/generator/gen_class.c
+		src/compiler/generator/gen_common.c
+		src/compiler/generator/gen_compare.c
+		src/compiler/generator/gen_condition.c
+		src/compiler/generator/gen_construct.c
+		src/compiler/generator/gen_declaration.c
+		src/compiler/generator/gen_extern.c
+		src/compiler/generator/gen_externfn.c
+		src/compiler/generator/gen_field.c
+		src/compiler/generator/gen_fmtstr.c
+		src/compiler/generator/gen_fn.c
+		src/compiler/generator/gen_handle.c
+		src/compiler/generator/gen_identifier.c
+		src/compiler/generator/gen_literal.c
+		src/compiler/generator/gen_logical.c
+		src/compiler/generator/gen_loop.c
+		src/compiler/generator/gen_math.c
+		src/compiler/generator/gen_reference.c
+		src/compiler/generator/gen_return.c
+		src/compiler/generator/gen_struct.c
+		src/compiler/generator/gen_typedef.c
+		src/compiler/generator/gen_unary_logical.c
+		src/compiler/generator/gen_unary_math.c
+		src/compiler/parser/utility.c
 		src/compiler/parser/pa_and.c
 		src/compiler/parser/pa_assignment.c
 		src/compiler/parser/pa_block.c
@@ -63,6 +102,8 @@ add_executable(fzc
 		src/compiler/parser/pa_class.c
 		src/compiler/parser/pa_cond.c
 		src/compiler/parser/pa_expression.c
+		src/compiler/parser/pa_extern.c
+		src/compiler/parser/pa_externfn.c
 		src/compiler/parser/pa_factor.c
 		src/compiler/parser/pa_for.c
 		src/compiler/parser/pa_function.c
@@ -74,28 +115,37 @@ add_executable(fzc
 		src/compiler/parser/pa_power.c
 		src/compiler/parser/pa_primary.c
 		src/compiler/parser/pa_program.c
+		src/compiler/parser/pa_ref.c
 		src/compiler/parser/pa_return.c
 		src/compiler/parser/pa_statement.c
+		src/compiler/parser/pa_struct.c
 		src/compiler/parser/pa_term.c
+		src/compiler/parser/pa_typedef.c
 		src/compiler/parser/pa_unary.c
 		src/compiler/parser/pa_while.c
-	src/compiler/parser/utility.c
 		src/compiler/reader/rd_fmtstr.c
 		src/compiler/reader/rd_name.c
 		src/compiler/reader/rd_number.c
 		src/compiler/reader/rd_string_literal.c
 		src/compiler/reader/utility.c
+		src/compiler/writer/wr_consts.c
+		src/compiler/writer/wr_extern_fns.c
+		src/compiler/writer/wr_extern_libs.c
+		src/compiler/writer/wr_extern_types.c
+		src/compiler/writer/wr_ops.c
 		src/compiler/fzl_analyzer.c
 		src/compiler/fzl_debug.c
+		src/compiler/fzl_gen.c
 		src/compiler/fzl_parser.c
 		src/compiler/fzl_reader.c
 		src/compiler/fzl_token.c
-	src/compiler/fzl_walker.c
 		src/compiler/fzl_writer.c
 		src/compiler/main.c)
+endif ()
 
 # Virtual machine
-add_executable(fz
+if (NOT FZL_SKIP_VM)
+	add_executable(fz
 		src/vm/handlers/group_and_or.c
 		src/vm/handlers/group_cmp.c
 		src/vm/handlers/group_ctx.c
@@ -109,21 +159,51 @@ add_executable(fz
 		src/vm/handlers/group_str.c
 		src/vm/handlers/group_strcmp.c
 		src/vm/handlers/master.c
+		src/vm/reader/utility.c
+		src/vm/reader/vm_rd_consts.c
+		src/vm/reader/vm_rd_extern_fns.c
+		src/vm/reader/vm_rd_extern_libs.c
+		src/vm/reader/vm_rd_extern_types.c
+		src/vm/reader/vm_rd_header.c
+		src/vm/reader/vm_rd_ops.c
+		src/vm/reader/vm_rd_sections_sz.c
 		src/vm/fzl_vm.c
 		src/vm/fzl_vm_env.c
+		src/vm/fzl_vm_extern.c
+		src/vm/fzl_vm_reader.c
 		src/vm/fzl_vm_debug.c
 		src/vm/main.c)
 
-target_link_libraries(fz PRIVATE ffi_static dl)
+	target_link_libraries(fz PRIVATE ffi_static dl)
+endif ()
+
+#
+# ========== Installtion ===========
+#
+
+if (NOT FZL_SKIP_C)
+	install (TARGETS fzc RUNTIME DESTINATION bin)
+endif ()
+
+if (NOT FZL_SKIP_VM)
+	install (TARGETS fz RUNTIME DESTINATION bin)
+endif ()
 
 #
 # ========== Tests ==========
 #
 
-enable_testing()
+if (FZL_TESTS)
+	enable_testing()
 
-file(GLOB TEST_PROGS RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}" "tests/programs/*.fzs")
-foreach (TEST_FILE IN LISTS TEST_PROGS)
+	file(GLOB TEST_LIBS RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}" "tests/libs/*.c")
+	foreach (TEST_LIB IN LISTS TEST_LIBS)
+		get_filename_component(LIB_NAME "${TEST_LIB}" NAME_WE)
+		add_library("${LIB_NAME}" ${TEST_LIB})
+	endforeach ()
+
+	file(GLOB TEST_PROGS RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}" "tests/programs/*.fzs")
+	foreach (TEST_FILE IN LISTS TEST_PROGS)
 		get_filename_component(TEST_NAME "${TEST_FILE}" NAME_WE)
 		
 		add_test(
@@ -142,6 +222,7 @@ foreach (TEST_FILE IN LISTS TEST_PROGS)
 
 		if (TEST_NAME MATCHES "negr_")
 			set_tests_properties("progs_runtime_${TEST_NAME}" PROPERTIES WILL_FAIL TRUE)
-	endif()
-endforeach()
+		endif ()
+	endforeach ()
+endif ()
 

Makefile

@@ -7,34 +7,37 @@ MAX_ITER ?= 2000000
 
 current_time = python3 -c "import time; print(time.time())"
 
-build:
+build-debug:
 	cmake -S . -B build -DCMAKE_BUILD_TYPE=Debug
 	cmake --build build
 
-build-release:
+build:
 	cmake -S . -B build -DCMAKE_BUILD_TYPE=Release $(COMPARING)
 	cmake --build build $(COMPARING)
 
-debug-c: build
+install:
+	cmake --install build
+
+debug-c: build-debug
 	gdb --args ./build/fzc -v ${FILE}
 
-debug-vm: build
+debug-vm: build-debug
 	gdb --args ./build/fz ${FILE}
 
+test-debug: build-debug
+	ctest --output-on-failure --test-dir build
+
 test: build
 	ctest --output-on-failure --test-dir build
 
-test-release: build-release
-	ctest --output-on-failure --test-dir build
-
 bench: COMPARING=&>/dev/null
-bench: build-release
+bench: build
 	@./build/fzc -o build/benchmark.fzb $(BENCH_FILE)
 	@python3 scripts/benchmark.py --runs $(RUNS) --warmup $(WARMUP) \
 		--max-iter $(MAX_ITER) --vm ./build/fz --program build/benchmark.fzb
 
 compare: COMPARING=&>/dev/null
-compare: build-release
+compare: build
 	@echo "=== Million sums benchmark ==="
 
 	@./build/fzc -o build/bench.fzb $(BENCH_FILE) 1>/dev/null 2>/dev/null

README.ru.md

@@ -27,12 +27,8 @@
 ## Инструкции по сборке
 
 1. Склонировать проект: `git clone https://git.samsonium.dev/samsonium/fz-lang.git`
-2. Собрать проект: `make build-release`
-
-После этого в корне появится директория **"build"**. В ней будут лежать два скомпилированных бинарных файла:
-
-- `fzc` - компилятор
-- `fz` - виртуальная машина
+2. Собрать проект: `make build`
+3. Установить проект: `sudo make install`
 
 Оба бинарных файла предоставляют справку по использованию при запуске с флагом `--help` (или `-h`).
 

exl/linking.fzs

@@ -1,18 +1,21 @@
 extern "libglfw" {
-  type GLFWwindow  = handle;
-  type GLFWmonitor = handle;
 
-  struct GLFWvidmode {
+  // Opaque types
+  type GLFWwindow  handle;
+  type GLFWmonitor handle;
+
+  // Struct definition
+  type GLFWvidmode struct {
     int width;
     int height;
     int redBits;
     int greenBits;
     int blueBits;
     int refreshRate;
-  }
+  };
 
   /// GLFWvidmode*
-  type GLFWvidmodeRef = ref GLFWvidmode;
+  type GLFWvidmodeRef ref GLFWvidmode;
 
   /// Create window with specified [width], [height] and [title]
   fn glfw_mkWindow(

include/common/fzl_extern.h

@@ -0,0 +1,86 @@
+#ifndef FZL_EXTERN_H
+#define FZL_EXTERN_H
+
+#include <common/fzl_types.h>
+#include <stdbool.h>
+#include <stddef.h>
+
+typedef enum
+{
+  FZL_EXTERN_KIND_HANDLE,
+  FZL_EXTERN_KIND_STRUCT,
+  FZL_EXTERN_KIND_REF,
+  FZL_EXTERN_KIND_ALIAS,
+} fzl_extern_kind_t;
+
+// Type reference descriptor
+typedef struct
+{
+  bool is_primitive;
+  union
+  {
+    fzl_type_t primitive;
+    size_t type_slot;
+  };
+} fzl_extern_type_ref_t;
+
+// Structure field descriptor
+typedef struct
+{
+  char *name;
+  fzl_extern_type_ref_t type;
+} fzl_extern_struct_field_t;
+
+// Type descriptor
+typedef struct
+{
+  size_t lib_slot;
+  char *name;
+  fzl_extern_kind_t kind;
+
+  union
+  {
+    // Structure
+    struct
+    {
+      fzl_extern_struct_field_t *fields;
+      size_t fields_count;
+    } structure;
+
+    // Pointer (ref)
+    fzl_extern_type_ref_t ref_target;
+
+    // Alias
+    fzl_extern_type_ref_t alias_target;
+  };
+} fzl_extern_type_t;
+
+// Function argument descriptor
+typedef struct
+{
+  char *name;
+  fzl_extern_type_ref_t type;
+  bool is_out;
+} fzl_extern_arg_t;
+
+// Function descriptor
+typedef struct
+{
+  size_t lib_slot;
+  char *symbol_name;
+  char *used_name;
+
+  bool has_return;
+  fzl_extern_type_ref_t ret_type;
+
+  fzl_extern_arg_t *args;
+  size_t args_count;
+} fzl_extern_fn_t;
+
+// Library descriptor
+typedef struct
+{
+  char *name;
+} fzl_extern_lib_t;
+
+#endif // FZL_EXTERN_H

include/common/fzl_opcodes.h

@@ -22,6 +22,7 @@ typedef enum
 
   FZL_OPCODE_CALL        = 0xF30001, // Call function
   FZL_OPCODE_RET         = 0xF30002, // Return from function
+  FZL_OPCODE_CALL_EXTERN = 0xF30003, // Call external function
 
   FZL_OPCODE_ALLOC_OBJECT  = 0xFA0001, // Allocate N slots
   FZL_OPCODE_GET_FIELD     = 0xFA0002, // Get field N of an object at dstack

include/common/fzl_types.h

@@ -7,6 +7,8 @@ typedef enum
   FZL_TYPE_OBJECT,
 
   FZL_TYPE_EXTERN_FN,
+  FZL_TYPE_HANDLE,
+  FZL_TYPE_STRUCT,
 
   FZL_TYPE_STRING,
   FZL_TYPE_CHAR,

include/compiler/fzl_gen.h

@@ -0,0 +1,77 @@
+#ifndef FZL_GENERATOR_H
+#define FZL_GENERATOR_H
+
+#include <common/fzl_extern.h>
+#include <compiler/fzl_parser.h>
+#include <compiler/utils/fzl_const_pool.h>
+#include <compiler/utils/fzl_ctable.h>
+#include <compiler/utils/fzl_symtable.h>
+#include <stdbool.h>
+#include <stddef.h>
+
+// Generator context type
+typedef enum
+{
+  FZL_GEN_CTX_TYPE_UNECCESSARY,
+  FZL_GEN_CTX_TYPE_FUNCTION,
+  FZL_GEN_CTX_TYPE_CLASS,
+  FZL_GEN_CTX_TYPE_LOOP
+} fzl_gen_ctx_type_t;
+
+// Generator context descriptor
+typedef struct fzl_gen_ctx
+{
+  fzl_gen_ctx_type_t type;
+  struct fzl_gen_ctx *parent;
+
+  size_t level;
+
+  union
+  {
+    fzl_node_t *function;
+
+    struct
+    {
+      size_t breaks[256];
+      size_t breaks_count;
+    } loop;
+  };
+} fzl_gen_ctx_t;
+
+// Generator descriptor
+typedef struct
+{
+  fzl_node_t *root;
+  fzl_const_hash_pool_t *consts;
+  fzl_gen_ctx_t *ctx;
+
+  size_t *ops;
+  size_t ops_count;
+  size_t ops_remainder;
+
+  fzl_symtable_t *syms[256];
+  size_t syms_top;
+
+  fzl_ctable_t *classes[64];
+  size_t classes_count;
+
+  fzl_extern_lib_t extern_libs[64];
+  size_t extern_libs_count;
+
+  fzl_extern_type_t extern_types[256];
+  size_t extern_types_count;
+
+  fzl_extern_fn_t extern_fns[256];
+  size_t extern_fns_count;
+} fzl_gen_t;
+
+// Allocate new generator
+fzl_gen_t *fzl_mkgen(fzl_node_t *root);
+
+// Run program generation
+bool fzl_gen_run(fzl_gen_t *gen);
+
+// Free generator
+void fzl_freegen(fzl_gen_t *gen);
+
+#endif // FZL_GENERATOR_H

include/compiler/fzl_parser.h

@@ -3,22 +3,37 @@
 
 #include <compiler/fzl_reader.h>
 #include <compiler/fzl_token.h>
+#include <stdbool.h>
 #include <stddef.h>
 
 // AST node type
 typedef enum
 {
+  FZL_NODETYPE_TYPEDEF,
+  FZL_NODETYPE_HANDLE,
+  FZL_NODETYPE_ALIAS,
+  FZL_NODETYPE_STRUCT,
+  FZL_NODETYPE_REFERENCE,
+  FZL_NODETYPE_EXTERN_FN,
+
+  FZL_NODETYPE_EXTERN,
   FZL_NODETYPE_BLOCK,
-  FZL_NODETYPE_CALL,
+
   FZL_NODETYPE_LITERAL,
   FZL_NODETYPE_FMT_STRING,
+
   FZL_NODETYPE_IDENTIFIER,
+
   FZL_NODETYPE_CONDITIONAL,
+
   FZL_NODETYPE_FUNCTION,
   FZL_NODETYPE_RETURN,
+  FZL_NODETYPE_CALL,
+
   FZL_NODETYPE_CLASS,
   FZL_NODETYPE_FIELD,
   FZL_NODETYPE_CONSTRUCT,
+
   FZL_NODETYPE_LOOP,
   FZL_NODETYPE_BREAK,
 
@@ -92,6 +107,7 @@ typedef struct fzl_node
     {
       fzl_token_t *type;
       struct fzl_node *identifier;
+      bool is_out;
     } var;
 
     // Conditional blocks
@@ -153,6 +169,46 @@ typedef struct fzl_node
 
       struct fzl_node *body;
     } loop;
+
+    // Extern library
+    struct
+    {
+      char *libname;
+
+      struct fzl_node **typedefs;
+      size_t typedefs_count;
+
+      struct fzl_node **fns;
+      size_t fns_count;
+    } ext;
+
+    // Type definition
+    struct
+    {
+      char *typename;
+      struct fzl_node *type;
+    } typedefinition;
+
+    // Structure
+    struct
+    {
+      char *original_name;
+
+      struct fzl_node **entries;
+      size_t entries_count;
+    } structure;
+
+    // External function
+    struct
+    {
+      char *name;
+      char *original_name;
+
+      fzl_token_t *type;
+
+      struct fzl_node **args;
+      size_t args_count;
+    } ext_fn;
   };
 } fzl_node_t;
 

include/compiler/fzl_walker.h

@@ -1,92 +0,0 @@
-#ifndef FZL_WALKER_H
-#define FZL_WALKER_H
-
-#include <common/fzl_opcodes.h>
-#include <common/fzl_types.h>
-#include <compiler/fzl_parser.h>
-#include <compiler/utils/fzl_const_pool.h>
-#include <compiler/utils/fzl_ctable.h>
-#include <compiler/utils/fzl_symtable.h>
-#include <stdbool.h>
-#include <stddef.h>
-
-// Type of context
-typedef enum
-{
-  FZL_WALK_CTX_TYPE_GLOBAL,
-  FZL_WALK_CTX_TYPE_FN,
-  FZL_WALK_CTX_TYPE_CLASS,
-  FZL_WALK_CTX_TYPE_ASSIGN,
-  FZL_WALK_CTX_TYPE_LOOP,
-} fzl_walk_ctx_type_t;
-
-// Internal walk function result
-typedef struct
-{
-  fzl_type_t type;
-
-  char *error_msg;
-  bool error;
-
-  char *classname;
-} fzl_walk_res_t;
-
-// Function context descriptor
-typedef struct fzl_walk_ctx
-{
-  fzl_walk_ctx_type_t type;
-  struct fzl_walk_ctx *parent;
-
-  size_t initial_env_lvl;
-  union
-  {
-    // function info
-    struct
-    {
-      fzl_node_t *fn;
-    };
-
-    // loops `break`s writeback addrs
-    struct
-    {
-      size_t *breaks;
-      size_t breaks_count;
-      size_t breaks_remainder;
-    };
-  };
-} fzl_walk_ctx_t;
-
-// Walker descriptor
-typedef struct
-{
-  fzl_node_t *root;
-  fzl_const_hash_pool_t *consts;
-
-  uint64_t *ops;
-  size_t op_count;
-  size_t op_remainder;
-
-  fzl_symtable_t *syms[64];
-  size_t sym_top;
-
-  fzl_walk_ctx_t *ctx;
-
-  fzl_ctable_t *classes[64];
-  size_t classes_count;
-} fzl_walker_t;
-
-// Allocate new walker
-fzl_walker_t *fzl_mkwalker(fzl_node_t *root);
-
-// Walk throught the entire AST and build:
-// 1. Constants table
-// 2. Operations
-int fzl_walk(fzl_walker_t *walker);
-
-// Get last error message
-char *fzl_walker_geterror();
-
-// Free walker
-void fzl_freewalker(fzl_walker_t *walker);
-
-#endif // FZL_WALKER_H

include/compiler/fzl_writer.h

@@ -1,7 +1,7 @@
 #ifndef FZL_WRITER_H
 #define FZL_WRITER_H
 
-#include <compiler/fzl_walker.h>
+#include <compiler/fzl_gen.h>
 #include <compiler/utils/fzl_const_pool.h>
 
 // File writer descriptor
@@ -14,7 +14,7 @@ typedef struct
 fzl_writer_t *fzl_mkwriter(const char *filepath);
 
 // Write out a file
-int fzl_write(fzl_writer_t *writer, fzl_walker_t *walker);
+int fzl_write(fzl_writer_t *writer, fzl_gen_t *gen);
 
 // Get last writer error message
 char *fzl_writer_geterror();

include/compiler/internals/analyzer.h

@@ -3,6 +3,7 @@
 
 #include <common/fzl_types.h>
 #include <compiler/fzl_analyzer.h>
+#include <compiler/fzl_parser.h>
 #include <compiler/fzl_token.h>
 #include <stdbool.h>
 
@@ -10,7 +11,8 @@ extern char an_problem[256];
 
 bool an_is_compatible(fzl_type_t a, fzl_type_t b, char *ac, char *bc);
 char *an_typetostr(fzl_type_t type, char *classname);
-fzl_type_t an_toktotype(fzl_token_t *tok);
+fzl_type_t an_toktotype(fzl_analyzer_t *analyzer, fzl_token_t *tok,
+                        bool *sym_found);
 
 fzl_an_res_t analyze_common(fzl_analyzer_t *analyzer, fzl_node_t *node);
 fzl_an_res_t analyze_call(fzl_analyzer_t *analyzer, fzl_node_t *call_node);
@@ -31,6 +33,11 @@ fzl_an_res_t analyze_condition(fzl_analyzer_t *analyzer, fzl_node_t *cond_node);
 fzl_an_res_t analyze_unarycond(fzl_analyzer_t *analyzer, fzl_node_t *unary);
 fzl_an_res_t analyze_assign(fzl_analyzer_t *analyzer, fzl_node_t *assign_node);
 fzl_an_res_t analyze_strfmt(fzl_analyzer_t *analyzer, fzl_node_t *strfmt_node);
+fzl_an_res_t analyze_typedef(fzl_analyzer_t *analyzer, fzl_node_t *td_node);
+fzl_an_res_t analyze_struct(fzl_analyzer_t *analyzer, fzl_node_t *struct_node);
+fzl_an_res_t analyze_ref(fzl_analyzer_t *analyzer, fzl_node_t *ref_node);
+fzl_an_res_t analyze_externfn(fzl_analyzer_t *analyzer, fzl_node_t *externfn);
+fzl_an_res_t analyze_extern(fzl_analyzer_t *analyzer, fzl_node_t *extern_node);
 
 fzl_an_ctx_t *an_nest_ctx(fzl_analyzer_t *analyzer, fzl_an_ctx_type_t type);
 fzl_an_ctx_t *an_fin_ctx(fzl_analyzer_t *analyzer);

include/compiler/internals/gen.h

@@ -0,0 +1,69 @@
+#ifndef INTERNALS_GEN_H
+#define INTERNALS_GEN_H
+
+#include <common/fzl_extern.h>
+#include <common/fzl_opcodes.h>
+#include <common/fzl_types.h>
+#include <compiler/fzl_gen.h>
+#include <compiler/fzl_parser.h>
+#include <compiler/fzl_token.h>
+#include <compiler/utils/fzl_const_pool.h>
+#include <compiler/utils/fzl_symtable.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdio.h>
+
+typedef struct
+{
+  bool error;
+  fzl_type_t type;
+  char *classname;
+} gen_res_t;
+
+extern gen_res_t gen_error;
+extern gen_res_t gen_ok_null;
+extern char *null_name;
+extern fzl_extern_type_t type_buf;
+
+bool gen_resolve_name(fzl_gen_t *gen, char *name, fzl_sym_t *sym);
+bool gen_resolve_type(fzl_gen_t *gen, fzl_token_t *tok, fzl_type_t *t, char *c);
+ssize_t gen_resolve_extern_type(fzl_gen_t *gen, char *name);
+bool gen_is_types_compatible(fzl_type_t t1, fzl_type_t t2, char *c1, char *c2);
+size_t gen_add_const(fzl_gen_t *gen, fzl_const_t c);
+void gen_op(fzl_gen_t *gen, fzl_opcode_t opcode);
+void gen_word(fzl_gen_t *gen, size_t word);
+
+fzl_gen_ctx_t *gen_ctx(fzl_gen_t *gen, fzl_gen_ctx_type_t type,
+                       fzl_node_t *node);
+fzl_gen_ctx_t *gen_fin_ctx(fzl_gen_t *gen);
+
+gen_res_t gen_common(fzl_gen_t *gen, fzl_node_t *node);
+gen_res_t gen_extern(fzl_gen_t *gen, fzl_node_t *node);
+gen_res_t gen_externfn(fzl_gen_t *gen, fzl_node_t *node);
+gen_res_t gen_reference(fzl_gen_t *gen, fzl_node_t *node);
+gen_res_t gen_struct(fzl_gen_t *gen, fzl_node_t *node);
+gen_res_t gen_alias(fzl_gen_t *gen, fzl_node_t *node);
+gen_res_t gen_handle(fzl_gen_t *gen, fzl_node_t *node);
+gen_res_t gen_typedef(fzl_gen_t *gen, fzl_node_t *node);
+gen_res_t gen_fmtstr(fzl_gen_t *gen, fzl_node_t *node);
+gen_res_t gen_break(fzl_gen_t *gen, fzl_node_t *node);
+gen_res_t gen_loop(fzl_gen_t *gen, fzl_node_t *node);
+gen_res_t gen_class(fzl_gen_t *gen, fzl_node_t *node);
+gen_res_t gen_construct(fzl_gen_t *gen, fzl_node_t *node);
+gen_res_t gen_field(fzl_gen_t *gen, fzl_node_t *node);
+gen_res_t gen_fn(fzl_gen_t *gen, fzl_node_t *node);
+gen_res_t gen_return(fzl_gen_t *gen, fzl_node_t *node);
+gen_res_t gen_unary_logical(fzl_gen_t *gen, fzl_node_t *node);
+gen_res_t gen_compare(fzl_gen_t *gen, fzl_node_t *node);
+gen_res_t gen_logical(fzl_gen_t *gen, fzl_node_t *node);
+gen_res_t gen_condition(fzl_gen_t *gen, fzl_node_t *node);
+gen_res_t gen_unary_math(fzl_gen_t *gen, fzl_node_t *node);
+gen_res_t gen_declaration(fzl_gen_t *gen, fzl_node_t *node);
+gen_res_t gen_identifier(fzl_gen_t *gen, fzl_node_t *node);
+gen_res_t gen_block(fzl_gen_t *gen, fzl_node_t *node);
+gen_res_t gen_call(fzl_gen_t *gen, fzl_node_t *node);
+gen_res_t gen_literal(fzl_gen_t *gen, fzl_node_t *node);
+gen_res_t gen_math(fzl_gen_t *gen, fzl_node_t *node);
+gen_res_t gen_assign(fzl_gen_t *gen, fzl_node_t *node);
+
+#endif // FZL_INTERNALS_GEN_H

include/compiler/internals/parser.h

@@ -29,6 +29,11 @@ fzl_node_t *pa_new(fzl_parser_t *parser);
 fzl_node_t *pa_assignment(fzl_parser_t *parser);
 fzl_node_t *pa_expression(fzl_parser_t *parser);
 
+fzl_node_t *pa_struct(fzl_parser_t *parser);
+fzl_node_t *pa_ref(fzl_parser_t *parser);
+fzl_node_t *pa_typedef(fzl_parser_t *parser);
+fzl_node_t *pa_externfn(fzl_parser_t *parser);
+
 fzl_node_t *pa_class(fzl_parser_t *parser);
 fzl_node_t *pa_function(fzl_parser_t *parser);
 fzl_node_t *pa_return(fzl_parser_t *parser);
@@ -38,6 +43,7 @@ fzl_node_t *pa_for(fzl_parser_t *parser);
 fzl_node_t *pa_while(fzl_parser_t *parser);
 fzl_node_t *pa_loop(fzl_parser_t *parser);
 fzl_node_t *pa_break(fzl_parser_t *parser);
+fzl_node_t *pa_extern(fzl_parser_t *parser);
 
 fzl_node_t *pa_statement(fzl_parser_t *parser);
 fzl_node_t *pa_program(fzl_parser_t *parser);

include/compiler/internals/writer.h

@@ -0,0 +1,16 @@
+#ifndef INTERNALS_WRITER_H
+#define INTERNALS_WRITER_H
+
+#include <common/fzl_extern.h>
+#include <compiler/utils/fzl_const_pool.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdio.h>
+
+bool wr_consts(FILE *fd, fzl_const_hash_pool_t *consts);
+bool wr_extern_libs(FILE *fd, fzl_extern_lib_t *libs, size_t libs_count);
+bool wr_extern_types(FILE *fd, fzl_extern_type_t *types, size_t types_count);
+bool wr_extern_fns(FILE *fd, fzl_extern_fn_t *fns, size_t fns_count);
+bool wr_ops(FILE *fd, size_t *ops, size_t ops_count);
+
+#endif // INTERNALS_WRITER_H

include/vm/fzl_vm.h

@@ -1,26 +1,18 @@
 #ifndef FZL_VM_H
 #define FZL_VM_H
 
-#include <common/fzl_value.h>
-#include <compiler/utils/fzl_const_pool.h> // NOTE: move outside compiler scope to common
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <vm/fzl_vm_env.h>
 #include <vm/fzl_vm_extern.h>
-#include <vm/fzl_vm_object.h>
+#include <vm/fzl_vm_reader.h>
 
 // VM descriptor
 typedef struct
 {
-  fzl_const_t *consts;
-  size_t consts_count;
-
-  fzl_vm_extern_t *externs;
-  size_t externs_count;
-
-  uint64_t *ops;
-  size_t ops_count;
+  fzl_vm_reader_t *reader;
+  fzl_vm_extern_t *prep_fns;
 
   size_t ip;
 
@@ -41,7 +33,7 @@ typedef struct
 } fzl_vm_t;
 
 // Allocate FZL VM
-fzl_vm_t *fzl_mkvm(const char *filepath);
+fzl_vm_t *fzl_mkvm(fzl_vm_reader_t *reader);
 
 // Load and run code
 int fzl_vm_run(fzl_vm_t *vm);

include/vm/fzl_vm_extern.h

@@ -2,6 +2,8 @@
 #define FZL_VM_EXTERN_H
 
 #include <ffi.h>
+#include <stddef.h>
+#include <vm/fzl_vm_reader.h>
 
 // Loaded extern function definition
 typedef struct
@@ -9,6 +11,25 @@ typedef struct
   void *func_ptr;
   ffi_cif cif;
   ffi_type **arg_types;
+} fzl_vm_sym_t;
+
+// Extern object descriptor
+typedef struct
+{
+  void **libs;
+  size_t libs_loaded;
+
+  fzl_vm_sym_t *syms;
+  size_t syms_loaded;
 } fzl_vm_extern_t;
 
+// Load externs
+fzl_vm_extern_t *fzl_vm_init_externs(fzl_vm_reader_t *reader);
+
+// Get last error from externs loader
+char *fzl_vm_externs_geterror();
+
+// Close and free externs
+void fzl_vm_free_externs(fzl_vm_extern_t *ex);
+
 #endif // FZL_VM_EXTERN_H

include/vm/fzl_vm_reader.h

@@ -0,0 +1,43 @@
+#ifndef FZL_VM_READER_H
+#define FZL_VM_READER_H
+
+#include <common/fzl_extern.h>
+#include <common/fzl_value.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+// Binary file reader descriptor
+typedef struct
+{
+  char *filepath;
+
+  fzl_value_t *consts;
+  uint16_t consts_count;
+
+  size_t *ops;
+  size_t ops_count;
+
+  char **extern_libs;
+  uint16_t extern_libs_count;
+
+  fzl_extern_type_t *extern_types;
+  uint16_t extern_types_count;
+
+  fzl_extern_fn_t *extern_fns;
+  uint16_t extern_fns_count;
+} fzl_vm_reader_t;
+
+// Allocate binary file reader
+fzl_vm_reader_t *fzl_vm_mkreader(char *filepath);
+
+// Read the file
+bool fzl_vm_read(fzl_vm_reader_t *reader);
+
+// Get last error message from the reader
+char *fzl_vm_getreadererror();
+
+// Free file reader
+void fzl_vm_freereader(fzl_vm_reader_t *reader);
+
+#endif // FZL_VM_READER_H

include/vm/internals/opcode.h

@@ -7,7 +7,7 @@
 // Opcode handler descriptor
 typedef int (*opcode_handler)(fzl_vm_t *);
 
-extern char last_err[256];
+extern char last_err[512];
 extern size_t last_jmp_ip;
 extern size_t total_jmp_on_same;
 

include/vm/internals/reader.h

@@ -0,0 +1,24 @@
+#ifndef INTERNALS_VM_READER_H
+#define INTERNALS_VM_READER_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <vm/fzl_vm_reader.h>
+
+extern char internal_error[256];
+
+bool vm_rd_char(FILE *fd, size_t count, char *outbuf);
+bool vm_rd_u16(FILE *fd, size_t count, uint16_t *outbuf);
+bool vm_rd_word(FILE *fd, size_t count, size_t *outbuf);
+
+bool vm_rd_header(fzl_vm_reader_t *reader, FILE *fd);
+bool vm_rd_sections_sz(fzl_vm_reader_t *reader, FILE *fd);
+bool vm_rd_consts(fzl_vm_reader_t *reader, FILE *fd);
+bool vm_rd_extern_libs(fzl_vm_reader_t *reader, FILE *fd);
+bool vm_rd_extern_types(fzl_vm_reader_t *reader, FILE *fd);
+bool vm_rd_extern_fns(fzl_vm_reader_t *reader, FILE *fd);
+bool vm_rd_ops(fzl_vm_reader_t *reader, FILE *fd);
+
+#endif // INTERNALS_VM_READER_H

src/compiler/analyzer/an_block.c

@@ -3,6 +3,7 @@
 #include <compiler/fzl_parser.h>
 #include <compiler/fzl_token.h>
 #include <compiler/internals/analyzer.h>
+#include <stdbool.h>
 #include <stddef.h>
 #include <stdio.h>
 
@@ -49,10 +50,19 @@ fzl_an_res_t analyze_block(fzl_analyzer_t *analyzer, fzl_node_t *block_node)
 
   if (fnctx && fnctx->type == FZL_AN_CTX_TYPE_FUNCTION)
   {
-    fzl_type_t rettype = an_toktotype(fnctx->fn->fn.type);
+    bool found         = false;
+    fzl_type_t rettype = an_toktotype(analyzer, fnctx->fn->fn.type, &found);
     char *classname    = NULL;
     char *rettype_str  = an_typetostr(rettype, classname);
 
+    if (!found)
+    {
+      snprintf(an_problem, sizeof(an_problem), "symbol '%s' not found",
+               (char *)fnctx->fn->fn.type->value);
+      an_push_error(analyzer, fnctx->fn->fn.type, an_problem);
+      return (fzl_an_res_t){.error = true};
+    }
+
     if (rettype == FZL_TYPE_OBJECT)
       classname = (char *)fnctx->fn->fn.type->value;
 

src/compiler/analyzer/an_call.c

@@ -131,7 +131,8 @@ fzl_an_res_t analyze_call(fzl_analyzer_t *analyzer, fzl_node_t *call_node)
     return (fzl_an_res_t){.error = true};
   }
 
-  if (sym.node->type != FZL_NODETYPE_FUNCTION)
+  if (sym.node->type != FZL_NODETYPE_FUNCTION &&
+      sym.node->type != FZL_NODETYPE_EXTERN_FN)
   {
     snprintf(an_problem, sizeof(an_problem), "'%s' is not callable",
              callee_name);
@@ -147,21 +148,23 @@ fzl_an_res_t analyze_call(fzl_analyzer_t *analyzer, fzl_node_t *call_node)
   }
 
   size_t offset     = is_method ? 1 : 0;
-  if ((sym.node->fn.args_count - offset) != call_node->call.args_count)
+  size_t args_count = sym.node->type == FZL_NODETYPE_EXTERN_FN
+                          ? sym.node->ext_fn.args_count
+                          : sym.node->fn.args_count;
+  if ((args_count - offset) != call_node->call.args_count)
   {
     if (is_method)
     {
       snprintf(an_problem, sizeof(an_problem),
                "method '%s.%s' is expecting %zu argument(s), got %zu",
-               tmp_classname, tmp_fnname, sym.node->fn.args_count,
+               tmp_classname, tmp_fnname, args_count,
                call_node->call.args_count - offset);
     }
     else
     {
       snprintf(an_problem, sizeof(an_problem),
                "function '%s' is expecting %zu argument(s), got %zu",
-               callee_name, sym.node->fn.args_count,
-               call_node->call.args_count - offset);
+               callee_name, args_count, call_node->call.args_count - offset);
     }
     an_push_error(analyzer, call_node->token, an_problem);
 
@@ -174,11 +177,24 @@ fzl_an_res_t analyze_call(fzl_analyzer_t *analyzer, fzl_node_t *call_node)
     return (fzl_an_res_t){.error = true};
   }
 
+  fzl_node_t **args = sym.node->type == FZL_NODETYPE_EXTERN_FN
+                          ? sym.node->ext_fn.args
+                          : sym.node->fn.args;
   for (size_t i = offset; i < sym.node->fn.args_count; i++)
   {
-    fzl_node_t *arg     = sym.node->fn.args[i];
-    fzl_type_t req_type = an_toktotype(arg->var.type);
+    fzl_node_t *arg     = args[i];
+    bool found          = false;
+    fzl_type_t req_type = an_toktotype(analyzer, arg->var.type, &found);
     char *req_classname = NULL;
+
+    if (!found)
+    {
+      snprintf(an_problem, sizeof(an_problem), "symbol '%s' not found",
+               (char *)arg->var.type->value);
+      an_push_error(analyzer, arg->var.type, an_problem);
+      return (fzl_an_res_t){.error = true};
+    }
+
     if (req_type == FZL_TYPE_OBJECT)
       req_classname = arg->var.type->value;
 
@@ -226,9 +242,32 @@ fzl_an_res_t analyze_call(fzl_analyzer_t *analyzer, fzl_node_t *call_node)
     }
   }
 
-  fzl_type_t type = an_toktotype(sym.node->fn.type);
+  bool type_found = false;
+  fzl_token_t *ret_tok = NULL;
+  void        *ret_name = NULL;
+
+  if (sym.node->type == FZL_NODETYPE_EXTERN_FN)
+  {
+    ret_tok = sym.node->ext_fn.type;
+    ret_name = sym.node->ext_fn.name;
+  }
+  else
+  {
+    ret_tok = sym.node->fn.type;
+    ret_name = sym.node->fn.name;
+  }
+
+  fzl_type_t type = an_toktotype(analyzer, ret_tok, &type_found);
   char *classname = sym.classname;
 
+  if (!type_found)
+  {
+    snprintf(an_problem, sizeof(an_problem), "symbol '%s' not found",
+             (char *)ret_name);
+    an_push_error(analyzer, ret_tok, an_problem);
+    return (fzl_an_res_t){.error = true};
+  }
+
   if (tmp_method_name != NULL)
   {
     free(tmp_method_name);

src/compiler/analyzer/an_common.c

@@ -4,6 +4,7 @@
 #include <compiler/fzl_token.h>
 #include <compiler/internals/analyzer.h>
 #include <stddef.h>
+#include <stdio.h>
 #include <stdlib.h>
 
 // Analyzer main function
@@ -15,6 +16,34 @@ fzl_an_res_t analyze_common(fzl_analyzer_t *analyzer, fzl_node_t *node)
   fzl_an_res_t res = {.error = false, .type = FZL_TYPE_NULL, .classname = NULL};
   switch (node->type)
   {
+    case FZL_NODETYPE_EXTERN:
+      res = analyze_extern(analyzer, node);
+      break;
+
+    case FZL_NODETYPE_EXTERN_FN:
+      res = analyze_externfn(analyzer, node);
+      break;
+
+    case FZL_NODETYPE_REFERENCE:
+      res = analyze_ref(analyzer, node);
+      break;
+
+    case FZL_NODETYPE_STRUCT:
+      res = analyze_struct(analyzer, node);
+      break;
+
+    case FZL_NODETYPE_ALIAS:
+      res.type = an_toktotype(analyzer, node->token, NULL);
+      break;
+
+    case FZL_NODETYPE_HANDLE:
+      res.type = FZL_TYPE_HANDLE;
+      break;
+
+    case FZL_NODETYPE_TYPEDEF:
+      res = analyze_typedef(analyzer, node);
+      break;
+
     case FZL_NODETYPE_FMT_STRING:
       res = analyze_strfmt(analyzer, node);
       break;

src/compiler/analyzer/an_declaration.c

@@ -20,14 +20,23 @@ fzl_an_res_t analyze_declaration(fzl_analyzer_t *analyzer, fzl_node_t *decl)
   }
 
   char *name      = (char *)decl->var.identifier->token->value;
-  fzl_type_t type = an_toktotype(decl->var.type);
+  bool type_found = false;
+  fzl_type_t type = an_toktotype(analyzer, decl->var.type, &type_found);
+
+  if (!type_found)
+  {
+    snprintf(an_problem, sizeof(an_problem), "symbol '%s' not found",
+             (char *)decl->var.type->value);
+    an_push_error(analyzer, decl->var.type, an_problem);
+    return (fzl_an_res_t){.error = true};
+  }
+
   char *classname = NULL;
   if (type == FZL_TYPE_OBJECT)
     classname = decl->var.type->value;
 
-  fzl_symtable_res_t res =
-      fzl_symt_put(analyzer->symbols[analyzer->symbols_top - 1], decl, name,
-                   an_toktotype(decl->var.type), 0);
+  fzl_symtable_res_t res = fzl_symt_put(
+      analyzer->symbols[analyzer->symbols_top - 1], decl, name, type, 0);
   if (res != FZL_SYMTABLE_RESULT_OK)
   {
     if (res == FZL_SYMTABLE_RESULT_EXISTS)

src/compiler/analyzer/an_extern.c

@@ -0,0 +1,50 @@
+#include <common/fzl_types.h>
+#include <compiler/fzl_analyzer.h>
+#include <compiler/fzl_parser.h>
+#include <compiler/internals/analyzer.h>
+#include <stddef.h>
+#include <stdio.h>
+
+// Analyze extern block definition
+fzl_an_res_t analyze_extern(fzl_analyzer_t *analyzer, fzl_node_t *extern_node)
+{
+  if (!analyzer)
+    return (fzl_an_res_t){.error = true};
+
+  if (!extern_node || extern_node->type != FZL_NODETYPE_EXTERN)
+  {
+    an_push_error(analyzer, NULL, "node is not an extern block");
+    return (fzl_an_res_t){.error = true};
+  }
+
+  if (extern_node->ext.typedefs_count < 1 && extern_node->ext.fns_count < 1)
+    an_push_warning(analyzer, extern_node->token, "extern is empty");
+
+  for (size_t i = 0; i < extern_node->ext.typedefs_count; i++)
+  {
+    fzl_node_t *node = extern_node->ext.typedefs[i];
+    fzl_an_res_t res = analyze_common(analyzer, node);
+    if (res.error)
+      return (fzl_an_res_t){.error = true};
+
+    if (node->type != FZL_NODETYPE_TYPEDEF &&
+        node->type != FZL_NODETYPE_EXTERN_FN)
+    {
+      snprintf(an_problem, sizeof(an_problem),
+               "unexpected statement '%s' inside extern block",
+               (char *)node->token->value);
+      an_push_error(analyzer, node->token, an_problem);
+      return (fzl_an_res_t){.error = true};
+    }
+  }
+
+  for (size_t i = 0; i < extern_node->ext.fns_count; i++)
+  {
+    fzl_an_res_t res = analyze_common(analyzer, extern_node->ext.fns[i]);
+    if (res.error)
+      return (fzl_an_res_t){.error = true};
+  }
+
+  return (fzl_an_res_t){
+      .error = false, .type = FZL_TYPE_NULL, .classname = NULL};
+}

src/compiler/analyzer/an_externfn.c

@@ -0,0 +1,79 @@
+#include <common/fzl_types.h>
+#include <compiler/fzl_analyzer.h>
+#include <compiler/fzl_parser.h>
+#include <compiler/fzl_token.h>
+#include <compiler/internals/analyzer.h>
+#include <compiler/utils/fzl_symtable.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdio.h>
+
+// Analyze external function definition
+fzl_an_res_t analyze_externfn(fzl_analyzer_t *analyzer, fzl_node_t *externfn)
+{
+  if (!analyzer)
+    return (fzl_an_res_t){.error = true};
+
+  if (!externfn || externfn->type != FZL_NODETYPE_EXTERN_FN)
+  {
+    an_push_error(analyzer, NULL, "node is not an external function");
+    return (fzl_an_res_t){.error = true};
+  }
+
+  an_nest_ctx(analyzer, FZL_AN_CTX_TYPE_UNNECESSARY);
+
+  for (size_t i = 0; i < externfn->ext_fn.args_count; i++)
+  {
+    fzl_an_res_t res = analyze_common(analyzer, externfn->ext_fn.args[i]);
+    if (res.error)
+      return (fzl_an_res_t){.error = true};
+  }
+
+  if (externfn->ext_fn.type->type == FZL_TOKTYPE_NAME)
+  {
+    fzl_sym_t sym;
+    bool found = false;
+    for (ssize_t i = analyzer->symbols_top - 1; i >= 0; i--)
+    {
+      if ((found = fzl_symt_get(analyzer->symbols[i],
+                                (char *)externfn->ext_fn.type->value, &sym)))
+        break;
+    }
+
+    if (!found)
+    {
+      snprintf(an_problem, sizeof(an_problem),
+               "cannot find '%s' used as return type",
+               (char *)externfn->ext_fn.type->value);
+      an_push_error(analyzer, externfn->ext_fn.type, an_problem);
+      return (fzl_an_res_t){.error = true};
+    }
+  }
+
+  fzl_symtable_res_t wrres =
+      fzl_symt_put(analyzer->symbols[0], externfn,
+                   (char *)externfn->ext_fn.name, FZL_TYPE_EXTERN_FN, 0);
+  if (wrres != FZL_SYMTABLE_RESULT_OK)
+  {
+    if (wrres == FZL_SYMTABLE_RESULT_EXISTS)
+    {
+      snprintf(an_problem, sizeof(an_problem),
+               "symbol '%s' already has been declared", externfn->ext_fn.name);
+      an_push_error(analyzer, externfn->token, an_problem);
+      return (fzl_an_res_t){.error = true};
+    }
+    else
+    {
+      snprintf(an_problem, sizeof(an_problem), "cannot store symbol '%s'",
+               externfn->ext_fn.name);
+    }
+
+    an_push_error(analyzer, externfn->token, an_problem);
+    return (fzl_an_res_t){.error = true};
+  }
+
+  an_fin_ctx(analyzer);
+
+  return (fzl_an_res_t){
+      .error = false, .type = FZL_TYPE_EXTERN_FN, .classname = NULL};
+}

src/compiler/analyzer/an_field.c

@@ -69,7 +69,18 @@ fzl_an_res_t analyze_field(fzl_analyzer_t *analyzer, fzl_node_t *field)
     return (fzl_an_res_t){.error = true};
   }
 
-  fzl_type_t field_type = an_toktotype(field_node->var.type);
+  bool type_found = false;
+  fzl_type_t field_type =
+      an_toktotype(analyzer, field_node->var.type, &type_found);
+
+  if (!type_found)
+  {
+    snprintf(an_problem, sizeof(an_problem), "symbol '%s' not found",
+             (char *)field_node->var.type->value);
+    an_push_error(analyzer, field_node->var.type, an_problem);
+    return (fzl_an_res_t){.error = true};
+  }
+
   char *classname = NULL;
   if (field_type == FZL_TYPE_OBJECT)
     classname = field_node->var.type->value;

src/compiler/analyzer/an_function.c

@@ -38,8 +38,18 @@ fzl_an_res_t analyze_function(fzl_analyzer_t *analyzer, fzl_node_t *fn_node)
     ctx = ctx->parent;
   }
 
-  fzl_type_t rettype = an_toktotype(fn_node->fn.type);
+  bool type_found    = false;
+  fzl_type_t rettype = an_toktotype(analyzer, fn_node->fn.type, &type_found);
   char *classname    = NULL;
+
+  if (!type_found)
+  {
+    snprintf(an_problem, sizeof(an_problem), "symbol '%s' not found",
+             (char *)fn_node->fn.type->value);
+    an_push_error(analyzer, fn_node->fn.type, an_problem);
+    return (fzl_an_res_t){.error = true};
+  }
+
   if (rettype == FZL_TYPE_OBJECT)
     classname = (char *)fn_node->fn.type->value;
 

src/compiler/analyzer/an_loop.c

@@ -50,8 +50,17 @@ init_analysis check_init(fzl_analyzer_t *analyzer, fzl_node_t *init)
   else if (init->type == FZL_NODETYPE_DECLARATION)
   {
     char *name = init->var.identifier->token->value;
-    fzl_type_t type = an_toktotype(init->var.type);
+
+    bool type_found = false;
+    fzl_type_t type = an_toktotype(analyzer, init->var.type, &type_found);
     char *classname = NULL;
+
+    if (!type_found)
+    {
+      snprintf(an_problem, sizeof(an_problem), "symbol '%s' not found",
+               (char *)init->var.type->value);
+    }
+
     if (type == FZL_TYPE_OBJECT)
       classname = init->var.type->value;
 

src/compiler/analyzer/an_ref.c

@@ -0,0 +1,39 @@
+#include <common/fzl_types.h>
+#include <compiler/fzl_analyzer.h>
+#include <compiler/fzl_parser.h>
+#include <compiler/internals/analyzer.h>
+#include <compiler/utils/fzl_symtable.h>
+#include <stdbool.h>
+#include <stdio.h>
+
+// Analyze reference
+fzl_an_res_t analyze_ref(fzl_analyzer_t *analyzer, fzl_node_t *ref_node)
+{
+  if (!analyzer)
+    return (fzl_an_res_t){.error = true};
+
+  if (!ref_node || ref_node->type != FZL_NODETYPE_REFERENCE)
+  {
+    an_push_error(analyzer, NULL, "node is not a reference");
+    return (fzl_an_res_t){.error = true};
+  }
+
+  char *refto = (char *)ref_node->token->value;
+  fzl_sym_t sym;
+  bool found = false;
+  for (ssize_t i = analyzer->symbols_top - 1; i >= 0; i--)
+  {
+    if ((found = fzl_symt_get(analyzer->symbols[i], refto, &sym)))
+      break;
+  }
+
+  if (!found)
+  {
+    snprintf(an_problem, sizeof(an_problem), "cannot find name '%s'", refto);
+    an_push_error(analyzer, ref_node->token, an_problem);
+    return (fzl_an_res_t){.error = true};
+  }
+
+  return (fzl_an_res_t){
+      .error = false, .type = FZL_TYPE_HANDLE, .classname = refto};
+}

src/compiler/analyzer/an_return.c

@@ -3,6 +3,7 @@
 #include <compiler/fzl_parser.h>
 #include <compiler/fzl_token.h>
 #include <compiler/internals/analyzer.h>
+#include <stdbool.h>
 #include <stdio.h>
 
 // Analyze return statement
@@ -45,8 +46,18 @@ fzl_an_res_t analyze_return(fzl_analyzer_t *analyzer, fzl_node_t *ret_node)
     return (fzl_an_res_t){.error = true};
   }
 
-  fzl_type_t rettype = an_toktotype(fnctx->fn->fn.type);
+  bool type_found    = false;
+  fzl_type_t rettype = an_toktotype(analyzer, fnctx->fn->fn.type, &type_found);
   char *classname    = NULL;
+
+  if (!type_found)
+  {
+    snprintf(an_problem, sizeof(an_problem), "symbol '%s' not found",
+             (char *)fnctx->fn->fn.type->value);
+    an_push_error(analyzer, fnctx->fn->fn.type, an_problem);
+    return (fzl_an_res_t){.error = true};
+  }
+
   if (rettype == FZL_TYPE_OBJECT)
     classname = (char *)fnctx->fn->fn.type->value;
 

src/compiler/analyzer/an_struct.c

@@ -0,0 +1,56 @@
+#include <common/fzl_types.h>
+#include <compiler/fzl_analyzer.h>
+#include <compiler/fzl_parser.h>
+#include <compiler/internals/analyzer.h>
+#include <stdbool.h>
+#include <stddef.h>
+
+// Analyze structure definition
+fzl_an_res_t analyze_struct(fzl_analyzer_t *analyzer, fzl_node_t *struct_node)
+{
+  if (!analyzer)
+    return (fzl_an_res_t){.error = true};
+
+  if (!struct_node || struct_node->type != FZL_NODETYPE_STRUCT)
+  {
+    an_push_error(analyzer, NULL, "node is not a structure");
+    return (fzl_an_res_t){.error = true};
+  }
+
+  an_nest_ctx(analyzer, FZL_AN_CTX_TYPE_UNNECESSARY);
+
+  if (struct_node->structure.entries_count < 1)
+  {
+    an_push_warning(analyzer, struct_node->token, "empty structure");
+    return (fzl_an_res_t){.error = false};
+  }
+
+  for (size_t i = 0; i < struct_node->structure.entries_count; i++)
+  {
+    fzl_node_t *entry = struct_node->structure.entries[i];
+    if (entry->type != FZL_NODETYPE_DECLARATION &&
+        entry->type != FZL_NODETYPE_IDENTIFIER)
+    {
+      an_push_error(
+          analyzer, entry->token,
+          "structure can contain only declarations and another structures");
+      return (fzl_an_res_t){.error = true};
+    }
+
+    fzl_an_res_t res = analyze_common(analyzer, entry);
+    if (res.error)
+      return (fzl_an_res_t){.error = true};
+
+    if (res.type == FZL_TYPE_OBJECT)
+    {
+      an_push_error(analyzer, entry->token,
+                    "cannot store object inside struct");
+      return (fzl_an_res_t){.error = true};
+    }
+  }
+
+  an_fin_ctx(analyzer);
+
+  return (fzl_an_res_t){
+      .error = false, .type = FZL_TYPE_STRUCT, .classname = NULL};
+}

src/compiler/analyzer/an_typedef.c

@@ -0,0 +1,57 @@
+#include <common/fzl_types.h>
+#include <compiler/fzl_analyzer.h>
+#include <compiler/fzl_parser.h>
+#include <compiler/internals/analyzer.h>
+#include <compiler/utils/fzl_symtable.h>
+#include <stdio.h>
+
+// Analyze type definition
+fzl_an_res_t analyze_typedef(fzl_analyzer_t *analyzer, fzl_node_t *td_node)
+{
+  if (!analyzer)
+    return (fzl_an_res_t){.error = true};
+
+  if (!td_node || td_node->type != FZL_NODETYPE_TYPEDEF)
+  {
+    an_push_error(analyzer, NULL, "node is not a type definition");
+    return (fzl_an_res_t){.error = true};
+  }
+
+  fzl_an_res_t res = analyze_common(analyzer, td_node->typedefinition.type);
+  if (res.error)
+    return (fzl_an_res_t){.error = true};
+
+  fzl_nodetype_t type = td_node->typedefinition.type->type;
+  if (type != FZL_NODETYPE_ALIAS && type != FZL_NODETYPE_STRUCT &&
+      type != FZL_NODETYPE_HANDLE && type != FZL_NODETYPE_REFERENCE)
+  {
+    an_push_error(
+        analyzer, td_node->token,
+        "only alias, structure, reference and handle are allowed in type "
+        "definition value");
+    return (fzl_an_res_t){.error = true};
+  }
+
+  fzl_symtable_res_t putres =
+      fzl_symt_put(analyzer->symbols[0], td_node,
+                   td_node->typedefinition.typename, res.type, 0);
+  if (putres != FZL_SYMTABLE_RESULT_OK)
+  {
+    if (putres == FZL_SYMTABLE_RESULT_EXISTS)
+      snprintf(an_problem, sizeof(an_problem),
+               "symbol '%s' already has been declared",
+               td_node->typedefinition.typename);
+    else
+      snprintf(an_problem, sizeof(an_problem), "cannot store symbol '%s'",
+               td_node->typedefinition.typename);
+
+    an_push_error(analyzer, td_node->token, an_problem);
+    return (fzl_an_res_t){.error = true};
+  }
+
+  if (res.type == FZL_TYPE_STRUCT || res.type == FZL_TYPE_HANDLE)
+    fzl_symt_setobjclass(analyzer->symbols[0], td_node->typedefinition.typename,
+                         td_node->typedefinition.typename);
+
+  return (fzl_an_res_t){.error = false, .type = res.type, .classname = NULL};
+}

src/compiler/analyzer/utility.c

@@ -1,6 +1,11 @@
 #include <common/fzl_types.h>
+#include <compiler/fzl_analyzer.h>
+#include <compiler/fzl_parser.h>
 #include <compiler/fzl_token.h>
+#include <compiler/internals/analyzer.h>
+#include <compiler/utils/fzl_symtable.h>
 #include <stdbool.h>
+#include <stdio.h>
 #include <string.h>
 
 // Check compatibility between A and B types (and classnames)
@@ -79,14 +84,45 @@ char *an_typetostr(fzl_type_t type, char *classname)
 }
 
 // Convert type token to type
-fzl_type_t an_toktotype(fzl_token_t *tok)
+fzl_type_t an_toktotype(fzl_analyzer_t *analyzer, fzl_token_t *tok,
+                        bool *sym_found)
 {
   if (!tok)
     return FZL_TYPE_NULL;
 
   if (tok->type == FZL_TOKTYPE_NAME)
+  {
+    fzl_sym_t sym;
+    bool found = false;
+    for (ssize_t i = analyzer->symbols_top - 1; i >= 0; i--)
+    {
+      if ((found = fzl_symt_get(analyzer->symbols[i], tok->value, &sym)))
+        break;
+    }
+
+    if (sym_found)
+      *sym_found = found;
+
+    if (found && sym.node->type == FZL_NODETYPE_CLASS)
       return FZL_TYPE_OBJECT;
 
+    if (found && sym.node->type != FZL_NODETYPE_CLASS &&
+        sym.node->type != FZL_NODETYPE_TYPEDEF)
+    {
+      snprintf(an_problem, sizeof(an_problem), "cannot use '%s' as type",
+               sym.name);
+      an_push_error(analyzer, sym.node->token, an_problem);
+      return FZL_TYPE_NULL;
+    }
+
+    return (found || (tok->value && strcmp(tok->value, "null") == 0))
+               ? sym.type
+               : FZL_TYPE_NULL;
+  }
+
+  if (sym_found)
+    *sym_found = true;
+
   if (strcmp(tok->value, "null") == 0)
     return FZL_TYPE_NULL;
 

src/compiler/fzl_debug.c

@@ -32,6 +32,52 @@ void print_node(fzl_node_t *node, int level)
 
   switch (node->type)
   {
+    case FZL_NODETYPE_EXTERN:
+      printf("%s Extern bindings to library '%s':\n", levelbuf,
+             node->ext.libname);
+      printf("-%s Types:\n", levelbuf);
+      for (size_t i = 0; i < node->ext.typedefs_count; i++)
+        print_node(node->ext.typedefs[i], level + 2);
+      printf("-%s Functions:\n", levelbuf);
+      for (size_t i = 0; i < node->ext.fns_count; i++)
+        print_node(node->ext.fns[i], level + 2);
+      break;
+
+    case FZL_NODETYPE_EXTERN_FN:
+      printf("%s External function '%s' (original name %s), rettype '%s':\n",
+             levelbuf, node->ext_fn.name, node->ext_fn.original_name,
+             (char *)node->ext_fn.type->value);
+      printf("-%s Arguments:\n", levelbuf);
+      for (size_t i = 0; i < node->ext_fn.args_count; i++)
+        print_node(node->ext_fn.args[i], level + 2);
+      break;
+
+    case FZL_NODETYPE_REFERENCE:
+      printf("%s Reference (pointer type) to '%s'\n", levelbuf,
+             (char *)node->token->value);
+      break;
+
+    case FZL_NODETYPE_STRUCT:
+      printf("%s Structure '%s' (original name %s):\n", levelbuf,
+             (char *)node->token->value, node->structure.original_name);
+      for (size_t i = 0; i < node->structure.entries_count; i++)
+        print_node(node->structure.entries[i], level + 1);
+      break;
+
+    case FZL_NODETYPE_ALIAS:
+      printf("%s Type alias to '%s'\n", levelbuf, (char *)node->token->value);
+      break;
+
+    case FZL_NODETYPE_HANDLE:
+      printf("%s Opaque pointer (handle)\n", levelbuf);
+      break;
+
+    case FZL_NODETYPE_TYPEDEF:
+      printf("%s Type definition '%s':\n", levelbuf,
+             node->typedefinition.typename);
+      print_node(node->typedefinition.type, level + 1);
+      break;
+
     case FZL_NODETYPE_UNARY_MINUS:
       printf("%s Unary '-':\n", levelbuf);
       print_node(node->unary_op.operand, level + 1);

src/compiler/fzl_gen.c

@@ -0,0 +1,107 @@
+#include <common/fzl_opcodes.h>
+#include <compiler/fzl_gen.h>
+#include <compiler/fzl_parser.h>
+#include <compiler/internals/gen.h>
+#include <compiler/utils/fzl_const_pool.h>
+#include <compiler/utils/fzl_ctable.h>
+#include <compiler/utils/fzl_symtable.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+fzl_gen_t *fzl_mkgen(fzl_node_t *root)
+{
+  if (!root)
+    return NULL;
+
+  fzl_gen_t *gen = malloc(sizeof(fzl_gen_t));
+  if (!gen)
+    return NULL;
+
+  memset(gen, 0, sizeof(fzl_gen_t));
+
+  gen->root   = root;
+  gen->consts = fzl_mkconstpool();
+  if (!gen->consts)
+  {
+    free(gen);
+    return NULL;
+  }
+
+  gen->ops_remainder = 2;
+  gen->ops           = malloc(gen->ops_remainder * sizeof(size_t));
+
+  gen->ctx = gen_ctx(gen, FZL_GEN_CTX_TYPE_UNECCESSARY, NULL);
+  if (!gen->ctx)
+  {
+    fzl_consts_pool_free(gen->consts);
+    free(gen->ops);
+    free(gen);
+    return NULL;
+  }
+
+  return gen;
+}
+
+bool fzl_gen_run(fzl_gen_t *gen)
+{
+  if (!gen)
+    return false;
+
+  gen_op(gen, FZL_OPCODE_MK_ENVTABLE);
+
+  fzl_node_t *current = gen->root;
+  while (current != NULL)
+  {
+    if (gen_common(gen, current).error)
+      return false;
+
+    current = current->next;
+  }
+
+  gen_op(gen, FZL_OPCODE_RM_ENVTABLE);
+
+  return true;
+}
+
+void fzl_freegen(fzl_gen_t *gen)
+{
+  if (!gen)
+    return;
+
+  if (gen->consts)
+    fzl_consts_pool_free(gen->consts);
+
+  if (gen->ops)
+    free(gen->ops);
+
+  while (gen->ctx != NULL)
+    gen_fin_ctx(gen);
+
+  if (gen->syms_top > 0)
+    for (ssize_t i = gen->syms_top - 1; i >= 0; i--)
+      fzl_freesymt(gen->syms[i]);
+
+  if (gen->classes_count > 0)
+    for (ssize_t i = gen->classes_count - 1; i >= 0; i--)
+      fzl_freectable(gen->classes[i]);
+
+  for (size_t i = 0; i < gen->extern_types_count; i++)
+  {
+    fzl_extern_type_t *type = &gen->extern_types[i];
+    if (type->kind == FZL_EXTERN_KIND_STRUCT)
+      if (type->structure.fields)
+        free(type->structure.fields);
+  }
+
+  for (size_t i = 0; i < gen->extern_fns_count; i++)
+  {
+    fzl_extern_fn_t *fn = &gen->extern_fns[i];
+    if (fn->args)
+      free(fn->args);
+  }
+
+  free(gen);
+}

src/compiler/fzl_parser.c

@@ -94,11 +94,40 @@ void fzl_freeast(fzl_node_t *root)
   {
     switch (root->type)
     {
+      case FZL_NODETYPE_REFERENCE:
+      case FZL_NODETYPE_ALIAS:
+      case FZL_NODETYPE_HANDLE:
       case FZL_NODETYPE_BREAK:
       case FZL_NODETYPE_IDENTIFIER:
       case FZL_NODETYPE_LITERAL:
         break;
 
+      case FZL_NODETYPE_EXTERN:
+        for (size_t i = 0; i < root->ext.typedefs_count; i++)
+          fzl_freeast(root->ext.typedefs[i]);
+        free(root->ext.typedefs);
+
+        for (size_t i = 0; i < root->ext.fns_count; i++)
+          fzl_freeast(root->ext.fns[i]);
+        free(root->ext.fns);
+        break;
+
+      case FZL_NODETYPE_EXTERN_FN:
+        for (size_t i = 0; i < root->ext_fn.args_count; i++)
+          fzl_freeast(root->ext_fn.args[i]);
+        free(root->ext_fn.args);
+        break;
+
+      case FZL_NODETYPE_STRUCT:
+        for (size_t i = 0; i < root->structure.entries_count; i++)
+          fzl_freeast(root->structure.entries[i]);
+        free(root->structure.entries);
+        break;
+
+      case FZL_NODETYPE_TYPEDEF:
+        fzl_freeast(root->typedefinition.type);
+        break;
+
       case FZL_NODETYPE_FMT_STRING:
       case FZL_NODETYPE_BLOCK:
         if (root->list.entries)

src/compiler/fzl_token.c

@@ -33,7 +33,7 @@ void fzl_freetoken(fzl_token_t *tok)
   if (!tok)
     return;
 
-  if (tok->store_value)
+  if (tok->store_value && tok->value)
     free(tok->value);
 
   free(tok);

src/compiler/fzl_writer.c

@@ -1,4 +1,6 @@
+#include <compiler/fzl_gen.h>
 #include <compiler/fzl_writer.h>
+#include <compiler/internals/writer.h>
 #include <compiler/utils/fzl_const_pool.h>
 #include <stddef.h>
 #include <stdint.h>
@@ -11,52 +13,82 @@ char wrlast_err[256];
 fzl_writer_t *fzl_mkwriter(const char *filepath)
 {
   if (strlen(filepath) < 1)
-    return NULL;
+    return nullptr;
 
   fzl_writer_t *writer = malloc(sizeof(fzl_writer_t));
   if (!writer)
-    return NULL;
+    return nullptr;
 
   writer->filepath = filepath;
 
   return writer;
 }
 
-int fzl_write(fzl_writer_t *writer, fzl_walker_t *walker)
+int fzl_write(fzl_writer_t *writer, fzl_gen_t *gen)
 {
-  if (!writer || !walker)
+  if (!writer || !gen)
     return -1;
 
-  FILE *fp = fopen(writer->filepath, "wb");
-  if (!fp)
+  FILE *fd = fopen(writer->filepath, "wb");
+  if (!fd)
   {
     snprintf(wrlast_err, sizeof(wrlast_err), "failed to open '%s' to write",
              writer->filepath);
     return -1;
   }
 
-  const char hdr[5] = {'F', 'Z', 'L', 0x0, 0x1};
-  fwrite(hdr, sizeof(char), 5, fp);
-  fwrite(&walker->consts->size, sizeof(size_t), 1, fp);
-  fwrite(&walker->op_count, sizeof(size_t), 1, fp);
+  constexpr char hdr[5] = {'F', 'Z', 'L', 0x0, 0x2};
+  fwrite(hdr, sizeof(char), 5, fd);
+  fwrite(&gen->consts->size, sizeof(uint16_t), 1, fd);
+  fwrite(&gen->extern_libs_count, sizeof(uint16_t), 1, fd);
+  fwrite(&gen->extern_types_count, sizeof(uint16_t), 1, fd);
+  fwrite(&gen->extern_fns_count, sizeof(uint16_t), 1, fd);
+  fwrite(&gen->ops_count, sizeof(size_t), 1, fd);
 
-  for (size_t i = 0; i < walker->consts->size; i++)
+  bool result = wr_consts(fd, gen->consts);
+  if (!result)
   {
-    fzl_const_t c = walker->consts->array[i];
-    fwrite(&c.type, sizeof(fzl_consttype_t), 1, fp);
-
-    if (c.type == FZL_CONSTTYPE_STRING)
-    {
-      size_t strlen = c.as.string.length;
-      fwrite(&c.as.string.length, sizeof(size_t), 1, fp);
-      fwrite(c.as.string.chars, sizeof(char), strlen, fp);
-    }
+    snprintf(wrlast_err, sizeof(wrlast_err), "failed to write constants table");
+    fclose(fd);
+    return -1;
   }
 
-  if (walker->op_count > 0)
-    fwrite(walker->ops, sizeof(uint64_t), walker->op_count, fp);
+  result = wr_extern_libs(fd, gen->extern_libs, gen->extern_libs_count);
+  if (!result)
+  {
+    snprintf(wrlast_err, sizeof(wrlast_err),
+             "failed to write external lib names");
+    fclose(fd);
+    return -1;
+  }
 
-  fclose(fp);
+  result = wr_extern_types(fd, gen->extern_types, gen->extern_types_count);
+  if (!result)
+  {
+    snprintf(wrlast_err, sizeof(wrlast_err),
+             "failed to write extern lib types");
+    fclose(fd);
+    return -1;
+  }
+
+  result = wr_extern_fns(fd, gen->extern_fns, gen->extern_fns_count);
+  if (!result)
+  {
+    snprintf(wrlast_err, sizeof(wrlast_err),
+             "failed to write extern lib functions");
+    fclose(fd);
+    return -1;
+  }
+
+  result = wr_ops(fd, gen->ops, gen->ops_count);
+  if (!result)
+  {
+    snprintf(wrlast_err, sizeof(wrlast_err), "failed to write opcodes");
+    fclose(fd);
+    return -1;
+  }
+
+  fclose(fd);
 
   return 0;
 }

src/compiler/generator/context.c

@@ -0,0 +1,84 @@
+#include "compiler/fzl_parser.h"
+#include <compiler/fzl_gen.h>
+#include <compiler/internals/gen.h>
+#include <compiler/utils/fzl_symtable.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <string.h>
+
+// Nest context
+fzl_gen_ctx_t *gen_ctx(fzl_gen_t *gen, fzl_gen_ctx_type_t type,
+                       fzl_node_t *node)
+{
+  if (!gen)
+    return NULL;
+
+  fzl_gen_ctx_t *ctx = malloc(sizeof(fzl_gen_ctx_t));
+  if (!ctx)
+    return NULL;
+
+  memset(ctx, 0, sizeof(fzl_gen_ctx_t));
+  ctx->type = type;
+
+  if (ctx->type != FZL_GEN_CTX_TYPE_CLASS)
+  {
+    fzl_symtable_t *symt = fzl_mksymt();
+    if (!symt)
+    {
+      free(ctx);
+      return NULL;
+    }
+
+    gen->syms[gen->syms_top++] = symt;
+  }
+
+  size_t level          = 0;
+  fzl_gen_ctx_t *parent = gen->ctx;
+  while (parent != NULL)
+  {
+    level++;
+    parent = parent->parent;
+  }
+
+  ctx->level  = level;
+  ctx->parent = gen->ctx;
+
+  if (type == FZL_GEN_CTX_TYPE_FUNCTION)
+  {
+    if (node->type == FZL_NODETYPE_FUNCTION ||
+        node->type == FZL_NODETYPE_EXTERN_FN)
+      ctx->function = node;
+    else
+    {
+      fzl_freesymt(gen->syms[--gen->syms_top]);
+      free(ctx);
+      return NULL;
+    }
+  }
+
+  gen->ctx = ctx;
+
+  return gen->ctx;
+}
+
+fzl_gen_ctx_t *gen_fin_ctx(fzl_gen_t *gen)
+{
+  if (!gen)
+    return NULL;
+
+  fzl_gen_ctx_t *ctx = gen->ctx;
+  if (!ctx)
+    return NULL;
+
+  if (ctx->type != FZL_GEN_CTX_TYPE_CLASS)
+  {
+    fzl_symtable_t *sym = gen->syms[--gen->syms_top];
+    if (sym)
+      fzl_freesymt(sym);
+  }
+
+  gen->ctx = ctx->parent;
+  free(ctx);
+
+  return gen->ctx;
+}

src/compiler/generator/gen_alias.c

@@ -0,0 +1,31 @@
+#include <common/fzl_types.h>
+#include <compiler/internals/gen.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <string.h>
+
+char alias_typecn[256];
+
+// Type aliasing
+gen_res_t gen_alias(fzl_gen_t *gen, fzl_node_t *node)
+{
+  if (!gen || !node)
+    return gen_error;
+
+  fzl_type_t type;
+  memset(alias_typecn, 0, sizeof(alias_typecn));
+
+  bool resolved = gen_resolve_type(gen, node->token, &type, alias_typecn);
+  if (!resolved)
+    return gen_error;
+
+  ssize_t slot = gen_resolve_extern_type(gen, alias_typecn);
+  if (slot == -1)
+    type_buf.alias_target =
+        (fzl_extern_type_ref_t){.is_primitive = true, .primitive = type};
+  else
+    type_buf.alias_target =
+        (fzl_extern_type_ref_t){.is_primitive = false, .type_slot = slot};
+
+  return gen_ok_null;
+}

src/compiler/generator/gen_assign.c

@@ -0,0 +1,122 @@
+#include <compiler/fzl_gen.h>
+#include <compiler/fzl_parser.h>
+#include <compiler/internals/gen.h>
+#include <string.h>
+
+// Assignment to declaration
+gen_res_t assign_declaration(fzl_gen_t *gen, fzl_node_t *node)
+{
+  gen_res_t rres = gen_common(gen, node->binary_op.right);
+  if (rres.error)
+    return gen_error;
+
+  gen_res_t lres = gen_common(gen, node->binary_op.left);
+  if (lres.error)
+    return gen_error;
+
+  if (!gen_is_types_compatible(rres.type, lres.type, rres.classname,
+                               lres.classname))
+    return gen_error;
+
+  gen_op(gen, FZL_OPCODE_WRITE);
+
+  return (gen_res_t){
+      .error = false, .type = rres.type, .classname = rres.classname};
+}
+
+// Assignment to identifier
+gen_res_t assign_id(fzl_gen_t *gen, fzl_node_t *node)
+{
+  gen_res_t rres = gen_common(gen, node->binary_op.right);
+  if (rres.error)
+    return gen_error;
+
+  char *name = (char *)node->binary_op.left->token->value;
+  fzl_sym_t sym;
+  bool found = false;
+  ssize_t i  = gen->syms_top - 1;
+  for (; i >= 0; i--)
+    if ((found = fzl_symt_get(gen->syms[i], name, &sym)))
+      break;
+
+  if (!found)
+    return gen_error;
+
+  if (!gen_is_types_compatible(sym.type, rres.type, sym.classname,
+                               rres.classname))
+    return gen_error;
+
+  if (!sym.slot_set)
+    return gen_error;
+
+  size_t depth = gen->syms_top - 1 - i;
+  gen_op(gen, FZL_OPCODE_STORE_LOCAL);
+  gen_word(gen, depth);
+  gen_word(gen, sym.slot);
+
+  return (gen_res_t){
+      .error = false, .type = rres.type, .classname = rres.classname};
+}
+
+// Assignment to field
+gen_res_t assign_field(fzl_gen_t *gen, fzl_node_t *node)
+{
+  gen_res_t rres = gen_common(gen, node->binary_op.right);
+  if (rres.error)
+    return gen_error;
+
+  fzl_node_t *field_node = node->binary_op.left;
+  gen_res_t obj_res      = gen_common(gen, field_node->memb.parent);
+  if (obj_res.error)
+    return gen_error;
+
+  fzl_ctable_t *ct = NULL;
+  for (size_t i = 0; i < gen->classes_count; i++)
+  {
+    if (strcmp(obj_res.classname, gen->classes[i]->name) == 0)
+    {
+      ct = gen->classes[i];
+      break;
+    }
+  }
+
+  if (!ct)
+    return gen_error;
+
+  fzl_ctable_field_t *ctf = NULL;
+  for (size_t i = 0; i < ct->fields_count; i++)
+  {
+    if (strcmp(field_node->memb.field->token->value, ct->fields[i].name) == 0)
+    {
+      ctf = &ct->fields[i];
+      break;
+    }
+  }
+
+  if (!ctf)
+    return gen_error;
+
+  gen_op(gen, FZL_OPCODE_SET_FIELD);
+  gen_word(gen, ctf->slot_index);
+
+  return (gen_res_t){
+      .error = false, .type = rres.type, .classname = rres.classname};
+}
+
+// Assignment
+gen_res_t gen_assign(fzl_gen_t *gen, fzl_node_t *node)
+{
+  if (!gen || !node)
+    return gen_error;
+
+  if (node->binary_op.left->type == FZL_NODETYPE_DECLARATION)
+    return assign_declaration(gen, node);
+
+  if (node->binary_op.left->type == FZL_NODETYPE_IDENTIFIER)
+    return assign_id(gen, node);
+
+  if (node->binary_op.left->type == FZL_NODETYPE_FIELD)
+    return assign_field(gen, node);
+
+  return gen_error;
+}

src/compiler/generator/gen_block.c

@@ -0,0 +1,27 @@
+#include <compiler/fzl_gen.h>
+#include <compiler/internals/gen.h>
+
+// Block definition
+gen_res_t gen_block(fzl_gen_t *gen, fzl_node_t *node)
+{
+  if (!gen || !node)
+    return gen_error;
+
+  fzl_gen_ctx_t *ctx = gen_ctx(gen, FZL_GEN_CTX_TYPE_UNECCESSARY, node);
+  if (!ctx)
+    return gen_error;
+
+  gen_op(gen, FZL_OPCODE_MK_ENVTABLE);
+  if (node->list.entry_count > 0)
+    for (size_t i = 0; i < node->list.entry_count; i++)
+      if (gen_common(gen, node->list.entries[i]).error)
+        return gen_error;
+
+  ctx = gen_fin_ctx(gen);
+  if (!ctx)
+    return gen_error;
+
+  gen_op(gen, FZL_OPCODE_RM_ENVTABLE);
+
+  return gen_ok_null;
+}

src/compiler/generator/gen_break.c

@@ -0,0 +1,33 @@
+#include <common/fzl_types.h>
+#include <compiler/fzl_gen.h>
+#include <compiler/internals/gen.h>
+#include <stdbool.h>
+#include <stdio.h>
+
+// Break keyword
+gen_res_t gen_break(fzl_gen_t *gen, fzl_node_t *node)
+{
+  if (!gen || !node)
+    return gen_error;
+
+  fzl_gen_ctx_t *ctx = gen->ctx;
+  while (ctx != NULL)
+  {
+    if (ctx && ctx->type == FZL_GEN_CTX_TYPE_LOOP)
+      break;
+
+    ctx = ctx->parent;
+  }
+
+  if (!ctx || ctx->type != FZL_GEN_CTX_TYPE_LOOP)
+    return gen_error;
+
+  for (size_t i = gen->syms_top - 1; i > ctx->level + 1; i--)
+    gen_op(gen, FZL_OPCODE_RM_ENVTABLE);
+
+  gen_op(gen, FZL_OPCODE_JMP);
+  ctx->loop.breaks[ctx->loop.breaks_count++] = gen->ops_count;
+  gen_word(gen, 0);
+
+  return gen_ok_null;
+}

src/compiler/generator/gen_call.c

@@ -0,0 +1,230 @@
+#include <common/fzl_builtins.h>
+#include <common/fzl_extern.h>
+#include <common/fzl_opcodes.h>
+#include <common/fzl_types.h>
+#include <compiler/fzl_parser.h>
+#include <compiler/internals/gen.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <string.h>
+
+// Call definition
+// NOTE: split by call type (builtin/declared/extern)
+gen_res_t gen_call(fzl_gen_t *gen, fzl_node_t *node)
+{
+  if (!gen || !node)
+    return gen_error;
+
+  // `printline(x)` builtin function
+  if (strcmp(node->token->value, "printline") == 0)
+  {
+    if (node->call.args_count > 0)
+      for (size_t i = 0; i < node->call.args_count; i++)
+        if (gen_common(gen, node->call.args[i]).error)
+          return gen_error;
+
+    gen_op(gen, FZL_OPCODE_CALL_BUILTIN);
+    gen_word(gen, FZL_BUILTIN_PRINTLINE);
+    if (node->call.args_count < 1)
+      return gen_error;
+
+    return gen_ok_null;
+  }
+
+  // `exit(x?)` builtin function
+  if (strcmp(node->token->value, "exit") == 0)
+  {
+    if (node->call.args_count > 0)
+    {
+      for (size_t i = 0; i < node->call.args_count; i++)
+        if (gen_common(gen, node->call.args[i]).error)
+          return gen_error;
+
+      gen_op(gen, FZL_OPCODE_CALL_BUILTIN);
+      gen_word(gen, FZL_BUILTIN_EXIT);
+      if (node->call.args_count < 1)
+        return gen_error;
+    }
+
+    return gen_ok_null;
+  }
+
+  if (node->call.callee->type == FZL_NODETYPE_IDENTIFIER)
+  {
+    if (node->call.args_count > 0)
+      for (size_t i = 0; i < node->call.args_count; i++)
+        if (gen_common(gen, node->call.args[i]).error)
+          return gen_error;
+
+    char *name = (char *)node->token->value;
+    fzl_sym_t sym;
+    bool found = gen_resolve_name(gen, name, &sym);
+    if (!found)
+      return gen_error;
+
+    if (sym.node->type == FZL_NODETYPE_EXTERN_FN)
+    {
+      size_t fn_n         = 0;
+      fzl_extern_fn_t *fn = NULL;
+      for (size_t i = 0; i < gen->extern_fns_count; i++)
+      {
+        if (strcmp(gen->extern_fns[i].used_name, name) == 0)
+        {
+          fn   = &gen->extern_fns[i];
+          fn_n = i;
+          break;
+        }
+      }
+
+      if (!fn)
+        return gen_error;
+
+      fzl_type_t rettype;
+      char *rettypecn = NULL;
+
+      if (!fn->has_return)
+      {
+        rettype = FZL_TYPE_NULL;
+      }
+      else if (fn->ret_type.is_primitive)
+      {
+        rettype = fn->ret_type.primitive;
+      }
+      else
+      {
+        fzl_extern_type_t *type = &gen->extern_types[fn->ret_type.type_slot];
+        switch (type->kind)
+        {
+          case FZL_EXTERN_KIND_REF:
+            rettype   = FZL_TYPE_HANDLE;
+            rettypecn = type->name;
+            break;
+
+          case FZL_EXTERN_KIND_STRUCT:
+            rettype   = FZL_TYPE_STRUCT;
+            rettypecn = type->name;
+            break;
+
+          case FZL_EXTERN_KIND_HANDLE:
+            rettype   = FZL_TYPE_HANDLE;
+            rettypecn = type->name;
+            break;
+
+          case FZL_EXTERN_KIND_ALIAS:
+            if (type->alias_target.is_primitive)
+            {
+              rettype = type->alias_target.primitive;
+            }
+            else
+            {
+              fzl_extern_type_t *aliased =
+                  &gen->extern_types[type->alias_target.type_slot];
+              switch (aliased->kind)
+              {
+                case FZL_EXTERN_KIND_ALIAS:
+                  return gen_error;
+
+                case FZL_EXTERN_KIND_HANDLE:
+                  rettype   = FZL_TYPE_HANDLE;
+                  rettypecn = aliased->name;
+                  break;
+
+                case FZL_EXTERN_KIND_STRUCT:
+                  rettype   = FZL_TYPE_STRUCT;
+                  rettypecn = aliased->name;
+                  break;
+
+                case FZL_EXTERN_KIND_REF:
+                  rettype   = FZL_TYPE_HANDLE;
+                  rettypecn = aliased->name;
+                  break;
+
+                default:
+                  return gen_error;
+              }
+            }
+            break;
+
+          default:
+            return gen_error;
+        }
+      }
+
+      gen_op(gen, FZL_OPCODE_CALL_EXTERN);
+      gen_word(gen, fn_n);
+
+      return (gen_res_t){
+          .error = false, .type = rettype, .classname = rettypecn};
+    }
+    else
+    {
+      if (!sym.ip)
+        return gen_error;
+
+      gen_op(gen, FZL_OPCODE_CALL);
+      gen_word(gen, sym.ip);
+
+      return (gen_res_t){
+          .error = false, .type = sym.type, .classname = sym.classname};
+    }
+  }
+
+  if (node->call.callee->type == FZL_NODETYPE_FIELD)
+  {
+    fzl_node_t *parent_node = node->call.callee->memb.parent;
+    fzl_node_t *method_node = node->call.callee->memb.field;
+
+    gen_res_t parent_res = gen_common(gen, parent_node);
+    if (parent_res.error)
+      return gen_error;
+
+    if (parent_res.type != FZL_TYPE_OBJECT || !parent_res.classname)
+      return gen_error;
+
+    char *classname   = parent_res.classname;
+    bool class_exists = false;
+    for (size_t i = 0; i < gen->classes_count; i++)
+    {
+      if (strcmp(classname, gen->classes[i]->name) == 0)
+      {
+        class_exists = true;
+        break;
+      }
+    }
+
+    if (!class_exists)
+      return gen_error;
+
+    size_t classlen  = strlen(classname);
+    size_t fnlen     = strlen(method_node->token->value);
+    char *methodname = malloc(classlen + fnlen + 2);
+    strcpy(methodname, classname);
+    strcpy((methodname + classlen + 1), method_node->token->value);
+    methodname[classlen]             = '_';
+    methodname[classlen + fnlen + 1] = 0;
+
+    fzl_sym_t fn_sym;
+    bool found_method = false;
+    for (ssize_t i = gen->syms_top - 1; i >= 0; i--)
+      if ((found_method = fzl_symt_get(gen->syms[i], methodname, &fn_sym)))
+        break;
+
+    free(methodname);
+    if (!found_method)
+      return gen_error;
+
+    if (node->call.args_count > 0)
+      for (size_t i = 0; i < node->call.args_count; i++)
+        if (gen_common(gen, node->call.args[i]).error)
+          return gen_error;
+
+    gen_op(gen, FZL_OPCODE_CALL);
+    gen_word(gen, fn_sym.ip);
+
+    return (gen_res_t){
+        .error = false, .type = fn_sym.type, .classname = fn_sym.classname};
+  }
+
+  return gen_error;
+}

src/compiler/generator/gen_class.c

@@ -0,0 +1,79 @@
+#include <common/fzl_types.h>
+#include <compiler/fzl_gen.h>
+#include <compiler/internals/gen.h>
+#include <compiler/utils/fzl_symtable.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+char class_typecn[256];
+
+// Class definition
+gen_res_t gen_class(fzl_gen_t *gen, fzl_node_t *node)
+{
+  if (!gen || !node)
+    return gen_error;
+
+  fzl_gen_ctx_t *ctx = gen_ctx(gen, FZL_GEN_CTX_TYPE_CLASS, node);
+  if (!ctx)
+    return gen_error;
+
+  gen->classes[gen->classes_count] = fzl_mkctable(node->class.name->value);
+  fzl_ctable_t *class              = gen->classes[gen->classes_count++];
+  class->name                      = (char *)node->class.name->value;
+
+  for (size_t i = 0; i < node->class.fields_count; i++)
+  {
+    if (class->fields_remainder <= class->fields_count)
+    {
+      class->fields_remainder *= 2;
+      class->fields = realloc(class->fields, class->fields_remainder *
+                                                 sizeof(fzl_ctable_field_t));
+    }
+
+    fzl_type_t type;
+    memset(class_typecn, 0, sizeof(class_typecn));
+
+    bool resolved = gen_resolve_type(gen, node->class.fields[i]->var.type,
+                                     &type, class_typecn);
+    if (!resolved)
+      return gen_error;
+
+    class->fields[class->fields_count] = (fzl_ctable_field_t){
+        .name       = node->class.fields[i]->var.identifier->token->value,
+        .type       = type,
+        .slot_index = class->fields_count++};
+  }
+
+  for (size_t i = 0; i < node->class.methods_count; i++)
+  {
+    fzl_node_t *fn = node->class.methods[i];
+
+    size_t classname_len = strlen(class->name);
+    size_t fnname_len    = strlen(fn->fn.name->value);
+    char *method_name    = malloc(classname_len + fnname_len + 2);
+
+    strcpy(method_name, class->name);
+    method_name[classname_len] = '_';
+    strcpy((method_name + classname_len + 1), fn->fn.name->value);
+    method_name[classname_len + fnname_len + 1] = 0;
+
+    if (fn->fn.name->value)
+      free(fn->fn.name->value);
+
+    fn->fn.name->value = method_name;
+    if (gen_common(gen, fn).error)
+    {
+      free(method_name);
+      fn->fn.name->value = NULL;
+      return gen_error;
+    }
+  }
+
+  ctx = gen_fin_ctx(gen);
+  if (!ctx)
+    return gen_error;
+
+  return gen_ok_null;
+}

src/compiler/generator/gen_common.c

@@ -0,0 +1,154 @@
+#include <common/fzl_types.h>
+#include <compiler/fzl_gen.h>
+#include <compiler/fzl_parser.h>
+#include <compiler/internals/gen.h>
+#include <stdbool.h>
+#include <stdio.h>
+
+typedef gen_res_t (*gen_handle_fn)(fzl_gen_t *, fzl_node_t *);
+
+char *null_name = "<null>";
+
+gen_res_t gen_error = (gen_res_t){.error = true};
+gen_res_t gen_ok_null =
+    (gen_res_t){.error = false, .type = FZL_TYPE_NULL, .classname = NULL};
+
+// Common generator entry point
+gen_res_t gen_common(fzl_gen_t *gen, fzl_node_t *node)
+{
+  if (!gen || !node)
+    return gen_error;
+
+  gen_handle_fn res = NULL;
+  switch (node->type)
+  {
+    case FZL_NODETYPE_ASSIGN:
+      res = gen_assign;
+      break;
+
+    case FZL_NODETYPE_DECLARATION:
+      res = gen_declaration;
+      break;
+
+    case FZL_NODETYPE_NOT:
+      res = gen_unary_logical;
+      break;
+
+    case FZL_NODETYPE_EQUAL:
+    case FZL_NODETYPE_NEQUAL:
+    case FZL_NODETYPE_LESS:
+    case FZL_NODETYPE_LESS_EQUAL:
+    case FZL_NODETYPE_GREATER:
+    case FZL_NODETYPE_GREATER_EQUAL:
+      res = gen_compare;
+      break;
+
+    case FZL_NODETYPE_OR:
+    case FZL_NODETYPE_AND:
+      res = gen_logical;
+      break;
+
+    case FZL_NODETYPE_UNARY_PLUS:
+    case FZL_NODETYPE_UNARY_MINUS:
+      res = gen_unary_math;
+      break;
+
+    case FZL_NODETYPE_ADD:
+    case FZL_NODETYPE_SUB:
+    case FZL_NODETYPE_MUL:
+    case FZL_NODETYPE_DIV:
+    case FZL_NODETYPE_POW:
+    case FZL_NODETYPE_MOD:
+      res = gen_math;
+      break;
+
+    case FZL_NODETYPE_BREAK:
+      res = gen_break;
+      break;
+
+    case FZL_NODETYPE_LOOP:
+      res = gen_loop;
+      break;
+
+    case FZL_NODETYPE_CONSTRUCT:
+      res = gen_construct;
+      break;
+
+    case FZL_NODETYPE_FIELD:
+      res = gen_field;
+      break;
+
+    case FZL_NODETYPE_CLASS:
+      res = gen_class;
+      break;
+
+    case FZL_NODETYPE_CALL:
+      res = gen_call;
+      break;
+
+    case FZL_NODETYPE_RETURN:
+      res = gen_return;
+      break;
+
+    case FZL_NODETYPE_FUNCTION:
+      res = gen_fn;
+      break;
+
+    case FZL_NODETYPE_CONDITIONAL:
+      res = gen_condition;
+      break;
+
+    case FZL_NODETYPE_IDENTIFIER:
+      res = gen_identifier;
+      break;
+
+    case FZL_NODETYPE_FMT_STRING:
+      res = gen_fmtstr;
+      break;
+
+    case FZL_NODETYPE_LITERAL:
+      res = gen_literal;
+      break;
+
+    case FZL_NODETYPE_BLOCK:
+      res = gen_block;
+      break;
+
+    case FZL_NODETYPE_EXTERN:
+      res = gen_extern;
+      break;
+
+    case FZL_NODETYPE_TYPEDEF:
+      res = gen_typedef;
+      break;
+
+    case FZL_NODETYPE_HANDLE:
+      res = gen_handle;
+      break;
+
+    case FZL_NODETYPE_ALIAS:
+      res = gen_alias;
+      break;
+
+    case FZL_NODETYPE_STRUCT:
+      res = gen_struct;
+      break;
+
+    case FZL_NODETYPE_REFERENCE:
+      res = gen_reference;
+      break;
+
+    case FZL_NODETYPE_EXTERN_FN:
+      res = gen_externfn;
+      break;
+  }
+
+  if (!res)
+  {
+    printf("Bruh, you, suka, go fix the generator blyat (%s:%d)\n", __FILE__,
+           __LINE__);
+    return gen_error;
+  }
+
+  return res(gen, node);
+}

src/compiler/generator/gen_compare.c

@@ -0,0 +1,83 @@
+#include <common/fzl_types.h>
+#include <compiler/internals/gen.h>
+#include <stdio.h>
+
+// Comparison operations
+gen_res_t gen_compare(fzl_gen_t *gen, fzl_node_t *node)
+{
+  if (!gen || !node)
+    return gen_error;
+
+  gen_res_t left = gen_common(gen, node->binary_op.left);
+  if (left.error)
+    return left;
+
+  gen_res_t right = gen_common(gen, node->binary_op.right);
+  if (right.error)
+    return right;
+
+  if (!gen_is_types_compatible(left.type, right.type, left.classname,
+                               right.classname))
+    return gen_error;
+
+  if (left.type == FZL_TYPE_STRING && right.type == FZL_TYPE_STRING)
+  {
+    switch (node->type)
+    {
+      case FZL_NODETYPE_EQUAL:
+        gen_op(gen, FZL_OPCODE_CMP_EQ_STR);
+        break;
+
+      case FZL_NODETYPE_NEQUAL:
+        gen_op(gen, FZL_OPCODE_CMP_NEQ_STR);
+        break;
+
+      default:
+        return gen_error;
+    }
+  }
+  else if (left.type == FZL_TYPE_OBJECT && right.type == FZL_TYPE_OBJECT)
+  {
+    switch (node->type)
+    {
+      case FZL_NODETYPE_EQUAL:
+        gen_op(gen, FZL_OPCODE_CMP_EQ_OBJ);
+        break;
+
+      case FZL_NODETYPE_NEQUAL:
+        gen_op(gen, FZL_OPCODE_CMP_NEQ_OBJ);
+        break;
+
+      default:
+        return gen_error;
+    }
+  }
+  else
+  {
+    switch (node->type)
+    {
+      case FZL_NODETYPE_EQUAL:
+        gen_op(gen, FZL_OPCODE_CMP_EQ);
+        break;
+      case FZL_NODETYPE_NEQUAL:
+        gen_op(gen, FZL_OPCODE_CMP_NEQ);
+        break;
+      case FZL_NODETYPE_LESS:
+        gen_op(gen, FZL_OPCODE_CMP_LT);
+        break;
+      case FZL_NODETYPE_LESS_EQUAL:
+        gen_op(gen, FZL_OPCODE_CMP_LTEQ);
+        break;
+      case FZL_NODETYPE_GREATER:
+        gen_op(gen, FZL_OPCODE_CMP_GT);
+        break;
+      case FZL_NODETYPE_GREATER_EQUAL:
+        gen_op(gen, FZL_OPCODE_CMP_GTEQ);
+        break;
+      default:
+        break;
+    }
+  }
+
+  return (gen_res_t){.error = false, .type = FZL_TYPE_BOOL, .classname = NULL};
+}

src/compiler/generator/gen_condition.c

@@ -0,0 +1,37 @@
+#include <compiler/internals/gen.h>
+
+// Conditional operation
+gen_res_t gen_condition(fzl_gen_t *gen, fzl_node_t *node)
+{
+  if (!gen || !node)
+    return gen_error;
+
+  gen_res_t cres = gen_common(gen, node->cond.condition);
+  if (cres.error)
+    return gen_error;
+
+  gen_op(gen, FZL_OPCODE_JZ);
+
+  size_t jz_if = gen->ops_count;
+  gen_word(gen, (uint64_t)0);
+
+  gen_res_t tblock_res = gen_common(gen, node->cond.true_block);
+  if (tblock_res.error)
+    return gen_error;
+
+  gen_op(gen, FZL_OPCODE_JMP);
+  size_t jmp_else = gen->ops_count;
+  gen_word(gen, (uint64_t)0);
+
+  gen->ops[jz_if] = gen->ops_count;
+
+  if (node->cond.else_block)
+  {
+    gen_res_t fblock_res = gen_common(gen, node->cond.else_block);
+    if (fblock_res.error)
+      return gen_error;
+  }
+
+  gen->ops[jmp_else] = gen->ops_count;
+  return gen_ok_null;
+}

src/compiler/generator/gen_construct.c

@@ -0,0 +1,30 @@
+#include <common/fzl_types.h>
+#include <compiler/internals/gen.h>
+#include <stdbool.h>
+#include <string.h>
+
+// Object constructing
+gen_res_t gen_construct(fzl_gen_t *gen, fzl_node_t *node)
+{
+  if (!gen || !node)
+    return gen_error;
+
+  fzl_node_t *classname = node->construct.name;
+  fzl_ctable_t *ct      = NULL;
+  for (size_t i = 0; i < gen->classes_count; i++)
+  {
+    if (strcmp((char *)classname->token->value, gen->classes[i]->name) == 0)
+    {
+      ct = gen->classes[i];
+      break;
+    }
+  }
+  if (!ct)
+    return gen_error;
+
+  gen_op(gen, FZL_OPCODE_ALLOC_OBJECT);
+  gen_word(gen, ct->fields_count);
+
+  return (gen_res_t){
+      .error = false, .type = FZL_TYPE_OBJECT, .classname = ct->name};
+}

src/compiler/generator/gen_declaration.c

@@ -0,0 +1,61 @@
+#include <common/fzl_types.h>
+#include <compiler/internals/gen.h>
+#include <stdbool.h>
+#include <string.h>
+
+char dec_typecn[256];
+
+// Variable (or argument) declaration
+gen_res_t gen_declaration(fzl_gen_t *gen, fzl_node_t *node)
+{
+  if (!gen || !node)
+    return gen_error;
+
+  char *name = (char *)node->var.identifier->token->value;
+  fzl_type_t type;
+  memset(dec_typecn, 0, sizeof(dec_typecn));
+
+  bool resolved = gen_resolve_type(gen, node->var.type, &type, dec_typecn);
+  if (!resolved)
+    return gen_error;
+
+  fzl_ctable_t *ct = NULL;
+  if (type == FZL_TYPE_OBJECT)
+  {
+    for (size_t i = 0; i < gen->classes_count; i++)
+    {
+      if (strcmp(node->var.type->value, gen->classes[i]->name) == 0)
+      {
+        ct = gen->classes[i];
+        break;
+      }
+    }
+  }
+
+  fzl_symtable_res_t res =
+      fzl_symt_put(gen->syms[gen->syms_top - 1], node, name, type, 0);
+
+  if (ct)
+    fzl_symt_setobjclass(gen->syms[gen->syms_top - 1], name, ct->name);
+
+  if (res != FZL_SYMTABLE_RESULT_OK)
+    return gen_error;
+
+  if (fzl_symt_setslot(gen->syms[gen->syms_top - 1], name) < 0)
+    return gen_error;
+
+  fzl_token_t *id_tok = node->var.identifier->token;
+  size_t const_n =
+      gen_add_const(gen, (fzl_const_t){.type             = FZL_CONSTTYPE_STRING,
+                                       .as.string.chars  = id_tok->value,
+                                       .as.string.length = id_tok->value_sz});
+
+  gen_op(gen, FZL_OPCODE_LOADCONST);
+  gen_word(gen, const_n);
+
+  gen_op(gen, FZL_OPCODE_STORE);
+  gen_op(gen, FZL_OPCODE_LOADCONST);
+  gen_word(gen, const_n);
+
+  return (gen_res_t){.error = false, .type = type, .classname = dec_typecn};
+}

src/compiler/generator/gen_extern.c

@@ -0,0 +1,26 @@
+#include <common/fzl_extern.h>
+#include <common/fzl_types.h>
+#include <compiler/fzl_gen.h>
+#include <compiler/internals/gen.h>
+#include <stdbool.h>
+#include <stdio.h>
+
+// Extern block
+gen_res_t gen_extern(fzl_gen_t *gen, fzl_node_t *node)
+{
+  if (!gen || !node)
+    return gen_error;
+
+  gen->extern_libs[gen->extern_libs_count++] =
+      (fzl_extern_lib_t){.name = (char *)node->ext.libname};
+
+  for (size_t i = 0; i < node->ext.typedefs_count; i++)
+    if (gen_common(gen, node->ext.typedefs[i]).error)
+      return gen_error;
+
+  for (size_t i = 0; i < node->ext.fns_count; i++)
+    if (gen_common(gen, node->ext.fns[i]).error)
+      return gen_error;
+
+  return gen_ok_null;
+}

src/compiler/generator/gen_externfn.c

@@ -0,0 +1,135 @@
+#include <common/fzl_extern.h>
+#include <common/fzl_types.h>
+#include <compiler/fzl_gen.h>
+#include <compiler/fzl_parser.h>
+#include <compiler/internals/gen.h>
+#include <compiler/utils/fzl_symtable.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+char ex_argcn[256];
+char ex_retcn[256];
+
+// External function definition
+gen_res_t gen_externfn(fzl_gen_t *gen, fzl_node_t *node)
+{
+  if (!gen || !node)
+    return gen_error;
+
+  fzl_gen_ctx_t *ctx = gen_ctx(gen, FZL_GEN_CTX_TYPE_FUNCTION, node);
+  if (!ctx)
+    return gen_error;
+
+  size_t args_remainder  = 2;
+  size_t args_count      = 0;
+  fzl_extern_arg_t *args = malloc(args_remainder * sizeof(fzl_extern_arg_t));
+  if (!args)
+    return gen_error;
+
+  for (size_t i = 0; i < node->ext_fn.args_count; i++)
+  {
+    fzl_node_t *argnode = node->ext_fn.args[i];
+    if (args_count >= args_remainder)
+    {
+      args_remainder *= 2;
+      fzl_extern_arg_t *newargs =
+          realloc(args, args_remainder * sizeof(fzl_extern_arg_t));
+      if (!newargs)
+      {
+        free(args);
+        return gen_error;
+      }
+
+      args = newargs;
+    }
+
+    if (argnode->type != FZL_NODETYPE_DECLARATION)
+    {
+      free(args);
+      return gen_error;
+    }
+
+    fzl_extern_arg_t *arg = &args[args_count++];
+
+    fzl_type_t argtype;
+    memset(ex_argcn, 0, sizeof(ex_argcn));
+
+    bool resolved =
+        gen_resolve_type(gen, argnode->var.type, &argtype, ex_argcn);
+    if (!resolved)
+    {
+      free(args);
+      return gen_error;
+    }
+
+    ssize_t slot = gen_resolve_extern_type(gen, ex_argcn);
+    if (slot == -1)
+      arg->type =
+          (fzl_extern_type_ref_t){.is_primitive = true, .primitive = argtype};
+    else
+      arg->type =
+          (fzl_extern_type_ref_t){.is_primitive = false, .type_slot = slot};
+
+    arg->name   = (char *)argnode->var.identifier->token->value;
+    arg->is_out = argnode->var.is_out;
+  }
+
+  ctx = gen_fin_ctx(gen);
+  if (!ctx)
+  {
+    free(args);
+    return gen_error;
+  }
+
+  fzl_type_t ret;
+  memset(ex_retcn, 0, sizeof(ex_retcn));
+
+  bool resolved = gen_resolve_type(gen, node->ext_fn.type, &ret, ex_retcn);
+  if (!resolved)
+  {
+    free(args);
+    return gen_error;
+  }
+
+  fzl_symtable_res_t res =
+      fzl_symt_put(gen->syms[0], node, node->ext_fn.name, ret, 0);
+  if (res != FZL_SYMTABLE_RESULT_OK)
+  {
+    free(args);
+    return gen_error;
+  }
+
+  if (ret == FZL_TYPE_OBJECT || ret == FZL_TYPE_STRUCT ||
+      ret == FZL_TYPE_HANDLE)
+  {
+    res = fzl_symt_setobjclass(gen->syms[0], node->ext_fn.name, ex_retcn);
+    if (res != FZL_SYMTABLE_RESULT_OK)
+    {
+      free(args);
+      return gen_error;
+    }
+  }
+
+  fzl_extern_fn_t *result = &gen->extern_fns[gen->extern_fns_count++];
+
+  ssize_t slot = gen_resolve_extern_type(gen, ex_retcn);
+  if (slot == -1)
+    result->ret_type =
+        (fzl_extern_type_ref_t){.is_primitive = true, .primitive = ret};
+  else
+    result->ret_type =
+        (fzl_extern_type_ref_t){.is_primitive = false, .type_slot = slot};
+
+  result->lib_slot    = gen->extern_libs_count - 1;
+  result->args        = args;
+  result->args_count  = args_count;
+  result->has_return  = ret != FZL_TYPE_NULL;
+  result->used_name   = node->ext_fn.name;
+  result->symbol_name = node->ext_fn.original_name ? node->ext_fn.original_name
+                                                  : node->ext_fn.name;
+
+  return gen_ok_null;
+}

src/compiler/generator/gen_field.c

@@ -0,0 +1,49 @@
+#include <compiler/internals/gen.h>
+#include <stdbool.h>
+#include <string.h>
+
+// Field access
+gen_res_t gen_field(fzl_gen_t *gen, fzl_node_t *node)
+{
+  if (!gen || !node)
+    return gen_error;
+
+  gen_res_t parent_res = gen_common(gen, node->memb.parent);
+  if (parent_res.error)
+    return gen_error;
+
+  fzl_ctable_t *ct = NULL;
+  for (size_t i = 0; i < gen->classes_count; i++)
+  {
+    if (strcmp(parent_res.classname, gen->classes[i]->name) == 0)
+    {
+      ct = gen->classes[i];
+      break;
+    }
+  }
+
+  if (!ct)
+    return gen_error;
+
+  fzl_token_t *ftok = node->memb.field->token;
+  fzl_ctable_field_t ctf;
+  bool field_exists = false;
+  for (size_t i = 0; i < ct->fields_count; i++)
+  {
+    if (strcmp(ftok->value, ct->fields[i].name) == 0)
+    {
+      field_exists = true;
+      ctf          = ct->fields[i];
+      break;
+    }
+  }
+
+  if (!field_exists)
+    return gen_error;
+
+  gen_op(gen, FZL_OPCODE_GET_FIELD);
+  gen_word(gen, ctf.slot_index);
+
+  return (gen_res_t){
+      .error = false, .type = ctf.type, .classname = parent_res.classname};
+}

src/compiler/generator/gen_fmtstr.c

@@ -0,0 +1,21 @@
+#include <common/fzl_types.h>
+#include <compiler/internals/gen.h>
+#include <stdbool.h>
+#include <stdio.h>
+
+// Format string
+gen_res_t gen_fmtstr(fzl_gen_t *gen, fzl_node_t *node)
+{
+  if (!gen || !node)
+    return gen_error;
+
+  for (size_t i = 0; i < node->list.entry_count; i++)
+    if (gen_common(gen, node->list.entries[i]).error)
+      return gen_error;
+
+  gen_op(gen, FZL_OPCODE_BUILD_STR);
+  gen_word(gen, node->list.entry_count);
+
+  return (gen_res_t){
+      .error = false, .type = FZL_TYPE_STRING, .classname = NULL};
+}

src/compiler/generator/gen_fn.c

@@ -0,0 +1,67 @@
+#include <compiler/fzl_gen.h>
+#include <compiler/internals/gen.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <string.h>
+
+char fn_typecn[256];
+
+// Function definition
+gen_res_t gen_fn(fzl_gen_t *gen, fzl_node_t *node)
+{
+  if (!gen || !node)
+    return gen_error;
+
+  gen_op(gen, FZL_OPCODE_JMP);
+  size_t skip_ip = gen->ops_count;
+  gen_word(gen, (uint64_t)0);
+
+  fzl_type_t fntype;
+  memset(fn_typecn, 0, sizeof(fn_typecn));
+
+  bool resolved = gen_resolve_type(gen, node->fn.type, &fntype, fn_typecn);
+  if (!resolved)
+    return gen_error;
+
+  fzl_symtable_res_t putres =
+      fzl_symt_put(gen->syms[gen->syms_top - 1], node, node->fn.name->value,
+                   fntype, gen->ops_count);
+
+  if (putres != FZL_SYMTABLE_RESULT_OK)
+    return gen_error;
+
+  if (fntype == FZL_TYPE_OBJECT)
+  {
+    fzl_symtable_res_t updres = fzl_symt_setobjclass(
+        gen->syms[gen->syms_top - 1], node->fn.name->value, fn_typecn);
+    if (updres != FZL_SYMTABLE_RESULT_OK)
+      return gen_error;
+  }
+
+  fzl_gen_ctx_t *ctx = gen_ctx(gen, FZL_GEN_CTX_TYPE_FUNCTION, node);
+  if (!ctx)
+    return gen_error;
+
+  gen_op(gen, FZL_OPCODE_MK_ENVTABLE);
+
+  for (ssize_t i = node->fn.args_count - 1; i >= 0; i--)
+  {
+    if (gen_common(gen, node->fn.args[i]).error)
+      return gen_error;
+
+    gen_op(gen, FZL_OPCODE_WRITE);
+  }
+
+  if (gen_common(gen, node->fn.body).error)
+    return gen_error;
+
+  gen_op(gen, FZL_OPCODE_RM_ENVTABLE);
+  gen_op(gen, FZL_OPCODE_RET);
+  gen->ops[skip_ip] = gen->ops_count;
+
+  ctx = gen_fin_ctx(gen);
+  if (!ctx)
+    return gen_error;
+
+  return (gen_res_t){.error = false, .type = fntype, .classname = fn_typecn};
+}

src/compiler/generator/gen_handle.c

@@ -0,0 +1,13 @@
+#include <common/fzl_extern.h>
+#include <compiler/internals/gen.h>
+#include <stdbool.h>
+
+// Opaque pointer
+gen_res_t gen_handle(fzl_gen_t *gen, fzl_node_t *node)
+{
+  if (!gen || !node)
+    return gen_error;
+
+  type_buf.kind = FZL_EXTERN_KIND_HANDLE;
+  return gen_ok_null;
+}

src/compiler/generator/gen_identifier.c

@@ -0,0 +1,29 @@
+#include <compiler/internals/gen.h>
+
+// Identifier lookup
+gen_res_t gen_identifier(fzl_gen_t *gen, fzl_node_t *node)
+{
+  if (!gen || !node)
+    return gen_error;
+
+  fzl_sym_t sym;
+  bool exists = false;
+  ssize_t i   = gen->syms_top - 1;
+  for (; i >= 0; i--)
+    if ((exists = fzl_symt_get(gen->syms[i], node->token->value, &sym)))
+      break;
+
+  if (!exists)
+    return gen_error;
+
+  if (!sym.slot_set)
+    return gen_error;
+
+  size_t depth = gen->syms_top - 1 - i;
+  gen_op(gen, FZL_OPCODE_LOAD_LOCAL);
+  gen_word(gen, depth);
+  gen_word(gen, sym.slot);
+
+  return (gen_res_t){
+      .error = false, .type = sym.type, .classname = sym.classname};
+}

src/compiler/generator/gen_literal.c

@@ -0,0 +1,59 @@
+#include <common/fzl_types.h>
+#include <compiler/internals/gen.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+gen_res_t gen_literal(fzl_gen_t *gen, fzl_node_t *node)
+{
+  if (!gen || !node)
+    return gen_error;
+
+  if (node->token->type == FZL_TOKTYPE_STR_LITERAL)
+  {
+    size_t n = gen_add_const(
+        gen, (fzl_const_t){.type             = FZL_CONSTTYPE_STRING,
+                           .as.string.chars  = node->token->value,
+                           .as.string.length = node->token->value_sz});
+
+    gen_op(gen, FZL_OPCODE_LOADCONST);
+    gen_word(gen, n);
+
+    return (gen_res_t){
+        .error = false, .type = FZL_TYPE_STRING, .classname = NULL};
+  }
+
+  if (node->token->type == FZL_TOKTYPE_NUM_LITERAL)
+  {
+    gen_op(gen, FZL_OPCODE_PUSHNUM);
+
+    uint64_t num = strtol(node->token->value, NULL, 10);
+    gen_word(gen, num);
+
+    return (gen_res_t){.error = false, .type = FZL_TYPE_INT, .classname = NULL};
+  }
+
+  if (node->token->type == FZL_TOKTYPE_BOOL_LITERAL)
+  {
+    fzl_token_t *tok = node->token;
+    uint64_t val     = strcmp(tok->value, "true") == 0 ? 1 : 0;
+
+    gen_op(gen, FZL_OPCODE_PUSHBOOL);
+    gen_word(gen, val);
+
+    return (gen_res_t){
+        .error = false, .type = FZL_TYPE_BOOL, .classname = NULL};
+  }
+
+  if (node->token->type == FZL_TOKTYPE_NULL_LITERAL)
+  {
+    gen_op(gen, FZL_OPCODE_PUSHNUM);
+    gen_word(gen, 0);
+    gen_op(gen, FZL_OPCODE_DEREFERENCE);
+
+    return (gen_res_t){
+        .error = false, .type = FZL_TYPE_OBJECT, .classname = null_name};
+  }
+
+  return gen_error;
+}

src/compiler/generator/gen_logical.c

@@ -0,0 +1,29 @@
+#include <common/fzl_types.h>
+#include <compiler/internals/gen.h>
+#include <stdio.h>
+
+// Binary logical operations (and / or)
+gen_res_t gen_logical(fzl_gen_t *gen, fzl_node_t *node)
+{
+  if (!gen || !node)
+    return gen_error;
+
+  gen_res_t left = gen_common(gen, node->binary_op.left);
+  if (left.error)
+    return left;
+
+  gen_res_t right = gen_common(gen, node->binary_op.right);
+  if (right.error)
+    return right;
+
+  if (!gen_is_types_compatible(left.type, right.type, left.classname,
+                               right.classname))
+    return gen_error;
+
+  if (node->type == FZL_NODETYPE_AND)
+    gen_op(gen, FZL_OPCODE_AND);
+  else
+    gen_op(gen, FZL_OPCODE_OR);
+
+  return (gen_res_t){.error = false, .type = FZL_TYPE_BOOL, .classname = NULL};
+}

src/compiler/generator/gen_loop.c

@@ -0,0 +1,63 @@
+#include <common/fzl_types.h>
+#include <compiler/fzl_gen.h>
+#include <compiler/internals/gen.h>
+#include <stdbool.h>
+#include <stdio.h>
+
+// While or for loops
+gen_res_t gen_loop(fzl_gen_t *gen, fzl_node_t *node)
+{
+  if (!gen || !node)
+    return gen_error;
+
+  fzl_gen_ctx_t *ctx = gen_ctx(gen, FZL_GEN_CTX_TYPE_LOOP, node);
+  if (!ctx)
+    return gen_error;
+
+  gen_op(gen, FZL_OPCODE_MK_ENVTABLE);
+
+  if (node->loop.init)
+    if (gen_common(gen, node->loop.init).error)
+      return gen_error;
+
+  size_t start_ip = gen->ops_count;
+  if (node->loop.cond)
+  {
+    if (gen_common(gen, node->loop.cond).error)
+      return gen_error;
+  }
+  else
+  {
+    gen_op(gen, FZL_OPCODE_PUSHNUM);
+    gen_word(gen, 1);
+  }
+
+  gen_op(gen, FZL_OPCODE_JZ);
+  ctx->loop.breaks[ctx->loop.breaks_count++] = gen->ops_count;
+  gen_word(gen, 0);
+
+  if (gen_common(gen, node->loop.body).error)
+    return gen_error;
+
+  if (node->loop.step)
+    if (gen_common(gen, node->loop.step).error)
+      return gen_error;
+
+  gen_op(gen, FZL_OPCODE_JMP);
+  gen_word(gen, start_ip);
+
+  // backpatch `break`s
+  for (size_t i = 0; i < ctx->loop.breaks_count; i++)
+    gen->ops[ctx->loop.breaks[i]] = gen->ops_count;
+
+  gen_op(gen, FZL_OPCODE_RM_ENVTABLE);
+
+  for (size_t i = gen->syms_top - 1; i > ctx->level + 1; i--)
+    fzl_freesymt(gen->syms[--gen->syms_top]);
+
+  ctx = gen_fin_ctx(gen);
+  if (!ctx)
+    return gen_error;
+
+  return gen_ok_null;
+}

src/compiler/generator/gen_math.c

@@ -0,0 +1,47 @@
+#include <common/fzl_types.h>
+#include <compiler/internals/gen.h>
+#include <stdio.h>
+
+// Binary math operations
+gen_res_t gen_math(fzl_gen_t *gen, fzl_node_t *node)
+{
+  if (!gen || !node)
+    return gen_error;
+
+  gen_res_t lres = gen_common(gen, node->binary_op.left);
+  if (lres.error)
+    return lres;
+
+  gen_res_t rres = gen_common(gen, node->binary_op.right);
+  if (rres.error)
+    return rres;
+
+  if (lres.type < FZL_TYPE_INT8 || rres.type < FZL_TYPE_INT8)
+    return gen_error;
+
+  switch (node->type)
+  {
+    case FZL_NODETYPE_ADD:
+      gen_op(gen, FZL_OPCODE_ADD);
+      break;
+    case FZL_NODETYPE_SUB:
+      gen_op(gen, FZL_OPCODE_SUB);
+      break;
+    case FZL_NODETYPE_MUL:
+      gen_op(gen, FZL_OPCODE_MUL);
+      break;
+    case FZL_NODETYPE_DIV:
+      gen_op(gen, FZL_OPCODE_DIV);
+      break;
+    case FZL_NODETYPE_POW:
+      gen_op(gen, FZL_OPCODE_POW);
+      break;
+    case FZL_NODETYPE_MOD:
+      gen_op(gen, FZL_OPCODE_MOD);
+      break;
+    default:
+      return gen_error;
+  }
+
+  return (gen_res_t){.error = false, .type = lres.type, .classname = NULL};
+}

src/compiler/generator/gen_reference.c

@@ -0,0 +1,24 @@
+#include <common/fzl_extern.h>
+#include <common/fzl_types.h>
+#include <compiler/fzl_token.h>
+#include <compiler/internals/gen.h>
+#include <stdbool.h>
+#include <stdio.h>
+
+// Type reference (convert T => T*)
+gen_res_t gen_reference(fzl_gen_t *gen, fzl_node_t *node)
+{
+  if (!gen || !node)
+    return gen_error;
+
+  char *refname = (char *)node->token->value;
+  ssize_t slot  = gen_resolve_extern_type(gen, refname);
+  if (slot == -1)
+    return gen_error;
+
+  type_buf.kind = FZL_EXTERN_KIND_REF;
+  type_buf.ref_target =
+      (fzl_extern_type_ref_t){.is_primitive = false, .type_slot = slot};
+
+  return gen_ok_null;
+}

src/compiler/generator/gen_return.c

@@ -0,0 +1,81 @@
+#include <common/fzl_types.h>
+#include <compiler/fzl_gen.h>
+#include <compiler/internals/gen.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <string.h>
+
+char ret_typecn[256];
+
+// Return keyword
+gen_res_t gen_return(fzl_gen_t *gen, fzl_node_t *node)
+{
+  if (!gen || !node)
+    return gen_error;
+
+  fzl_gen_ctx_t *ctx = gen->ctx;
+  while (ctx != NULL)
+  {
+    if (ctx && ctx->type == FZL_GEN_CTX_TYPE_FUNCTION)
+      break;
+
+    ctx = ctx->parent;
+  }
+
+  if (!ctx || ctx->type != FZL_GEN_CTX_TYPE_FUNCTION)
+    return gen_error;
+
+  gen_res_t result;
+  bool returning_object = false;
+  if (node->ret.value)
+  {
+    gen_res_t retres = gen_common(gen, node->ret.value);
+    if (retres.error)
+      return gen_error;
+
+    fzl_node_t *fn_node = ctx->function;
+    fzl_type_t fntype;
+    memset(ret_typecn, 0, sizeof(ret_typecn));
+
+    bool resolved =
+        gen_resolve_type(gen, fn_node->fn.type, &fntype, ret_typecn);
+    if (!resolved)
+      return gen_error;
+
+    if (!gen_is_types_compatible(retres.type, fntype, retres.classname,
+                                 ret_typecn))
+      return gen_error;
+
+    if (retres.type == FZL_TYPE_OBJECT)
+      returning_object = true;
+
+    result = retres;
+  }
+  else
+    result = gen_ok_null;
+
+  bool is_method         = false;
+  fzl_gen_ctx_t *cur_ctx = gen->ctx;
+  while (cur_ctx != NULL)
+  {
+    if (cur_ctx && cur_ctx->type == FZL_GEN_CTX_TYPE_CLASS)
+    {
+      is_method = true;
+      break;
+    }
+
+    cur_ctx = cur_ctx->parent;
+  }
+
+  size_t method_dec = is_method;
+  for (size_t i = 0; i < (gen->syms_top - ctx->level + method_dec); i++)
+  {
+    if (returning_object)
+      gen_op(gen, FZL_OPCODE_ESCAPE_OBJECT);
+    gen_op(gen, FZL_OPCODE_RM_ENVTABLE);
+  }
+  gen_op(gen, FZL_OPCODE_RET);
+
+  return result;
+}

src/compiler/generator/gen_struct.c

@@ -0,0 +1,95 @@
+#include <common/fzl_extern.h>
+#include <common/fzl_types.h>
+#include <compiler/fzl_gen.h>
+#include <compiler/fzl_parser.h>
+#include <compiler/internals/gen.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+char struct_typecn[256];
+
+// Structure
+gen_res_t gen_struct(fzl_gen_t *gen, fzl_node_t *node)
+{
+  if (!gen || !node)
+    return gen_error;
+
+  type_buf.kind = FZL_EXTERN_KIND_STRUCT;
+
+  size_t remainder = 2;
+  size_t count     = 0;
+  fzl_extern_struct_field_t *fields =
+      malloc(remainder * sizeof(fzl_extern_struct_field_t));
+  if (!fields)
+    return gen_error;
+
+  for (size_t i = 0; i < node->structure.entries_count; i++)
+  {
+    fzl_node_t *fnode = node->structure.entries[i];
+    if (count >= remainder)
+    {
+      remainder *= 2;
+      fzl_extern_struct_field_t *newfields =
+          realloc(fields, remainder * sizeof(fzl_extern_struct_field_t));
+      if (!newfields)
+      {
+        free(fields);
+        return gen_error;
+      }
+      fields = newfields;
+    }
+
+    fzl_type_t type;
+    memset(struct_typecn, 0, sizeof(struct_typecn));
+
+    fzl_extern_struct_field_t *field = &fields[count++];
+
+    if (fnode->type == FZL_NODETYPE_DECLARATION)
+    {
+      field->name = (char *)fnode->var.identifier->token->value;
+
+      bool resolved =
+          gen_resolve_type(gen, fnode->var.type, &type, struct_typecn);
+      if (!resolved)
+      {
+        free(fields);
+        return gen_error;
+      }
+
+      ssize_t slot = gen_resolve_extern_type(gen, struct_typecn);
+      if (slot == -1)
+        field->type =
+            (fzl_extern_type_ref_t){.is_primitive = true, .primitive = type};
+      else
+        field->type =
+            (fzl_extern_type_ref_t){.is_primitive = false, .type_slot = slot};
+    }
+    else if (fnode->type == FZL_NODETYPE_IDENTIFIER)
+    {
+      field->name = (char *)fnode->token->value;
+
+      ssize_t slot = gen_resolve_extern_type(gen, struct_typecn);
+      if (slot == -1)
+      {
+        free(fields);
+        return gen_error;
+      }
+      else
+        field->type =
+            (fzl_extern_type_ref_t){.is_primitive = false, .type_slot = slot};
+    }
+    else
+    {
+      free(fields);
+      return gen_error;
+    }
+  }
+
+  type_buf.structure.fields       = fields;
+  type_buf.structure.fields_count = count;
+
+  return gen_ok_null;
+}

src/compiler/generator/gen_typedef.c

@@ -0,0 +1,80 @@
+#include <common/fzl_extern.h>
+#include <common/fzl_types.h>
+#include <compiler/fzl_parser.h>
+#include <compiler/internals/gen.h>
+#include <compiler/utils/fzl_symtable.h>
+#include <stdbool.h>
+#include <string.h>
+
+fzl_extern_type_t type_buf;
+
+// Type definition
+gen_res_t gen_typedef(fzl_gen_t *gen, fzl_node_t *node)
+{
+  if (!gen || !node)
+    return gen_error;
+
+  memset(&type_buf, 0, sizeof(type_buf));
+  if (gen_common(gen, node->typedefinition.type).error)
+    return gen_error;
+
+  fzl_extern_type_t *newtype = &gen->extern_types[gen->extern_types_count++];
+  newtype->lib_slot          = gen->extern_libs_count - 1;
+  newtype->name              = node->typedefinition.typename;
+
+  fzl_type_t type;
+  switch (type_buf.kind)
+  {
+    case FZL_EXTERN_KIND_REF:
+      newtype->kind       = FZL_EXTERN_KIND_REF;
+      newtype->ref_target = type_buf.ref_target;
+      type                = FZL_TYPE_HANDLE;
+      break;
+
+    case FZL_EXTERN_KIND_HANDLE:
+      newtype->kind = FZL_EXTERN_KIND_HANDLE;
+      type          = FZL_TYPE_HANDLE;
+      break;
+
+    case FZL_EXTERN_KIND_ALIAS:
+      newtype->kind         = FZL_EXTERN_KIND_ALIAS;
+      newtype->alias_target = type_buf.alias_target;
+      if (type_buf.alias_target.is_primitive)
+        type = type_buf.alias_target.primitive;
+      else
+      {
+        fzl_extern_type_t *aliased =
+            &gen->extern_types[type_buf.alias_target.type_slot];
+        if (aliased->kind == FZL_EXTERN_KIND_ALIAS)
+          return gen_error;
+        else if (aliased->kind == FZL_EXTERN_KIND_REF)
+          type = FZL_TYPE_HANDLE;
+        else if (aliased->kind == FZL_EXTERN_KIND_STRUCT)
+          type = FZL_TYPE_STRUCT;
+        else
+          type = FZL_TYPE_HANDLE;
+      }
+      break;
+
+    case FZL_EXTERN_KIND_STRUCT:
+      newtype->kind                   = FZL_EXTERN_KIND_STRUCT;
+      newtype->structure.fields       = type_buf.structure.fields;
+      newtype->structure.fields_count = type_buf.structure.fields_count;
+      type                            = FZL_TYPE_STRUCT;
+      break;
+  }
+
+  fzl_symtable_res_t res =
+      fzl_symt_put(gen->syms[0], node, newtype->name, type, 0);
+  if (res != FZL_SYMTABLE_RESULT_OK)
+    return gen_error;
+
+  if (type == FZL_TYPE_STRUCT || type == FZL_TYPE_HANDLE)
+  {
+    res = fzl_symt_setobjclass(gen->syms[0], newtype->name, newtype->name);
+    if (res != FZL_SYMTABLE_RESULT_OK)
+      return gen_error;
+  }
+
+  return gen_ok_null;
+}

src/compiler/generator/gen_unary_logical.c

@@ -0,0 +1,23 @@
+#include <common/fzl_opcodes.h>
+#include <common/fzl_types.h>
+#include <compiler/fzl_parser.h>
+#include <compiler/internals/gen.h>
+#include <stdio.h>
+
+// Currently, only NOT operator
+gen_res_t gen_unary_logical(fzl_gen_t *gen, fzl_node_t *node)
+{
+  if (!gen || !node)
+    return gen_error;
+
+  gen_res_t operand_res = gen_common(gen, node->unary_op.operand);
+  if (operand_res.error)
+    return gen_error;
+
+  if (node->type == FZL_NODETYPE_NOT)
+    gen_op(gen, FZL_OPCODE_NOT);
+  else
+    return gen_error;
+
+  return (gen_res_t){.error = false, .type = FZL_TYPE_BOOL, .classname = NULL};
+}

src/compiler/generator/gen_unary_math.c

@@ -0,0 +1,20 @@
+#include <common/fzl_opcodes.h>
+#include <compiler/fzl_parser.h>
+#include <compiler/internals/gen.h>
+#include <stdio.h>
+
+// Unary math operations
+gen_res_t gen_unary_math(fzl_gen_t *gen, fzl_node_t *node)
+{
+  if (!gen || !node)
+    return gen_error;
+
+  gen_res_t res = gen_common(gen, node->unary_op.operand);
+  if (res.error)
+    return gen_error;
+
+  if (node->type == FZL_NODETYPE_UNARY_MINUS)
+    gen_op(gen, FZL_OPCODE_NEG);
+
+  return (gen_res_t){.error = false, .type = res.type, .classname = NULL};
+}

src/compiler/generator/op.c

@@ -0,0 +1,48 @@
+#include <compiler/fzl_gen.h>
+#include <compiler/internals/gen.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdlib.h>
+
+// Check ops length and resize if needed
+bool ops_check_size(fzl_gen_t *gen)
+{
+  if (!gen)
+    return false;
+
+  if (gen->ops_count >= gen->ops_remainder)
+  {
+    gen->ops_remainder *= 2;
+    size_t *newops = realloc(gen->ops, gen->ops_remainder * sizeof(size_t));
+    if (!newops)
+      return false;
+
+    gen->ops = newops;
+  }
+
+  return true;
+}
+
+// Push opcode
+void gen_op(fzl_gen_t *gen, fzl_opcode_t opcode)
+{
+  if (!gen)
+    return;
+
+  if (!ops_check_size(gen))
+    return;
+
+  gen->ops[gen->ops_count++] = opcode;
+}
+
+// Push word
+void gen_word(fzl_gen_t *gen, size_t word)
+{
+  if (!gen)
+    return;
+
+  if (!ops_check_size(gen))
+    return;
+
+  gen->ops[gen->ops_count++] = word;
+}

src/compiler/generator/utility.c

@@ -0,0 +1,168 @@
+#include <common/fzl_types.h>
+#include <compiler/fzl_parser.h>
+#include <compiler/fzl_token.h>
+#include <compiler/internals/gen.h>
+#include <compiler/utils/fzl_const_pool.h>
+#include <compiler/utils/fzl_symtable.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <string.h>
+
+// Resolve name in symbol tables
+bool gen_resolve_name(fzl_gen_t *gen, char *name, fzl_sym_t *sym)
+{
+  if (!gen || !name || !sym)
+    return NULL;
+
+  bool found = false;
+  for (ssize_t i = gen->syms_top - 1; i >= 0; i--)
+  {
+    if ((found = fzl_symt_get(gen->syms[i], name, sym)))
+      break;
+  }
+
+  return found;
+}
+
+// Resolve type and return if was resolved or not
+bool gen_resolve_type(fzl_gen_t *gen, fzl_token_t *tok, fzl_type_t *t, char *c)
+{
+  if (!gen || !tok || !t)
+    return false;
+
+  if (tok->type == FZL_TOKTYPE_NAME)
+  {
+    char *name = (char *)tok->value;
+    if (!name)
+      return false;
+
+    fzl_sym_t sym;
+    if (!gen_resolve_name(gen, name, &sym))
+    {
+      fzl_ctable_t *class = NULL;
+      for (size_t i = 0; i < gen->classes_count; i++)
+      {
+        if (strcmp(name, gen->classes[i]->name) == 0)
+        {
+          class = gen->classes[i];
+          break;
+        }
+      }
+
+      if (!class)
+        return false;
+
+      *t = FZL_TYPE_OBJECT;
+      if (c && class->name)
+        strcpy(c, class->name);
+    }
+    else if (sym.node && sym.node->type == FZL_NODETYPE_CLASS)
+    {
+      *t = FZL_TYPE_OBJECT;
+      if (c && sym.classname)
+        strcpy(c, sym.classname);
+    }
+    else if (sym.node && sym.node->type == FZL_NODETYPE_TYPEDEF)
+    {
+      *t = sym.type;
+      if (c && sym.classname)
+        strcpy(c, sym.classname);
+    }
+    else
+      return false;
+
+    return true;
+  }
+
+  if (strcmp(tok->value, "null") == 0)
+    *t = FZL_TYPE_NULL;
+  else if (strcmp(tok->value, "str") == 0)
+    *t = FZL_TYPE_STRING;
+  else if (strcmp(tok->value, "bool") == 0)
+    *t = FZL_TYPE_BOOL;
+  else if (strcmp(tok->value, "char") == 0)
+    *t = FZL_TYPE_CHAR;
+
+  else if (strcmp(tok->value, "uint") == 0)
+    *t = FZL_TYPE_UINT;
+  else if (strcmp(tok->value, "u8") == 0)
+    *t = FZL_TYPE_UINT8;
+  else if (strcmp(tok->value, "u16") == 0)
+    *t = FZL_TYPE_UINT16;
+  else if (strcmp(tok->value, "u32") == 0)
+    *t = FZL_TYPE_UINT32;
+  else if (strcmp(tok->value, "u64") == 0)
+    *t = FZL_TYPE_UINT64;
+
+  else if (strcmp(tok->value, "int") == 0)
+    *t = FZL_TYPE_INT;
+  else if (strcmp(tok->value, "i8") == 0)
+    *t = FZL_TYPE_INT8;
+  else if (strcmp(tok->value, "i16") == 0)
+    *t = FZL_TYPE_INT16;
+  else if (strcmp(tok->value, "i32") == 0)
+    *t = FZL_TYPE_INT32;
+  else if (strcmp(tok->value, "i64") == 0)
+    *t = FZL_TYPE_INT64;
+  else
+    return false;
+
+  return true;
+}
+
+// Resolve external type
+ssize_t gen_resolve_extern_type(fzl_gen_t *gen, char *name)
+{
+  if (!gen || !name)
+    return -1;
+
+  for (size_t i = 0; i < gen->extern_types_count; i++)
+  {
+    if (strcmp(name, gen->extern_types[i].name) == 0)
+      return i;
+  }
+
+  return -1;
+}
+
+// Check if left and right types are compatible
+bool gen_is_types_compatible(fzl_type_t t1, fzl_type_t t2, char *c1, char *c2)
+{
+  if (t1 == FZL_TYPE_OBJECT && t2 == FZL_TYPE_OBJECT)
+  {
+    if (!c1 || !c2)
+      return false;
+
+    if (strcmp(c1, null_name) == 0 || strcmp(c2, null_name) == 0)
+      return true;
+
+    return strcmp(c1, c2) == 0;
+  }
+
+  if ((t1 == FZL_TYPE_HANDLE && t2 == FZL_TYPE_HANDLE) ||
+      (t1 == FZL_TYPE_STRUCT && t2 == FZL_TYPE_STRUCT))
+  {
+    if (!c1 || !c2)
+      return false;
+
+    return strcmp(c1, c2) == 0;
+  }
+
+  if (t1 == t2)
+    return true;
+
+  if (t1 >= FZL_TYPE_INT8 && t2 >= FZL_TYPE_INT8)
+    return true;
+
+  return false;
+}
+
+// Add new constant to constants table
+size_t gen_add_const(fzl_gen_t *gen, fzl_const_t c)
+{
+  if (!gen)
+    return 0;
+
+  return fzl_consts_pool_add(gen->consts, c);
+}

src/compiler/main.c

@@ -1,9 +1,9 @@
 #include <common/fzl_colors.h>
 #include <compiler/fzl_analyzer.h>
 #include <compiler/fzl_debug.h>
+#include <compiler/fzl_gen.h>
 #include <compiler/fzl_parser.h>
 #include <compiler/fzl_reader.h>
-#include <compiler/fzl_walker.h>
 #include <compiler/fzl_writer.h>
 #include <compiler/utils/fzl_linked.h>
 #include <compiler/utils/fzl_options.h>
@@ -122,8 +122,7 @@ int main(int argc, char **argv)
   {
     printf("%sok%s!\n", FZL_COK, FZL_CRST);
     fzl_debug_print_ast(parser->root);
-    printf("%s> building%s\n", FZL_CDEBUG, FZL_CRST);
-    printf("%s-> analyzing AST...%s\n", FZL_CDEBUG, FZL_CRST);
+    printf("%s-> analyzing AST...%s", FZL_CDEBUG, FZL_CRST);
   }
 
   fzl_analyzer_t *analyzer = fzl_mkanalyzer(parser->root);
@@ -159,10 +158,16 @@ int main(int argc, char **argv)
              analyzer->warnings[i]);
   }
 
-  fzl_walker_t *walker = fzl_mkwalker(parser->root);
-  if (!walker)
+  if (opts->verbose)
   {
-    printf("%sError%s: failed to allocate writer\n", FZL_CERROR, FZL_CRST);
+    printf("%sok%s!\n", FZL_COK, FZL_CRST);
+    printf("%s> generate\n-> generating bytecode...%s", FZL_CDEBUG, FZL_CRST);
+  }
+
+  fzl_gen_t *gen = fzl_mkgen(parser->root);
+  if (!gen)
+  {
+    printf("%sError%s: failed to allocate generator\n", FZL_CERROR, FZL_CRST);
     fzl_freeoptions(opts);
     fzl_freeast(parser->root);
     fzl_freeanalyzer(analyzer);
@@ -172,12 +177,12 @@ int main(int argc, char **argv)
     return -1;
   }
 
-  result = fzl_walk(walker);
-  if (result != 0)
+  bool gen_res = fzl_gen_run(gen);
+  if (!gen_res)
   {
-    printf("%sError%s: %s\n", FZL_CERROR, FZL_CRST, fzl_walker_geterror());
+    printf("%sError%s: couldn't generate operations\n", FZL_CERROR, FZL_CRST);
     fzl_freeoptions(opts);
-    fzl_freewalker(walker);
+    fzl_freegen(gen);
     fzl_freeast(parser->root);
     fzl_freeanalyzer(analyzer);
     fzl_freeparser(parser);
@@ -191,16 +196,16 @@ int main(int argc, char **argv)
     printf("%sok%s!\n", FZL_COK, FZL_CRST);
 
     printf("%s--> Constants table%s:\n", FZL_CDEBUG, FZL_CRST);
-    for (size_t i = 0; i < walker->consts->size; i++)
-      printf("---> %s\n", walker->consts->array[i].as.string.chars);
+    for (size_t i = 0; i < gen->consts->size; i++)
+      printf("---> %s\n", gen->consts->array[i].as.string.chars);
 
     printf("%s--> Ops%s:\n", FZL_CDEBUG, FZL_CRST);
     printf("---> ");
-    for (size_t i = 0; i < walker->op_count; i++)
+    for (size_t i = 0; i < gen->ops_count; i++)
     {
-      if (i > 0 && i < walker->op_count)
+      if (i > 0 && i < gen->ops_count)
         printf("->");
-      printf("%lu", walker->ops[i]);
+      printf("%lX", gen->ops[i]);
     }
     printf("\n");
 
@@ -224,7 +229,7 @@ int main(int argc, char **argv)
   {
     printf("%sError%s: failed to allocate writer\n", FZL_CERROR, FZL_CRST);
     fzl_freeoptions(opts);
-    fzl_freewalker(walker);
+    fzl_freegen(gen);
     fzl_freeast(parser->root);
     fzl_freeanalyzer(analyzer);
     fzl_freeparser(parser);
@@ -233,13 +238,13 @@ int main(int argc, char **argv)
     return -1;
   }
 
-  result = fzl_write(writer, walker);
+  result = fzl_write(writer, gen);
   if (result != 0)
   {
     printf("%sError%s: %s\n", FZL_CERROR, FZL_CRST, fzl_writer_geterror());
     fzl_freeoptions(opts);
     fzl_freewriter(writer);
-    fzl_freewalker(walker);
+    fzl_freegen(gen);
     fzl_freeast(parser->root);
     fzl_freeanalyzer(analyzer);
     fzl_freeparser(parser);
@@ -257,7 +262,7 @@ int main(int argc, char **argv)
   fzl_freeast(parser->root);
   fzl_freeanalyzer(analyzer);
   fzl_freeparser(parser);
-  fzl_freewalker(walker);
+  fzl_freegen(gen);
   fzl_freewriter(writer);
 
   printf("%sCompiled successfully%s.\n", FZL_COK, FZL_CRST);

src/compiler/parser/pa_extern.c

@@ -0,0 +1,192 @@
+#include <compiler/fzl_parser.h>
+#include <compiler/fzl_token.h>
+#include <compiler/internals/parser.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+// Parse extern definition
+fzl_node_t *pa_extern(fzl_parser_t *parser)
+{
+  if (!parser || !peek(parser))
+    return NULL;
+
+  fzl_token_t *kw = consume(parser);
+  if (!kw || kw->type != FZL_TOKTYPE_EXTERN)
+  {
+    snprintf(plast_err, sizeof(plast_err),
+             "'%s':%zu:%zu => expected 'extern' keyword",
+             last_known_tok->filename, last_known_tok->ln, last_known_tok->cn);
+    return NULL;
+  }
+
+  fzl_token_t *libname = consume(parser);
+  if (!libname || libname->type != FZL_TOKTYPE_STR_LITERAL)
+  {
+    snprintf(plast_err, sizeof(plast_err),
+             "'%s':%zu:%zu => expected library name after 'extern'",
+             last_known_tok->filename, last_known_tok->ln, last_known_tok->cn);
+    return NULL;
+  }
+
+  fzl_token_t *lbra = consume(parser);
+  if (!lbra || lbra->type != FZL_TOKTYPE_LBRACE)
+  {
+    snprintf(plast_err, sizeof(plast_err),
+             "'%s':%zu:%zu => expected '{' after library name",
+             last_known_tok->filename, last_known_tok->ln, last_known_tok->cn);
+    return NULL;
+  }
+
+  // Typedefs array
+  size_t td_remainder = 2;
+  size_t td_count     = 0;
+  fzl_node_t **td     = malloc(td_remainder * sizeof(fzl_node_t *));
+  if (!td)
+  {
+    snprintf(plast_err, sizeof(plast_err), "out of memory");
+    return NULL;
+  }
+
+  // Functions array
+  size_t fn_remainder = 2;
+  size_t fn_count     = 0;
+  fzl_node_t **fn     = malloc(fn_remainder * sizeof(fzl_node_t *));
+  if (!fn)
+  {
+    free(td);
+    snprintf(plast_err, sizeof(plast_err), "out of memory");
+    return NULL;
+  }
+
+  bool error = false;
+  while (peek(parser))
+  {
+    if (is(parser, FZL_TOKTYPE_RBRACE))
+      break;
+
+    if (td_remainder <= td_count)
+    {
+      td_remainder *= 2;
+      fzl_node_t **newarr = realloc(td, td_remainder * sizeof(fzl_node_t *));
+      if (!newarr)
+      {
+        snprintf(plast_err, sizeof(plast_err), "out of memory");
+        error = true;
+        break;
+      }
+
+      td = newarr;
+    }
+
+    if (fn_remainder <= fn_count)
+    {
+      fn_remainder *= 2;
+      fzl_node_t **newarr = realloc(fn, fn_remainder * sizeof(fzl_node_t *));
+      if (!newarr)
+      {
+        snprintf(plast_err, sizeof(plast_err), "out of memory");
+        error = true;
+        break;
+      }
+
+      fn = newarr;
+    }
+
+    if (is(parser, FZL_TOKTYPE_TYPEDEF))
+    {
+      fzl_node_t *result = pa_typedef(parser);
+      if (!result)
+      {
+        error = true;
+        break;
+      }
+
+      td[td_count++] = result;
+    }
+    else if (is(parser, FZL_TOKTYPE_FUNCTION))
+    {
+      fzl_node_t *result = pa_externfn(parser);
+      if (!result)
+      {
+        error = true;
+        break;
+      }
+
+      fn[fn_count++] = result;
+    }
+    else
+    {
+      snprintf(plast_err, sizeof(plast_err),
+               "'%s':%zu:%zu => unexpected statement inside extern block",
+               last_known_tok->filename, last_known_tok->ln,
+               last_known_tok->cn);
+      error = true;
+      break;
+    }
+
+    fzl_token_t *sc = consume(parser);
+    if (!sc || sc->type != FZL_TOKTYPE_SEMICOLON)
+    {
+      snprintf(plast_err, sizeof(plast_err), "'%s':%zu:%zu => missing ';'",
+               last_known_tok->filename, last_known_tok->ln,
+               last_known_tok->cn);
+      error = true;
+      break;
+    }
+  }
+
+  if (error)
+  {
+    for (size_t i = 0; i < td_count; i++)
+      fzl_freeast(td[i]);
+    free(td);
+
+    for (size_t i = 0; i < fn_count; i++)
+      fzl_freeast(fn[i]);
+    free(fn);
+
+    return NULL;
+  }
+
+  fzl_token_t *rbra = consume(parser);
+  if (!rbra || rbra->type != FZL_TOKTYPE_RBRACE)
+  {
+    for (size_t i = 0; i < td_count; i++)
+      fzl_freeast(td[i]);
+    free(td);
+
+    for (size_t i = 0; i < fn_count; i++)
+      fzl_freeast(fn[i]);
+    free(fn);
+
+    snprintf(plast_err, sizeof(plast_err),
+             "'%s':%zu:%zu => expected '}' after extern block",
+             last_known_tok->filename, last_known_tok->ln, last_known_tok->cn);
+    return NULL;
+  }
+
+  fzl_node_t *node = fzl_mknode(FZL_NODETYPE_EXTERN, kw);
+  if (!node)
+  {
+    for (size_t i = 0; i < td_count; i++)
+      fzl_freeast(td[i]);
+    free(td);
+
+    for (size_t i = 0; i < fn_count; i++)
+      fzl_freeast(fn[i]);
+    free(fn);
+
+    snprintf(plast_err, sizeof(plast_err), "out of memory");
+    return NULL;
+  }
+
+  node->ext.libname        = (char *)libname->value;
+  node->ext.typedefs       = td;
+  node->ext.typedefs_count = td_count;
+  node->ext.fns            = fn;
+  node->ext.fns_count      = fn_count;
+
+  return node;
+}

src/compiler/parser/pa_externfn.c

@@ -0,0 +1,154 @@
+#include <compiler/fzl_parser.h>
+#include <compiler/fzl_token.h>
+#include <compiler/internals/parser.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+// Parse external function
+fzl_node_t *pa_externfn(fzl_parser_t *parser)
+{
+  if (!parser || !peek(parser))
+    return NULL;
+
+  fzl_token_t *tok = consume(parser);
+  if (!tok || tok->type != FZL_TOKTYPE_FUNCTION)
+  {
+    snprintf(plast_err, sizeof(plast_err),
+             "'%s':%zu:%zu => expected 'function' keyword",
+             last_known_tok->filename, last_known_tok->ln, last_known_tok->cn);
+    return NULL;
+  }
+
+  fzl_token_t *name = consume(parser);
+  if (!name || name->type != FZL_TOKTYPE_NAME)
+  {
+    snprintf(plast_err, sizeof(plast_err),
+             "'%s':%zu:%zu => expected function name after 'fn'",
+             last_known_tok->filename, last_known_tok->ln, last_known_tok->cn);
+    return NULL;
+  }
+
+  fzl_token_t *lpar = consume(parser);
+  if (!lpar || lpar->type != FZL_TOKTYPE_LPAREN)
+  {
+    snprintf(plast_err, sizeof(plast_err),
+             "'%s':%zu:%zu => expected '(' after function name",
+             last_known_tok->filename, last_known_tok->ln, last_known_tok->cn);
+    return NULL;
+  }
+
+  size_t remainder  = 2;
+  size_t count      = 0;
+  fzl_node_t **args = malloc(remainder * sizeof(fzl_node_t *));
+  if (!args)
+  {
+    snprintf(plast_err, sizeof(plast_err), "out of memory");
+    return NULL;
+  }
+
+  while (peek(parser) && !is(parser, FZL_TOKTYPE_RPAREN))
+  {
+    if (remainder <= count)
+    {
+      remainder *= 2;
+      fzl_node_t **newarr = realloc(args, remainder * sizeof(fzl_node_t *));
+      if (!newarr)
+      {
+        for (size_t i = 0; i < count; i++)
+          fzl_freeast(args[i]);
+        free(args);
+        snprintf(plast_err, sizeof(plast_err), "out of memory");
+        return NULL;
+      }
+      args = newarr;
+    }
+
+    bool is_out = false;
+    if (is(parser, FZL_TOKTYPE_OUT))
+    {
+      consume(parser);
+      is_out = true;
+    }
+
+    fzl_node_t *node = pa_expression(parser);
+    if (!node || node->type != FZL_NODETYPE_DECLARATION)
+    {
+      for (size_t i = 0; i < count; i++)
+        fzl_freeast(args[i]);
+      free(args);
+
+      if (!plast_err[0])
+        snprintf(plast_err, sizeof(plast_err),
+                 "'%s':%zu:%zu => expected declaration",
+                 last_known_tok->filename, last_known_tok->ln,
+                 last_known_tok->cn);
+      return NULL;
+    }
+
+    node->var.is_out = is_out;
+    args[count++]    = node;
+
+    if (is(parser, FZL_TOKTYPE_RPAREN))
+      break;
+
+    fzl_token_t *comma = consume(parser);
+    if (!comma || comma->type != FZL_TOKTYPE_COMMA)
+    {
+      for (size_t i = 0; i < count; i++)
+        fzl_freeast(args[i]);
+      free(args);
+      snprintf(plast_err, sizeof(plast_err),
+               "'%s':%zu:%zu => missing ',' between arguments",
+               last_known_tok->filename, last_known_tok->ln,
+               last_known_tok->cn);
+      return NULL;
+    }
+  }
+
+  fzl_token_t *rpar = consume(parser);
+  if (!rpar || rpar->type != FZL_TOKTYPE_RPAREN)
+  {
+    for (size_t i = 0; i < count; i++)
+      fzl_freeast(args[i]);
+    free(args);
+    snprintf(plast_err, sizeof(plast_err),
+             "'%s':%zu:%zu => expected ')' after arguments list",
+             last_known_tok->filename, last_known_tok->ln, last_known_tok->cn);
+    return NULL;
+  }
+
+  char *original_name = NULL;
+  fzl_token_t *type   = &null_tok;
+  if (is(parser, FZL_TOKTYPE_NAME) || is(parser, FZL_TOKTYPE_TYPE))
+    type = consume(parser);
+
+  if (is(parser, FZL_TOKTYPE_EQ))
+  {
+    consume(parser);
+    fzl_token_t *orig = consume(parser);
+
+    if (!orig || orig->type != FZL_TOKTYPE_STR_LITERAL)
+    {
+      for (size_t i = 0; i < count; i++)
+        fzl_freeast(args[i]);
+      free(args);
+
+      snprintf(plast_err, sizeof(plast_err),
+               "'%s':%zu:%zu => expected original function name",
+               last_known_tok->filename, last_known_tok->ln,
+               last_known_tok->cn);
+      return NULL;
+    }
+
+    original_name = (char *)orig->value;
+  }
+
+  fzl_node_t *node           = fzl_mknode(FZL_NODETYPE_EXTERN_FN, tok);
+  node->ext_fn.name          = (char *)name->value;
+  node->ext_fn.original_name = original_name;
+  node->ext_fn.args_count    = count;
+  node->ext_fn.args          = args;
+  node->ext_fn.type          = type;
+
+  return node;
+}

src/compiler/parser/pa_primary.c

@@ -67,7 +67,7 @@ fzl_node_t *pa_primary(fzl_parser_t *parser)
     }
 
     fzl_token_t *end = consume(parser);
-    if (end->type != FZL_TOKTYPE_STR_FORMAT_END)
+    if (!end || end->type != FZL_TOKTYPE_STR_FORMAT_END)
     {
       snprintf(plast_err, sizeof(plast_err),
                "'%s':%zu:%zu => unterminated format string",
@@ -78,6 +78,7 @@ fzl_node_t *pa_primary(fzl_parser_t *parser)
         fzl_freeast(entries[i]);
 
       free(entries);
+      return NULL;
     }
 
     if (count < 1)

src/compiler/parser/pa_ref.c

@@ -0,0 +1,38 @@
+#include <compiler/fzl_parser.h>
+#include <compiler/fzl_token.h>
+#include <compiler/internals/parser.h>
+#include <stdio.h>
+
+// Parse reference definition
+fzl_node_t *pa_ref(fzl_parser_t *parser)
+{
+  if (!parser || !peek(parser))
+    return NULL;
+
+  fzl_token_t *tok = consume(parser);
+  if (!tok || tok->type != FZL_TOKTYPE_REFERENCE)
+  {
+    snprintf(plast_err, sizeof(plast_err),
+             "'%s':%zu:%zu => expected 'ref' keyword", last_known_tok->filename,
+             last_known_tok->ln, last_known_tok->cn);
+    return NULL;
+  }
+
+  fzl_token_t *name = consume(parser);
+  if (!name || name->type != FZL_TOKTYPE_NAME)
+  {
+    snprintf(plast_err, sizeof(plast_err),
+             "'%s':%zu:%zu => expected name after 'ref'",
+             last_known_tok->filename, last_known_tok->ln, last_known_tok->cn);
+    return NULL;
+  }
+
+  fzl_node_t *node = fzl_mknode(FZL_NODETYPE_REFERENCE, name);
+  if (!node)
+  {
+    snprintf(plast_err, sizeof(plast_err), "out of memory");
+    return NULL;
+  }
+
+  return node;
+}

src/compiler/parser/pa_statement.c

@@ -1,4 +1,5 @@
 #include <compiler/fzl_parser.h>
+#include <compiler/fzl_token.h>
 #include <compiler/internals/parser.h>
 #include <stdio.h>
 
@@ -24,6 +25,8 @@ fzl_node_t *pa_statement(fzl_parser_t *parser)
     return pa_loop(parser);
   else if (is(parser, FZL_TOKTYPE_BREAK))
     res = pa_break(parser);
+  else if (is(parser, FZL_TOKTYPE_EXTERN))
+    return pa_extern(parser);
 
   if (!res)
     res = pa_expression(parser);

src/compiler/parser/pa_struct.c

@@ -0,0 +1,133 @@
+#include <compiler/fzl_parser.h>
+#include <compiler/fzl_token.h>
+#include <compiler/internals/parser.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+// Parse structure
+fzl_node_t *pa_struct(fzl_parser_t *parser)
+{
+  if (!parser || !peek(parser))
+    return NULL;
+
+  fzl_token_t *tok = consume(parser);
+  if (!tok || tok->type != FZL_TOKTYPE_STRUCT)
+  {
+    snprintf(plast_err, sizeof(plast_err),
+             "'%s':%zu:%zu => expected 'struct' keyword",
+             last_known_tok->filename, last_known_tok->ln, last_known_tok->cn);
+    return NULL;
+  }
+
+  char *original = NULL;
+  if (is(parser, FZL_TOKTYPE_NAME))
+  {
+    fzl_token_t *name = consume(parser);
+    if (!name || name->type != FZL_TOKTYPE_NAME)
+    {
+      snprintf(plast_err, sizeof(plast_err),
+               "'%s':%zu:%zu => expected struct name after 'struct'",
+               last_known_tok->filename, last_known_tok->ln,
+               last_known_tok->cn);
+      return NULL;
+    }
+
+    original = (char *)name->value;
+  }
+
+  fzl_token_t *lbra = consume(parser);
+  if (!lbra || lbra->type != FZL_TOKTYPE_LBRACE)
+  {
+    snprintf(plast_err, sizeof(plast_err),
+             "'%s':%zu:%zu => expected '{' after structure name",
+             last_known_tok->filename, last_known_tok->ln, last_known_tok->cn);
+    return NULL;
+  }
+
+  size_t remainder     = 2;
+  size_t count         = 0;
+  fzl_node_t **entries = malloc(remainder * sizeof(fzl_node_t *));
+  if (!entries)
+  {
+    snprintf(plast_err, sizeof(plast_err), "out of memory");
+    return NULL;
+  }
+
+  while (peek(parser))
+  {
+    if (is(parser, FZL_TOKTYPE_RBRACE))
+      break;
+
+    if (remainder <= count)
+    {
+      remainder *= 2;
+      fzl_node_t **newarr = realloc(entries, remainder * sizeof(fzl_node_t *));
+      if (!newarr)
+      {
+        free(entries);
+        snprintf(plast_err, sizeof(plast_err), "out of memory");
+        return NULL;
+      }
+      entries = newarr;
+    }
+
+    fzl_node_t *entry = pa_statement(parser);
+    if (!entry)
+    {
+      for (size_t i = 0; i < count; i++)
+        fzl_freeast(entries[i]);
+      free(entries);
+      return NULL;
+    }
+
+    if (entry->type != FZL_NODETYPE_DECLARATION &&
+        entry->type != FZL_NODETYPE_IDENTIFIER)
+    {
+      fzl_freeast(entry);
+
+      for (size_t i = 0; i < count; i++)
+        fzl_freeast(entries[i]);
+      free(entries);
+
+      snprintf(plast_err, sizeof(plast_err),
+               "'%s':%zu:%zu => structure entry must be a declaration or "
+               "another structure name",
+               last_known_tok->filename, last_known_tok->ln,
+               last_known_tok->cn);
+      return NULL;
+    }
+
+    entries[count++] = entry;
+  }
+
+  fzl_token_t *rbra = consume(parser);
+  if (!rbra || rbra->type != FZL_TOKTYPE_RBRACE)
+  {
+    for (size_t i = 0; i < count; i++)
+      fzl_freeast(entries[i]);
+    free(entries);
+
+    snprintf(plast_err, sizeof(plast_err),
+             "'%s':%zu:%zu => expected '}' after structure fields",
+             last_known_tok->filename, last_known_tok->ln, last_known_tok->cn);
+    return NULL;
+  }
+
+  fzl_node_t *node = fzl_mknode(FZL_NODETYPE_STRUCT, tok);
+  if (!node)
+  {
+    for (size_t i = 0; i < count; i++)
+      fzl_freeast(entries[i]);
+    free(entries);
+
+    snprintf(plast_err, sizeof(plast_err), "out of memory");
+    return NULL;
+  }
+
+  node->structure.original_name = original;
+  node->structure.entries       = entries;
+  node->structure.entries_count = count;
+
+  return node;
+}

src/compiler/parser/pa_typedef.c

@@ -0,0 +1,81 @@
+#include <compiler/fzl_parser.h>
+#include <compiler/fzl_token.h>
+#include <compiler/internals/parser.h>
+#include <stdio.h>
+
+// Parse type definition
+fzl_node_t *pa_typedef(fzl_parser_t *parser)
+{
+  if (!parser || !peek(parser))
+    return NULL;
+
+  fzl_token_t *tok = consume(parser);
+  if (!tok || tok->type != FZL_TOKTYPE_TYPEDEF)
+  {
+    snprintf(plast_err, sizeof(plast_err),
+             "'%s':%zu:%zu => expected 'type' keyword",
+             last_known_tok->filename, last_known_tok->ln, last_known_tok->cn);
+    return NULL;
+  }
+
+  fzl_token_t *name = consume(parser);
+  if (!name || name->type != FZL_TOKTYPE_NAME)
+  {
+    snprintf(plast_err, sizeof(plast_err),
+             "'%s':%zu:%zu => expected type name after 'type'",
+             last_known_tok->filename, last_known_tok->ln, last_known_tok->cn);
+    return NULL;
+  }
+
+  fzl_node_t *result = NULL;
+
+  if (is(parser, FZL_TOKTYPE_HANDLE))
+  {
+    result = fzl_mknode(FZL_NODETYPE_HANDLE, consume(parser));
+    if (!result)
+    {
+      snprintf(plast_err, sizeof(plast_err), "out of memory");
+      return NULL;
+    }
+  }
+  else if (is(parser, FZL_TOKTYPE_STRUCT))
+  {
+    result = pa_struct(parser);
+  }
+  else if (is(parser, FZL_TOKTYPE_TYPE))
+  {
+    result = fzl_mknode(FZL_NODETYPE_ALIAS, consume(parser));
+    if (!result)
+    {
+      snprintf(plast_err, sizeof(plast_err), "out of memory");
+      return NULL;
+    }
+  }
+  else if (is(parser, FZL_TOKTYPE_REFERENCE))
+  {
+    result = pa_ref(parser);
+  }
+
+  if (!result)
+  {
+    if (!plast_err[0])
+      snprintf(plast_err, sizeof(plast_err),
+               "'%s':%zu:%zu => unsupported typedef type",
+               last_known_tok->filename, last_known_tok->ln,
+               last_known_tok->cn);
+    return NULL;
+  }
+
+  fzl_node_t *node = fzl_mknode(FZL_NODETYPE_TYPEDEF, tok);
+  if (!node)
+  {
+    fzl_freeast(result);
+    snprintf(plast_err, sizeof(plast_err), "out of memory");
+    return NULL;
+  }
+
+  node->typedefinition.typename = (char *)name->value;
+  node->typedefinition.type     = result;
+
+  return node;
+}

src/compiler/reader/rd_name.c

@@ -1,3 +1,4 @@
+#include "compiler/fzl_token.h"
 #include <compiler/fzl_reader.h>
 #include <compiler/internals/reader.h>
 #include <stdio.h>
@@ -38,6 +39,26 @@ fzl_token_t *rd_name(fzl_reader_t *reader)
   if (strcmp(value, "class") == 0)
     tok =
         fzl_mktoken(FZL_TOKTYPE_CLASS, l.line, l.col, value, size, l.filename);
+  else if (strcmp(value, "import") == 0)
+    tok =
+        fzl_mktoken(FZL_TOKTYPE_IMPORT, l.line, l.col, value, size, l.filename);
+  else if (strcmp(value, "extern") == 0)
+    tok =
+        fzl_mktoken(FZL_TOKTYPE_EXTERN, l.line, l.col, value, size, l.filename);
+  else if (strcmp(value, "type") == 0)
+    tok = fzl_mktoken(FZL_TOKTYPE_TYPEDEF, l.line, l.col, value, size,
+                      l.filename);
+  else if (strcmp(value, "handle") == 0)
+    tok =
+        fzl_mktoken(FZL_TOKTYPE_HANDLE, l.line, l.col, value, size, l.filename);
+  else if (strcmp(value, "struct") == 0)
+    tok =
+        fzl_mktoken(FZL_TOKTYPE_STRUCT, l.line, l.col, value, size, l.filename);
+  else if (strcmp(value, "ref") == 0)
+    tok = fzl_mktoken(FZL_TOKTYPE_REFERENCE, l.line, l.col, value, size,
+                      l.filename);
+  else if (strcmp(value, "out") == 0)
+    tok = fzl_mktoken(FZL_TOKTYPE_OUT, l.line, l.col, value, size, l.filename);
   else if (strcmp(value, "for") == 0)
     tok = fzl_mktoken(FZL_TOKTYPE_FOR, l.line, l.col, value, size, l.filename);
   else if (strcmp(value, "while") == 0)

src/compiler/utils/fzl_symtable.c

@@ -59,7 +59,9 @@ fzl_symtable_res_t fzl_symt_setobjclass(fzl_symtable_t *symt, char *name,
   {
     if (strcmp(symt->symbols[i].name, name) == 0)
     {
-      if (symt->symbols[i].type != FZL_TYPE_OBJECT)
+      if (symt->symbols[i].type != FZL_TYPE_OBJECT &&
+          symt->symbols[i].type != FZL_TYPE_STRUCT &&
+          symt->symbols[i].type != FZL_TYPE_HANDLE)
         return FZL_SYMTABLE_RESULT_NOT_OBJECT;
 
       symt->symbols[i].classname = classname;

src/compiler/writer/wr_consts.c

@@ -0,0 +1,20 @@
+#include <compiler/internals/writer.h>
+#include <stdbool.h>
+#include <stdint.h>
+
+// Write constants table
+bool wr_consts(FILE *fd, fzl_const_hash_pool_t *consts)
+{
+  if (!fd || !consts)
+    return false;
+
+  for (size_t i = 0; i < consts->size; i++)
+  {
+    fzl_const_t c = consts->array[i];
+    size_t strlen = c.as.string.length;
+    fwrite(&c.as.string.length, sizeof(uint16_t), 1, fd);
+    fwrite(c.as.string.chars, sizeof(char), strlen, fd);
+  }
+
+  return true;
+}

src/compiler/writer/wr_extern_fns.c

@@ -0,0 +1,68 @@
+#include <common/fzl_extern.h>
+#include <compiler/internals/writer.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+
+// Write arguments
+bool write_args(FILE *fd, fzl_extern_arg_t *args, size_t args_count)
+{
+  for (size_t i = 0; i < args_count; i++)
+  {
+    fzl_extern_arg_t *arg = &args[i];
+    fwrite(&arg->is_out, sizeof(uint8_t), 1, fd);
+    fwrite(&arg->type.is_primitive, sizeof(uint8_t), 1, fd);
+    if (arg->type.is_primitive)
+      fwrite(&arg->type.primitive, sizeof(uint8_t), 1, fd);
+    else
+      fwrite(&arg->type.type_slot, sizeof(uint16_t), 1, fd);
+  }
+
+  return true;
+}
+
+// Write external function references
+bool wr_extern_fns(FILE *fd, fzl_extern_fn_t *fns, size_t fns_count)
+{
+  if (!fd || !fns)
+    return false;
+
+  for (size_t i = 0; i < fns_count; i++)
+  {
+    fzl_extern_fn_t *fn = &fns[i];
+    fwrite(&fn->lib_slot, sizeof(uint16_t), 1, fd);
+
+    size_t used_name_sz  = strlen(fn->used_name);
+    bool has_symbol_name = fn->symbol_name != NULL;
+
+    fwrite(&used_name_sz, sizeof(uint16_t), 1, fd);
+    fwrite(fn->used_name, sizeof(char), used_name_sz, fd);
+    fwrite(&has_symbol_name, sizeof(uint8_t), 1, fd);
+
+    if (has_symbol_name)
+    {
+      size_t symbol_name_sz = strlen(fn->symbol_name);
+      fwrite(&symbol_name_sz, sizeof(uint16_t), 1, fd);
+      fwrite(fn->symbol_name, sizeof(char), symbol_name_sz, fd);
+    }
+
+    fwrite(&fn->has_return, sizeof(uint8_t), 1, fd);
+    if (fn->has_return)
+    {
+      fwrite(&fn->ret_type.is_primitive, sizeof(uint8_t), 1, fd);
+      if (fn->ret_type.is_primitive)
+        fwrite(&fn->ret_type.primitive, sizeof(uint8_t), 1, fd);
+      else
+        fwrite(&fn->ret_type.type_slot, sizeof(uint16_t), 1, fd);
+    }
+
+    fwrite(&fn->args_count, sizeof(uint16_t), 1, fd);
+    if (fn->args_count > 0)
+      if (!write_args(fd, fn->args, fn->args_count))
+        return false;
+  }
+
+  return true;
+}

src/compiler/writer/wr_extern_libs.c

@@ -0,0 +1,30 @@
+#include <common/fzl_extern.h>
+#include <compiler/internals/writer.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <string.h>
+
+// Writer external lib names
+bool wr_extern_libs(FILE *fd, fzl_extern_lib_t *libs, size_t libs_count)
+{
+  if (!fd || !libs)
+    return false;
+
+  for (size_t i = 0; i < libs_count; i++)
+  {
+    fzl_extern_lib_t *lib = &libs[i];
+
+    if (!lib || !lib->name)
+      return false;
+
+    size_t len = strlen(lib->name);
+    if (len < 1)
+      return false;
+
+    fwrite(&len, sizeof(size_t), 1, fd);
+    fwrite(lib->name, sizeof(char), len, fd);
+  }
+
+  return true;
+}

src/compiler/writer/wr_extern_types.c

@@ -0,0 +1,80 @@
+#include <common/fzl_extern.h>
+#include <compiler/internals/writer.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+
+// Write structure
+bool write_struct(FILE *fd, fzl_extern_type_t *st)
+{
+  fwrite(&st->structure.fields_count, sizeof(uint16_t), 1, fd);
+
+  for (size_t i = 0; i < st->structure.fields_count; i++)
+  {
+    fzl_extern_struct_field_t *field = &st->structure.fields[i];
+
+    bool has_name = field->name != NULL;
+    fwrite(&has_name, sizeof(uint8_t), 1, fd);
+    if (field->name)
+    {
+      size_t name_sz = strlen(field->name);
+      if (name_sz < 1)
+        return false;
+
+      fwrite(&name_sz, sizeof(uint16_t), 1, fd);
+      fwrite(field->name, sizeof(char), name_sz, fd);
+    }
+
+    fwrite(&field->type.is_primitive, sizeof(uint8_t), 1, fd);
+    if (field->type.is_primitive)
+      fwrite(&field->type.primitive, sizeof(uint8_t), 1, fd);
+    else
+      fwrite(&field->type.type_slot, sizeof(uint16_t), 1, fd);
+  }
+
+  return true;
+}
+
+// Write external libs type definitions
+bool wr_extern_types(FILE *fd, fzl_extern_type_t *types, size_t types_count)
+{
+  if (!fd || !types)
+    return false;
+
+  for (size_t i = 0; i < types_count; i++)
+  {
+    fzl_extern_type_t *type = &types[i];
+    fwrite(&type->lib_slot, sizeof(uint16_t), 1, fd);
+    fwrite(&type->kind, sizeof(uint8_t), 1, fd);
+
+    uint16_t name_sz = strlen(type->name);
+    fwrite(&name_sz, sizeof(uint16_t), 1, fd);
+    fwrite(type->name, sizeof(char), name_sz, fd);
+
+    if (type->kind == FZL_EXTERN_KIND_STRUCT)
+    {
+      if (!write_struct(fd, type))
+        return false;
+    }
+    else if (type->kind == FZL_EXTERN_KIND_REF)
+    {
+      fwrite(&type->ref_target.is_primitive, sizeof(uint8_t), 1, fd);
+      if (type->ref_target.is_primitive)
+        fwrite(&type->ref_target.primitive, sizeof(uint8_t), 1, fd);
+      else
+        fwrite(&type->ref_target.type_slot, sizeof(uint16_t), 1, fd);
+    }
+    else if (type->kind == FZL_EXTERN_KIND_ALIAS)
+    {
+      fwrite(&type->alias_target.is_primitive, sizeof(uint8_t), 1, fd);
+      if (type->alias_target.is_primitive)
+        fwrite(&type->alias_target.primitive, sizeof(uint8_t), 1, fd);
+      else
+        fwrite(&type->alias_target.type_slot, sizeof(uint16_t), 1, fd);
+    }
+  }
+
+  return true;
+}

src/compiler/writer/wr_ops.c

@@ -0,0 +1,14 @@
+#include <compiler/internals/writer.h>
+#include <stdbool.h>
+
+// Write opcodes
+bool wr_ops(FILE *fd, size_t *ops, size_t ops_count)
+{
+  if (!fd || !ops)
+    return false;
+
+  if (ops_count > 0)
+    fwrite(ops, sizeof(uint64_t), ops_count, fd);
+
+  return true;
+}

src/vm/fzl_vm.c

@@ -1,27 +1,31 @@
-#include <common/fzl_builtins.h>
 #include <common/fzl_opcodes.h>
 #include <common/fzl_types.h>
 #include <common/fzl_value.h>
 #include <compiler/utils/fzl_const_pool.h>
-#include <stdbool.h>
 #include <stddef.h>
-#include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <vm/fzl_vm.h>
 #include <vm/fzl_vm_env.h>
+#include <vm/fzl_vm_extern.h>
 #include <vm/fzl_vm_object.h>
+#include <vm/fzl_vm_reader.h>
 #include <vm/internals/opcode.h>
 
-char last_err[256];
+char last_err[512];
+char internal_error[256];
 size_t last_jmp_ip       = 0;
 size_t total_jmp_on_same = 0;
 
-static char *expect_hdr = "FZL\0\1";
-
-fzl_vm_t *fzl_mkvm(const char *filepath)
+fzl_vm_t *fzl_mkvm(fzl_vm_reader_t *reader)
 {
+  if (!reader)
+  {
+    snprintf(last_err, sizeof(last_err), "reader is not provided");
+    return NULL;
+  }
+
   fzl_vm_t *vm = malloc(sizeof(fzl_vm_t));
   if (!vm)
   {
@@ -30,86 +34,7 @@ fzl_vm_t *fzl_mkvm(const char *filepath)
   }
 
   memset(vm, 0, sizeof(fzl_vm_t));
-
-  FILE *fd = fopen(filepath, "rb");
-  if (!fd)
-  {
-    snprintf(last_err, sizeof(last_err), "failed to open file '%s'", filepath);
-    free(vm);
-    return NULL;
-  }
-
-  char hdr[5];
-  fread(hdr, sizeof(char), 5,
-        fd); // NOTE: add red bytes check (also for freads below)
-  if (memcmp(hdr, expect_hdr, 5) != 0)
-  {
-    snprintf(last_err, sizeof(last_err), "magic check error");
-    fclose(fd);
-    free(vm);
-    return NULL;
-  }
-
-  size_t consts_count, ops_count;
-  fread(&consts_count, sizeof(size_t), 1, fd);
-  fread(&ops_count, sizeof(size_t), 1, fd);
-  // TODO: read externs count
-
-  if (ops_count < 1)
-  {
-    snprintf(last_err, sizeof(last_err), "there is nothing to do (0 ops)");
-    fclose(fd);
-    free(vm);
-    return NULL;
-  }
-
-  if (consts_count > 0)
-  {
-    vm->consts_count = consts_count;
-    vm->consts       = malloc(consts_count * sizeof(fzl_value_t));
-
-    for (size_t i = 0; i < consts_count; i++)
-    {
-      fzl_consttype_t type;
-      fread(&type, sizeof(fzl_consttype_t), 1, fd);
-
-      if (type == FZL_CONSTTYPE_STRING)
-      {
-        size_t length;
-        char *chars;
-
-        fread(&length, sizeof(size_t), 1, fd);
-
-        chars = malloc(length * sizeof(char) + 1);
-        fread(chars, sizeof(char), length, fd);
-        chars[length] = 0;
-
-        vm->consts[i] = (fzl_const_t){
-            .type = type, .as.string.length = length, .as.string.chars = chars};
-      }
-      else
-      {
-        fclose(fd);
-        free(vm->consts);
-        free(vm);
-        snprintf(last_err, sizeof(last_err), "unknown const type at index %ld",
-                 i);
-        return NULL;
-      }
-    }
-  }
-
-  vm->ops_count = ops_count;
-  vm->ops       = malloc(ops_count * sizeof(uint64_t));
-  for (size_t i = 0; i < ops_count; i++)
-  {
-    uint64_t op;
-    fread(&op, sizeof(uint64_t), 1, fd);
-    vm->ops[i] = op;
-  }
-
-  // TODO: read externs
-  fclose(fd);
+  vm->reader = reader;
 
   return vm;
 }
@@ -229,9 +154,9 @@ int fzl_vm_run(fzl_vm_t *vm)
 
   vm->ip     = 0;
   int result = 0;
-  while (vm->ip < vm->ops_count)
+  while (vm->ip < vm->reader->ops_count)
   {
-    fzl_opcode_t opcode = vm->ops[vm->ip];
+    fzl_opcode_t opcode = vm->reader->ops[vm->ip];
     size_t op_group     = (opcode >> 16) & 0xFF;
     size_t op_fnnum     = (opcode & 0xFF);
 
@@ -265,13 +190,5 @@ void fzl_freevm(fzl_vm_t *vm)
   while (vm->etop > 0)
     fzl_freeenv(vm->estack[--vm->etop]);
 
-  for (size_t i = 0; i < vm->consts_count; i++)
-  {
-    if (vm->consts[i].type == FZL_CONSTTYPE_STRING)
-      free((void *)vm->consts[i].as.string.chars);
-  }
-
-  free(vm->consts);
-  free(vm->ops);
   free(vm);
 }

src/vm/fzl_vm_debug.c

@@ -1,5 +1,8 @@
 #include <common/fzl_opcodes.h>
+#include <common/fzl_value.h>
 #include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
 #include <stdio.h>
 #include <vm/fzl_vm.h>
 
@@ -8,36 +11,44 @@ void fzl_vm_print_ops(fzl_vm_t *vm)
   if (!vm)
     return;
 
-  if (vm->ops_count < 1)
+  if (vm->reader->ops_count < 1)
   {
     printf("no opcodes\n");
     return;
   }
 
-  for (size_t i = 0; i < vm->ops_count; i++)
+  for (size_t i = 0; i < vm->reader->ops_count; i++)
   {
     printf("%04ld: ", i);
 
-    switch (vm->ops[i])
+    switch (vm->reader->ops[i])
     {
+      case FZL_OPCODE_CALL_EXTERN:
+      {
+        size_t fn_n = vm->reader->ops[++i];
+        printf("CALL_EXTERN FN=#%zu (%s)\n", fn_n,
+               vm->reader->extern_fns[fn_n].used_name);
+        break;
+      }
+
       case FZL_OPCODE_STORE_LOCAL:
       {
-        size_t depth = vm->ops[++i];
-        size_t slot  = vm->ops[++i];
+        size_t depth = vm->reader->ops[++i];
+        size_t slot  = vm->reader->ops[++i];
         printf("STORE_LOCAL D=%zu S=%zu\n", depth, slot);
         break;
       }
 
       case FZL_OPCODE_LOAD_LOCAL:
       {
-        size_t depth = vm->ops[++i];
-        size_t slot  = vm->ops[++i];
+        size_t depth = vm->reader->ops[++i];
+        size_t slot  = vm->reader->ops[++i];
         printf("LOAD_LOCAL D=%zu S=%zu\n", depth, slot);
         break;
       }
 
       case FZL_OPCODE_BUILD_STR:
-        printf("BUILD_STR %zu\n", vm->ops[++i]);
+        printf("BUILD_STR %zu\n", vm->reader->ops[++i]);
         break;
 
       case FZL_OPCODE_DEREFERENCE:
@@ -65,20 +76,20 @@ void fzl_vm_print_ops(fzl_vm_t *vm)
         break;
 
       case FZL_OPCODE_ALLOC_OBJECT:
-        printf("ALLOC_OBJECT: %lu fields\n", vm->ops[++i]);
+        printf("ALLOC_OBJECT: %lu fields\n", vm->reader->ops[++i]);
         break;
 
       case FZL_OPCODE_GET_FIELD:
-        printf("GET_FIELD #%lu\n", vm->ops[++i]);
+        printf("GET_FIELD #%lu\n", vm->reader->ops[++i]);
         break;
 
       case FZL_OPCODE_SET_FIELD:
-        printf("SET_FIELD #%lu\n", vm->ops[++i]);
+        printf("SET_FIELD #%lu\n", vm->reader->ops[++i]);
         break;
 
       case FZL_OPCODE_CALL:
       {
-        size_t ip = vm->ops[++i];
+        size_t ip = vm->reader->ops[++i];
         printf("CALL IP: %lu\n", ip);
         break;
       }
@@ -89,22 +100,22 @@ void fzl_vm_print_ops(fzl_vm_t *vm)
 
       case FZL_OPCODE_LOADCONST:
       {
-        size_t const_n = vm->ops[++i];
-        fzl_const_t c  = vm->consts[const_n];
-        printf("LOADCONST #%lu ('%s')\n", const_n, c.as.string.chars);
+        size_t const_n = vm->reader->ops[++i];
+        fzl_value_t c  = vm->reader->consts[const_n];
+        printf("LOADCONST #%lu ('%s')\n", const_n, c.as.s.value);
         break;
       }
 
       case FZL_OPCODE_CALL_BUILTIN:
-        printf("CALL_BUILTIN #%lu\n", vm->ops[++i]);
+        printf("CALL_BUILTIN #%lu\n", vm->reader->ops[++i]);
         break;
 
       case FZL_OPCODE_PUSHNUM:
-        printf("PUSHNUM %lu\n", vm->ops[++i]);
+        printf("PUSHNUM %lu\n", vm->reader->ops[++i]);
         break;
 
       case FZL_OPCODE_PUSHBOOL:
-        printf("PUSHBOOL %s\n", vm->ops[++i] ? "true" : "false");
+        printf("PUSHBOOL %s\n", vm->reader->ops[++i] ? "true" : "false");
         break;
 
       case FZL_OPCODE_MK_ENVTABLE:
@@ -177,11 +188,11 @@ void fzl_vm_print_ops(fzl_vm_t *vm)
         break;
 
       case FZL_OPCODE_JZ:
-        printf("JZ IP: %ld\n", vm->ops[++i]);
+        printf("JZ IP: %ld\n", vm->reader->ops[++i]);
         break;
 
       case FZL_OPCODE_JMP:
-        printf("JMP IP: %ld\n", vm->ops[++i]);
+        printf("JMP IP: %ld\n", vm->reader->ops[++i]);
         break;
     }
   }

src/vm/fzl_vm_extern.c

@@ -0,0 +1,271 @@
+#include <common/fzl_extern.h>
+#include <common/fzl_types.h>
+#include <dlfcn.h>
+#include <ffi.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <vm/fzl_vm_extern.h>
+#include <vm/fzl_vm_reader.h>
+
+char ex_err[256];
+
+// Resolve specified type reference
+ffi_type *resolve_type(fzl_vm_reader_t *reader, fzl_extern_type_ref_t *ref)
+{
+  if (ref->is_primitive)
+  {
+    switch (ref->primitive)
+    {
+      case FZL_TYPE_INT8:
+        return &ffi_type_sint8;
+
+      case FZL_TYPE_INT16:
+        return &ffi_type_sint16;
+
+      case FZL_TYPE_INT32:
+        return &ffi_type_sint32;
+
+      case FZL_TYPE_INT64:
+        return &ffi_type_sint64;
+
+      case FZL_TYPE_UINT8:
+      case FZL_TYPE_BOOL:
+        return &ffi_type_uint8;
+
+      case FZL_TYPE_UINT16:
+        return &ffi_type_uint16;
+
+      case FZL_TYPE_UINT32:
+        return &ffi_type_uint32;
+
+      case FZL_TYPE_UINT64:
+        return &ffi_type_uint64;
+
+      case FZL_TYPE_INT:
+        return &ffi_type_sint;
+
+      case FZL_TYPE_UINT:
+        return &ffi_type_uint;
+
+      case FZL_TYPE_CHAR:
+        return &ffi_type_schar;
+
+      case FZL_TYPE_STRING:
+      case FZL_TYPE_HANDLE:
+      case FZL_TYPE_STRUCT:
+        return &ffi_type_pointer;
+
+      default:
+        return &ffi_type_void;
+    }
+  }
+  else
+  {
+    fzl_extern_type_t *t = &reader->extern_types[ref->type_slot];
+    if (!t)
+      return &ffi_type_void;
+
+    switch (t->kind)
+    {
+      case FZL_EXTERN_KIND_STRUCT:
+      case FZL_EXTERN_KIND_HANDLE:
+      case FZL_EXTERN_KIND_REF:
+        return &ffi_type_pointer;
+
+      case FZL_EXTERN_KIND_ALIAS:
+        return resolve_type(reader, &t->alias_target);
+    }
+  }
+}
+
+// Preapre sym, put result in out and return operation result
+bool prepare_sym(fzl_vm_reader_t *reader, void *sym, fzl_extern_fn_t *fn,
+                 fzl_vm_sym_t *out)
+{
+  if (!reader || !fn || !sym || !out)
+  {
+    snprintf(ex_err, sizeof(ex_err),
+             "cannot prepare sym: function def, symbol handle or outvar is not "
+             "specified");
+    return false;
+  }
+  memset(out, 0, sizeof(fzl_vm_sym_t));
+
+  out->func_ptr  = sym;
+  out->arg_types = malloc(sizeof(ffi_type *) * fn->args_count);
+  if (!out->arg_types)
+  {
+    snprintf(ex_err, sizeof(ex_err), "out of memory");
+    return false;
+  }
+
+  memset(out->arg_types, 0, sizeof(ffi_type *) * fn->args_count);
+  for (size_t i = 0; i < fn->args_count; i++)
+  {
+    fzl_extern_arg_t *arg = &fn->args[i];
+    if (arg->is_out)
+      out->arg_types[i] = &ffi_type_pointer;
+    else
+      out->arg_types[i] = resolve_type(reader, &arg->type);
+  }
+
+  ffi_type *ret =
+      fn->has_return ? resolve_type(reader, &fn->ret_type) : &ffi_type_void;
+  ffi_status res = ffi_prep_cif(&out->cif, FFI_DEFAULT_ABI, fn->args_count, ret,
+                                out->arg_types);
+  if (res != FFI_OK)
+  {
+    snprintf(ex_err, sizeof(ex_err), "failed to prepare FFI");
+    return false;
+  }
+
+  return true;
+}
+
+fzl_vm_extern_t *fzl_vm_init_externs(fzl_vm_reader_t *reader)
+{
+  if (!reader)
+  {
+    snprintf(ex_err, sizeof(ex_err), "reader is not provided");
+    return NULL;
+  }
+
+  fzl_vm_extern_t *ex = malloc(sizeof(fzl_vm_extern_t));
+  if (!ex)
+  {
+    snprintf(ex_err, sizeof(ex_err), "out of memory");
+    return NULL;
+  }
+
+  memset(ex, 0, sizeof(fzl_vm_extern_t));
+
+  if (reader->extern_libs_count < 1 || reader->extern_fns_count < 1)
+    return ex;
+
+  ex->libs = malloc(sizeof(void *) * reader->extern_libs_count);
+  if (!ex->libs)
+  {
+    snprintf(ex_err, sizeof(ex_err), "out of memory");
+    free(ex);
+    return NULL;
+  }
+
+  memset(ex->libs, 0, sizeof(void *) * reader->extern_libs_count);
+  for (uint16_t i = 0; i < reader->extern_libs_count; i++)
+  {
+    void *lib = dlopen(reader->extern_libs[i], RTLD_NOW);
+    if (!lib)
+    {
+      snprintf(ex_err, sizeof(ex_err), "cannot open library '%s'",
+               reader->extern_libs[i]);
+
+      if (i > 0)
+      {
+        for (size_t j = 0; j < ex->libs_loaded; j++)
+          if (ex->libs[j])
+            dlclose(ex->libs[j]);
+      }
+
+      free(ex->libs);
+      free(ex);
+      return NULL;
+    }
+
+    ex->libs[ex->libs_loaded++] = lib;
+  }
+
+  ex->syms = malloc(sizeof(fzl_vm_sym_t) * reader->extern_fns_count);
+  if (!ex->syms)
+  {
+    snprintf(ex_err, sizeof(ex_err), "out of memory");
+
+    for (size_t i = 0; i < ex->libs_loaded; i++)
+      if (ex->libs[i])
+        dlclose(ex->libs[i]);
+
+    free(ex->libs);
+    free(ex);
+    return NULL;
+  }
+
+  memset(ex->syms, 0, sizeof(fzl_vm_sym_t) * reader->extern_fns_count);
+  for (uint16_t i = 0; i < reader->extern_fns_count; i++)
+  {
+    fzl_extern_fn_t *fn = &reader->extern_fns[i];
+    char *fnname = fn->symbol_name != NULL ? fn->symbol_name : fn->used_name;
+
+    void *sym = dlsym(ex->libs[fn->lib_slot], fnname);
+    if (!sym)
+    {
+      snprintf(ex_err, sizeof(ex_err), "couldn't find symbol '%s' in lib '%s'",
+               fnname, reader->extern_libs[fn->lib_slot]);
+
+      for (size_t j = 0; j < ex->libs_loaded; j++)
+        if (ex->libs[j])
+          dlclose(ex->libs[j]);
+
+      free(ex->libs);
+
+      for (size_t j = 0; j < ex->syms_loaded; j++)
+      {
+        if (ex->syms->arg_types)
+          free(ex->syms->arg_types);
+      }
+
+      free(ex->syms);
+      free(ex);
+      return NULL;
+    }
+
+    if (!prepare_sym(reader, sym, fn, &ex->syms[ex->syms_loaded++]))
+    {
+      if (!ex_err[0])
+      {
+        snprintf(ex_err, sizeof(ex_err),
+                 "failed to preapre FFI structure for sym '%s'", fnname);
+      }
+
+      for (size_t j = 0; j < ex->libs_loaded; j++)
+        if (ex->libs[j])
+          dlclose(ex->libs[j]);
+
+      free(ex->libs);
+      free(ex->syms);
+      free(ex);
+      return NULL;
+    }
+  }
+
+  return ex;
+}
+
+char *fzl_vm_externs_geterror() { return ex_err; }
+
+void fzl_vm_free_externs(fzl_vm_extern_t *ex)
+{
+  if (!ex)
+    return;
+
+  if (ex->libs)
+  {
+    for (size_t i = 0; i < ex->libs_loaded; i++)
+      if (ex->libs[i])
+        dlclose(ex->libs[i]);
+
+    free(ex->libs);
+  }
+
+  if (ex->syms)
+  {
+    for (size_t i = 0; i < ex->syms_loaded; i++)
+      free(ex->syms[i].arg_types);
+
+    free(ex->syms);
+  }
+
+  free(ex);
+}

src/vm/fzl_vm_reader.c

@@ -0,0 +1,194 @@
+#include <common/fzl_extern.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <vm/fzl_vm_reader.h>
+#include <vm/internals/reader.h>
+
+char reader_err[512];
+
+fzl_vm_reader_t *fzl_vm_mkreader(char *filepath)
+{
+  if (!filepath)
+  {
+    snprintf(reader_err, sizeof(reader_err),
+             "init error - filepath is not defined");
+    return NULL;
+  }
+
+  fzl_vm_reader_t *reader = malloc(sizeof(fzl_vm_reader_t));
+  if (!reader)
+  {
+    snprintf(reader_err, sizeof(reader_err),
+             "init error - couldn't allocate memory for reader");
+    return NULL;
+  }
+
+  memset(reader, 0, sizeof(fzl_vm_reader_t));
+  reader->filepath = filepath;
+
+  return reader;
+}
+
+void wr_validation_err(char *section)
+{
+  if (internal_error[0])
+    snprintf(reader_err, sizeof(reader_err), "init error - section '%s': %s",
+             section, internal_error);
+  else
+    snprintf(reader_err, sizeof(reader_err),
+             "init error - section '%s' is not valid", section);
+}
+
+bool fzl_vm_read(fzl_vm_reader_t *reader)
+{
+  if (!reader)
+  {
+    snprintf(reader_err, sizeof(reader_err),
+             "init error - reader is not provided");
+    return false;
+  }
+
+  FILE *fd = fopen(reader->filepath, "rb");
+  if (!fd)
+  {
+    snprintf(reader_err, sizeof(reader_err),
+             "init error - couldn't open file '%s'", reader->filepath);
+    return false;
+  }
+
+  bool result = vm_rd_header(reader, fd);
+  if (!result)
+  {
+    wr_validation_err("header");
+    fclose(fd);
+    return false;
+  }
+
+  result = vm_rd_sections_sz(reader, fd);
+  if (!result)
+  {
+    wr_validation_err("sizes");
+    fclose(fd);
+    return false;
+  }
+
+  result = vm_rd_consts(reader, fd);
+  if (!result)
+  {
+    wr_validation_err("constants table");
+    fclose(fd);
+    return false;
+  }
+
+  result = vm_rd_extern_libs(reader, fd);
+  if (!result)
+  {
+    wr_validation_err("extern libs");
+    fclose(fd);
+    return false;
+  }
+
+  result = vm_rd_extern_types(reader, fd);
+  if (!result)
+  {
+    wr_validation_err("extern types");
+    fclose(fd);
+    return false;
+  }
+
+  result = vm_rd_extern_fns(reader, fd);
+  if (!result)
+  {
+    wr_validation_err("extern functions");
+    fclose(fd);
+    return false;
+  }
+
+  result = vm_rd_ops(reader, fd);
+  if (!result)
+  {
+    wr_validation_err("opcodes");
+    fclose(fd);
+    return false;
+  }
+
+  fclose(fd);
+
+  return true;
+}
+
+char *fzl_vm_getreadererror() { return reader_err; }
+
+void fzl_vm_freereader(fzl_vm_reader_t *reader)
+{
+  if (!reader)
+    return;
+
+  if (reader->consts)
+  {
+    for (uint16_t i = 0; i < reader->consts_count; i++)
+      if (reader->consts[i].as.s.value)
+        free((void *)reader->consts[i].as.s.value);
+
+    free(reader->consts);
+  }
+
+  if (reader->extern_libs)
+  {
+    for (uint16_t i = 0; i < reader->extern_libs_count; i++)
+      free(reader->extern_libs[i]);
+
+    free(reader->extern_libs);
+  }
+
+  if (reader->extern_types)
+  {
+    for (uint16_t i = 0; i < reader->extern_types_count; i++)
+    {
+      free(reader->extern_types[i].name);
+
+      if (reader->extern_types[i].kind == FZL_EXTERN_KIND_STRUCT)
+      {
+        fzl_extern_struct_field_t *fields =
+            reader->extern_types[i].structure.fields;
+        for (uint16_t j = 0; j < reader->extern_types[i].structure.fields_count;
+             j++)
+        {
+          if (fields[j].name)
+            free(fields[j].name);
+        }
+
+        free(fields);
+      }
+    }
+
+    free(reader->extern_types);
+  }
+
+  if (reader->extern_fns)
+  {
+    for (uint16_t i = 0; i < reader->extern_fns_count; i++)
+    {
+      fzl_extern_fn_t *fn = &reader->extern_fns[i];
+      if (fn->used_name)
+        free(fn->used_name);
+
+      if (fn->symbol_name)
+        free(fn->symbol_name);
+
+      if (fn->args_count > 0)
+        free(fn->args);
+    }
+
+    free(reader->extern_fns);
+  }
+
+  if (reader->ops)
+    free(reader->ops);
+
+  free(reader);
+}

src/vm/handlers/group_and_or.c

@@ -1,3 +1,4 @@
+#include <stdio.h>
 #include <vm/fzl_vm.h>
 #include <vm/internals/opcode.h>
 

src/vm/handlers/group_cmp.c

@@ -1,3 +1,4 @@
+#include <stdio.h>
 #include <vm/fzl_vm.h>
 #include <vm/internals/opcode.h>
 

src/vm/handlers/group_ctx.c

@@ -132,8 +132,8 @@ int op_write(fzl_vm_t *vm)
 
 int op_load_local(fzl_vm_t *vm)
 {
-  size_t depth = vm->ops[++vm->ip];
-  size_t slot  = vm->ops[++vm->ip];
+  size_t depth = vm->reader->ops[++vm->ip];
+  size_t slot  = vm->reader->ops[++vm->ip];
 
   if (depth >= vm->etop)
   {
@@ -168,8 +168,8 @@ int op_store_local(fzl_vm_t *vm)
 
   fzl_value_t value = vm->dstack[--vm->dtop];
 
-  size_t depth = vm->ops[++vm->ip];
-  size_t slot  = vm->ops[++vm->ip];
+  size_t depth = vm->reader->ops[++vm->ip];
+  size_t slot  = vm->reader->ops[++vm->ip];
 
   if (depth >= vm->etop)
   {

src/vm/handlers/group_flow.c

@@ -1,16 +1,17 @@
+#include <stdio.h>
 #include <vm/fzl_vm.h>
 #include <vm/internals/opcode.h>
 
 // Jump at specified address
 int op_jmp(fzl_vm_t *vm)
 {
-  if (vm->ops_count <= vm->ip)
+  if (vm->reader->ops_count <= vm->ip)
   {
     snprintf(last_err, sizeof(last_err), "runtime error - expected JMP addr");
     return -1;
   }
 
-  uint64_t jmp_ip = vm->ops[++vm->ip];
+  uint64_t jmp_ip = vm->reader->ops[++vm->ip];
   if (!vm->allow_infinite)
   {
     if (jmp_ip == last_jmp_ip)
@@ -46,7 +47,7 @@ int op_jz(fzl_vm_t *vm)
   }
 
   fzl_value_t jzval = vm->dstack[--vm->dtop];
-  uint64_t jzip     = vm->ops[++vm->ip] - 1;
+  uint64_t jzip     = vm->reader->ops[++vm->ip] - 1;
   if (jzval.as.b == 0)
     vm->ip = jzip;
 

src/vm/handlers/group_fn.c

@@ -1,10 +1,14 @@
+#include <common/fzl_value.h>
+#include <stddef.h>
+#include <stdio.h>
 #include <vm/fzl_vm.h>
+#include <vm/fzl_vm_extern.h>
 #include <vm/internals/opcode.h>
 
 // Call function (store return address and jump into function init)
 int op_call(fzl_vm_t *vm)
 {
-  uint64_t ip            = vm->ops[++vm->ip];
+  uint64_t ip            = vm->reader->ops[++vm->ip];
   vm->cstack[vm->ctop++] = vm->ip;
   vm->ip                 = ip - 1;
   return 0;
@@ -27,7 +31,31 @@ int op_ret(fzl_vm_t *vm)
 // Call externally defined function
 int op_call_extern(fzl_vm_t *vm)
 {
-  (void)vm;
-  // TODO: implement
+  size_t fn_n = vm->reader->ops[++vm->ip];
+  if (fn_n >= vm->reader->extern_fns_count)
+  {
+    snprintf(last_err, sizeof(last_err),
+             "runtime error - unknown external function");
+    print_err_data(vm);
+    return -1;
+  }
+
+  fzl_vm_sym_t *fn = &vm->prep_fns->syms[fn_n];
+  if (!fn)
+  {
+    snprintf(last_err, sizeof(last_err),
+             "runtime error - failed to load extern function");
+    print_err_data(vm);
+    return -1;
+  }
+
+  if (vm->dtop < fn->cif.nargs)
+  {
+    snprintf(last_err, sizeof(last_err),
+             "runtime error - expected %u valued on dstack", fn->cif.nargs);
+    print_err_data(vm);
+    return -1;
+  }
+
   return 0;
 }

src/vm/handlers/group_math.c

@@ -1,3 +1,4 @@
+#include <stdio.h>
 #include <vm/fzl_vm.h>
 #include <vm/internals/opcode.h>
 

src/vm/handlers/group_not.c

@@ -1,3 +1,4 @@
+#include <stdio.h>
 #include <vm/fzl_vm.h>
 #include <vm/internals/opcode.h>
 

src/vm/handlers/group_obj.c

@@ -1,3 +1,4 @@
+#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <vm/fzl_vm.h>
@@ -57,7 +58,7 @@ void escape_recursive(fzl_vm_env_t *current, fzl_vm_env_t *parent,
 // Allocate specified count of fields and create object
 int op_alloc_object(fzl_vm_t *vm)
 {
-  uint64_t values_count = vm->ops[++vm->ip];
+  uint64_t values_count = vm->reader->ops[++vm->ip];
   fzl_vm_object_t *obj  = malloc(sizeof(fzl_vm_object_t));
 
   if (values_count < 1)
@@ -94,7 +95,7 @@ int op_get_field(fzl_vm_t *vm)
     return -1;
   }
 
-  uint64_t field_slot = vm->ops[++vm->ip];
+  uint64_t field_slot = vm->reader->ops[++vm->ip];
   fzl_value_t val     = vm->dstack[--vm->dtop];
   if (val.type != FZL_TYPE_OBJECT)
   {
@@ -130,7 +131,7 @@ int op_set_field(fzl_vm_t *vm)
     return -1;
   }
 
-  uint64_t field_slot = vm->ops[++vm->ip];
+  uint64_t field_slot = vm->reader->ops[++vm->ip];
   fzl_value_t objval  = vm->dstack[--vm->dtop];
   fzl_value_t wrval   = vm->dstack[--vm->dtop];
   if (objval.type != FZL_TYPE_OBJECT)