diff --git a/core_compiler.cpp b/core_compiler.cpp
index 1007e55..2e00d14 100644
--- a/core_compiler.cpp
+++ b/core_compiler.cpp
@@ -1,13 +1,14 @@
 
 CORE_Static void
 core_init_compiler(Core_Ctx *ctx, Allocator *allocator) {
+  ctx->init_ctx_time_begin = os_time();
+  pctx                = ctx;
+
   ctx->emit_type_info = true;
   ctx->emit_line_directives = true;
   ctx->color_codes_enabled = true;
   ctx->same_scope_token = { SAME_SCOPE };
 
-  ctx->init_ctx_time_begin = os_time();
-  pctx                = ctx;
   ctx->perm_push_only = make_push_arena(allocator);
   ctx->perm = &ctx->perm_push_only;
   ctx->scratch = allocate_scratch_arena(ctx->perm, mib(1));
@@ -24,49 +25,49 @@ core_init_compiler(Core_Ctx *ctx, Allocator *allocator) {
 
   /*#import meta
     for i in meta.keywords:
-    print(f'keyword_{i.lower()} = ctx->intern("{i}"_s);')
-    print(f'ctx->interns.first_keyword = keyword_{meta.keywords[0].lower()}.str;')
-    print(f'ctx->interns.last_keyword  = keyword_{meta.keywords[-1].lower()}.str;')
+      print(f'pctx->keyword_{i.lower()} = pctx->intern("{i}"_s);')
+    print(f'pctx->interns.first_keyword = keyword_{meta.keywords[0].lower()}.str;')
+    print(f'pctx->interns.last_keyword  = keyword_{meta.keywords[-1].lower()}.str;')
 
     for i in meta.interns:
-    print(f'intern_{i.lower()} = ctx->intern("{i}"_s);')
+      print(f'pctx->intern_{i.lower()} = pctx->intern("{i}"_s);')
 
     index = 0
     for i in meta.token_simple_expr:
-    if i[1] != "SPECIAL":
-    print(f'op_info_table[{index}].op = ctx->intern("{i[1]}"_s);')
-    index += 1
+      if i[1] != "SPECIAL":
+        print(f'op_info_table[{index}].op = pctx->intern("{i[1]}"_s);')
+      index += 1
 
     */
-  keyword_struct = ctx->intern("struct"_s);
-  keyword_union = ctx->intern("union"_s);
-  keyword_true = ctx->intern("true"_s);
-  keyword_default = ctx->intern("default"_s);
-  keyword_break = ctx->intern("break"_s);
-  keyword_false = ctx->intern("false"_s);
-  keyword_return = ctx->intern("return"_s);
-  keyword_switch = ctx->intern("switch"_s);
-  keyword_assert = ctx->intern("Assert"_s);
-  keyword_if = ctx->intern("if"_s);
-  keyword_elif = ctx->intern("elif"_s);
-  keyword_pass = ctx->intern("pass"_s);
-  keyword_else = ctx->intern("else"_s);
-  keyword_for = ctx->intern("for"_s);
-  keyword_enum = ctx->intern("enum"_s);
-  ctx->interns.first_keyword = keyword_struct.str;
-  ctx->interns.last_keyword  = keyword_enum.str;
-  intern_typeof = ctx->intern("TypeOf"_s);
-  intern_sizeof = ctx->intern("SizeOf"_s);
-  intern_len = ctx->intern("Len"_s);
-  intern_alignof = ctx->intern("AlignOf"_s);
-  intern_foreign = ctx->intern("foreign"_s);
-  intern_strict = ctx->intern("strict"_s);
-  intern_void = ctx->intern("void"_s);
-  intern_flag = ctx->intern("flag"_s);
-  intern_it = ctx->intern("it"_s);
-  intern_load = ctx->intern("load"_s);
-  intern_import = ctx->intern("import"_s);
-  intern_link = ctx->intern("link"_s);
+  pctx->keyword_struct = ctx->intern("struct"_s);
+  pctx->keyword_union = ctx->intern("union"_s);
+  pctx->keyword_true = ctx->intern("true"_s);
+  pctx->keyword_default = ctx->intern("default"_s);
+  pctx->keyword_break = ctx->intern("break"_s);
+  pctx->keyword_false = ctx->intern("false"_s);
+  pctx->keyword_return = ctx->intern("return"_s);
+  pctx->keyword_switch = ctx->intern("switch"_s);
+  pctx->keyword_assert = ctx->intern("Assert"_s);
+  pctx->keyword_if = ctx->intern("if"_s);
+  pctx->keyword_elif = ctx->intern("elif"_s);
+  pctx->keyword_pass = ctx->intern("pass"_s);
+  pctx->keyword_else = ctx->intern("else"_s);
+  pctx->keyword_for = ctx->intern("for"_s);
+  pctx->keyword_enum = ctx->intern("enum"_s);
+  pctx->interns.first_keyword = pctx->keyword_struct.str;
+  pctx->interns.last_keyword  = pctx->keyword_enum.str;
+  pctx->intern_typeof = ctx->intern("TypeOf"_s);
+  pctx->intern_sizeof = ctx->intern("SizeOf"_s);
+  pctx->intern_len = ctx->intern("Len"_s);
+  pctx->intern_alignof = ctx->intern("AlignOf"_s);
+  pctx->intern_foreign = ctx->intern("foreign"_s);
+  pctx->intern_strict = ctx->intern("strict"_s);
+  pctx->intern_void = ctx->intern("void"_s);
+  pctx->intern_flag = ctx->intern("flag"_s);
+  pctx->intern_it = ctx->intern("it"_s);
+  pctx->intern_load = ctx->intern("load"_s);
+  pctx->intern_import = ctx->intern("import"_s);
+  pctx->intern_link = ctx->intern("link"_s);
   op_info_table[0].op = ctx->intern("*"_s);
   op_info_table[1].op = ctx->intern("/"_s);
   op_info_table[2].op = ctx->intern("%"_s);
diff --git a/core_compiler.h b/core_compiler.h
index 57b6618..a3800c4 100644
--- a/core_compiler.h
+++ b/core_compiler.h
@@ -96,6 +96,39 @@ struct Core_Ctx{
 
   Token same_scope_token;
   Token null_token;
+  /*#import meta
+    for i in meta.keywords: print(f'Intern_String keyword_{i.lower()};')
+    for i in meta.interns: print(f'Intern_String intern_{i.lower()};')
+
+    */
+  Intern_String keyword_struct;
+  Intern_String keyword_union;
+  Intern_String keyword_true;
+  Intern_String keyword_default;
+  Intern_String keyword_break;
+  Intern_String keyword_false;
+  Intern_String keyword_return;
+  Intern_String keyword_switch;
+  Intern_String keyword_assert;
+  Intern_String keyword_if;
+  Intern_String keyword_elif;
+  Intern_String keyword_pass;
+  Intern_String keyword_else;
+  Intern_String keyword_for;
+  Intern_String keyword_enum;
+  Intern_String intern_typeof;
+  Intern_String intern_sizeof;
+  Intern_String intern_len;
+  Intern_String intern_alignof;
+  Intern_String intern_foreign;
+  Intern_String intern_strict;
+  Intern_String intern_void;
+  Intern_String intern_flag;
+  Intern_String intern_it;
+  Intern_String intern_load;
+  Intern_String intern_import;
+  Intern_String intern_link;
+  /*END*/
 
   Intern_String intern(String string){
     assert(string.len > 0);
diff --git a/core_globals.cpp b/core_globals.cpp
index f02b285..37ff9e9 100644
--- a/core_globals.cpp
+++ b/core_globals.cpp
@@ -3,40 +3,6 @@ thread_local Core_Ctx *pctx;
 Allocator *bigint_allocator;
 global S64 bigint_allocation_count;
 
-/*#import meta
-for i in meta.keywords: print(f'Intern_String keyword_{i.lower()};')
-for i in meta.interns: print(f'Intern_String intern_{i.lower()};')
-
-*/
-Intern_String keyword_struct;
-Intern_String keyword_union;
-Intern_String keyword_true;
-Intern_String keyword_default;
-Intern_String keyword_break;
-Intern_String keyword_false;
-Intern_String keyword_return;
-Intern_String keyword_switch;
-Intern_String keyword_assert;
-Intern_String keyword_if;
-Intern_String keyword_elif;
-Intern_String keyword_pass;
-Intern_String keyword_else;
-Intern_String keyword_for;
-Intern_String keyword_enum;
-Intern_String intern_typeof;
-Intern_String intern_sizeof;
-Intern_String intern_len;
-Intern_String intern_alignof;
-Intern_String intern_foreign;
-Intern_String intern_strict;
-Intern_String intern_void;
-Intern_String intern_flag;
-Intern_String intern_it;
-Intern_String intern_load;
-Intern_String intern_import;
-Intern_String intern_link;
-/*END*/
-
 //-----------------------------------------------------------------------------
 // Type globals
 //-----------------------------------------------------------------------------
diff --git a/core_parsing.cpp b/core_parsing.cpp
index 3d5e923..85f10b8 100644
--- a/core_parsing.cpp
+++ b/core_parsing.cpp
@@ -282,7 +282,7 @@ parse_stmt_scope(Ast_Scope *scope_defined_outside = 0){
     do{
       Token *token = token_get();
 
-      if(token_match_keyword(keyword_return)){
+      if(token_match_keyword(pctx->keyword_return)){
         Array<Ast_Expr *> expr = {scratch};
         if(!token_is_scope()) {
           do{
@@ -293,22 +293,22 @@ parse_stmt_scope(Ast_Scope *scope_defined_outside = 0){
         scope->stmts.add(ast_return(token, expr));
       }
 
-      else if(token_match_keyword(keyword_break)){
+      else if(token_match_keyword(pctx->keyword_break)){
         scope->stmts.add(ast_break(token));
       }
 
-      else if(token_match_keyword(keyword_pass)){
+      else if(token_match_keyword(pctx->keyword_pass)){
         scope->stmts.add(ast_pass(token));
       }
 
-      else if(token_match_keyword(keyword_switch)){
+      else if(token_match_keyword(pctx->keyword_switch)){
         Ast_Switch *result = ast_new(Ast_Switch, AST_SWITCH, token, AST_STMT);
         result->value = parse_expr();
         result->cases = {scratch};
 
         token_expect(OPEN_SCOPE);
         do{
-          if(token_match_keyword(keyword_default)){
+          if(token_match_keyword(pctx->keyword_default)){
             result->default_scope = parse_stmt_scope();
             continue;
           }
@@ -332,7 +332,7 @@ parse_stmt_scope(Ast_Scope *scope_defined_outside = 0){
         scope->stmts.add(result);
       }
 
-      else if(token_match_keyword(keyword_assert)){
+      else if(token_match_keyword(pctx->keyword_assert)){
         token_expect(TK_OpenParen);
         Ast_Expr *expr = parse_expr();
         Intern_String message = {};
@@ -344,7 +344,7 @@ parse_stmt_scope(Ast_Scope *scope_defined_outside = 0){
         scope->stmts.add(ast_runtime_assert(token, expr, message));
       }
 
-      else if(token_match_pound(keyword_assert)){
+      else if(token_match_pound(pctx->keyword_assert)){
         token_expect(TK_OpenParen);
         Ast_Expr *expr = parse_expr();
         Intern_String message = {};
@@ -356,7 +356,7 @@ parse_stmt_scope(Ast_Scope *scope_defined_outside = 0){
         scope->stmts.add(ast_constant_assert(token, expr, message));
       }
 
-      else if(token_match_keyword(keyword_for)){
+      else if(token_match_keyword(pctx->keyword_for)){
         Ast_Scope *for_scope = begin_stmt_scope(scratch, token_get());
         Ast_Expr *init = 0;
         Ast_Expr *cond = 0;
@@ -382,7 +382,7 @@ parse_stmt_scope(Ast_Scope *scope_defined_outside = 0){
         scope->stmts.add(ast_for(token, init, cond, iter, for_scope));
       }
 
-      else if(token_match_keyword(keyword_if)){
+      else if(token_match_keyword(pctx->keyword_if)){
         Array<Ast_If_Node *> if_nodes = {scratch};
         Ast_Expr *expr     = parse_expr();
         Ast_Expr *init_val = parse_init_stmt(expr);
@@ -396,19 +396,19 @@ parse_stmt_scope(Ast_Scope *scope_defined_outside = 0){
         Ast_If_Node *if_node = ast_if_node(token, init_val, expr, if_block);
         if_nodes.add(if_node);
 
-        while(token_is(SAME_SCOPE) && (token_is_keyword(keyword_elif, 1) || (token_is_keyword(keyword_else, 1)))){
+        while(token_is(SAME_SCOPE) && (token_is_keyword(pctx->keyword_elif, 1) || (token_is_keyword(pctx->keyword_else, 1)))){
           token_next();
           token = token_get();
-          if(token_match_keyword(keyword_elif)){
-            assert(token->intern_val == keyword_elif);
+          if(token_match_keyword(pctx->keyword_elif)){
+            assert(token->intern_val == pctx->keyword_elif);
             Ast_Expr *expr = parse_expr();
             Ast_Scope *else_if_block = parse_stmt_scope();
             Ast_If_Node *if_node = ast_if_node(token, 0, expr, else_if_block);
             if_nodes.add(if_node);
           }
           else{
-            token_match_keyword(keyword_else);
-            assert(token->intern_val == keyword_else);
+            token_match_keyword(pctx->keyword_else);
+            assert(token->intern_val == pctx->keyword_else);
             Ast_Scope *else_block = parse_stmt_scope();
             Ast_If_Node *if_node = ast_if_node(token, 0, 0, else_block);
             if_nodes.add(if_node);
@@ -494,7 +494,7 @@ parse_lambda(Token *token){
       ret.add(typespec);
     }while(token_match(TK_Comma));
   }
-  else ret.add(ast_ident(token, intern_void));
+  else ret.add(ast_ident(token, pctx->intern_void));
 
   Ast_Scope *scope   = token_is(OPEN_SCOPE) ? parse_stmt_scope() : 0;
   Ast_Lambda *result = ast_lambda(token, params, ret, scope);
@@ -612,9 +612,9 @@ parse_expr(S64 min_bp){
     }break;
 
     case TK_Keyword: {
-      if(token->intern_val == keyword_true)
+      if(token->intern_val == pctx->keyword_true)
         left = ast_bool(token, 1);
-      else if(token->intern_val == keyword_false)
+      else if(token->intern_val == pctx->keyword_false)
         left = ast_bool(token, 0);
       else compiler_error(token, "Unexpected keyword: [%s]", token->intern_val.str);
     }break;
@@ -717,7 +717,7 @@ parse_enum(Token *pos){
   Scratch_Arena *scratch = pctx->scratch;
   Scratch_Scope __scope(scratch);
   Ast_Expr *typespec = parse_optional_type();
-  Token *flag = token_match_pound(intern_flag);
+  Token *flag = token_match_pound(pctx->intern_flag);
 
   token_match(OPEN_SCOPE);
   Ast_Scope *scope = begin_decl_scope(scratch, token_get());
@@ -845,18 +845,18 @@ parse_decl(B32 is_global){
   Token *tname = token_get();
   if(token_match(TK_Identifier, TK_DoubleColon)){
 
-    if(token_match_pound(intern_foreign)){
+    if(token_match_pound(pctx->intern_foreign)){
       set_flag(flags, AST_FOREIGN);
-    } else if(token_match_pound(intern_strict)){
+    } else if(token_match_pound(pctx->intern_strict)){
       set_flag(flags, AST_STRICT);
     }
 
     // @note parse struct binding
-    if(token_match_keyword(keyword_struct)){
+    if(token_match_keyword(pctx->keyword_struct)){
       result = parse_struct(tname);
     }
 
-    else if(token_match_keyword(keyword_enum)){
+    else if(token_match_keyword(pctx->keyword_enum)){
       result = parse_enum(tname);
     }
 
@@ -914,7 +914,7 @@ parse_decl(B32 is_global){
   else if(token_match(TK_Identifier, TK_Colon)){
     Ast_Expr *typespec = parse_expr();
     Ast_Expr *expr     = parse_assign_expr();
-    if(token_match_pound(intern_foreign))
+    if(token_match_pound(pctx->intern_foreign))
       set_flag(flags, AST_FOREIGN);
 
     result = ast_var(tname, typespec, tname->intern_val, expr);
@@ -952,13 +952,13 @@ parse_file(Ast_File *file){
   pctx->currently_parsed_scope = file;
   lex_restream(pctx, file->filecontent, file->absolute_file_path);
   while (token_expect(SAME_SCOPE)) {
-    if (token_match_pound(intern_load)) {
+    if (token_match_pound(pctx->intern_load)) {
       parse_load(true);
       continue;
-    } else if (token_match_pound(intern_import)) {
+    } else if (token_match_pound(pctx->intern_import)) {
       parse_import(true);
       continue;
-    } else if (token_match_pound(intern_link)) {
+    } else if (token_match_pound(pctx->intern_link)) {
       Token *file = token_expect(TK_StringLit);
       add(pctx->perm, &pctx->files_to_link, file);
       continue;
diff --git a/core_typechecking.cpp b/core_typechecking.cpp
index 5253bda..d91e0cc 100644
--- a/core_typechecking.cpp
+++ b/core_typechecking.cpp
@@ -810,7 +810,7 @@ resolve_stmt(Ast *ast, Ast_Type *ret){
           Ast_Decl *var = ast_new(Ast_Decl, AST_VAR, node->cond->pos, AST_DECL);
           var->state = DECL_RESOLVED;
           var->type = type_pointer(op.type->base);
-          var->name = intern_it;
+          var->name = pctx->intern_it;
           insert_into_scope(node->scope, var);
           node->array_traversal_var = var;
         }
@@ -1440,7 +1440,7 @@ resolve_expr(Ast_Expr *ast, Resolve_Flag flags, Ast_Type *compound_and_const_str
     }
 
     CASE(CALL, Call){
-      if(expr_atom_is_equal_intern(node->name, intern_sizeof)){
+      if(expr_atom_is_equal_intern(node->name, pctx->intern_sizeof)){
         Ast_Expr *expr = unpack_ast_call_expr_for_builtin(node);
 
         Operand name = resolve_expr(expr, inherit_flag(flags, AST_CANT_BE_NULL), 0, field_access_scope);
@@ -1458,7 +1458,7 @@ resolve_expr(Ast_Expr *ast, Resolve_Flag flags, Ast_Type *compound_and_const_str
         return operand_const_rvalue(v);
       }
 
-      else if(expr_atom_is_equal_intern(node->name, intern_typeof)){
+      else if(expr_atom_is_equal_intern(node->name, pctx->intern_typeof)){
         Ast_Expr *expr = unpack_ast_call_expr_for_builtin(node);
 
         Operand name = resolve_expr(expr, inherit_flag(flags, AST_CANT_BE_NULL), 0, field_access_scope);
@@ -1470,7 +1470,7 @@ resolve_expr(Ast_Expr *ast, Resolve_Flag flags, Ast_Type *compound_and_const_str
         return result;
       }
 
-      else if(expr_atom_is_equal_intern(node->name, intern_alignof)){
+      else if(expr_atom_is_equal_intern(node->name, pctx->intern_alignof)){
         Ast_Expr *expr = unpack_ast_call_expr_for_builtin(node);
         Operand name = resolve_expr(expr, inherit_flag(flags, AST_CANT_BE_NULL), 0, field_access_scope);
         node->kind = AST_ALIGN_OF;
@@ -1486,7 +1486,7 @@ resolve_expr(Ast_Expr *ast, Resolve_Flag flags, Ast_Type *compound_and_const_str
         return operand_const_rvalue(v);
       }
 
-      else if(expr_atom_is_equal_intern(node->name, intern_len)){
+      else if(expr_atom_is_equal_intern(node->name, pctx->intern_len)){
         Ast_Expr *expr = unpack_ast_call_expr_for_builtin(node);
 
         Operand name = resolve_expr(expr, inherit_flag(flags, AST_CANT_BE_NULL), 0, field_access_scope);