diff --git a/bin/build_examples.sh b/bin/build_examples.sh
index 29a8413..ab64871 100644
--- a/bin/build_examples.sh
+++ b/bin/build_examples.sh
@@ -10,8 +10,6 @@ echo "~~~ Build All Exampes ~~~"
 bin/bld_core.sh show_ctx
 
 bin/bld_core.sh unit old_style_custom_layer examples/old_style_custom_layer.c
-bin/bld_core.sh unit output_parse           examples/output_parse/output_parse.c
-bin/bld_core.sh unit c_code_generation      examples/c_code_generation.c
 bin/bld_core.sh unit node_errors            examples/node_errors/node_errors.c
 bin/bld_core.sh unit parse_check            examples/parse_check.c
 
diff --git a/bin/build_samples.sh b/bin/build_samples.sh
deleted file mode 100644
index 29a8413..0000000
--- a/bin/build_samples.sh
+++ /dev/null
@@ -1,21 +0,0 @@
-#!/bin/bash
-
-###### Get Paths ##############################################################
-og_path=$PWD
-cd "$(dirname "$0")"
-cd ..
-
-###### Script #################################################################
-echo "~~~ Build All Exampes ~~~"
-bin/bld_core.sh show_ctx
-
-bin/bld_core.sh unit old_style_custom_layer examples/old_style_custom_layer.c
-bin/bld_core.sh unit output_parse           examples/output_parse/output_parse.c
-bin/bld_core.sh unit c_code_generation      examples/c_code_generation.c
-bin/bld_core.sh unit node_errors            examples/node_errors/node_errors.c
-bin/bld_core.sh unit parse_check            examples/parse_check.c
-
-echo
-
-###### Restore Path ###########################################################
-cd $og_path
diff --git a/bin/run_examples.sh b/bin/run_examples.sh
index 3f2b967..0b1e0da 100644
--- a/bin/run_examples.sh
+++ b/bin/run_examples.sh
@@ -18,11 +18,6 @@ if [ -d "output_parse/examples" ]; then
 fi
 echo
 
-echo ~~~ Running C Code Generation Example ~~~
-cd $build_path
-./c_code_generation.exe
-echo
-
 echo ~~~ Running Error Generation Example ~~~
 cd $build_path
 ./node_errors.exe $examples_path/node_errors/node_errors.mdesk
diff --git a/bin/run_samples.sh b/bin/run_samples.sh
deleted file mode 100644
index 3f2b967..0000000
--- a/bin/run_samples.sh
+++ /dev/null
@@ -1,37 +0,0 @@
-#!/bin/bash
-
-###### Get Paths ##############################################################
-og_path=$PWD
-cd "$(dirname "$0")"
-cd ..
-    root_path=$PWD
-   build_path=$root_path/build
-examples_path=$root_path/examples
-
-echo ~~~ Running Output Parse Example ~~~
-cd $examples_path
-if [ -d "output_parse/examples" ]; then
-  cd output_parse/examples
-  mkdir -p output
-  cd output
-  $build_path/output_parse.exe ../example.mdesk ../example2.mdesk
-fi
-echo
-
-echo ~~~ Running C Code Generation Example ~~~
-cd $build_path
-./c_code_generation.exe
-echo
-
-echo ~~~ Running Error Generation Example ~~~
-cd $build_path
-./node_errors.exe $examples_path/node_errors/node_errors.mdesk
-echo
-
-echo ~~~ Running C++ Example ~~~
-cd $build_path
-./cpp_build_test.exe
-echo
-
-###### Restore Path ###########################################################
-cd $og_path
diff --git a/examples/c_code_generation.c b/examples/c_code_generation.c
deleted file mode 100644
index 25264ce..0000000
--- a/examples/c_code_generation.c
+++ /dev/null
@@ -1,42 +0,0 @@
-// Sample program that takes C-like information specified in the Metadesk format
-// and generates valid C code from it.
-
-#include "md.h"
-#include "md_c_helpers.h"
-
-#include "md.c"
-#include "md_c_helpers.c"
-
-static MD_Arena *arena = 0;
-
-int main(int argument_count, char **arguments)
-{
-    arena = MD_ArenaAlloc(1ull << 40);
-    
-    MD_String8 example_code = MD_S8Lit("@struct Foo:\n"
-                                       "{\n"
-                                       "  a: S32,\n"
-                                       "  b: *S32,\n"
-                                       "  c: **void,\n"
-                                       "  d: F32,\n"
-                                       "  e: *[100]F32,\n"
-                                       "  f: ([4 + 5]S32),\n"
-                                       "  g: ([FOO + BAR]I32),\n"
-                                       "}\n\n");
-    MD_Node *code = MD_ParseWholeString(arena, MD_S8Lit("Generated Test Code"), example_code).node;
-    
-    printf("Source Metadesk Code:\n");
-    printf("%.*s\n\n", MD_S8VArg(example_code));
-    
-    printf("Generated C Code:\n");
-    for(MD_EachNode(node, code->first_child))
-    {
-        if(MD_NodeHasTag(node, MD_S8Lit("struct"), 0))
-        {
-            MD_C_Generate_Struct(stdout, node);
-        }
-    }
-    printf("\n\n");
-    
-    return 0;
-}
\ No newline at end of file
diff --git a/examples/namespaced_types/conversion_test.c b/examples/namespaced_types/conversion_test.c
deleted file mode 100644
index 2911e4e..0000000
--- a/examples/namespaced_types/conversion_test.c
+++ /dev/null
@@ -1,39 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-#include <stdint.h>
-#include <assert.h>
-#include "generated/converter.c"
-
-int main(void)
-{
-    v1_Entry v1_entry = {0};
-
-    v1_entry.to_remove = 12;
-
-    v1_entry.kind = v1_EntryKind_C;
-
-    v1_entry.flags = v1_EntryFlag_B | v1_EntryFlag_C;
-
-    v1_entry.color.components.r = 255;
-    v1_entry.color.components.g = 128;
-    v1_entry.color.components.b = 1;
-    v1_entry.color.components.a = 42;
-
-    v1_entry.p.x = 2;
-    v1_entry.p.y = 3;
-
-    Entry entry = EntryFromV1(v1_entry);
-
-    assert(entry.kind == EntryKind_C);
-    assert(entry.flags == (EntryFlag_B | EntryFlag_C));
-    assert(entry.color.components.r == 255);
-    assert(entry.color.components.g == 128);
-    assert(entry.color.components.b == 1);
-    assert(entry.color.components.a == 42);
-    assert(v1_entry.p.x == 2);
-    assert(v1_entry.p.y == 3);
-
-    printf("Conversion test success!\n");
-
-    return 0;
-}
diff --git a/examples/namespaced_types/generated/converter.c b/examples/namespaced_types/generated/converter.c
deleted file mode 100644
index 8e3e9de..0000000
--- a/examples/namespaced_types/generated/converter.c
+++ /dev/null
@@ -1,131 +0,0 @@
-// V1
-typedef enum
-{
-    v1_EntryKind_A,
-    v1_EntryKind_B,
-    v1_EntryKind_C,
-    v1_EntryKind_E,
-} v1_EntryKind;
-
-typedef enum
-{
-    v1_EntryFlag_A = (1<<0),
-    v1_EntryFlag_B = (1<<1),
-    v1_EntryFlag_C = (1<<2),
-} v1_EntryFlags;
-
-typedef union v1_Color v1_Color;
-union v1_Color
-{
-    struct
-    {
-        uint8_t r;
-        uint8_t g;
-        uint8_t b;
-        uint8_t a;
-    } components;
-    uint8_t raw[4];
-};
-
-typedef struct v1_Entry v1_Entry;
-struct v1_Entry
-{
-    uint16_t to_remove;
-    v1_EntryKind kind;
-    v1_EntryFlags flags;
-    v1_Color color;
-    struct
-    {
-        float x;
-        float y;
-    } p;
-};
-
-// V2
-typedef enum
-{
-    EntryKind_A,
-    EntryKind_B,
-    EntryKind_B2,
-    EntryKind_C,
-} EntryKind;
-
-typedef enum
-{
-    EntryFlag_B = (1<<0),
-    EntryFlag_C = (1<<1),
-    EntryFlag_D = (1<<2),
-} EntryFlags;
-
-typedef union Color Color;
-union Color
-{
-    struct
-    {
-        uint8_t b;
-        uint8_t g;
-        uint8_t r;
-        uint8_t a;
-    } components;
-    uint8_t raw[4];
-};
-
-typedef struct Entry Entry;
-struct Entry
-{
-    EntryKind kind;
-    Color color;
-    struct
-    {
-        float x;
-        float y;
-        float z;
-    } p;
-    EntryFlags flags;
-};
-
-// V1->V2
-static EntryKind EntryKindFromV1(v1_EntryKind v)
-{
-    EntryKind result = 0;
-    switch(v)
-    {
-        case v1_EntryKind_A: result = EntryKind_A; break;
-        case v1_EntryKind_B: result = EntryKind_B; break;
-        case v1_EntryKind_C: result = EntryKind_C; break;
-        case v1_EntryKind_E: assert(!"Enumerand v1_EntryKind_E is no longer allowed\n");
-        default: assert(!"Illegal value for enum v1_EntryKind\n"); break;
-    }
-    return result;
-}
-
-static EntryFlags EntryFlagsFromV1(v1_EntryFlags v)
-{
-    EntryFlags result = 0;
-    if(v & v1_EntryFlag_A) assert(!"Flag v1_A is no longer allowed\n");
-    if(v & v1_EntryFlag_B) result |= EntryFlag_B;
-    if(v & v1_EntryFlag_C) result |= EntryFlag_C;
-    return result;
-}
-
-static Color ColorFromV1(v1_Color v)
-{
-    Color result = {0};
-    result.components.r = v.components.r;
-    result.components.g = v.components.g;
-    result.components.b = v.components.b;
-    result.components.a = v.components.a;
-    return result;
-}
-
-static Entry EntryFromV1(v1_Entry v)
-{
-    Entry result = {0};
-    result.kind = EntryKindFromV1(v.kind);
-    result.color = ColorFromV1(v.color);
-    result.p.x = v.p.x;
-    result.p.y = v.p.y;
-    result.flags = EntryFlagsFromV1(v.flags);
-    return result;
-}
-
diff --git a/examples/output_parse/examples/example.mdesk b/examples/output_parse/examples/example.mdesk
deleted file mode 100644
index ab805ff..0000000
--- a/examples/output_parse/examples/example.mdesk
+++ /dev/null
@@ -1,8 +0,0 @@
-@struct foo : {
-    x : ([MAX_PATH]char),
-}
-
-@struct @test_tag bar : {
-    y : float,
-	z: i32,
-}
diff --git a/examples/output_parse/examples/example2.mdesk b/examples/output_parse/examples/example2.mdesk
deleted file mode 100644
index 9c7a8e3..0000000
--- a/examples/output_parse/examples/example2.mdesk
+++ /dev/null
@@ -1,20 +0,0 @@
-@sets a_set : {
-    named_set : {1, 3, 7},
-	{not, named, set},
-	@tag_with_params(p1, p2, p3) { e1, e2, e3 },
-	@tag_with_params(p1, p2, p3) @tag2_with_params(p, pp, ppp) { e1, e2, e3 },
-}
-
-@empty_set empty : {
-}
-
-@tagged_unnamed_set {
-	a_label: {unnamed_set_element}
-}
-
-@showcase_mixed_set_scoping {
-	@symbol_label
-	+: (1 2 3],
-	@symbol_label
-	*: [x y z),
-}
\ No newline at end of file
diff --git a/examples/output_parse/examples/output/parsed_example.txt b/examples/output_parse/examples/output/parsed_example.txt
deleted file mode 100644
index f8180fc..0000000
--- a/examples/output_parse/examples/output/parsed_example.txt
+++ /dev/null
@@ -1,73 +0,0 @@
-Node {
-  Kind: Main,
-  Flags: 0000110000000001000000000000000000000000000000000000000000000000,
-  Flag Names: HasBraceLeft, HasBraceRight, Identifier,
-  String: foo,
-  Whole String: foo,
-  Tag: @struct
-  Node {
-    Kind: Main,
-    Flags: 1100000010000001000000000000000000000000000000000000000000000000,
-    Flag Names: HasParenLeft, HasParenRight, IsBeforeComma, Identifier,
-    String: x,
-    Whole String: x,
-    Node {
-      Kind: Main,
-      Flags: 0011000000000000000000000000000000000000000000000000000000000000,
-      Flag Names: HasBracketLeft, HasBracketRight,
-      Node {
-        Kind: Main,
-        Flags: 0000000000000001000000000000000000000000000000000000000000000000,
-        Flag Names: Identifier,
-        String: MAX_PATH,
-        Whole String: MAX_PATH,
-      }
-    }
-    Node {
-      Kind: Main,
-      Flags: 0000000000000001000000000000000000000000000000000000000000000000,
-      Flag Names: Identifier,
-      String: char,
-      Whole String: char,
-    }
-  }
-}
-
-Node {
-  Kind: Main,
-  Flags: 0000110000000001000000000000000000000000000000000000000000000000,
-  Flag Names: HasBraceLeft, HasBraceRight, Identifier,
-  String: bar,
-  Whole String: bar,
-  Tag: @struct
-  Tag: @test_tag
-  Node {
-    Kind: Main,
-    Flags: 0000000000000001000000000000000000000000000000000000000000000000,
-    Flag Names: Identifier,
-    String: y,
-    Whole String: y,
-    Node {
-      Kind: Main,
-      Flags: 0000000000000001000000000000000000000000000000000000000000000000,
-      Flag Names: Identifier,
-      String: float,
-      Whole String: float,
-    }
-  }
-  Node {
-    Kind: Main,
-    Flags: 0000000000000001000000000000000000000000000000000000000000000000,
-    Flag Names: Identifier,
-    String: z,
-    Whole String: z,
-    Node {
-      Kind: Main,
-      Flags: 0000000000000001000000000000000000000000000000000000000000000000,
-      Flag Names: Identifier,
-      String: i32,
-      Whole String: i32,
-    }
-  }
-}
-
diff --git a/examples/output_parse/examples/output/parsed_example2.txt b/examples/output_parse/examples/output/parsed_example2.txt
deleted file mode 100644
index 7c82c01..0000000
--- a/examples/output_parse/examples/output/parsed_example2.txt
+++ /dev/null
@@ -1,282 +0,0 @@
-Node {
-  Kind: Main,
-  Flags: 0000110000000001000000000000000000000000000000000000000000000000,
-  Flag Names: HasBraceLeft, HasBraceRight, Identifier,
-  String: a_set,
-  Whole String: a_set,
-  Tag: @sets
-  Node {
-    Kind: Main,
-    Flags: 0000110010000001000000000000000000000000000000000000000000000000,
-    Flag Names: HasBraceLeft, HasBraceRight, IsBeforeComma, Identifier,
-    String: named_set,
-    Whole String: named_set,
-    Node {
-      Kind: Main,
-      Flags: 0000000010000010000000000000000000000000000000000000000000000000,
-      Flag Names: IsBeforeComma, Numeric,
-      String: 1,
-      Whole String: 1,
-    }
-    Node {
-      Kind: Main,
-      Flags: 0000000011000010000000000000000000000000000000000000000000000000,
-      Flag Names: IsBeforeComma, IsAfterComma, Numeric,
-      String: 3,
-      Whole String: 3,
-    }
-    Node {
-      Kind: Main,
-      Flags: 0000000001000010000000000000000000000000000000000000000000000000,
-      Flag Names: IsAfterComma, Numeric,
-      String: 7,
-      Whole String: 7,
-    }
-  }
-  Node {
-    Kind: Main,
-    Flags: 0000110011000000000000000000000000000000000000000000000000000000,
-    Flag Names: HasBraceLeft, HasBraceRight, IsBeforeComma, IsAfterComma,
-    Node {
-      Kind: Main,
-      Flags: 0000000010000001000000000000000000000000000000000000000000000000,
-      Flag Names: IsBeforeComma, Identifier,
-      String: not,
-      Whole String: not,
-    }
-    Node {
-      Kind: Main,
-      Flags: 0000000011000001000000000000000000000000000000000000000000000000,
-      Flag Names: IsBeforeComma, IsAfterComma, Identifier,
-      String: named,
-      Whole String: named,
-    }
-    Node {
-      Kind: Main,
-      Flags: 0000000001000001000000000000000000000000000000000000000000000000,
-      Flag Names: IsAfterComma, Identifier,
-      String: set,
-      Whole String: set,
-    }
-  }
-  Node {
-    Kind: Main,
-    Flags: 0000110011000000000000000000000000000000000000000000000000000000,
-    Flag Names: HasBraceLeft, HasBraceRight, IsBeforeComma, IsAfterComma,
-    Tag: @tag_with_params
-      Tag Children{
-        Node {
-          Kind: Main,
-          Flags: 0000000010000001000000000000000000000000000000000000000000000000,
-          Flag Names: IsBeforeComma, Identifier,
-          String: p1,
-          Whole String: p1,
-        }
-        Node {
-          Kind: Main,
-          Flags: 0000000011000001000000000000000000000000000000000000000000000000,
-          Flag Names: IsBeforeComma, IsAfterComma, Identifier,
-          String: p2,
-          Whole String: p2,
-        }
-        Node {
-          Kind: Main,
-          Flags: 0000000001000001000000000000000000000000000000000000000000000000,
-          Flag Names: IsAfterComma, Identifier,
-          String: p3,
-          Whole String: p3,
-        }
-      }
-    Node {
-      Kind: Main,
-      Flags: 0000000010000001000000000000000000000000000000000000000000000000,
-      Flag Names: IsBeforeComma, Identifier,
-      String: e1,
-      Whole String: e1,
-    }
-    Node {
-      Kind: Main,
-      Flags: 0000000011000001000000000000000000000000000000000000000000000000,
-      Flag Names: IsBeforeComma, IsAfterComma, Identifier,
-      String: e2,
-      Whole String: e2,
-    }
-    Node {
-      Kind: Main,
-      Flags: 0000000001000001000000000000000000000000000000000000000000000000,
-      Flag Names: IsAfterComma, Identifier,
-      String: e3,
-      Whole String: e3,
-    }
-  }
-  Node {
-    Kind: Main,
-    Flags: 0000110011000000000000000000000000000000000000000000000000000000,
-    Flag Names: HasBraceLeft, HasBraceRight, IsBeforeComma, IsAfterComma,
-    Tag: @tag_with_params
-      Tag Children{
-        Node {
-          Kind: Main,
-          Flags: 0000000010000001000000000000000000000000000000000000000000000000,
-          Flag Names: IsBeforeComma, Identifier,
-          String: p1,
-          Whole String: p1,
-        }
-        Node {
-          Kind: Main,
-          Flags: 0000000011000001000000000000000000000000000000000000000000000000,
-          Flag Names: IsBeforeComma, IsAfterComma, Identifier,
-          String: p2,
-          Whole String: p2,
-        }
-        Node {
-          Kind: Main,
-          Flags: 0000000001000001000000000000000000000000000000000000000000000000,
-          Flag Names: IsAfterComma, Identifier,
-          String: p3,
-          Whole String: p3,
-        }
-      }
-    Tag: @tag2_with_params
-      Tag Children{
-        Node {
-          Kind: Main,
-          Flags: 0000000010000001000000000000000000000000000000000000000000000000,
-          Flag Names: IsBeforeComma, Identifier,
-          String: p,
-          Whole String: p,
-        }
-        Node {
-          Kind: Main,
-          Flags: 0000000011000001000000000000000000000000000000000000000000000000,
-          Flag Names: IsBeforeComma, IsAfterComma, Identifier,
-          String: pp,
-          Whole String: pp,
-        }
-        Node {
-          Kind: Main,
-          Flags: 0000000001000001000000000000000000000000000000000000000000000000,
-          Flag Names: IsAfterComma, Identifier,
-          String: ppp,
-          Whole String: ppp,
-        }
-      }
-    Node {
-      Kind: Main,
-      Flags: 0000000010000001000000000000000000000000000000000000000000000000,
-      Flag Names: IsBeforeComma, Identifier,
-      String: e1,
-      Whole String: e1,
-    }
-    Node {
-      Kind: Main,
-      Flags: 0000000011000001000000000000000000000000000000000000000000000000,
-      Flag Names: IsBeforeComma, IsAfterComma, Identifier,
-      String: e2,
-      Whole String: e2,
-    }
-    Node {
-      Kind: Main,
-      Flags: 0000000001000001000000000000000000000000000000000000000000000000,
-      Flag Names: IsAfterComma, Identifier,
-      String: e3,
-      Whole String: e3,
-    }
-  }
-}
-
-Node {
-  Kind: Main,
-  Flags: 0000110000000001000000000000000000000000000000000000000000000000,
-  Flag Names: HasBraceLeft, HasBraceRight, Identifier,
-  String: empty,
-  Whole String: empty,
-  Tag: @empty_set
-}
-
-Node {
-  Kind: Main,
-  Flags: 0000110000000000000000000000000000000000000000000000000000000000,
-  Flag Names: HasBraceLeft, HasBraceRight,
-  Tag: @tagged_unnamed_set
-  Node {
-    Kind: Main,
-    Flags: 0000110000000001000000000000000000000000000000000000000000000000,
-    Flag Names: HasBraceLeft, HasBraceRight, Identifier,
-    String: a_label,
-    Whole String: a_label,
-    Node {
-      Kind: Main,
-      Flags: 0000000000000001000000000000000000000000000000000000000000000000,
-      Flag Names: Identifier,
-      String: unnamed_set_element,
-      Whole String: unnamed_set_element,
-    }
-  }
-}
-
-Node {
-  Kind: Main,
-  Flags: 0000110000000000000000000000000000000000000000000000000000000000,
-  Flag Names: HasBraceLeft, HasBraceRight,
-  Tag: @showcase_mixed_set_scoping
-  Node {
-    Kind: Main,
-    Flags: 1001000010000000000000000000000000000000000000000000000000000000,
-    Flag Names: HasParenLeft, HasBracketRight, IsBeforeComma,
-    String: +,
-    Whole String: +,
-    Tag: @symbol_label
-    Node {
-      Kind: Main,
-      Flags: 0000000000000010000000000000000000000000000000000000000000000000,
-      Flag Names: Numeric,
-      String: 1,
-      Whole String: 1,
-    }
-    Node {
-      Kind: Main,
-      Flags: 0000000000000010000000000000000000000000000000000000000000000000,
-      Flag Names: Numeric,
-      String: 2,
-      Whole String: 2,
-    }
-    Node {
-      Kind: Main,
-      Flags: 0000000000000010000000000000000000000000000000000000000000000000,
-      Flag Names: Numeric,
-      String: 3,
-      Whole String: 3,
-    }
-  }
-  Node {
-    Kind: Main,
-    Flags: 0110000011000000000000000000000000000000000000000000000000000000,
-    Flag Names: HasParenRight, HasBracketLeft, IsBeforeComma, IsAfterComma,
-    String: *,
-    Whole String: *,
-    Tag: @symbol_label
-    Node {
-      Kind: Main,
-      Flags: 0000000000000001000000000000000000000000000000000000000000000000,
-      Flag Names: Identifier,
-      String: x,
-      Whole String: x,
-    }
-    Node {
-      Kind: Main,
-      Flags: 0000000000000001000000000000000000000000000000000000000000000000,
-      Flag Names: Identifier,
-      String: y,
-      Whole String: y,
-    }
-    Node {
-      Kind: Main,
-      Flags: 0000000000000001000000000000000000000000000000000000000000000000,
-      Flag Names: Identifier,
-      String: z,
-      Whole String: z,
-    }
-  }
-}
-
diff --git a/examples/output_parse/output_parse.c b/examples/output_parse/output_parse.c
deleted file mode 100644
index 4e6959e..0000000
--- a/examples/output_parse/output_parse.c
+++ /dev/null
@@ -1,94 +0,0 @@
-// Sample code to print out the data from MD_ParseWholeFile
-#include "md.h"
-#include "md.c"
-
-static MD_Arena *arena = 0;
-
-#define INDENT_SPACES 2
-static void Print(FILE* file, int indent_count, char* fmt, ...) {
-    for(int i = 0; i < indent_count*INDENT_SPACES; i += 1)
-    {
-        fprintf(file, " ");
-    }
-    va_list args;
-    va_start(args, fmt);
-    vfprintf(file, fmt, args);
-    va_end(args);
-}
-
-static void PrintNode(MD_Node* node, FILE* file, int indent_count) {
-    Print(file, indent_count, "Node {\n");
-    Print(file, indent_count+1, "Kind: %.*s,\n", MD_S8VArg(MD_StringFromNodeKind(node->kind)));
-    
-    int flags_bits = sizeof(node->flags)*8;
-    char binary_flags[sizeof(node->flags)*8+1];
-    binary_flags[flags_bits] = '\0';
-    int flag_index = 0;
-    MD_NodeFlags flags = node->flags;
-    for (int i = 0; i < flags_bits; i++) {
-        binary_flags[i] = (flags&1) ? '1' : '0';
-        flag_index++;
-        flags >>= 1;
-    }
-    
-    Print(file, indent_count+1, "Flags: %s,\n", binary_flags);
-    Print(file, indent_count+1, "Flag Names: ", binary_flags);
-    MD_String8List flags_list = MD_StringListFromNodeFlags(arena, node->flags);
-    
-    MD_StringJoin join = MD_ZERO_STRUCT;
-    join.mid = MD_S8CString(", ");
-    
-    MD_String8 flag_names = MD_S8ListJoin(arena, flags_list, &join);
-    fprintf(file, "%.*s,\n", MD_S8VArg(flag_names));
-    
-    if(node->string.size > 0) Print(file, indent_count+1, "String: %.*s,\n", MD_S8VArg(node->string));
-    if(node->raw_string.size > 0) Print(file, indent_count+1, "Whole String: %.*s,\n", MD_S8VArg(node->raw_string));
-    if (node->first_tag->kind != MD_NodeKind_Nil) {
-        for (MD_EachNode(tag, node->first_tag)) {
-            Print(file, indent_count+1, "Tag: @%.*s\n", MD_S8VArg(tag->string));
-            if (tag->first_child->kind != MD_NodeKind_Nil) {
-                Print(file, indent_count+2, "Tag Children{\n");
-                for (MD_EachNode(arg, tag->first_child)) {
-                    PrintNode(arg, file, indent_count+3);
-                }
-                Print(file, indent_count+2, "}\n");
-            }
-        }
-    }
-    
-    for(MD_EachNode(child, node->first_child)) {
-        PrintNode(child, file, indent_count+1);
-    }
-    Print(file, indent_count, "}\n");
-}
-
-int main(int argument_count, char **arguments)
-{
-    arena = MD_ArenaAlloc(1ull << 40);
-    
-    // NOTE(pmh): Parse all the files passed in via command line.
-    MD_Node *list = MD_MakeList(arena);
-    for(int i = 1; i < argument_count; i += 1)
-    {
-        MD_Node *root = MD_ParseWholeFile(arena, MD_S8CString(arguments[i])).node;
-        MD_PushNewReference(arena, list, root);
-    }
-    
-    for(MD_EachNode(ref, list->first_child))
-    {
-        MD_Node *root = MD_NodeFromReference(ref);
-        MD_String8 code_filename = MD_PathChopLastPeriod(MD_PathSkipLastSlash(root->string));
-        MD_String8 info_filename = MD_S8Fmt(arena, "parsed_%.*s.txt", MD_S8VArg(code_filename));
-        printf("Parse Input -> Output: %.*s -> %.*s\n", MD_S8VArg(code_filename), MD_S8VArg(info_filename));
-        
-        FILE* file = fopen((char *)info_filename.str, "wb");
-        for(MD_EachNode(node, root->first_child))
-        {
-            PrintNode(node, file, 0);
-            fprintf(file, "\n");
-        }
-        fclose(file);
-    }
-    
-    return 0;
-}
\ No newline at end of file
diff --git a/intro_notes.txt b/intro_notes.txt
index 99afdd6..92bbb7e 100644
--- a/intro_notes.txt
+++ b/intro_notes.txt
@@ -1,7 +1,19 @@
-inspecting error information
-MD_CodeLocFromNode, (MD_Node from MD_Message)
-nil nodes
-tips on generating C
-concat
-PushStringF
-match flags (which are relevant)
+Intro Materials Should Cover:
+arena
+string helpers
+immutable tree model
+nil
+
+Examples:
+[ ] Metadesk parse checker
+[ ] Metadesk reprinter
+[ ] Example of helpers: string helpers, linked lists, map type
+                        printing errors, cmd line, file iter
+[ ] Datadesk-like setup
+[ ] Example type metadata
+[ ] Example of simple expression parser
+[ ] Example of C-like expression parser (with value and type expressions)
+[ ] Example(s) of using overrides
+[ ] Example memory clearing in long-running program
+[ ] Example multi-threaded parsing
+
diff --git a/project.4coder b/project.4coder
index 116b4dc..ff6bf90 100644
--- a/project.4coder
+++ b/project.4coder
@@ -31,7 +31,7 @@ command_list =
     {
         .name = "all_dev_checks",
         .out = "*compilation*",
-        .footer_panel = true,
+        .footer_panel = false,
         .save_dirty_files = true,
         .cursor_at_end = false,
         .cmd =
diff --git a/source/md.h b/source/md.h
index 03429f8..4791288 100644
--- a/source/md.h
+++ b/source/md.h
@@ -665,8 +665,7 @@ typedef enum MD_ParseSetRule
 {
     MD_ParseSetRule_EndOnDelimiter,
     MD_ParseSetRule_Global,
-}
-MD_ParseSetRule;
+} MD_ParseSetRule;
 
 typedef struct MD_ParseResult MD_ParseResult;
 struct MD_ParseResult