diff --git a/meta/4ed_metagen.cpp b/meta/4ed_metagen.cpp
index 6dcf33fa..7c714983 100644
--- a/meta/4ed_metagen.cpp
+++ b/meta/4ed_metagen.cpp
@@ -20,7 +20,7 @@
 
 #define FSTRING_IMPLEMENTATION
 #include "../4coder_lib/4coder_string.h"
-#include "../4coder_lib/4coder_mem.h"
+//#include "../4coder_lib/4coder_mem.h"
 
 #include "../4cpp/4cpp_lexer.h"
 
@@ -28,7 +28,10 @@
 #include <stdio.h>
 #include <string.h>
 
+#define FTECH_FILE_MOVING_IMPLEMENTATION
+#include "4ed_file_moving.h"
 #include "4ed_meta_parser.cpp"
+#include "4ed_meta_keywords.h"
 #include "4ed_out_context.cpp"
 
 //////////////////////////////////////////////////////////////////////////////////////////////////
@@ -82,36 +85,36 @@ generate_keycode_enum(){
     if (begin_file_out(&context, filename_keycodes, &out)){
         int32_t count = ArrayCount(keys_that_need_codes);
         
-        append_sc(&out, "enum{\n");
+        append(&out, "enum{\n");
         for (int32_t i = 0; i < count;){
-            append_sc(&out, "key_");
-            append_sc(&out, keys_that_need_codes[i++]);
-            append_sc(&out, " = ");
+            append(&out, "key_");
+            append(&out, keys_that_need_codes[i++]);
+            append(&out, " = ");
             append_int_to_str(&out, code++);
-            append_sc(&out, ",\n");
+            append(&out, ",\n");
         }
-        append_sc(&out, "};\n");
+        append(&out, "};\n");
         
-        append_sc(&out,
-                  "static char*\n"
-                  "global_key_name(uint32_t key_code, int32_t *size){\n"
-                  "char *result = 0;\n"
-                  "switch(key_code){\n");
+        append(&out,
+               "static char*\n"
+               "global_key_name(uint32_t key_code, int32_t *size){\n"
+               "char *result = 0;\n"
+               "switch(key_code){\n");
         
         for (int32_t i = 0; i < count; ++i){
-            append_sc(&out, "case key_");
-            append_sc(&out, keys_that_need_codes[i]);
-            append_sc(&out, ": result = \"");
-            append_sc(&out, keys_that_need_codes[i]);
-            append_sc(&out, "\"; *size = sizeof(\"");
-            append_sc(&out, keys_that_need_codes[i]);
-            append_sc(&out, "\")-1; break;\n");
+            append(&out, "case key_");
+            append(&out, keys_that_need_codes[i]);
+            append(&out, ": result = \"");
+            append(&out, keys_that_need_codes[i]);
+            append(&out, "\"; *size = sizeof(\"");
+            append(&out, keys_that_need_codes[i]);
+            append(&out, "\")-1; break;\n");
         }
         
-        append_sc(&out,
-                  "}\n"
-                  "return(result);\n"
-                  "}\n");
+        append(&out,
+               "}\n"
+               "return(result);\n"
+               "}\n");
         
         end_file_out(context);
     }
@@ -120,21 +123,21 @@ generate_keycode_enum(){
 //////////////////////////////////////////////////////////////////////////////////////////////////
 static void
 struct_begin(String *str, char *name){
-    append_sc(str, "struct ");
-    append_sc(str, name);
-    append_sc(str, "{\n"); //}
+    append(str, "struct ");
+    append(str, name);
+    append(str, "{\n"); //}
 }
 
 static void
 enum_begin(String *str, char *name){
-    append_sc(str, "enum ");
-    append_sc(str, name);
-    append_sc(str, "{\n"); //}
+    append(str, "enum ");
+    append(str, name);
+    append(str, "{\n"); //}
 }
 
 static void
 struct_end(String *str){ //{
-    append_sc(str, "};\n\n");
+    append(str, "};\n\n");
 }
 
 static char* bar_style_fields[] = {
@@ -205,46 +208,46 @@ generate_style(){
             int32_t count = ArrayCount(bar_style_fields);
             for (int32_t i = 0; i < count; ++i){
                 char *tag = make_style_tag(bar_style_fields[i]);
-                append_sc(&out, "Stag_");
-                append_sc(&out, tag);
-                append_sc(&out, ",\n");
+                append(&out, "Stag_");
+                append(&out, tag);
+                append(&out, ",\n");
                 free(tag);
             }
             
             count = ArrayCount(main_style_fields);
             for (int32_t i = 0; i < count; ++i){
                 char *tag = make_style_tag(main_style_fields[i]);
-                append_sc(&out, "Stag_");
-                append_sc(&out, tag);
-                append_sc(&out, ",\n");
+                append(&out, "Stag_");
+                append(&out, tag);
+                append(&out, ",\n");
                 free(tag);
             }
             
-            append_sc(&out, "Stag_COUNT\n");
+            append(&out, "Stag_COUNT\n");
         }
         struct_end(&out);
         
-        append_sc(&out, "static char *style_tag_names[] = {\n");
+        append(&out, "static char *style_tag_names[] = {\n");
         {
             int32_t count = ArrayCount(bar_style_fields);
             for (int32_t i = 0; i < count; ++i){
                 char *tag = make_style_tag(bar_style_fields[i]);
-                append_sc(&out, "\"");
-                append_sc(&out, tag);
-                append_sc(&out, "\",\n");
+                append(&out, "\"");
+                append(&out, tag);
+                append(&out, "\",\n");
                 free(tag);
             }
             
             count = ArrayCount(main_style_fields);
             for (int32_t i = 0; i < count; ++i){
                 char *tag = make_style_tag(main_style_fields[i]);
-                append_sc(&out, "\"");
-                append_sc(&out, tag);
-                append_sc(&out, "\",\n");
+                append(&out, "\"");
+                append(&out, tag);
+                append(&out, "\",\n");
                 free(tag);
             }
         }
-        append_sc(&out, "};\n");
+        append(&out, "};\n");
         
         end_file_out(context);
     }
@@ -255,9 +258,9 @@ generate_style(){
         {
             int32_t count = ArrayCount(bar_style_fields);
             for (int32_t i = 0; i < count; ++i){
-                append_sc(&out, "u32 ");
-                append_sc(&out, bar_style_fields[i]);
-                append_sc(&out, "_color;\n");
+                append(&out, "u32 ");
+                append(&out, bar_style_fields[i]);
+                append(&out, "_color;\n");
             }
         }
         struct_end(&out);
@@ -266,47 +269,47 @@ generate_style(){
         {
             int32_t count = ArrayCount(main_style_fields);
             for (int32_t i = 0; i < count; ++i){
-                append_sc(&out, "u32 ");
-                append_sc(&out, main_style_fields[i]);
-                append_sc(&out, "_color;\n");
+                append(&out, "u32 ");
+                append(&out, main_style_fields[i]);
+                append(&out, "_color;\n");
             }
-            append_sc(&out, "Interactive_Style file_info_style;\n");
+            append(&out, "Interactive_Style file_info_style;\n");
         }
         struct_end(&out);
         
         {
-            append_sc(&out,
-                      "inline u32*\n"
-                      "style_index_by_tag(Style_Main_Data *s, u32 tag){\n"
-                      "u32 *result = 0;\n"
-                      "switch (tag){\n");
+            append(&out,
+                   "inline u32*\n"
+                   "style_index_by_tag(Style_Main_Data *s, u32 tag){\n"
+                   "u32 *result = 0;\n"
+                   "switch (tag){\n");
             
             int32_t count = ArrayCount(bar_style_fields);
             for (int32_t i = 0; i < count; ++i){
                 char *tag = make_style_tag(bar_style_fields[i]);
-                append_sc(&out, "case Stag_");
-                append_sc(&out, tag);
-                append_sc(&out, ": result = &s->file_info_style.");
-                append_sc(&out, bar_style_fields[i]);
-                append_sc(&out, "_color; break;\n");
+                append(&out, "case Stag_");
+                append(&out, tag);
+                append(&out, ": result = &s->file_info_style.");
+                append(&out, bar_style_fields[i]);
+                append(&out, "_color; break;\n");
                 free(tag);
             }
             
             count = ArrayCount(main_style_fields);
             for (int32_t i = 0; i < count; ++i){
                 char *tag = make_style_tag(main_style_fields[i]);
-                append_sc(&out, "case Stag_");
-                append_sc(&out, tag);
-                append_sc(&out, ": result = &s->");
-                append_sc(&out, main_style_fields[i]);
-                append_sc(&out, "_color; break;\n");
+                append(&out, "case Stag_");
+                append(&out, tag);
+                append(&out, ": result = &s->");
+                append(&out, main_style_fields[i]);
+                append(&out, "_color; break;\n");
                 free(tag);
             }
             
-            append_sc(&out,
-                      "}\n"
-                      "return(result);\n"
-                      "}\n\n");
+            append(&out,
+                   "}\n"
+                   "return(result);\n"
+                   "}\n\n");
         }
         
         end_file_out(context);
@@ -335,7 +338,7 @@ print_function_body_code(String *out, Parse_Context *context, int32_t start){
     for (; (token = get_token(context)) != 0; get_next_token(context)){
         if (do_whitespace_print){
             pstr = str_start_end(context->data, start, token->start);
-            append_ss(out, pstr);
+            append(out, pstr);
         }
         else{
             do_whitespace_print = true;
@@ -364,7 +367,7 @@ print_function_body_code(String *out, Parse_Context *context, int32_t start){
         
         if (do_print){
             pstr = get_lexeme(*token, context->data);
-            append_ss(out, pstr);
+            append(out, pstr);
         }
         
         start = token->start + token->size;
@@ -385,9 +388,9 @@ typedef struct App_API{
 } App_API;
 
 static App_API
-allocate_app_api(Partition *part, int32_t count){
+allocate_app_api(int32_t count){
     App_API app_api = {0};
-    app_api.names = push_array(part, App_API_Name, count);
+    app_api.names = fm_push_array(App_API_Name, count);
     memset(app_api.names, 0, sizeof(App_API_Name)*count);
     return(app_api);
 }
@@ -400,73 +403,57 @@ generate_custom_headers(){
     void *mem = malloc(size);
     memset(mem, 0, size);
     
-    Partition part_ = make_part(mem, size);
-    Partition *part = &part_;
-    
-    static Meta_Keywords meta_keywords[] = {
-        {make_lit_string("API_EXPORT")        , Item_Function } ,
-        {make_lit_string("API_EXPORT_INLINE") , Item_Function } ,
-        {make_lit_string("API_EXPORT_MACRO")  , Item_Macro    } ,
-        {make_lit_string("CPP_NAME")          , Item_CppName  } ,
-        {make_lit_string("TYPEDEF") , Item_Typedef } ,
-        {make_lit_string("STRUCT")  , Item_Struct  } ,
-        {make_lit_string("UNION")   , Item_Union   } ,
-        {make_lit_string("ENUM")    , Item_Enum    } ,
-    };
-    
-#define ExpandArray(a) (a), (ArrayCount(a))
-    
     // NOTE(allen): Parse the customization API files
     static char *functions_files[] = { "4ed_api_implementation.cpp", 0 };
-    Meta_Unit unit_custom = compile_meta_unit(part, ".", functions_files, ExpandArray(meta_keywords));
+    Meta_Unit unit_custom = compile_meta_unit(".", functions_files, ExpandArray(meta_keywords));
     if (unit_custom.parse == 0){
         Assert(!"Missing one or more input files!");
     }
     
     // NOTE(allen): Compute and store variations of the function names
-    App_API func_4ed_names = allocate_app_api(part, unit_custom.set.count);
+    App_API func_4ed_names = allocate_app_api(unit_custom.set.count);
     
     for (int32_t i = 0; i < unit_custom.set.count; ++i){
         String name_string = unit_custom.set.items[i].name;
         String *macro = &func_4ed_names.names[i].macro;
         String *public_name = &func_4ed_names.names[i].public_name;
         
-        *macro = str_alloc(part, name_string.size+4);
+        *macro = str_alloc(name_string.size+4);
         to_upper_ss(macro, name_string);
-        append_ss(macro, make_lit_string("_SIG"));
+        append(macro, make_lit_string("_SIG"));
         
-        *public_name = str_alloc(part, name_string.size);
+        *public_name = str_alloc(name_string.size);
         to_lower_ss(public_name, name_string);
         
-        partition_align(part, 4);
+        fm_align();
     }
     
     // NOTE(allen): Output
-    String out = str_alloc(part, 10 << 20);
+    String out = str_alloc(10 << 20);
     Out_Context context = {0};
     
     // NOTE(allen): Custom API headers
     if (begin_file_out(&context, OS_API_H, &out)){
         int32_t main_api_count = unit_custom.parse[0].item_count;
         int32_t os_api_count = unit_custom.parse[1].item_count;
-        append_sc(&out, "struct Application_Links;\n");
+        append(&out, "struct Application_Links;\n");
         
         for (int32_t i = main_api_count; i < os_api_count; ++i){
-            append_sc(&out, "#define ");
-            append_ss(&out, func_4ed_names.names[i].macro);
-            append_sc(&out, "(n) ");
-            append_ss(&out, unit_custom.set.items[i].ret);
-            append_sc(&out, " n");
-            append_ss(&out, unit_custom.set.items[i].args);
+            append(&out, "#define ");
+            append(&out, func_4ed_names.names[i].macro);
+            append(&out, "(n) ");
+            append(&out, unit_custom.set.items[i].ret);
+            append(&out, " n");
+            append(&out, unit_custom.set.items[i].args);
             append_s_char(&out, '\n');
         }
         
         for (int32_t i = main_api_count; i < os_api_count; ++i){
-            append_sc(&out, "typedef ");
-            append_ss(&out, func_4ed_names.names[i].macro);
+            append(&out, "typedef ");
+            append(&out, func_4ed_names.names[i].macro);
             append_s_char(&out, '(');
-            append_ss(&out, unit_custom.set.items[i].name);
-            append_sc(&out, "_Function);\n");
+            append(&out, unit_custom.set.items[i].name);
+            append(&out, "_Function);\n");
         }
         
         end_file_out(context);
@@ -476,116 +463,116 @@ generate_custom_headers(){
     }
     
     if (begin_file_out(&context, API_H, &out)){
-        append_sc(&out, "struct Application_Links;\n");
+        append(&out, "struct Application_Links;\n");
         
         for (int32_t i = 0; i < unit_custom.set.count; ++i){
-            append_sc(&out, "#define ");
-            append_ss(&out, func_4ed_names.names[i].macro);
-            append_sc(&out, "(n) ");
-            append_ss(&out, unit_custom.set.items[i].ret);
-            append_sc(&out, " n");
-            append_ss(&out, unit_custom.set.items[i].args);
+            append(&out, "#define ");
+            append(&out, func_4ed_names.names[i].macro);
+            append(&out, "(n) ");
+            append(&out, unit_custom.set.items[i].ret);
+            append(&out, " n");
+            append(&out, unit_custom.set.items[i].args);
             append_s_char(&out, '\n');
         }
         
         for (int32_t i = 0; i < unit_custom.set.count; ++i){
-            append_sc(&out, "typedef ");
-            append_ss(&out, func_4ed_names.names[i].macro);
+            append(&out, "typedef ");
+            append(&out, func_4ed_names.names[i].macro);
             append_s_char(&out, '(');
-            append_ss(&out, unit_custom.set.items[i].name);
-            append_sc(&out, "_Function);\n");
+            append(&out, unit_custom.set.items[i].name);
+            append(&out, "_Function);\n");
         }
         
-        append_sc(&out, "struct Application_Links{\n");
+        append(&out, "struct Application_Links{\n");
         
         
-        append_sc(&out, "#if defined(ALLOW_DEP_4CODER)\n");
+        append(&out, "#if defined(ALLOW_DEP_4CODER)\n");
         for (int32_t i = 0; i < unit_custom.set.count; ++i){
-            append_ss(&out, unit_custom.set.items[i].name);
-            append_sc(&out, "_Function *");
-            append_ss(&out, func_4ed_names.names[i].public_name);
-            append_sc(&out, ";\n");
+            append(&out, unit_custom.set.items[i].name);
+            append(&out, "_Function *");
+            append(&out, func_4ed_names.names[i].public_name);
+            append(&out, ";\n");
         }
         
-        append_sc(&out, "#else\n");
+        append(&out, "#else\n");
         
         for (int32_t i = 0; i < unit_custom.set.count; ++i){
-            append_ss(&out, unit_custom.set.items[i].name);
-            append_sc(&out, "_Function *");
-            append_ss(&out, func_4ed_names.names[i].public_name);
-            append_sc(&out, "_;\n");
+            append(&out, unit_custom.set.items[i].name);
+            append(&out, "_Function *");
+            append(&out, func_4ed_names.names[i].public_name);
+            append(&out, "_;\n");
         }
-        append_sc(&out, "#endif\n");
+        append(&out, "#endif\n");
         
-        append_sc(&out,
-                  "void *memory;\n"
-                  "int32_t memory_size;\n"
-                  "void *cmd_context;\n"
-                  "void *system_links;\n"
-                  "void *current_coroutine;\n"
-                  "int32_t type_coroutine;\n"
-                  "};\n");
+        append(&out,
+               "void *memory;\n"
+               "int32_t memory_size;\n"
+               "void *cmd_context;\n"
+               "void *system_links;\n"
+               "void *current_coroutine;\n"
+               "int32_t type_coroutine;\n"
+               "};\n");
         
-        append_sc(&out, "#define FillAppLinksAPI(app_links) do{");
+        append(&out, "#define FillAppLinksAPI(app_links) do{");
         for (int32_t i = 0; i < unit_custom.set.count; ++i){
-            append_sc(&out, "\\\napp_links->");
-            append_ss(&out, func_4ed_names.names[i].public_name);
-            append_sc(&out, "_ = ");
-            append_ss(&out, unit_custom.set.items[i].name);
+            append(&out, "\\\napp_links->");
+            append(&out, func_4ed_names.names[i].public_name);
+            append(&out, "_ = ");
+            append(&out, unit_custom.set.items[i].name);
             append_s_char(&out, ';');
         }
-        append_sc(&out, "} while(false)\n");
+        append(&out, "} while(false)\n");
         
-        append_sc(&out, "#if defined(ALLOW_DEP_4CODER)\n");
+        append(&out, "#if defined(ALLOW_DEP_4CODER)\n");
         for (int32_t use_dep = 1; use_dep >= 0; --use_dep){
             for (int32_t i = 0; i < unit_custom.set.count; ++i){
                 Argument_Breakdown breakdown = unit_custom.set.items[i].breakdown;
                 String ret = unit_custom.set.items[i].ret;
                 String public_name = func_4ed_names.names[i].public_name;
                 
-                append_sc(&out, "static inline ");
-                append_ss(&out, ret);
-                append_sc(&out, " ");
-                append_ss(&out, public_name);
+                append(&out, "static inline ");
+                append(&out, ret);
+                append(&out, " ");
+                append(&out, public_name);
                 
-                append_sc(&out, "(");
+                append(&out, "(");
                 for (int32_t j = 0; j < breakdown.count; ++j){
-                    append_ss(&out, breakdown.args[j].param_string);
+                    append(&out, breakdown.args[j].param_string);
                     if (j+1 != breakdown.count){
-                        append_sc(&out, ", ");
+                        append(&out, ", ");
                     }
                 }
-                append_sc(&out, "){");
+                append(&out, "){");
                 
                 if (match_ss(ret, make_lit_string("void"))){
-                    append_sc(&out, "(");
+                    append(&out, "(");
                 }
                 else{
-                    append_sc(&out, "return(");
+                    append(&out, "return(");
                 }
                 
-                append_sc(&out, "app->");
-                append_ss(&out, public_name);
+                append(&out, "app->");
+                append(&out, public_name);
                 if (!use_dep){
-                    append_sc(&out, "_");
+                    append(&out, "_");
                 }
                 
-                append_sc(&out, "(");
+                append(&out, "(");
                 for (int32_t j = 0; j < breakdown.count; ++j){
-                    append_ss(&out, breakdown.args[j].param_name);
+                    append(&out, breakdown.args[j].param_name);
                     if (j+1 != breakdown.count){
-                        append_sc(&out, ", ");
+                        append(&out, ", ");
                     }
                 }
-                append_sc(&out, ")");
+                append(&out, ")");
                 
-                append_sc(&out, ");}\n");
+                append(&out, ");}\n");
             }
             if (use_dep == 1){
-                append_sc(&out, "#else\n");
+                append(&out, "#else\n");
             }
         }
-        append_sc(&out, "#endif\n");
+        append(&out, "#endif\n");
         
         end_file_out(context);
     }
@@ -597,6 +584,7 @@ generate_custom_headers(){
 }
 
 int main(int argc, char **argv){
+    fm_init_system();
     generate_keycode_enum();
     generate_style();
     generate_custom_headers();