From a55d91c267ff63094fd71d6fd4eef30799d046d2 Mon Sep 17 00:00:00 2001
From: xolatile <xolatile@proton.me>
Date: Mon, 14 Apr 2025 19:49:49 +0200
Subject: [PATCH] EMIL ANON LNAO

---
 test                | Bin 63264 -> 151488 bytes
 test.c              | 146 +++++--
 xachine.h           |  88 ++--
 xanguage.h          |  68 +--
 xanguage/ada.h      |   4 +-
 xanguage/bash.h     |   4 +-
 xanguage/c++.h      |   8 +-
 xanguage/c.h        |  11 +-
 xanguage/common.h   |   2 +-
 xanguage/d.h        |   6 +-
 xanguage/eaxhla.h   |  10 +-
 xanguage/flat.h     |   8 +-
 xanguage/fortran.h  |   8 +-
 xanguage/go.h       |   8 +-
 xanguage/haskell.h  |   6 +-
 xanguage/holy_c.h   |  50 +++
 xanguage/lua.h      |   8 +-
 xanguage/pascal.h   |   4 +-
 xanguage/python.h   |   6 +-
 xanguage/valgrind.h |   4 +-
 xaptor.c            |   2 +-
 xaptor.h            |  78 ++--
 xarbon.c            |  33 +-
 xarticle.h          |   4 +-
 xatrix.h            |  92 ++--
 xcript.h            |  30 +-
 xctree.h            |  32 ++
 xector.h            |  94 ++---
 xerminal.h          |  10 +-
 xhallenge.c         |  42 +-
 xhape.h             | 175 ++++++++
 xiasma.h            |   4 +-
 xighlight.c         |  12 +-
 xision.h            | 997 ++++++++++++++++++++++++++++++++++++++++++++
 xommon.h            |  38 +-
 xormat.h            |  66 +--
 xormat/jxl.h        |   2 +-
 xormat/ply.h        |   6 +
 xormat/png.h        |   4 +-
 xpengl.h            |  62 +--
 xphere.h            |  22 +-
 xprite.h            |   2 +-
 xrena.h             |   4 +-
 xrocessor.h         |  42 +-
 xscii.c             |   4 +-
 xtandard.h          |  99 +++--
 xui.h               | 116 +++---
 xulkan.h            |  46 +-
 xungeon.h           |  16 +-
 xuxuxu.c            |   8 +-
 xyntax.h            |   4 +-
 51 files changed, 1963 insertions(+), 632 deletions(-)
 create mode 100755 xanguage/holy_c.h
 create mode 100644 xctree.h
 create mode 100644 xhape.h
 create mode 100644 xision.h
 create mode 100644 xormat/ply.h

diff --git a/test b/test
index 7eae4d25f40f38ba58419fd518048020c3af974e..47544be0ce9cc3afbc7a7dd861cad37103d8a039 100755
GIT binary patch
literal 151488
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

literal 63264
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

diff --git a/test.c b/test.c
index 8b241cb..b18b2f4 100644
--- a/test.c
+++ b/test.c
@@ -1,39 +1,86 @@
+#define use_fatal_failure
 #define use_mathematics
+#define use_png_library
 
 #include "xtandard.h"
 #include "xector.h"
+#include "xormat.h"
 #include "xarticle.h"
+#include "xhape.h"
+#include "xision.h"
 
-#include <raylib.h>
+static void print_shape (shape_node * sh) {
+	print ("shape data:\n");
+	print ("v = %i // %i\n", sh->vertex_count, sh->vertex_limit);
+	print ("i = %i // %i\n", sh->index_count, sh->index_limit);
+}
 
-int main (void) {
-	particle_structure * particle = particle_initialize (1024);
+static void render_shape (vision_structure * vision, shape_node * sh) {
+	//~uint vc = sh->vertex_count;
+	//~uint ic = sh->index_count;
 
-	InitWindow (800, 600, "Xarticle");
+	//~float va [100] = { 0 };
+	//~uint  ia [100] = { 0 };
 
-	Camera camera = { 0 };
-	camera.position = (Vector3){ 0.0f, 2.0f, 4.0f };    // Camera position
-	camera.target = (Vector3){ 0.0f, 2.0f, 0.0f };      // Camera looking at point
-	camera.up = (Vector3){ 0.0f, 1.0f, 0.0f };          // Camera up vector (rotation towards target)
-	camera.fovy = 60.0f;                                // Camera field-of-view Y
-	camera.projection = CAMERA_PERSPECTIVE;             // Camera projection type
+	//~for (uint i = 0; i < vc; i += 5) {
+		//~va [i+0] = sh->vertex_array [i/5]->x;
+		//~va [i+1] = sh->vertex_array [i/5]->y;
+		//~va [i+2] = sh->vertex_array [i/5]->z;
+		//~va [i+3] = sh->unwrap_array [i/5]->x;
+		//~va [i+4] = sh->unwrap_array [i/5]->y;
+	//~}
+
+	//~for (uint i = 0; i < ic; i += 5) {
+		//~ia [i] = sh->index_array [i];
+	//~}
+
+	vision_render_base (vision, sh->vertex_count, sh->vertex_array, sh->index_count, sh->index_array, 0, 0xff7733ff);
+}
 
-	SetTargetFPS(60);
+int main (void) {
+	//~vector_3 as = { +2,0,0 };
+	//~vector_3 bs = { -2,0,0 };
+	//~vector_3 cs = { 0,+2,0 };
+	//~vector_3 ds = { 0,-2,0 };
+	//~vector_3 es = { 0,0,+2 };
+	//~vector_3 fs = { 0,0,-2 };
+
+	shape_node * a = shape_tetrahedron_colour (+2,0,0, 1, 0xff7733ff);
+	shape_node * b = shape_tetrahedron_colour (-2,0,0, 1, 0xff7733ff);
+	shape_node * c = shape_tetrahedron_colour (0,+2,0, 1, 0xff7733ff);
+	shape_node * d = shape_tetrahedron_colour (0,-2,0, 1, 0xff7733ff);
+	shape_node * e = shape_tetrahedron_colour (0,0,+2, 1, 0xff7733ff);
+	shape_node * f = shape_tetrahedron_colour (0,0,-2, 1, 0xff7733ff);
+
+	//~print ("> v = %i // %i\n", a->vertex_count, a->vertex_limit);
+	//~print ("> i = %i // %i\n", a->index_count, a->index_limit);
+	print_shape (a);
+
+	vision_structure   * vision   = vision_initialize   (60, 60, false, 6000, 3000, 256);
+	particle_structure * particle = particle_initialize (1024);
 
-	Texture texture = LoadTexture ("xui/fullscreen_on.png");
+	uint i0 = vision_sprite_import (vision, "xui/goblin/end_turn_button.png");
+	uint i1 = vision_sprite_import (vision, "xui/goblin/separator_center.png");
+	uint i2 = vision_sprite_import (vision, "xui/goblin/separator_left.png");
+	uint i3 = vision_sprite_import (vision, "xui/goblin/separator_middle.png");
+	uint i4 = vision_sprite_import (vision, "xui/goblin/separator_right.png");
 
-	while (! WindowShouldClose ()) {
-		UpdateCamera(& camera, CAMERA_FIRST_PERSON);
+	vision_configure (vision, 800, 600, "Xube");
 
-		BeginDrawing ();
+	while (vision->active == true) {
+		if (vision->signal [signal_q] == true) break;
 
-		ClearBackground(RAYWHITE);
+		if (vision->signal [signal_i] == true) { vision_change_field_of_view (vision, + 0.1f); }
+		if (vision->signal [signal_o] == true) { vision_change_field_of_view (vision, - 0.1f); }
 
-		BeginMode3D(camera);
+		if (vision->signal [signal_a] == true) { vision_change_translation (vision, + 0.1f, 0.0f,   0.0f); }
+		if (vision->signal [signal_d] == true) { vision_change_translation (vision, - 0.1f, 0.0f,   0.0f); }
+		if (vision->signal [signal_s] == true) { vision_change_translation (vision,   0.0f, 0.0f, + 0.1f); }
+		if (vision->signal [signal_w] == true) { vision_change_translation (vision,   0.0f, 0.0f, - 0.1f); }
 
-		DrawPlane((Vector3){ 0.0f, 0.0f, 0.0f }, (Vector2){ 32.0f, 32.0f }, LIGHTGRAY); // Draw ground
+		//~vision_change_rotation (vision, 0.0f, xxx);
 
-		if (IsKeyPressed (KEY_ONE)) {
+		if (vision->signal [signal_1] == true) {
 			vector_3 p = {0,0,0};
 			vector_3 t = {0,0,0};
 			vector_3 s = {0.1f,0.1f,0.1f};
@@ -41,39 +88,76 @@ int main (void) {
 			particle_append (particle, 0, 1.0f, 0, 0, & p, & t, & s);
 		}
 
-		if (IsKeyPressed (KEY_TWO)) {
+		if (vision->signal [signal_2] == true) {
 			vector_3 p = {1,1,1};
 
 			particle_effect_splash (particle, 0, 2.0f, 0, 0, & p, 60, 0.03, 3);
 		}
 
-		if (IsKeyPressed (KEY_THREE)) {
+		if (vision->signal [signal_3] == true) {
 			vector_3 p = {1,1,1};
 
 			particle_effect_evaporate (particle, 0, 2.0f, 0, 0, & p, 20, 0.001, 3);
 		}
 
-		BeginBlendMode (BLEND_ALPHA_PREMULTIPLY);
+		render_shape (vision, a);
+		render_shape (vision, b);
+		render_shape (vision, c);
+		render_shape (vision, d);
+		render_shape (vision, e);
+		render_shape (vision, f);
+
+		//~float t0 [] = {1,0,0,0,0,1,0,1,0};
+		//~float t1 [] = {1,0,0,0,0,1,0,1,0};
+		//~float t2 [] = {1,0,0,0,0,1,0,1,0};
+		//~float t3 [] = {1,0,0,0,0,1,0,1,0};
+		//~float t4 [] = {1,0,0,0,0,1,0,1,0};
+		//~float t5 [] = {1,0,0,0,0,1,0,1,0};
+
+		//~vision_render_triangle (vision, t0, 0xff7733ff);
+		//~vision_render_triangle (vision, t1, 0xff7733ff);
+		//~vision_render_triangle (vision, t2, 0xff7733ff);
+		//~vision_render_triangle (vision, t3, 0xff7733ff);
+		//~vision_render_triangle (vision, t4, 0xff7733ff);
+		//~vision_render_triangle (vision, t5, 0xff7733ff);
+
+		//~for (uint i = 0; i < particle->count; ++i) {
+			//~Vector3 vector = {particle->position [i]->x, particle->position [i]->y, particle->position [i]->z};
+			//~DrawBillboard (camera, texture, vector, 1, RED);
+		//~}
+
+
+
+
+
+
+		//~float va [] = {
+			//~-1, -1, 0, 0, 1, 1, 1, 1, 1,
+			//~-1, +1, 0, 0, 0, 1, 1, 1, 1,
+			//~+1, +1, 0, 1, 0, 1, 1, 1, 1,
+			//~+1, -1, 0, 1, 1, 1, 1, 1, 1
+		//~};
+
+		//~uint ia [] = { 2, 1, 0, 3, 2, 1 };
+
+		//~vision_render_base (vision, sizeof(va)/4, va, sizeof(ia)/4, ia, 1, 0xff7733ff);
+
+
+
 
-		for (uint i = 0; i < particle->count; ++i) {
-			Vector3 vector = {particle->position [i]->x, particle->position [i]->y, particle->position [i]->z};
-			DrawBillboard (camera, texture, vector, 1, RED);
-		}
 
-		EndBlendMode ();
 
-		EndMode3D();
 
-		DrawText (TextFormat ("count = %i", particle->count), 0, 0, 4, RED);
 
-		EndDrawing ();
 
+		vision_synchronize   (vision,   0xff);
 		particle_synchronize (particle, 60);
 	}
 
-	CloseWindow ();
+	png_image_export ("meme.png", vision->spritesheet_data, 256, 256);
 
 	particle = particle_deinitialize (particle);
+	vision   = vision_deinitialize (vision);
 
 	return (0);
 }
diff --git a/xachine.h b/xachine.h
index aaed02a..7f343a2 100755
--- a/xachine.h
+++ b/xachine.h
@@ -45,11 +45,11 @@ typedef enum {
 
 #ifdef use_debug_printing
 
-static const char * operand_name [operand_count] = {
+static char * operand_name [operand_count] = {
 	"rel",          "reg",          "mem",          "imm"
 };
 
-static const char * operation_name [operation_count] = {
+static char * operation_name [operation_count] = {
 	"asmmem",       "asmrel",       "asmnum",       "asmstr",
 	"add",          "or",           "adc",          "sbb",          "and",          "sub",          "xor",          "cmp",
 	"inc",          "dec",          "not",          "neg",          "mul",          "imul",         "div",          "idiv",
@@ -159,8 +159,8 @@ static uint m05 (uint code) {
 	return (0x05 + 0x08 * code);
 }
 
-static uint store_relative (const uint * array) {
-	const uint relative = array [1];
+static uint store_relative (uint * array) {
+	uint relative = array [1];
 #ifdef use_debug_printing
 	print ("/3asmrel/- %i", relative);
 #endif
@@ -172,8 +172,8 @@ static uint store_relative (const uint * array) {
 	return 1;
 }
 
-static uint store_memory (const uint * array) {
-	const uint memory = array [1];
+static uint store_memory (uint * array) {
+	uint memory = array [1];
 #ifdef use_debug_printing
 	print ("/3asmmem/- %i", memory);
 #endif
@@ -184,8 +184,8 @@ static uint store_memory (const uint * array) {
 	return 1;
 }
 
-static uint store_number (const uint * array) {
-	const uint amount = array [1];
+static uint store_number (uint * array) {
+	uint amount = array [1];
 
 #ifdef use_debug_printing
 	print ("/3asmnum/- %i", amount);
@@ -197,8 +197,8 @@ static uint store_number (const uint * array) {
 	return amount + 1;
 }
 
-static uint store_string (const uint * array) {
-	const uint amount = array [1];
+static uint store_string (uint * array) {
+	uint amount = array [1];
 
 #ifdef use_debug_printing
 	print ("/3asmstr/- %i", amount);
@@ -210,12 +210,12 @@ static uint store_string (const uint * array) {
 	return amount + 1;
 }
 
-static uint build_double (const uint * array) {
-	const uint operation   = array [0];
-	const uint to          = array [1];
-	const uint destination = array [2];
-	const uint from        = array [3];
-	const uint source      = array [4];
+static uint build_double (uint * array) {
+	uint operation   = array [0];
+	uint to          = array [1];
+	uint destination = array [2];
+	uint from        = array [3];
+	uint source      = array [4];
 #ifdef use_debug_printing
 	print ("/3%s/- /6%s/- %i /6%s/- %i", operation_name [operation], operand_name [to], destination, operand_name [from], source);
 #endif
@@ -248,10 +248,10 @@ static uint build_double (const uint * array) {
 	return 4;
 }
 
-static uint build_single (const uint * array) {
-	const uint operation   = array [0];
-	const uint to          = array [1];
-	const uint destination = array [2];
+static uint build_single (uint * array) {
+	uint operation   = array [0];
+	uint to          = array [1];
+	uint destination = array [2];
 #ifdef use_debug_printing
 	print ("/3%s/- /6%s/- %i", operation_name [operation], operand_name [to], destination);
 #endif
@@ -264,11 +264,11 @@ static uint build_single (const uint * array) {
 	return 2;
 }
 
-static uint build_shift (const uint * array) {
-	const uint operation   = array [0];
-	const uint to          = array [1];
-	const uint destination = array [2];
-	const uint offset      = array [3];
+static uint build_shift (uint * array) {
+	uint operation   = array [0];
+	uint to          = array [1];
+	uint destination = array [2];
+	uint offset      = array [3];
 #ifdef use_debug_printing
 	print ("/3%s/- /6%s/- %i /cimm/- %i", operation_name [operation], operand_name [to], destination, offset);
 #endif
@@ -284,8 +284,8 @@ static uint build_shift (const uint * array) {
 	return 3;
 }
 
-static uint build_static_1 (const uint * array) {
-	const uint operation = array [0];
+static uint build_static_1 (uint * array) {
+	uint operation = array [0];
 #ifdef use_debug_printing
 	print ("/3%s/-", operation_name [operation]);
 #endif
@@ -299,9 +299,9 @@ static uint build_static_1 (const uint * array) {
 	return 0;
 }
 
-static uint build_jump_if (const uint * array) {
-	const uint operation = array [0];
-	const uint location  = array [1];
+static uint build_jump_if (uint * array) {
+	uint operation = array [0];
+	uint location  = array [1];
 #ifdef use_debug_printing
 	print ("/3%s/- %i", operation_name [operation], location);
 #endif
@@ -313,9 +313,9 @@ static uint build_jump_if (const uint * array) {
 	return 2;
 }
 
-static uint build_jump (const uint * array) {
-	const uint to          = array [1];
-	const uint destination = array [2];
+static uint build_jump (uint * array) {
+	uint to          = array [1];
+	uint destination = array [2];
 #ifdef use_debug_printing
 	print ("/3jmp/- /6%s/- %i", operand_name [to], destination);
 #endif
@@ -328,11 +328,11 @@ static uint build_jump (const uint * array) {
 	return 2;
 }
 
-static uint build_move (const uint * array) {
-	const uint to          = array [1];
-	const uint destination = array [2];
-	const uint from        = array [3];
-	const uint source      = array [4];
+static uint build_move (uint * array) {
+	uint to          = array [1];
+	uint destination = array [2];
+	uint from        = array [3];
+	uint source      = array [4];
 #ifdef use_debug_printing
 	print ("/3mov/- /6%s/- %i /6%s/- %i", operand_name [to], destination, operand_name [from], source);
 #endif
@@ -359,9 +359,9 @@ static uint build_move (const uint * array) {
 	return 4;
 }
 
-static uint build_call (const uint * array) {
-	const uint from   = array [1];
-	const uint source = array [2];
+static uint build_call (uint * array) {
+	uint from   = array [1];
+	uint source = array [2];
 #ifdef use_debug_printing
 	print ("/3call/- /6%s/- %i", operand_name [from], source);
 #endif
@@ -374,7 +374,7 @@ static uint build_call (const uint * array) {
 	return 2;
 }
 
-static uint (* build_instruction [operation_count]) (const uint * array) = {
+static uint (* build_instruction [operation_count]) (uint * array) = {
 	store_memory,   // operation_memory : LABEL
 	store_relative, // operation_relative : "IMPLEMENTED"
 	store_number,
@@ -387,7 +387,7 @@ static uint (* build_instruction [operation_count]) (const uint * array) = {
 	build_static_1, build_static_1, build_static_1, build_call,     build_jump,     build_move
 };
 
-static void assemble (uint count, const uint * array, uint external_memory, uint internal_memory) {
+static void assemble (uint count, uint * array, uint external_memory, uint internal_memory) {
 	text_sector_byte = arena_add (external_memory * sizeof (* text_sector_byte));
 	data_sector_byte = arena_add (external_memory * sizeof (* text_sector_byte));
 
@@ -396,7 +396,7 @@ static void assemble (uint count, const uint * array, uint external_memory, uint
 	empty_store = arena_add (internal_memory * sizeof (* empty_store));
 
 	for (uint index = 0; index < count; ++index) {
-		const uint size = text_sector_size;
+		uint size = text_sector_size;
 
 		uchar byte = 0;
 #ifdef use_debug_nopping
diff --git a/xanguage.h b/xanguage.h
index 3efd312..12b2a86 100755
--- a/xanguage.h
+++ b/xanguage.h
@@ -72,6 +72,27 @@ typedef struct {
 #include <xolatile/xanguage/haskell.h>
 #include <xolatile/xanguage/valgrind.h>
 
+static void (* language_highlighter [language_count]) (language_structure * language, syntax_structure * syntax) = {
+	language_highlight_common,      language_highlight_ada,         language_highlight_c,           language_highlight_cpp,
+	language_highlight_d,           language_highlight_eaxhla,      language_highlight_flat,        language_highlight_fortran,
+	language_highlight_pascal,      language_highlight_python,      language_highlight_go,          language_highlight_lua,
+	language_highlight_bash,        language_highlight_haskell,     language_highlight_valgrind
+};
+
+static char * language_short_option [language_count] = {
+	"-X",   "-A",   "-C",   "-S",   "-D",   "-E",   "-T",   "-F",   "-P",   "-Y",   "-G",   "-L",   "-B",   "-H",   "-V"
+};
+
+static char * language_long_option [language_count] = {
+	"--common",     "--ada",        "--c",          "--cpp",        "--d",          "--eaxhla",     "--flat",       "--fortran",
+	"--pascal",     "--python",     "--go",         "--lua",        "--bash",       "--haskell",    "--valgrind"
+};
+
+static char * language_identifier [language_count] = {
+	"Common",       "Ada",          "C",            "C++",          "D",            "EAXHLA",       "Flat",         "Fortran",
+	"Pascal",       "Python",       "Go",           "Lua",          "Bash",         "Haskell",      "Valgrind"
+};
+
 static language_structure * language_initialize (bool true_colour) {
 	language_structure * language = allocate (sizeof (* language));
 
@@ -131,52 +152,7 @@ static language_structure * language_deinitialize (language_structure * language
 	return (deallocate (language));
 }
 
-static void (* language_highlighter (language_enumeration language)) (language_structure * language, syntax_structure * syntax) {
-	static const void (* highlighter [language_count]) (language_structure * language, syntax_structure * syntax) = {
-		language_highlight_common,      language_highlight_ada,         language_highlight_c,           language_highlight_cpp,
-		language_highlight_d,           language_highlight_eaxhla,      language_highlight_flat,        language_highlight_fortran,
-		language_highlight_pascal,      language_highlight_python,      language_highlight_go,          language_highlight_lua,
-		language_highlight_bash,        language_highlight_haskell,     language_highlight_valgrind
-	};
-
-	fatal_failure (language >= language_count, "language_highlighter: Language index not in enumeration.");
-
-	return (highlighter [language]);
-}
-
-static char * language_short_option (language_enumeration language) {
-	static const char * short_option [language_count] = {
-		"-X",   "-A",   "-C",   "-S",   "-D",   "-E",   "-T",   "-F",   "-P",   "-Y",   "-G",   "-L",   "-B",   "-H",   "-V"
-	};
-
-	fatal_failure (language >= language_count, "language_short_option: Language index not in enumeration.");
-
-	return (short_option [language]);
-}
-
-static char * language_long_option (language_enumeration language) {
-	static const char * long_option [language_count] = {
-		"--common",     "--ada",        "--c",          "--cpp",        "--d",          "--eaxhla",     "--flat",       "--fortran",
-		"--pascal",     "--python",     "--go",         "--lua",        "--bash",       "--haskell",    "--valgrind"
-	};
-
-	fatal_failure (language >= language_count, "language_long_option: Language index not in enumeration.");
-
-	return (long_option [language]);
-}
-
-static char * language_identifier (language_enumeration language) {
-	static const char * identifier [language_count] = {
-		"Common",       "Ada",          "C",            "C++",          "D",            "EAXHLA",       "Flat",         "Fortran",
-		"Pascal",       "Python",       "Go",           "Lua",          "Bash",         "Haskell",      "Valgrind"
-	};
-
-	fatal_failure (language >= language_count, "language_identifier: Language index not in enumeration.");
-
-	return (identifier [language]);
-}
-
-static void language_conditionally_select (language_structure * language, syntax_structure * syntax, uint select) {
+static void language_conditionally_select (language_structure * language, syntax_structure * syntax, language_enumeration select) {
 	if (syntax->count == 0) {
 		if ((select == file_type_c_source) || (select == file_type_c_header)) {
 			language_highlight_c (language, syntax);
diff --git a/xanguage/ada.h b/xanguage/ada.h
index 0e453b1..8773e5e 100755
--- a/xanguage/ada.h
+++ b/xanguage/ada.h
@@ -1,7 +1,7 @@
 static void language_highlight_ada (language_structure * language, syntax_structure * syntax) {
-	const char * separators = ".,:;<=>+-*/&|()\" \t\r\n";
+	char * separators = ".,:;<=>+-*/&|()\" \t\r\n";
 
-	const char * keywords [] = {
+	char * keywords [] = {
 		"abort",        "else",         "new",          "return",       "abs",          "elsif",        "not",          "reverse",
 		"abstract",     "end",          "null",         "accept",       "entry",        "select",       "access",       "of",
 		"separate",     "aliased",      "exit",         "or",           "some",         "all",          "others",       "subtype",
diff --git a/xanguage/bash.h b/xanguage/bash.h
index 351c2f3..7a3b058 100755
--- a/xanguage/bash.h
+++ b/xanguage/bash.h
@@ -1,7 +1,7 @@
 static void language_highlight_bash (language_structure * language, syntax_structure * syntax) {
-	const char * separators = ".,:;<=>+-*/%!&~^?|@#$()[]{}'\" \t\r\n";
+	char * separators = ".,:;<=>+-*/%!&~^?|@#$()[]{}'\" \t\r\n";
 
-	const char * keywords [] = {
+	char * keywords [] = {
 		"exit",         "set",          "elif",         "done",         "in",           "then",         "function",     "fi",
 		"if",           "else",         "do",           "while",        "for"
 	};
diff --git a/xanguage/c++.h b/xanguage/c++.h
index 131176d..b68df96 100755
--- a/xanguage/c++.h
+++ b/xanguage/c++.h
@@ -1,7 +1,7 @@
 static void language_highlight_cpp (language_structure * language, syntax_structure * syntax) {
-	const char * separators = ".,:;<=>+-*/%!&~^?|()[]{}'\" \t\r\n";
+	char * separators = ".,:;<=>+-*/%!&~^?|()[]{}'\" \t\r\n";
 
-	const char * keywords [] = {
+	char * keywords [] = {
 		"alignas",      "alignof",      "and",          "asm",          "auto",         "break",        "case",
 		"catch",        "class",        "compl",        "concept",      "const",        "consteval",    "constexpr",
 		"constinit",    "continue",     "decltype",     "default",      "delete",       "do",           "else",
@@ -14,14 +14,14 @@ static void language_highlight_cpp (language_structure * language, syntax_struct
 		"volatile",     "while",        "xor",          "final",        "override",     "import",       "module"
 	};
 
-	const char * types [] = {
+	char * types [] = {
 		"void",         "bool",         "off_t",        "va_list",      "float",        "double",       "float_t",      "double_t",
 		"char",         "short",        "int",          "long",         "uchar",        "ushort",       "uint",         "ulong",
 		"int8_t",       "int16_t",      "int32_t",      "int64_t",      "uint8_t",      "uint16_t",     "uint32_t",     "uint64_t",
 		"signed",       "unsigned",     "size_t",       "ssize_t"
 	};
 
-	const char * commons [] = {
+	char * commons [] = {
 		"std",          "FILE",         "DIR",          "EOF",          "va_arg",       "va_start",     "va_end",       "va_copy"
 	};
 
diff --git a/xanguage/c.h b/xanguage/c.h
index 8005724..7012ceb 100755
--- a/xanguage/c.h
+++ b/xanguage/c.h
@@ -1,24 +1,25 @@
 static void language_highlight_c (language_structure * language, syntax_structure * syntax) {
-	const char * separators = ".,:;<=>+-*/%!&~^?|()[]{}'\" \t\r\n";
+	char * separators = ".,:;<=>+-*/%!&~^?|()[]{}'\" \t\r\n";
 
-	const char * keywords [] = {
+	char * keywords [] = {
 		"register",     "volatile",     "auto",         "const",        "static",       "extern",       "if",           "else",
 		"do",           "while",        "for",          "continue",     "switch",       "case",         "default",      "break",
 		"enum",         "union",        "struct",       "typedef",      "goto",         "return",       "sizeof",       "inline",
 		"restrict",     "true",         "false"
 	};
 
-	const char * types [] = {
+	char * types [] = {
 		"void",         "bool",         "off_t",        "va_list",      "float",        "double",       "float_t",      "double_t",
 		"char",         "short",        "int",          "long",         "uchar",        "ushort",       "uint",         "ulong",
 		"int8_t",       "int16_t",      "int32_t",      "int64_t",      "uint8_t",      "uint16_t",     "uint32_t",     "uint64_t",
 		"signed",       "unsigned",     "size_t",       "ssize_t"
 	};
 
-	const char * commons [] = {
+	char * commons [] = {
 		"null",         "NULL",         "FILE",         "DIR",          "va_arg",       "va_start",     "va_end",       "va_copy",
 		"alignas",      "alignof",      "offsetof",     "typeof",       "EOF",          "ABS",          "MIN",          "MAX",
-		"ARRAYSIZE",    "SWAP",         "UNUSED",       "UNREACHABLE",  "STRINGIFY",    "CONCAT",       "assert",       "static_assert"
+		"ARRAYSIZE",    "SWAP",         "UNUSED",       "UNREACHABLE",  "STRINGIFY",    "CONCAT",       "assert",       "static_assert",
+		"thread_local", "nullptr"
 	};
 
 	syntax_define (syntax, false, false, "/*",  "*/", '\0', language->comment_colour,   language->comment_effect);
diff --git a/xanguage/common.h b/xanguage/common.h
index 652b10b..2ccd03d 100755
--- a/xanguage/common.h
+++ b/xanguage/common.h
@@ -1,5 +1,5 @@
 static void language_highlight_common (language_structure * language, syntax_structure * syntax) {
-	const char * separators = ".,:;<=>+*-/%!&~^?|()[]{}'\"@#$` \t\r\n";
+	char * separators = ".,:;<=>+*-/%!&~^?|()[]{}'\"@#$` \t\r\n";
 
 	syntax_define (syntax, false, false, "'",                      "'",        '\\', language->character_colour, language->character_effect);
 	syntax_define (syntax, false, false, "\"",                     "\"",       '\\', language->string_colour,    language->string_effect);
diff --git a/xanguage/d.h b/xanguage/d.h
index d5a043a..592edcf 100755
--- a/xanguage/d.h
+++ b/xanguage/d.h
@@ -1,7 +1,7 @@
 static void language_highlight_d (language_structure * language, syntax_structure * syntax) {
-	const char * separators = ".,:;<=>+-*/%!&~^?|@()[]{}'\"` \t\r\n";
+	char * separators = ".,:;<=>+-*/%!&~^?|@()[]{}'\"` \t\r\n";
 
-	const char * keywords [] = {
+	char * keywords [] = {
 		"abstract",     "alias",        "align",        "asm",          "assert",       "auto",         "body",         "bool",
 		"break",        "byte",         "case",         "cast",         "catch",        "cdouble",      "cent",         "cfloat",
 		"char",         "class",        "const",        "continue",     "creal",        "dchar",        "debug",        "default",
@@ -17,7 +17,7 @@ static void language_highlight_d (language_structure * language, syntax_structur
 		"void",         "wchar",        "while",        "foreach_reverse"
 	};
 
-	const char * types [] = {
+	char * types [] = {
 		"byte",         "ubyte",        "short",        "ushort",       "int",          "uint",         "long",         "ulong",
 		"cent",         "ucent",        "char",         "wchar",        "dchar",        "float",        "double",       "real",
 		"ifloat",       "idouble",      "ireal",        "cfloat",       "cdouble",      "creal",        "void",         "bool",
diff --git a/xanguage/eaxhla.h b/xanguage/eaxhla.h
index ca99f20..b24065f 100755
--- a/xanguage/eaxhla.h
+++ b/xanguage/eaxhla.h
@@ -1,19 +1,19 @@
 static void language_highlight_eaxhla (language_structure * language, syntax_structure * syntax) {
-	const char * separators = ".,+-*/[]<>=; \t\r\n";
+	char * separators = ".,+-*/[]<>=; \t\r\n";
 
-	const char * declarations [] = {
+	char * declarations [] = {
 		"program",      "procedure",    "machine",      "library",      "fast",         "unix",         "begin",        "end",
 		"if",           "then",         "else",         "repeat",       "break",        "continue",     "until",        "exit",
 		"fastcall",     "shell",        "alias",        "macro",        "scope",        "unscope",      "use",          "include"
 	};
 
-	const char * types [] = {
+	char * types [] = {
 		"s8",           "s16",          "s32",          "s64",          "u8",           "u16",          "u32",          "u64",
 		"f32",          "f64",          "f80",          "v0",           "s128",         "u128",         "s256",         "u256",
 		"s512",         "u512"
 	};
 
-	const char * instructions [] = {
+	char * instructions [] = {
 		"jnpe",         "jpo",          "jnpo",         "jpe",          "jnb",           "jae",          "jnbe",          "ja",
 		"jna",          "jbe",          "jnae",         "jb",           "jnl",           "jge",          "jnle",          "jg",
 		"jng",          "jle",          "jnge",         "jl",           "cmovng",        "cmovle",       "cmovnge",       "cmovl",
@@ -34,7 +34,7 @@ static void language_highlight_eaxhla (language_structure * language, syntax_str
 		"bswap",        "bsf",          "bsr",          "loop",         "loope",         "loopne"
 	};
 
-	const char * registers [] = {
+	char * registers [] = {
 		"rax",          "rcx",          "rdx",          "rbx",          "rsp",          "rbp",          "rsi",          "rdi",
 		"r8",           "r9",           "r10",          "r11",          "r12",          "r13",          "r14",          "r15",
 		"eax",          "ecx",          "edx",          "ebx",          "esp",          "ebp",          "esi",          "edi",
diff --git a/xanguage/flat.h b/xanguage/flat.h
index eabf301..5fb123e 100755
--- a/xanguage/flat.h
+++ b/xanguage/flat.h
@@ -1,12 +1,12 @@
 static void language_highlight_flat (language_structure * language, syntax_structure * syntax) {
-	const char * separators = ".,+-=:;(){}[]%$<> \t\r\n";
+	char * separators = ".,+-=:;(){}[]%$<> \t\r\n";
 
-	const char * declarations [] = {
+	char * declarations [] = {
 		"format",       "executable",   "readable",     "writable",     "segment",      "sector",       "entry",        "macro",
 		"db",           "dw",           "dd",           "dq",           "rb",           "rw",           "rd",           "rq"
 	};
 
-	const char * instructions [] = {
+	char * instructions [] = {
 		"mov",          "movabs",       "movapd",       "movaps",       "movebe",       "movsd",        "movsx",        "movzx",
 		"movsxd",       "movd",         "movq",         "movs",         "movsb",        "movsw",        "movsd",        "movsq",
 		"cmovmp",       "cmovrcxz",     "cmovc",        "cmovnc",       "cmove",        "cmovne",       "cmovz",        "cmovnz",
@@ -26,7 +26,7 @@ static void language_highlight_flat (language_structure * language, syntax_struc
 		"rep",          "repe",         "repz",         "repne",        "repnz",        "loop",         "loope",        "loopne"
 	};
 
-	const char * registers [] = {
+	char * registers [] = {
 		"rax",          "rcx",          "rdx",          "rbx",          "rsp",          "rbp",          "rsi",          "rdi",
 		"r8",           "r9",           "r10",          "r11",          "r12",          "r13",          "r14",          "r15",
 		"eax",          "ecx",          "edx",          "ebx",          "esp",          "ebp",          "esi",          "edi",
diff --git a/xanguage/fortran.h b/xanguage/fortran.h
index e24923a..45443ae 100755
--- a/xanguage/fortran.h
+++ b/xanguage/fortran.h
@@ -1,7 +1,7 @@
 static void language_highlight_fortran (language_structure * language, syntax_structure * syntax) {
-	const char * separators = ",:<=>+-*/&()[]\"\' \t\r\n";
+	char * separators = ",:<=>+-*/&()[]\"\' \t\r\n";
 
-	const char * keywords [] = {
+	char * keywords [] = {
 		"allocatable",  "allocate",     "associate",    "backspace",    "block",        "call",         "case",         "common",
 		"contains",     "cycle",        "data",         "deallocate",   "d0",           "do",           "else",         "elseif",
 		"end",          "enddo",        "endfile",      "endif",        "entry",        "equivalence",  "exit",         "external",
@@ -12,11 +12,11 @@ static void language_highlight_fortran (language_structure * language, syntax_st
 		"then",         "to",           "type",         "use",          "where",        "write"
 	};
 
-	const char * types [] = {
+	char * types [] = {
 		"character",    "integer",      "logical",      "real",         "complex"
 	};
 
-	const char * subkeywords [] = {
+	char * subkeywords [] = {
 		".and.",        ".or.",         ".not.",        ".true.",       ".false.",      "in",           "out",          "len",
 		"dimension",    "modulo",       "advance"
 	};
diff --git a/xanguage/go.h b/xanguage/go.h
index 38919e8..c2cf3d7 100755
--- a/xanguage/go.h
+++ b/xanguage/go.h
@@ -1,20 +1,20 @@
 static void language_highlight_go (language_structure * language, syntax_structure * syntax) {
-	const char * separators = ".,:;<=>+-*/%!&~^?|()[]{}'\"` \t\r\n";
+	char * separators = ".,:;<=>+-*/%!&~^?|()[]{}'\"` \t\r\n";
 
-	const char * keywords [] = {
+	char * keywords [] = {
 		"break",        "default",      "func",         "interface",    "select",       "case",         "defer",        "go",
 		"struct",       "else",         "goto",         "package",      "switch",       "const",        "var",          "for",
 		"fallthrough",  "if",           "range",        "type",         "continue",     "import",       "return"
 	};
 
-	const char * types [] = {
+	char * types [] = {
 		"map",          "uint",         "int",          "uintptr",      "uint8",        "uint16",       "uint32",       "uint64",
 		"int8",         "int16",        "int32",        "int64",        "float32",      "float64",      "complex64",    "complex128",
 		"byte",         "rune",         "string",       "chan",         "bool"
 
 	};
 
-	const char * commons [] = {
+	char * commons [] = {
 		"true",         "false",        "nil",          "err"
 	};
 
diff --git a/xanguage/haskell.h b/xanguage/haskell.h
index 5766d29..a2c1409 100755
--- a/xanguage/haskell.h
+++ b/xanguage/haskell.h
@@ -1,13 +1,13 @@
 static void language_highlight_haskell (language_structure * language, syntax_structure * syntax) {
-	const char * separators = ".,:;<=>+-*/%!@#$&~^?|()[]{}'\" \t\r\n";
+	char * separators = ".,:;<=>+-*/%!@#$&~^?|()[]{}'\" \t\r\n";
 
-	const char * keywords [] = {
+	char * keywords [] = {
 		"case",         "class",        "data",         "deriving",     "do",           "else",         "if",           "import",
 		"in",           "infix",        "infixl",       "infixr",       "instance",     "let",          "of",           "module",
 		"newtype",      "then",         "type",         "where"
 	};
 
-	const char * types [] = {
+	char * types [] = {
 		"Int",          "Integer",      "String",       "Char",         "Float",        "Boolean"
 	};
 
diff --git a/xanguage/holy_c.h b/xanguage/holy_c.h
new file mode 100755
index 0000000..3041453
--- /dev/null
+++ b/xanguage/holy_c.h
@@ -0,0 +1,50 @@
+static void language_highlight_holy_c (language_structure * language, syntax_structure * syntax) {
+	char * separators = ".,:;<=>+-*/%!&~^?|()[]{}'\" \t\r\n";
+///////////// DOES NOT FUCKING WORK YET
+	char * keywords [] = {
+		"auto",         "extern",       "if",           "else",
+		"do",           "while",        "for",          "switch",       "case",         "default",      "break",
+		"enum",         "union",        "struct",       "typedef",      "goto",         "return",       "sizeof",       "inline",
+		"restrict",     "true",         "false"
+	};
+
+	char * types [] = {
+		"void",         "bool",         "off_t",        "va_list",      "float",        "double",       "float_t",      "double_t",
+		"char",         "short",        "int",          "long",         "uchar",        "ushort",       "uint",         "ulong",
+		"int8_t",       "int16_t",      "int32_t",      "int64_t",      "uint8_t",      "uint16_t",     "uint32_t",     "uint64_t",
+		"signed",       "unsigned",     "size_t",       "ssize_t"
+	};
+
+	char * commons [] = {
+		"null",         "NULL",         "FILE",         "DIR",          "va_arg",       "va_start",     "va_end",       "va_copy",
+		"alignas",      "alignof",      "offsetof",     "typeof",       "EOF",          "ABS",          "MIN",          "MAX",
+		"ARRAYSIZE",    "SWAP",         "UNUSED",       "UNREACHABLE",  "STRINGIFY",    "CONCAT",       "assert",       "static_assert",
+		"thread_local", "nullptr"
+	};
+
+	syntax_define (syntax, false, false, "/*",  "*/", '\0', language->comment_colour,   language->comment_effect);
+	syntax_define (syntax, false, false, "//",  "\n", '\0', language->comment_colour,   language->comment_effect);
+	syntax_define (syntax, false, false, "#",   "\n", '\\', language->processor_colour, language->processor_effect);
+	syntax_define (syntax, false, false, "'",   "'",  '\\', language->character_colour, language->character_effect);
+	syntax_define (syntax, false, false, "\"",  "\"", '\\', language->string_colour,    language->string_effect);
+
+	for (ulong word = 0; word < array_length (keywords); ++word) {
+		syntax_define (syntax, false, true, keywords [word], separators, '\0', language->keyword_colour, language->keyword_effect);
+	}
+
+	for (ulong word = 0; word < array_length (types); ++word) {
+		syntax_define (syntax, false, true, types [word], separators, '\0', language->type_colour, language->type_effect);
+	}
+
+	for (ulong word = 0; word < array_length (commons); ++word) {
+		syntax_define (syntax, false, true, commons [word], separators, '\0', language->extension_colour, language->extension_effect);
+	}
+
+	syntax_define (syntax, true, false, "()[]{}",             "", '\0', language->bracket_colour,  language->bracket_effect);
+	syntax_define (syntax, true, false, ".,:;<=>+*-/%!&~^?|", "", '\0', language->operator_colour, language->operator_effect);
+
+	syntax_define (syntax, true, true, "0123456789",                 separators, '\0', language->number_colour,     language->number_effect);
+	syntax_define (syntax, true, true, "abcdefghijklmnopqrstuvwxyz", separators, '\0', language->lowercase_colour,  language->lowercase_effect);
+	syntax_define (syntax, true, true, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", separators, '\0', language->uppercase_colour,  language->uppercase_effect);
+	syntax_define (syntax, true, true, "_",                          separators, '\0', language->underscore_colour, language->underscore_effect);
+}
diff --git a/xanguage/lua.h b/xanguage/lua.h
index 1509e86..bceb0fc 100755
--- a/xanguage/lua.h
+++ b/xanguage/lua.h
@@ -1,17 +1,17 @@
 static void language_highlight_lua (language_structure * language, syntax_structure * syntax) {
-	const char * separators = ".,:;<=>+-*/%~^#|()[]{}'\" \t\r\n";
+	char * separators = ".,:;<=>+-*/%~^#|()[]{}'\" \t\r\n";
 
-	const char * keywords [] = {
+	char * keywords [] = {
 		"and",          "break",        "do",           "else",         "elseif",       "end",          "false",        "for",
 		"function",     "if",           "in",           "local",        "nil",          "not",          "or",           "until",
 		"repeat",       "return",       "then",         "true",         "while"
 	};
 
-	const char * types [] = {
+	char * types [] = {
 		"boolean",      "number",       "string",       "userdata",     "function",     "thread",       "table"
 	};
 
-	const char * commons [] = {
+	char * commons [] = {
 		"require",      "print",        "seek",         "dofile",       "loadfile",     "assert",       "rawset",       "rawget",
 		"setfenv",      "pairs",        "ipairs",       "tonumber",     "tostring",     "foreach",      "setn",         "getn",
 		"insert",       "concat",       "sort",         "remove",       "abs",          "ceil",         "floor",        "log10",
diff --git a/xanguage/pascal.h b/xanguage/pascal.h
index 21bac25..df95763 100755
--- a/xanguage/pascal.h
+++ b/xanguage/pascal.h
@@ -1,7 +1,7 @@
 static void language_highlight_pascal (language_structure * language, syntax_structure * syntax) {
-	const char * separators = ".,:;<=>+-*/&@#$%^()[] \t\r\n";
+	char * separators = ".,:;<=>+-*/&@#$%^()[] \t\r\n";
 
-	const char * keywords [] = {
+	char * keywords [] = {
 		"absolute",     "and",          "array",        "asm",          "begin",        "case",         "const",        "constructor",
 		"destructor",   "div",          "do",           "downto",       "else",         "end",          "file",         "for",
 		"function",     "goto",         "if",           "in",           "inherited",    "inline",       "interface",    "xor",
diff --git a/xanguage/python.h b/xanguage/python.h
index ccd8dcd..dfea821 100755
--- a/xanguage/python.h
+++ b/xanguage/python.h
@@ -1,7 +1,7 @@
 static void language_highlight_python (language_structure * language, syntax_structure * syntax) {
-	const char * separators = ".,:;<=>+-*/%!&~^?|()[]{}'\" \t\r\n";
+	char * separators = ".,:;<=>+-*/%!&~^?|()[]{}'\" \t\r\n";
 
-	const char * keywords [] = {
+	char * keywords [] = {
 		"and",          "as",           "assert",       "break",        "class",        "continue",     "def",          "del",
 		"elif",         "else",         "except",       "False",        "finally",      "for",          "from",         "global",
 		"if",           "import",       "in",           "is",           "labmda",       "None",         "nonlocal",     "not",
@@ -9,7 +9,7 @@ static void language_highlight_python (language_structure * language, syntax_str
 		"yield",        "async",        "await"
 	};
 
-	const char * subkeywords [] = {
+	char * subkeywords [] = {
 		"abs",          "all",          "any",          "apply",        "ascii",        "basestring",   "bin",          "bool",
 		"breakpoint",   "buffer",       "bytearray",    "bytes",        "callable",     "chr",          "classmethod",  "cmp",
 		"coerce",       "compile",      "complex",      "copyright",    "credits",      "delattr",      "dict",         "dir",
diff --git a/xanguage/valgrind.h b/xanguage/valgrind.h
index 411f580..7cfb9cd 100755
--- a/xanguage/valgrind.h
+++ b/xanguage/valgrind.h
@@ -1,7 +1,7 @@
 static void language_highlight_valgrind (language_structure * language, syntax_structure * syntax) {
-	const char * separators = ".,:;<=>+-*/%!&~^?|@#$()[]{}'\" \t\r\n";
+	char * separators = ".,:;<=>+-*/%!&~^?|@#$()[]{}'\" \t\r\n";
 
-	const char * titles [] = {
+	char * titles [] = {
 		//~"exit",         "set",          "elif",         "done",         "in",           "then",         "function",     "fi",
 		"HEAP",         "LEAK",         "ERROR",        "SUMMARY"
 	};
diff --git a/xaptor.c b/xaptor.c
index cf59554..321db38 100644
--- a/xaptor.c
+++ b/xaptor.c
@@ -17,7 +17,7 @@ int main (void) {
 	cross_configure (cross, 640, 480, "Xaptor - File Manager");
 
 	while (cross->active == true) {
-		const uint offset = 48;
+		uint offset = 48;
 
 		cross_synchronize (cross, 0x00000000);
 
diff --git a/xaptor.h b/xaptor.h
index 8567acf..5315144 100644
--- a/xaptor.h
+++ b/xaptor.h
@@ -125,7 +125,7 @@ static uint raptor_font_raw_import (raptor_structure * raptor, uint * data, uint
 	uint   height  = 0;
 	uint * buffer = null;
 
-	const uint current = raptor->font_count;
+	uint current = raptor->font_count;
 
 	++raptor->font_count;
 
@@ -171,7 +171,7 @@ static uint raptor_font_raw_import (raptor_structure * raptor, uint * data, uint
 	return (current);
 }
 
-static uint raptor_sprite_import (raptor_structure * raptor, const char * path) {
+static uint raptor_sprite_import (raptor_structure * raptor, char * path) {
 	uint   width  = 0;
 	uint   height = 0;
 	uint * data   = null;
@@ -181,7 +181,7 @@ static uint raptor_sprite_import (raptor_structure * raptor, const char * path)
 	return (raptor_sprite_raw_import (raptor, data, width, height));
 }
 
-static uint raptor_font_import (raptor_structure * raptor, const char * path, char begin, char end, uint colour) {
+static uint raptor_font_import (raptor_structure * raptor, char * path, char begin, char end, uint colour) {
 	uint   width  = 0;
 	uint   height = 0;
 	uint   result = 0;
@@ -196,11 +196,11 @@ static uint raptor_font_import (raptor_structure * raptor, const char * path, ch
 	return (result);
 }
 
-static uint raptor_sprite_width (const raptor_structure * raptor, uint sprite) {
+static uint raptor_sprite_width (raptor_structure * raptor, uint sprite) {
 	return (raptor->sprite_width [sprite]);
 }
 
-static uint raptor_sprite_height (const raptor_structure * raptor, uint sprite) {
+static uint raptor_sprite_height (raptor_structure * raptor, uint sprite) {
 	return (raptor->sprite_height [sprite]);
 }
 
@@ -208,7 +208,7 @@ static uint raptor_character_width (raptor_structure * raptor, char character, u
 	if ((character < raptor->font_begin [font]) || (character > raptor->font_end [font])) {
 		return (0);
 	} else {
-		const uint index = raptor->font_index [font] [character - raptor->font_begin [font]];
+		uint index = raptor->font_index [font] [character - raptor->font_begin [font]];
 
 		return ((uint) (scale * (float) raptor->sprite_width [index]));
 	}
@@ -218,13 +218,13 @@ static uint raptor_character_height (raptor_structure * raptor, char character,
 	if ((character < raptor->font_begin [font]) || (character > raptor->font_end [font])) {
 		return (0);
 	} else {
-		const uint index = raptor->font_index [font] [character - raptor->font_begin [font]];
+		uint index = raptor->font_index [font] [character - raptor->font_begin [font]];
 
 		return ((uint) (scale * (float) raptor->sprite_height [index]));
 	}
 }
 
-static uint raptor_string_width (raptor_structure * raptor, const char * string, uint font, float scale) {
+static uint raptor_string_width (raptor_structure * raptor, char * string, uint font, float scale) {
 	uint width = 0;
 	uint match = 0;
 
@@ -246,7 +246,7 @@ static uint raptor_string_width (raptor_structure * raptor, const char * string,
 	return (maximum (width, match));
 }
 
-static uint raptor_string_height (raptor_structure * raptor, const char * string, uint font, float scale) {
+static uint raptor_string_height (raptor_structure * raptor, char * string, uint font, float scale) {
 	uint height = raptor_character_height (raptor, ' ', font, scale);
 
 	if ((string == null) || (string [0] == '\0')) {
@@ -262,22 +262,22 @@ static uint raptor_string_height (raptor_structure * raptor, const char * string
 	return (height);
 }
 
-static uint raptor_center_x (const raptor_structure * raptor, uint size) {
+static uint raptor_center_x (raptor_structure * raptor, uint size) {
 	return ((raptor->window_width - size) / 2);
 }
 
-static uint raptor_center_y (const raptor_structure * raptor, uint size) {
+static uint raptor_center_y (raptor_structure * raptor, uint size) {
 	return ((raptor->window_height - size) / 2);
 }
 
-static bool raptor_cursor_inside (const raptor_structure * raptor, int x, int y, uint width, uint height) {
+static bool raptor_cursor_inside (raptor_structure * raptor, int x, int y, uint width, uint height) {
 	return ((raptor->cursor_x > x)
 	     && (raptor->cursor_y > y)
 	     && (raptor->cursor_x < x + (int) width)
 	     && (raptor->cursor_y < y + (int) height));
 }
 
-static bool raptor_cursor_left_click (const raptor_structure * raptor, int x, int y, uint width, uint height) {
+static bool raptor_cursor_left_click (raptor_structure * raptor, int x, int y, uint width, uint height) {
 	if (raptor->cursor [cursor_left] == true) {
 		return (raptor_cursor_inside (raptor, x, y, width, height) == true);
 	}
@@ -285,7 +285,7 @@ static bool raptor_cursor_left_click (const raptor_structure * raptor, int x, in
 	return (false);
 }
 
-static bool raptor_cursor_right_click (const raptor_structure * raptor, int x, int y, uint width, uint height) {
+static bool raptor_cursor_right_click (raptor_structure * raptor, int x, int y, uint width, uint height) {
 	if (raptor->cursor [cursor_right] == true) {
 		return (raptor_cursor_inside (raptor, x, y, width, height));
 	}
@@ -293,8 +293,8 @@ static bool raptor_cursor_right_click (const raptor_structure * raptor, int x, i
 	return (false);
 }
 
-static void raptor_configure (raptor_structure * raptor, uint window_width, uint window_height, const char * window_title) {
-	const ulong font_bitmap [2 * 95] = {
+static void raptor_configure (raptor_structure * raptor, uint window_width, uint window_height, char * window_title) {
+	ulong font_bitmap [2 * 95] = {
 		0x0000000000000000, 0x0000000000000000, 0x0000101010101010, 0x1000101000000000, 0x0024242400000000, 0x0000000000000000,
 		0x00002424247e2424, 0x7e24242400000000, 0x0010107c9290907c, 0x1212927c10100000, 0x0000649468081010, 0x202c524c00000000,
 		0x000018242418304a, 0x4444443a00000000, 0x0010101000000000, 0x0000000000000000, 0x0000081020202020, 0x2020100800000000,
@@ -430,10 +430,10 @@ static void raptor_render_base (raptor_structure * raptor, uint sprite, int x, i
 	(void) lower_right;
 
 	uint interpolate_pixels (uint pixel, uint modifier) {
-		const uint r = (((pixel & 0xff000000) >> 24) * ((modifier & 0x000000ff) >>  0)) / 0xff;
-		const uint g = (((pixel & 0x00ff0000) >> 16) * ((modifier & 0x0000ff00) >>  8)) / 0xff;
-		const uint b = (((pixel & 0x0000ff00) >>  8) * ((modifier & 0x00ff0000) >> 16)) / 0xff;
-		const uint a = (((pixel & 0x000000ff) >>  0) * ((modifier & 0xff000000) >> 24)) / 0xff;
+		uint r = (((pixel & 0xff000000) >> 24) * ((modifier & 0x000000ff) >>  0)) / 0xff;
+		uint g = (((pixel & 0x00ff0000) >> 16) * ((modifier & 0x0000ff00) >>  8)) / 0xff;
+		uint b = (((pixel & 0x0000ff00) >>  8) * ((modifier & 0x00ff0000) >> 16)) / 0xff;
+		uint a = (((pixel & 0x000000ff) >>  0) * ((modifier & 0xff000000) >> 24)) / 0xff;
 
 		return ((r << 24) | (g << 16) | (b << 8) | a);
 	}
@@ -448,8 +448,8 @@ static void raptor_render_base (raptor_structure * raptor, uint sprite, int x, i
 			if (horizontal + x >= raptor->window_width) break;
 			if (horizontal + u >= raptor->sprite_width [sprite]) break;
 
-			const uint pixel = raptor->sprite_data [sprite] [(vertical + v) * raptor->sprite_width [sprite] + horizontal + u];
-			const uint at    = (y + vertical) * raptor->window_width + (x + horizontal);
+			uint pixel = raptor->sprite_data [sprite] [(vertical + v) * raptor->sprite_width [sprite] + horizontal + u];
+			uint at    = (y + vertical) * raptor->window_width + (x + horizontal);
 
 			raptor->framebuffer [at] = (((pixel & 0xff000000) >> 24) > 0x77)
 			                         ? interpolate_pixels (pixel, upper_left)
@@ -464,15 +464,15 @@ static void raptor_render_rectangle (raptor_structure * raptor, int x, int y, ui
 }
 
 static void raptor_render_sprite (raptor_structure * raptor, uint sprite, int x, int y) {
-	const uint width  = raptor->sprite_width  [sprite];
-	const uint height = raptor->sprite_height [sprite];
+	uint width  = raptor->sprite_width  [sprite];
+	uint height = raptor->sprite_height [sprite];
 
 	raptor_render_base (raptor, sprite, x, y, 0, 0, width, height, 1.0f, 1.0f, 0, 0, 0xffffffffu, 0xffffffffu, 0xffffffffu, 0xffffffffu);
 }
 
 static void raptor_render_sprite_scale (raptor_structure * raptor, uint sprite, int x, int y, float scale_x, float scale_y) {
-	const uint width  = raptor->sprite_width  [sprite];
-	const uint height = raptor->sprite_height [sprite];
+	uint width  = raptor->sprite_width  [sprite];
+	uint height = raptor->sprite_height [sprite];
 
 	raptor_render_base (raptor, sprite, x, y, 0, 0, width, height, scale_x, scale_y, 0, 0, 0xffffffffu, 0xffffffffu, 0xffffffffu,
 	                    0xffffffffu);
@@ -483,8 +483,8 @@ static void raptor_render_sprite_crop (raptor_structure * raptor, uint sprite, i
 }
 
 static void raptor_render_sprite_colour (raptor_structure * raptor, uint sprite, uint colour, int x, int y) {
-	const uint width  = raptor->sprite_width  [sprite];
-	const uint height = raptor->sprite_height [sprite];
+	uint width  = raptor->sprite_width  [sprite];
+	uint height = raptor->sprite_height [sprite];
 
 	raptor_render_base (raptor, sprite, x, y, 0, 0, width, height, 1.0f, 1.0f, 0, 0, colour, colour, colour, colour);
 }
@@ -494,19 +494,19 @@ static void raptor_render_sprite_crop_colour (raptor_structure * raptor, uint sp
 }
 
 static void raptor_render_sprite_flip (raptor_structure * raptor, uint sprite, int x, int y, int flip_x, int flip_y) {
-	const uint width  = raptor->sprite_width  [sprite];
-	const uint height = raptor->sprite_height [sprite];
+	uint width  = raptor->sprite_width  [sprite];
+	uint height = raptor->sprite_height [sprite];
 
 	raptor_render_base (raptor, sprite, x, y, 0, 0, width, height, 1.0f, 1.0f, flip_x, flip_y, 0xffffffffu, 0xffffffffu, 0xffffffffu,
 	                    0xffffffffu);
 }
 
 static void raptor_render_sprite_animate (raptor_structure * raptor, uint sprite, int x, int y, uint frames, uint state, uint states) {
-	const uint width  = raptor->sprite_width  [sprite] / states;
-	const uint height = raptor->sprite_height [sprite] / frames;
+	uint width  = raptor->sprite_width  [sprite] / states;
+	uint height = raptor->sprite_height [sprite] / frames;
 
-	const uint u = width  * (state                  % states);
-	const uint v = height * (raptor->animation_tick % frames);
+	uint u = width  * (state                  % states);
+	uint v = height * (raptor->animation_tick % frames);
 
 	raptor_render_sprite_crop (raptor, sprite, x, y, u, v, width, height);
 }
@@ -514,15 +514,15 @@ static void raptor_render_sprite_animate (raptor_structure * raptor, uint sprite
 static void raptor_render_character (raptor_structure * raptor, char character, uint font, int x, int y, float scale, uint colour) {
 	if ((character < raptor->font_begin [font]) || (character > raptor->font_end [font])) return;
 
-	const uint index  = raptor->font_index [font] [character - raptor->font_begin [font]];
+	uint index  = raptor->font_index [font] [character - raptor->font_begin [font]];
 
-	const uint width  = raptor->sprite_width  [index];
-	const uint height = raptor->sprite_height [index];
+	uint width  = raptor->sprite_width  [index];
+	uint height = raptor->sprite_height [index];
 
 	raptor_render_base (raptor, index, x, y, 0, 0, width, height, scale, scale, 0, 0, colour, colour, colour, colour);
 }
 
-static void raptor_render_string (raptor_structure * raptor, const char * string, uint font, int x, int y, float scale, uint colour) {
+static void raptor_render_string (raptor_structure * raptor, char * string, uint font, int x, int y, float scale, uint colour) {
 	int offset = x;
 
 	if (string == null) return;
@@ -548,7 +548,7 @@ static void raptor_render_framerate (raptor_structure * raptor, uint font, int x
 }
 
 static void raptor_synchronize (raptor_structure * raptor, uint clear_colour) {
-	const uint signal_code [signal_count] = {
+	uint signal_code [signal_count] = {
 		0,
 		38,     56,     54,     40,     26,     41,     42,     43,     31,     44,     45,     46,     58,     57,     32,     33,
 		24,     27,     39,     28,     30,     55,     25,     53,     29,     52,     19,     10,     11,     12,     13,     14,
diff --git a/xarbon.c b/xarbon.c
index a1bda6c..cdabfda 100755
--- a/xarbon.c
+++ b/xarbon.c
@@ -20,12 +20,12 @@
 #include <xolatile/xanguage.h>
 #include <xolatile/xormat/png.h>
 
-static const uint background    = 0xff181818;
-static const uint foreground    = 0xffcccccc;
-static const uint font_width    = 8;
-static const uint font_height   = 16;
-static const uint tab_width     = 8;
-static const uint render_border = 10;
+static uint background    = 0xff181818;
+static uint foreground    = 0xffcccccc;
+static uint font_width    = 8;
+static uint font_height   = 16;
+static uint tab_width     = 8;
+static uint render_border = 10;
 
 static uint * render_image  = null;
 static uint   render_width  = 0;
@@ -57,13 +57,13 @@ static void print_help (void) {
 	print ("\t/6$ xarbon file.ext/-               /0---/- Language is automatically detected in this case.\n\n");
 	print ("Supported languages:\n\n");
 
-	for (uint index = 0; index < language_count; ++index) {
+	for (language_enumeration index = 0; index < language_count; ++index) {
 		char align [32] = "";
 
 		print ("\t/B/4%s/- /4%s/- /0---/- %s syntax highlighting\n",
-		       language_short_option (index),
-		       string_align_left (string_copy (align, language_long_option (index)), 9, ' '),
-		       language_identifier (index));
+		       language_short_option [index],
+		       string_align_left (string_copy (align, language_long_option [index]), 9, ' '),
+		       language_identifier [index]);
 	}
 }
 
@@ -73,7 +73,7 @@ static void print_version (void) {
 	print ("\tVersion: /40 (Zero)/-\n");
 }
 
-static uint fetch_width (const char * data) {
+static uint fetch_width (char * data) {
 	uint image_width = 0;
 	uint count       = 0;
 
@@ -91,7 +91,7 @@ static uint fetch_width (const char * data) {
 	return (image_width - 1);
 }
 
-static uint fetch_height (const char * data) {
+static uint fetch_height (char * data) {
 	uint image_height = 0;
 	uint count        = 0;
 
@@ -113,7 +113,7 @@ static uint fetch_height (const char * data) {
 }
 
 static void render_character (char character, uint * x, uint * y, uint colour) {
-	const ulong glyphmap [192] = {
+	ulong glyphmap [192] = {
 		0x0000000000000000, 0x0000000000000000, 0x0000101010101010, 0x1000101000000000, 0x0024242400000000, 0x0000000000000000,
 		0x00002424247e2424, 0x7e24242400000000, 0x0010107c9290907c, 0x1212927c10100000, 0x0000649468081010, 0x202c524c00000000,
 		0x000018242418304a, 0x4444443a00000000, 0x0010101000000000, 0x0000000000000000, 0x0000081020202020, 0x2020100800000000,
@@ -168,7 +168,8 @@ static void render_string (char * string, uint length, uint * x, uint * y, uint
 			* y += font_height;
 			* x  = render_border;
 
-			render_string (format_to_string ((int) ++line_number, false, 10, (int) line_digits, ' '), line_digits, x, y, foreground);
+			render_string (format_to_string ((int) ++line_number, false, 10, (int) line_digits, ' '),
+			               line_digits, x, y, foreground);
 
 			* x += font_width;
 		} else {
@@ -207,8 +208,8 @@ int main (int argc, char * * argv) {
 		}
 
 		for (uint index = 0; index < language_count; ++index) {
-			if (argument_compare (argv [argument], language_short_option (index), language_long_option (index)) == true) {
-				(* (language_highlighter (index))) (language, syntax);
+			if (argument_compare (argv [argument], language_short_option [index], language_long_option [index]) == true) {
+				(* (language_highlighter [index])) (language, syntax);
 				select = index;
 				break;
 			}
diff --git a/xarticle.h b/xarticle.h
index 6c0f7bd..54beeb8 100644
--- a/xarticle.h
+++ b/xarticle.h
@@ -73,8 +73,8 @@ static particle_structure * particle_deinitialize (particle_structure * particle
 	return (deallocate (particle));
 }
 
-static void particle_append (particle_structure * particle, uint sprite, float life, uint colour_in, uint colour_out, const vector_3 * position,
-                             const vector_3 * target, const vector_3 * speed) {
+static void particle_append (particle_structure * particle, uint sprite, float life, uint colour_in, uint colour_out, vector_3 * position,
+                             vector_3 * target, vector_3 * speed) {
 	if (particle->count + 1 >= particle->limit) return;
 
 	++particle->count;
diff --git a/xatrix.h b/xatrix.h
index b0d8c8a..f3677b6 100644
--- a/xatrix.h
+++ b/xatrix.h
@@ -132,51 +132,51 @@ static matrix_4 * matrix_4_identity (matrix_4 * destination) {
 	return (destination);
 }
 
-static float matrix_2_determinant (const matrix_2 * matrix) {
-	const float a = matrix [0] [0] * matrix [1] [1];
-	const float b = matrix [0] [1] * matrix [1] [0];
+static float matrix_2_determinant (matrix_2 * matrix) {
+	float a = matrix [0] [0] * matrix [1] [1];
+	float b = matrix [0] [1] * matrix [1] [0];
 
 	return (a - b);
 }
 
-static float matrix_3_determinant (const matrix_3 * matrix) {
-	const matrix_2 matrix_a = { { matrix [1] [1], matrix [1] [2] },
+static float matrix_3_determinant (matrix_3 * matrix) {
+	matrix_2 matrix_a = { { matrix [1] [1], matrix [1] [2] },
 	                            { matrix [2] [1], matrix [2] [2] } };
-	const matrix_2 matrix_b = { { matrix [1] [0], matrix [1] [2] },
+	matrix_2 matrix_b = { { matrix [1] [0], matrix [1] [2] },
 	                            { matrix [2] [0], matrix [2] [2] } };
-	const matrix_2 matrix_c = { { matrix [1] [0], matrix [1] [1] },
+	matrix_2 matrix_c = { { matrix [1] [0], matrix [1] [1] },
 	                            { matrix [2] [0], matrix [2] [1] } };
 
-	const float a = matrix [0] [0] * matrix_2_determinant (& matrix_a);
-	const float b = matrix [0] [1] * matrix_2_determinant (& matrix_b);
-	const float c = matrix [0] [2] * matrix_2_determinant (& matrix_c);
+	float a = matrix [0] [0] * matrix_2_determinant (& matrix_a);
+	float b = matrix [0] [1] * matrix_2_determinant (& matrix_b);
+	float c = matrix [0] [2] * matrix_2_determinant (& matrix_c);
 
 	return (a - b + c);
 }
 
-static float matrix_4_determinant (const matrix_4 * matrix) {
-	const matrix_3 matrix_a = { { matrix [1] [1], matrix [1] [2], matrix [1] [3] },
+static float matrix_4_determinant (matrix_4 * matrix) {
+	matrix_3 matrix_a = { { matrix [1] [1], matrix [1] [2], matrix [1] [3] },
 	                            { matrix [2] [1], matrix [2] [2], matrix [2] [3] },
 	                            { matrix [3] [1], matrix [3] [2], matrix [3] [3] } };
-	const matrix_3 matrix_b = { { matrix [1] [0], matrix [1] [2], matrix [1] [3] },
+	matrix_3 matrix_b = { { matrix [1] [0], matrix [1] [2], matrix [1] [3] },
 	                            { matrix [2] [0], matrix [2] [2], matrix [2] [3] },
 	                            { matrix [3] [0], matrix [3] [2], matrix [3] [3] } };
-	const matrix_3 matrix_c = { { matrix [1] [0], matrix [1] [1], matrix [1] [3] },
+	matrix_3 matrix_c = { { matrix [1] [0], matrix [1] [1], matrix [1] [3] },
 	                            { matrix [2] [0], matrix [2] [1], matrix [2] [3] },
 	                            { matrix [3] [0], matrix [3] [1], matrix [3] [3] } };
-	const matrix_3 matrix_d = { { matrix [1] [0], matrix [1] [1], matrix [1] [2] },
+	matrix_3 matrix_d = { { matrix [1] [0], matrix [1] [1], matrix [1] [2] },
 	                            { matrix [2] [0], matrix [2] [1], matrix [2] [2] },
 	                            { matrix [3] [0], matrix [3] [1], matrix [3] [2] } };
 
-	const float a = matrix [0] [0] * matrix_3_determinant (& matrix_a);
-	const float b = matrix [0] [1] * matrix_3_determinant (& matrix_b);
-	const float c = matrix [0] [2] * matrix_3_determinant (& matrix_c);
-	const float d = matrix [0] [3] * matrix_3_determinant (& matrix_d);
+	float a = matrix [0] [0] * matrix_3_determinant (& matrix_a);
+	float b = matrix [0] [1] * matrix_3_determinant (& matrix_b);
+	float c = matrix [0] [2] * matrix_3_determinant (& matrix_c);
+	float d = matrix [0] [3] * matrix_3_determinant (& matrix_d);
 
 	return (a - b + c - d);
 }
 
-static matrix_2 * matrix_2_copy (matrix_2 * destination, const matrix_2 * source) {
+static matrix_2 * matrix_2_copy (matrix_2 * destination, matrix_2 * source) {
 	for (uint row = 0; row < 2; ++row) {
 		for (uint column = 0; column < 2; ++column) {
 			destination [row] [column] = source [row] [column];
@@ -186,7 +186,7 @@ static matrix_2 * matrix_2_copy (matrix_2 * destination, const matrix_2 * source
 	return (destination);
 }
 
-static matrix_3 * matrix_3_copy (matrix_3 * destination, const matrix_3 * source) {
+static matrix_3 * matrix_3_copy (matrix_3 * destination, matrix_3 * source) {
 	for (uint row = 0; row < 3; ++row) {
 		for (uint column = 0; column < 3; ++column) {
 			destination [row] [column] = source [row] [column];
@@ -196,7 +196,7 @@ static matrix_3 * matrix_3_copy (matrix_3 * destination, const matrix_3 * source
 	return (destination);
 }
 
-static matrix_4 * matrix_4_copy (matrix_4 * destination, const matrix_4 * source) {
+static matrix_4 * matrix_4_copy (matrix_4 * destination, matrix_4 * source) {
 	for (uint row = 0; row < 4; ++row) {
 		for (uint column = 0; column < 4; ++column) {
 			destination [row] [column] = source [row] [column];
@@ -236,7 +236,7 @@ static matrix_4 * matrix_4_scale (matrix_4 * destination, float scale) {
 	return (destination);
 }
 
-static matrix_2 * matrix_2_scale_to (matrix_2 * destination, const matrix_2 * source, float scale) {
+static matrix_2 * matrix_2_scale_to (matrix_2 * destination, matrix_2 * source, float scale) {
 	for (uint row = 0; row < 2; ++row) {
 		for (uint column = 0; column < 2; ++column) {
 			destination [row] [column] = source [row] [column] * scale;
@@ -246,7 +246,7 @@ static matrix_2 * matrix_2_scale_to (matrix_2 * destination, const matrix_2 * so
 	return (destination);
 }
 
-static matrix_3 * matrix_3_scale_to (matrix_3 * destination, const matrix_3 * source, float scale) {
+static matrix_3 * matrix_3_scale_to (matrix_3 * destination, matrix_3 * source, float scale) {
 	for (uint row = 0; row < 3; ++row) {
 		for (uint column = 0; column < 3; ++column) {
 			destination [row] [column] = source [row] [column] * scale;
@@ -256,7 +256,7 @@ static matrix_3 * matrix_3_scale_to (matrix_3 * destination, const matrix_3 * so
 	return (destination);
 }
 
-static matrix_4 * matrix_4_scale_to (matrix_4 * destination, const matrix_4 * source, float scale) {
+static matrix_4 * matrix_4_scale_to (matrix_4 * destination, matrix_4 * source, float scale) {
 	for (uint row = 0; row < 4; ++row) {
 		for (uint column = 0; column < 4; ++column) {
 			destination [row] [column] = source [row] [column] * scale;
@@ -266,7 +266,7 @@ static matrix_4 * matrix_4_scale_to (matrix_4 * destination, const matrix_4 * so
 	return (destination);
 }
 
-static matrix_2 * matrix_2_add (matrix_2 * destination, const matrix_2 * source) {
+static matrix_2 * matrix_2_add (matrix_2 * destination, matrix_2 * source) {
 	for (uint row = 0; row < 2; ++row) {
 		for (uint column = 0; column < 2; ++column) {
 			destination [row] [column] += source [row] [column];
@@ -276,7 +276,7 @@ static matrix_2 * matrix_2_add (matrix_2 * destination, const matrix_2 * source)
 	return (destination);
 }
 
-static matrix_3 * matrix_3_add (matrix_3 * destination, const matrix_3 * source) {
+static matrix_3 * matrix_3_add (matrix_3 * destination, matrix_3 * source) {
 	for (uint row = 0; row < 3; ++row) {
 		for (uint column = 0; column < 3; ++column) {
 			destination [row] [column] += source [row] [column];
@@ -286,7 +286,7 @@ static matrix_3 * matrix_3_add (matrix_3 * destination, const matrix_3 * source)
 	return (destination);
 }
 
-static matrix_4 * matrix_4_add (matrix_4 * destination, const matrix_4 * source) {
+static matrix_4 * matrix_4_add (matrix_4 * destination, matrix_4 * source) {
 	for (uint row = 0; row < 4; ++row) {
 		for (uint column = 0; column < 4; ++column) {
 			destination [row] [column] += source [row] [column];
@@ -296,7 +296,7 @@ static matrix_4 * matrix_4_add (matrix_4 * destination, const matrix_4 * source)
 	return (destination);
 }
 
-static matrix_2 * matrix_2_add_to (matrix_2 * destination, const matrix_2 * matrix_a, const matrix_2 * matrix_b) {
+static matrix_2 * matrix_2_add_to (matrix_2 * destination, matrix_2 * matrix_a, matrix_2 * matrix_b) {
 	for (uint row = 0; row < 2; ++row) {
 		for (uint column = 0; column < 2; ++column) {
 			destination [row] [column] = matrix_a [row] [column] + matrix_b [row] [column];
@@ -306,7 +306,7 @@ static matrix_2 * matrix_2_add_to (matrix_2 * destination, const matrix_2 * matr
 	return (destination);
 }
 
-static matrix_3 * matrix_3_add_to (matrix_3 * destination, const matrix_3 * matrix_a, const matrix_3 * matrix_b) {
+static matrix_3 * matrix_3_add_to (matrix_3 * destination, matrix_3 * matrix_a, matrix_3 * matrix_b) {
 	for (uint row = 0; row < 3; ++row) {
 		for (uint column = 0; column < 3; ++column) {
 			destination [row] [column] = matrix_a [row] [column] + matrix_b [row] [column];
@@ -316,7 +316,7 @@ static matrix_3 * matrix_3_add_to (matrix_3 * destination, const matrix_3 * matr
 	return (destination);
 }
 
-static matrix_4 * matrix_4_add_to (matrix_4 * destination, const matrix_4 * matrix_a, const matrix_4 * matrix_b) {
+static matrix_4 * matrix_4_add_to (matrix_4 * destination, matrix_4 * matrix_a, matrix_4 * matrix_b) {
 	for (uint row = 0; row < 4; ++row) {
 		for (uint column = 0; column < 4; ++column) {
 			destination [row] [column] = matrix_a [row] [column] + matrix_b [row] [column];
@@ -326,7 +326,7 @@ static matrix_4 * matrix_4_add_to (matrix_4 * destination, const matrix_4 * matr
 	return (destination);
 }
 
-static matrix_2 * matrix_2_subtract (matrix_2 * destination, const matrix_2 * source) {
+static matrix_2 * matrix_2_subtract (matrix_2 * destination, matrix_2 * source) {
 	for (uint row = 0; row < 2; ++row) {
 		for (uint column = 0; column < 2; ++column) {
 			destination [row] [column] -= source [row] [column];
@@ -336,7 +336,7 @@ static matrix_2 * matrix_2_subtract (matrix_2 * destination, const matrix_2 * so
 	return (destination);
 }
 
-static matrix_3 * matrix_3_subtract (matrix_3 * destination, const matrix_3 * source) {
+static matrix_3 * matrix_3_subtract (matrix_3 * destination, matrix_3 * source) {
 	for (uint row = 0; row < 3; ++row) {
 		for (uint column = 0; column < 3; ++column) {
 			destination [row] [column] -= source [row] [column];
@@ -346,7 +346,7 @@ static matrix_3 * matrix_3_subtract (matrix_3 * destination, const matrix_3 * so
 	return (destination);
 }
 
-static matrix_4 * matrix_4_subtract (matrix_4 * destination, const matrix_4 * source) {
+static matrix_4 * matrix_4_subtract (matrix_4 * destination, matrix_4 * source) {
 	for (uint row = 0; row < 4; ++row) {
 		for (uint column = 0; column < 4; ++column) {
 			destination [row] [column] -= source [row] [column];
@@ -356,7 +356,7 @@ static matrix_4 * matrix_4_subtract (matrix_4 * destination, const matrix_4 * so
 	return (destination);
 }
 
-static matrix_2 * matrix_2_subtract_to (matrix_2 * destination, const matrix_2 * matrix_a, const matrix_2 * matrix_b) {
+static matrix_2 * matrix_2_subtract_to (matrix_2 * destination, matrix_2 * matrix_a, matrix_2 * matrix_b) {
 	for (uint row = 0; row < 2; ++row) {
 		for (uint column = 0; column < 2; ++column) {
 			destination [row] [column] = matrix_a [row] [column] - matrix_b [row] [column];
@@ -366,7 +366,7 @@ static matrix_2 * matrix_2_subtract_to (matrix_2 * destination, const matrix_2 *
 	return (destination);
 }
 
-static matrix_3 * matrix_3_subtract_to (matrix_3 * destination, const matrix_3 * matrix_a, const matrix_3 * matrix_b) {
+static matrix_3 * matrix_3_subtract_to (matrix_3 * destination, matrix_3 * matrix_a, matrix_3 * matrix_b) {
 	for (uint row = 0; row < 3; ++row) {
 		for (uint column = 0; column < 3; ++column) {
 			destination [row] [column] = matrix_a [row] [column] - matrix_b [row] [column];
@@ -376,7 +376,7 @@ static matrix_3 * matrix_3_subtract_to (matrix_3 * destination, const matrix_3 *
 	return (destination);
 }
 
-static matrix_4 * matrix_4_subtract_to (matrix_4 * destination, const matrix_4 * matrix_a, const matrix_4 * matrix_b) {
+static matrix_4 * matrix_4_subtract_to (matrix_4 * destination, matrix_4 * matrix_a, matrix_4 * matrix_b) {
 	for (uint row = 0; row < 4; ++row) {
 		for (uint column = 0; column < 4; ++column) {
 			destination [row] [column] = matrix_a [row] [column] - matrix_b [row] [column];
@@ -386,7 +386,7 @@ static matrix_4 * matrix_4_subtract_to (matrix_4 * destination, const matrix_4 *
 	return (destination);
 }
 
-static matrix_2 * matrix_2_multiply (matrix_2 * result, const matrix_2 * matrix_a, const matrix_2 * matrix_b) {
+static matrix_2 * matrix_2_multiply (matrix_2 * result, matrix_2 * matrix_a, matrix_2 * matrix_b) {
 	for (uint row = 0; row < 2; ++row) {
 		for (uint column = 0; column < 2; ++column) {
 			result [row] [column] = 0.0f;
@@ -400,7 +400,7 @@ static matrix_2 * matrix_2_multiply (matrix_2 * result, const matrix_2 * matrix_
 	return (result);
 }
 
-static matrix_3 * matrix_3_multiply (matrix_3 * result, const matrix_3 * matrix_a, const matrix_3 * matrix_b) {
+static matrix_3 * matrix_3_multiply (matrix_3 * result, matrix_3 * matrix_a, matrix_3 * matrix_b) {
 	for (uint row = 0; row < 3; ++row) {
 		for (uint column = 0; column < 3; ++column) {
 			result [row] [column] = 0.0f;
@@ -414,7 +414,7 @@ static matrix_3 * matrix_3_multiply (matrix_3 * result, const matrix_3 * matrix_
 	return (result);
 }
 
-static matrix_4 * matrix_4_multiply (matrix_4 * result, const matrix_4 * matrix_a, const matrix_4 * matrix_b) {
+static matrix_4 * matrix_4_multiply (matrix_4 * result, matrix_4 * matrix_a, matrix_4 * matrix_b) {
 	for (uint row = 0; row < 4; ++row) {
 		for (uint column = 0; column < 4; ++column) {
 			result [row] [column] = 0.0f;
@@ -428,19 +428,19 @@ static matrix_4 * matrix_4_multiply (matrix_4 * result, const matrix_4 * matrix_
 	return (result);
 }
 
-static float matrix_2_trace (const matrix_2 * matrix) {
+static float matrix_2_trace (matrix_2 * matrix) {
 	return (matrix [0] [0] + matrix [1] [1]);
 }
 
-static float matrix_3_trace (const matrix_3 * matrix) {
+static float matrix_3_trace (matrix_3 * matrix) {
 	return (matrix [0] [0] + matrix [1] [1] + matrix [2] [2]);
 }
 
-static float matrix_4_trace (const matrix_4 * matrix) {
+static float matrix_4_trace (matrix_4 * matrix) {
 	return (matrix [0] [0] + matrix [1] [1] + matrix [2] [2] + matrix [3] [3]);
 }
 
-static bool matrix_2_compare (const matrix_2 * matrix_a, const matrix_2 * matrix_b) {
+static bool matrix_2_compare (matrix_2 * matrix_a, matrix_2 * matrix_b) {
 	for (uint row = 0; row < 2; ++row) {
 		for (uint column = 0; column < 2; ++column) {
 			if (matrix_a [row] [column] != matrix_b [row] [column]) {
@@ -452,7 +452,7 @@ static bool matrix_2_compare (const matrix_2 * matrix_a, const matrix_2 * matrix
 	return (true);
 }
 
-static bool matrix_3_compare (const matrix_3 * matrix_a, const matrix_3 * matrix_b) {
+static bool matrix_3_compare (matrix_3 * matrix_a, matrix_3 * matrix_b) {
 	for (uint row = 0; row < 3; ++row) {
 		for (uint column = 0; column < 3; ++column) {
 			if (matrix_a [row] [column] != matrix_b [row] [column]) {
@@ -464,7 +464,7 @@ static bool matrix_3_compare (const matrix_3 * matrix_a, const matrix_3 * matrix
 	return (true);
 }
 
-static bool matrix_4_compare (const matrix_4 * matrix_a, const matrix_4 * matrix_b) {
+static bool matrix_4_compare (matrix_4 * matrix_a, matrix_4 * matrix_b) {
 	for (uint row = 0; row < 4; ++row) {
 		for (uint column = 0; column < 4; ++column) {
 			if (matrix_a [row] [column] != matrix_b [row] [column]) {
diff --git a/xcript.h b/xcript.h
index 6266e06..a644192 100755
--- a/xcript.h
+++ b/xcript.h
@@ -41,13 +41,13 @@ typedef struct {
 	uint   * index;
 } script_information;
 
-static void script_warning (const script_structure * script, bool condition, const char * message) {
+static void script_warning (script_structure * script, bool condition, char * message) {
 	if (condition == true) {
 		print ("[/3Warning/-] %s: %i: %s\n", script->path, script->line, message);
 	}
 }
 
-static void script_failure (const script_structure * script, bool condition, const char * message) {
+static void script_failure (script_structure * script, bool condition, char * message) {
 	if (condition == true) {
 		print ("[/1Failure/-] %s: %i: %s\n", script->path, script->line, message);
 
@@ -57,7 +57,7 @@ static void script_failure (const script_structure * script, bool condition, con
 	}
 }
 
-static script_structure * script_open (const char * path) {
+static script_structure * script_open (char * path) {
 	script_structure * script = allocate (sizeof (* script));
 
 	script->path   = string_duplicate (path);
@@ -81,23 +81,23 @@ static script_structure * script_close (script_structure * script) {
 	return (deallocate (script));
 }
 
-static bool script_compare (const script_structure * script, const char * string) {
+static bool script_compare (script_structure * script, char * string) {
 	return (string_compare_limit (string, script->last_string, script->last_length));
 }
 
-static bool script_check (const script_information * information, uint index, const char * identifier) {
+static bool script_check (script_information * information, uint index, char * identifier) {
 	return (string_compare (identifier, information->identifier [index]));
 }
 
-static char * script_export_string (const script_structure * script) {
+static char * script_export_string (script_structure * script) {
 	return (string_duplicate_limit (script->last_string, script->last_length));
 }
 
-static uint script_export_number (const script_structure * script) {
+static uint script_export_number (script_structure * script) {
 	return (string_limit_to_number (script->last_string, script->last_length));
 }
 
-static uint script_export_marker (const script_information * information, const script_structure * script) {
+static uint script_export_marker (script_information * information, script_structure * script) {
 	for (uint counter = 0; counter < information->counter; ++counter) {
 		if (script_compare (script, information->identifier [counter]) == true) {
 			return (information->index [counter]);
@@ -207,7 +207,7 @@ static script_word_type script_parser (script_structure * script) {
 	return (word);
 }
 
-static char * script_expect_header (script_information * information, const script_structure * script, uint index, bool accept) {
+static char * script_expect_header (script_information * information, script_structure * script, uint index, bool accept) {
 	if (accept == true) {
 		++information->counter;
 
@@ -239,7 +239,7 @@ static uint script_expect_number (script_structure * script) {
 	return (script_export_number (script));
 }
 
-static uint script_expect_marker (const script_information * information, script_structure * script) {
+static uint script_expect_marker (script_information * information, script_structure * script) {
 	script_word_type word = script_unknown;
 
 	script_failure (script, (word = script_parser (script)) != script_assign, "Expected '=', assignment operator.");
@@ -248,7 +248,7 @@ static uint script_expect_marker (const script_information * information, script
 	return (script_export_marker (information, script));
 }
 
-static uint script_expect_number_or_marker (const script_information * information, script_structure * script) {
+static uint script_expect_number_or_marker (script_information * information, script_structure * script) {
 	script_word_type word = script_unknown;
 
 	script_failure (script, (word = script_parser (script)) != script_assign, "Expected '=', assignment operator.");
@@ -266,7 +266,7 @@ static uint script_expect_number_or_marker (const script_information * informati
 	return (~ 0u);
 }
 
-static uint * script_expect_ordered_array (const script_information * information, script_structure * script, uint * count) {
+static uint * script_expect_ordered_array (script_information * information, script_structure * script, uint * count) {
 	script_word_type word = script_unknown;
 
 	uint   found = 0;
@@ -299,7 +299,7 @@ static uint * script_expect_ordered_array (const script_information * informatio
 	return (array);
 }
 
-static uint * script_expect_unordered_array (const script_information * information, script_structure * script, uint count) {
+static uint * script_expect_unordered_array (script_information * information, script_structure * script, uint count) {
 	script_word_type word = script_unknown;
 
 	uint * array = allocate (count * sizeof (* array));
@@ -333,7 +333,7 @@ static uint * script_expect_unordered_array (const script_information * informat
 	return (array);
 }
 
-static script_information * script_initialize (const char * general_script_file_path) {
+static script_information * script_initialize (char * general_script_file_path) {
 	script_information * script = allocate (sizeof (* script));
 
 	script_word_type word = script_unknown;
@@ -370,7 +370,7 @@ static script_information * script_deinitialize (script_information * script) {
 	return (deallocate (script));
 }
 
-static uint script_indexer (script_information * information, const char * identifier) {
+static uint script_indexer (script_information * information, char * identifier) {
 	for (uint counter = 0; counter < information->counter; ++counter) {
 		if (string_compare (identifier, information->identifier [counter]) == true) {
 			return (information->index [counter]);
diff --git a/xctree.h b/xctree.h
new file mode 100644
index 0000000..8009fa5
--- /dev/null
+++ b/xctree.h
@@ -0,0 +1,32 @@
+///           _
+/// __  _____| |_ _ __ ___  ___
+/// \ \/ / __| __| '__/ _ \/ _ \
+///  >  < (__| |_| | |  __/  __/
+/// /_/\_\___|\__|_|  \___|\___|
+///
+/// Copyright (c) 1997 - Ognjen 'xolatile' Milan Robovic
+///
+/// xolatile@chud.cyou - xctree - Whitespace insignificant INI/CFG-like script parser.
+///
+/// This program is free software, free as in freedom and as in free beer, you can redistribute it and/or modify it under the terms of the GNU
+/// General Public License as published by the Free Software Foundation, either version 3 of the License, or any later version if you wish...
+///
+/// This program is distributed in the hope that it will be useful, but it is probably not, and without any warranty, without even the implied
+/// warranty of merchantability or fitness for a particular purpose, because it is pointless. Please see the GNU (Geenoo) General Public License
+/// for more details, if you dare, it is a lot of text that nobody wants to read...
+
+typedef struct {
+	bool         division;
+	float        scale;
+	vector_3 * * vertex;
+	vector_3   * origin;
+	vector_3   * offset;
+
+	struct octree_node * children [8];
+} octree_node;
+
+typedef struct {
+	uint            count;
+	uint            limit;
+	octree_node * * array;
+} octree_structure;
diff --git a/xector.h b/xector.h
index 22e49b6..d774a0a 100755
--- a/xector.h
+++ b/xector.h
@@ -69,32 +69,32 @@ static vector_4 * vector_4_nullify (vector_4 * destination) {
 	return (destination);
 }
 
-static float vector_2_length (const vector_2 * vector) {
-	const float x = vector->x;
-	const float y = vector->y;
+static float vector_2_length (vector_2 * vector) {
+	float x = vector->x;
+	float y = vector->y;
 
 	return (square_root (x * x + y * y));
 }
 
-static float vector_3_length (const vector_3 * vector) {
-	const float x = vector->x;
-	const float y = vector->y;
-	const float z = vector->z;
+static float vector_3_length (vector_3 * vector) {
+	float x = vector->x;
+	float y = vector->y;
+	float z = vector->z;
 
 	return (square_root (x * x + y * y + z * z));
 }
 
-static float vector_4_length (const vector_4 * vector) {
-	const float x = vector->x;
-	const float y = vector->y;
-	const float z = vector->z;
-	const float w = vector->w;
+static float vector_4_length (vector_4 * vector) {
+	float x = vector->x;
+	float y = vector->y;
+	float z = vector->z;
+	float w = vector->w;
 
 	return (square_root (x * x + y * y + z * z + w * w));
 }
 
 static vector_2 * vector_2_normalize (vector_2 * destination) {
-	const float length = vector_2_length (destination);
+	float length = vector_2_length (destination);
 
 	destination->x /= length;
 	destination->y /= length;
@@ -103,7 +103,7 @@ static vector_2 * vector_2_normalize (vector_2 * destination) {
 }
 
 static vector_3 * vector_3_normalize (vector_3 * destination) {
-	const float length = vector_3_length (destination);
+	float length = vector_3_length (destination);
 
 	destination->x /= length;
 	destination->y /= length;
@@ -113,7 +113,7 @@ static vector_3 * vector_3_normalize (vector_3 * destination) {
 }
 
 static vector_4 * vector_4_normalize (vector_4 * destination) {
-	const float length = vector_4_length (destination);
+	float length = vector_4_length (destination);
 
 	destination->x /= length;
 	destination->y /= length;
@@ -123,8 +123,8 @@ static vector_4 * vector_4_normalize (vector_4 * destination) {
 	return (destination);
 }
 
-static vector_2 * vector_2_normalize_to (vector_2 * destination, const vector_2 * source) {
-	const float length = vector_2_length (source);
+static vector_2 * vector_2_normalize_to (vector_2 * destination, vector_2 * source) {
+	float length = vector_2_length (source);
 
 	destination->x = source->x / length;
 	destination->y = source->y / length;
@@ -132,8 +132,8 @@ static vector_2 * vector_2_normalize_to (vector_2 * destination, const vector_2
 	return (destination);
 }
 
-static vector_3 * vector_3_normalize_to (vector_3 * destination, const vector_3 * source) {
-	const float length = vector_3_length (source);
+static vector_3 * vector_3_normalize_to (vector_3 * destination, vector_3 * source) {
+	float length = vector_3_length (source);
 
 	destination->x = source->x / length;
 	destination->y = source->y / length;
@@ -142,8 +142,8 @@ static vector_3 * vector_3_normalize_to (vector_3 * destination, const vector_3
 	return (destination);
 }
 
-static vector_4 * vector_4_normalize_to (vector_4 * destination, const vector_4 * source) {
-	const float length = vector_4_length (source);
+static vector_4 * vector_4_normalize_to (vector_4 * destination, vector_4 * source) {
+	float length = vector_4_length (source);
 
 	destination->x = source->x / length;
 	destination->y = source->y / length;
@@ -153,14 +153,14 @@ static vector_4 * vector_4_normalize_to (vector_4 * destination, const vector_4
 	return (destination);
 }
 
-static vector_2 * vector_2_copy (vector_2 * destination, const vector_2 * source) {
+static vector_2 * vector_2_copy (vector_2 * destination, vector_2 * source) {
 	destination->x = source->x;
 	destination->y = source->y;
 
 	return (destination);
 }
 
-static vector_3 * vector_3_copy (vector_3 * destination, const vector_3 * source) {
+static vector_3 * vector_3_copy (vector_3 * destination, vector_3 * source) {
 	destination->x = source->x;
 	destination->y = source->y;
 	destination->z = source->z;
@@ -168,7 +168,7 @@ static vector_3 * vector_3_copy (vector_3 * destination, const vector_3 * source
 	return (destination);
 }
 
-static vector_4 * vector_4_copy (vector_4 * destination, const vector_4 * source) {
+static vector_4 * vector_4_copy (vector_4 * destination, vector_4 * source) {
 	destination->x = source->x;
 	destination->y = source->y;
 	destination->z = source->z;
@@ -219,14 +219,14 @@ static vector_4 * vector_4_scale (vector_4 * destination, float scale) {
 	return (destination);
 }
 
-static vector_2 * vector_2_scale_to (vector_2 * destination, const vector_2 * source, float scale) {
+static vector_2 * vector_2_scale_to (vector_2 * destination, vector_2 * source, float scale) {
 	destination->x = source->x * scale;
 	destination->y = source->y * scale;
 
 	return (destination);
 }
 
-static vector_3 * vector_3_scale_to (vector_3 * destination, const vector_3 * source, float scale) {
+static vector_3 * vector_3_scale_to (vector_3 * destination, vector_3 * source, float scale) {
 	destination->x = source->x * scale;
 	destination->y = source->y * scale;
 	destination->z = source->z * scale;
@@ -234,7 +234,7 @@ static vector_3 * vector_3_scale_to (vector_3 * destination, const vector_3 * so
 	return (destination);
 }
 
-static vector_4 * vector_4_scale_to (vector_4 * destination, const vector_4 * source, float scale) {
+static vector_4 * vector_4_scale_to (vector_4 * destination, vector_4 * source, float scale) {
 	destination->x = source->x * scale;
 	destination->y = source->y * scale;
 	destination->z = source->z * scale;
@@ -243,14 +243,14 @@ static vector_4 * vector_4_scale_to (vector_4 * destination, const vector_4 * so
 	return (destination);
 }
 
-static vector_2 * vector_2_add (vector_2 * destination, const vector_2 * source) {
+static vector_2 * vector_2_add (vector_2 * destination, vector_2 * source) {
 	destination->x += source->x;
 	destination->y += source->y;
 
 	return (destination);
 }
 
-static vector_3 * vector_3_add (vector_3 * destination, const vector_3 * source) {
+static vector_3 * vector_3_add (vector_3 * destination, vector_3 * source) {
 	destination->x += source->x;
 	destination->y += source->y;
 	destination->z += source->z;
@@ -258,7 +258,7 @@ static vector_3 * vector_3_add (vector_3 * destination, const vector_3 * source)
 	return (destination);
 }
 
-static vector_4 * vector_4_add (vector_4 * destination, const vector_4 * source) {
+static vector_4 * vector_4_add (vector_4 * destination, vector_4 * source) {
 	destination->x += source->x;
 	destination->y += source->y;
 	destination->z += source->z;
@@ -267,14 +267,14 @@ static vector_4 * vector_4_add (vector_4 * destination, const vector_4 * source)
 	return (destination);
 }
 
-static vector_2 * vector_2_add_to (vector_2 * destination, const vector_2 * vector_a, const vector_2 * vector_b) {
+static vector_2 * vector_2_add_to (vector_2 * destination, vector_2 * vector_a, vector_2 * vector_b) {
 	destination->x = vector_a->x + vector_b->x;
 	destination->y = vector_a->y + vector_b->y;
 
 	return (destination);
 }
 
-static vector_3 * vector_3_add_to (vector_3 * destination, const vector_3 * vector_a, const vector_3 * vector_b) {
+static vector_3 * vector_3_add_to (vector_3 * destination, vector_3 * vector_a, vector_3 * vector_b) {
 	destination->x = vector_a->x + vector_b->x;
 	destination->y = vector_a->y + vector_b->y;
 	destination->z = vector_a->z + vector_b->z;
@@ -282,7 +282,7 @@ static vector_3 * vector_3_add_to (vector_3 * destination, const vector_3 * vect
 	return (destination);
 }
 
-static vector_4 * vector_4_add_to (vector_4 * destination, const vector_4 * vector_a, const vector_4 * vector_b) {
+static vector_4 * vector_4_add_to (vector_4 * destination, vector_4 * vector_a, vector_4 * vector_b) {
 	destination->x = vector_a->x + vector_b->x;
 	destination->y = vector_a->y + vector_b->y;
 	destination->z = vector_a->z + vector_b->z;
@@ -291,14 +291,14 @@ static vector_4 * vector_4_add_to (vector_4 * destination, const vector_4 * vect
 	return (destination);
 }
 
-static vector_2 * vector_2_subtract (vector_2 * destination, const vector_2 * source) {
+static vector_2 * vector_2_subtract (vector_2 * destination, vector_2 * source) {
 	destination->x -= source->x;
 	destination->y -= source->y;
 
 	return (destination);
 }
 
-static vector_3 * vector_3_subtract (vector_3 * destination, const vector_3 * source) {
+static vector_3 * vector_3_subtract (vector_3 * destination, vector_3 * source) {
 	destination->x -= source->x;
 	destination->y -= source->y;
 	destination->z -= source->z;
@@ -306,7 +306,7 @@ static vector_3 * vector_3_subtract (vector_3 * destination, const vector_3 * so
 	return (destination);
 }
 
-static vector_4 * vector_4_subtract (vector_4 * destination, const vector_4 * source) {
+static vector_4 * vector_4_subtract (vector_4 * destination, vector_4 * source) {
 	destination->x -= source->x;
 	destination->y -= source->y;
 	destination->z -= source->z;
@@ -315,14 +315,14 @@ static vector_4 * vector_4_subtract (vector_4 * destination, const vector_4 * so
 	return (destination);
 }
 
-static vector_2 * vector_2_subtract_to (vector_2 * destination, const vector_2 * vector_a, const vector_2 * vector_b) {
+static vector_2 * vector_2_subtract_to (vector_2 * destination, vector_2 * vector_a, vector_2 * vector_b) {
 	destination->x = vector_a->x - vector_b->x;
 	destination->y = vector_a->y - vector_b->y;
 
 	return (destination);
 }
 
-static vector_3 * vector_3_subtract_to (vector_3 * destination, const vector_3 * vector_a, const vector_3 * vector_b) {
+static vector_3 * vector_3_subtract_to (vector_3 * destination, vector_3 * vector_a, vector_3 * vector_b) {
 	destination->x = vector_a->x - vector_b->x;
 	destination->y = vector_a->y - vector_b->y;
 	destination->z = vector_a->z - vector_b->z;
@@ -330,7 +330,7 @@ static vector_3 * vector_3_subtract_to (vector_3 * destination, const vector_3 *
 	return (destination);
 }
 
-static vector_4 * vector_4_subtract_to (vector_4 * destination, const vector_4 * vector_a, const vector_4 * vector_b) {
+static vector_4 * vector_4_subtract_to (vector_4 * destination, vector_4 * vector_a, vector_4 * vector_b) {
 	destination->x = vector_a->x - vector_b->x;
 	destination->y = vector_a->y - vector_b->y;
 	destination->z = vector_a->z - vector_b->z;
@@ -339,7 +339,7 @@ static vector_4 * vector_4_subtract_to (vector_4 * destination, const vector_4 *
 	return (destination);
 }
 
-static bool vector_2_compare (const vector_2 * vector_a, const vector_2 * vector_b) {
+static bool vector_2_compare (vector_2 * vector_a, vector_2 * vector_b) {
 	if ((vector_a->x == vector_b->x) && (vector_a->y == vector_b->y)) {
 		return (true);
 	} else {
@@ -347,7 +347,7 @@ static bool vector_2_compare (const vector_2 * vector_a, const vector_2 * vector
 	}
 }
 
-static bool vector_3_compare (const vector_3 * vector_a, const vector_3 * vector_b) {
+static bool vector_3_compare (vector_3 * vector_a, vector_3 * vector_b) {
 	if ((vector_a->x == vector_b->x) && (vector_a->y == vector_b->y) && (vector_a->z == vector_b->z)) {
 		return (true);
 	} else {
@@ -355,7 +355,7 @@ static bool vector_3_compare (const vector_3 * vector_a, const vector_3 * vector
 	}
 }
 
-static bool vector_4_compare (const vector_4 * vector_a, const vector_4 * vector_b) {
+static bool vector_4_compare (vector_4 * vector_a, vector_4 * vector_b) {
 	if ((vector_a->x == vector_b->x) && (vector_a->y == vector_b->y) && (vector_a->z == vector_b->z) && (vector_a->w == vector_b->w)) {
 		return (true);
 	} else {
@@ -363,23 +363,23 @@ static bool vector_4_compare (const vector_4 * vector_a, const vector_4 * vector
 	}
 }
 
-static float vector_2_dot_product (const vector_2 * vector_a, const vector_2 * vector_b) {
+static float vector_2_dot_product (vector_2 * vector_a, vector_2 * vector_b) {
 	return (vector_a->x * vector_b->x + vector_a->y * vector_b->y);
 }
 
-static float vector_3_dot_product (const vector_3 * vector_a, const vector_3 * vector_b) {
+static float vector_3_dot_product (vector_3 * vector_a, vector_3 * vector_b) {
 	return (vector_a->x * vector_b->x + vector_a->y * vector_b->y + vector_a->z * vector_b->z);
 }
 
-static float vector_4_dot_product (const vector_4 * vector_a, const vector_4 * vector_b) {
+static float vector_4_dot_product (vector_4 * vector_a, vector_4 * vector_b) {
 	return (vector_a->x * vector_b->x + vector_a->y * vector_b->y + vector_a->z * vector_b->z + vector_a->w * vector_b->w);
 }
 
-static float vector_2_cross_product (const vector_2 * vector_a, const vector_2 * vector_b) {
+static float vector_2_cross_product (vector_2 * vector_a, vector_2 * vector_b) {
 	return (vector_a->x * vector_b->y - vector_a->y * vector_b->x);
 }
 
-static vector_3 * vector_3_cross_product (vector_3 * destination, const vector_3 * source) {
+static vector_3 * vector_3_cross_product (vector_3 * destination, vector_3 * source) {
 	destination->x = destination->y * source->z - destination->z * source->y;
 	destination->y = destination->z * source->x - destination->x * source->z;
 	destination->z = destination->x * source->y - destination->y * source->x;
diff --git a/xerminal.h b/xerminal.h
index fb402a8..e1a4cda 100755
--- a/xerminal.h
+++ b/xerminal.h
@@ -208,8 +208,8 @@ static void terminal_render_character (terminal_structure * terminal, char chara
 }
 
 static void terminal_render_toggle (terminal_structure * terminal, bool toggle, uint x, uint y) {
-	const char marker = (toggle == true) ? '+'          : '-';
-	const char colour = (toggle == true) ? colour_green : colour_red;
+	char marker = (toggle == true) ? '+'          : '-';
+	char colour = (toggle == true) ? colour_green : colour_red;
 
 	terminal_render_character (terminal, '[',    colour_grey, effect_bold, x + 0, y);
 	terminal_render_character (terminal, marker, colour,      effect_bold, x + 1, y);
@@ -225,7 +225,7 @@ static void terminal_render_fill_bar (terminal_structure * terminal, uint value,
 	}
 }
 
-static void terminal_render_string (terminal_structure * terminal, const char * string, uint colour, uint effect, uint x, uint y) {
+static void terminal_render_string (terminal_structure * terminal, char * string, uint colour, uint effect, uint x, uint y) {
 	for (uint index = 0; string [index] != '\0'; ++index) {
 		terminal_render_character (terminal, string [index], colour, effect, x + index, y);
 	}
@@ -235,7 +235,7 @@ static void terminal_render_number (terminal_structure * terminal, int number, u
 	terminal_render_string (terminal, number_to_string (number), colour, effect, x, y);
 }
 
-static void terminal_render_string_crop (terminal_structure * terminal, const char * string, uint colour, uint effect, uint x, uint y, uint crop) {
+static void terminal_render_string_crop (terminal_structure * terminal, char * string, uint colour, uint effect, uint x, uint y, uint crop) {
 	for (uint index = 0; (string [index] != '\0') && (index < crop); ++index) {
 		terminal_render_character (terminal, string [index], colour, effect, x + index, y);
 	}
@@ -280,7 +280,7 @@ static void terminal_render_background (terminal_structure * terminal, char char
 	}
 }
 
-static void terminal_render_format (terminal_structure * terminal, const char * format, uint x, uint y, ...) {
+static void terminal_render_format (terminal_structure * terminal, char * format, uint x, uint y, ...) {
 	va_list list;
 
 	uint offset_x = 0;
diff --git a/xhallenge.c b/xhallenge.c
index 2e97aa4..b530ec5 100755
--- a/xhallenge.c
+++ b/xhallenge.c
@@ -24,21 +24,21 @@ typedef struct {
 	char * * description;
 } challenge_structure;
 
-static const char * special_name [special_count] = {
+static char * special_name [special_count] = {
 	"strength",     "perception",   "edurance",     "charisma",     "intelligence", "agility",      "luck"
 };
 
-static bool challenge_is_repeatable (const challenge_structure * challenges, uint index) {
+static bool challenge_is_repeatable (challenge_structure * challenges, uint index) {
 	return ((challenges->type [index] == special_strength + 1) ||
 	        (challenges->type [index] == special_edurance + 1) ||
 	        (challenges->type [index] == special_agility  + 1));
 }
 
-static bool challenge_is_available (const challenge_structure * challenges, uint index) {
+static bool challenge_is_available (challenge_structure * challenges, uint index) {
 	return ((challenges->completed [index] == 0) || (challenge_is_repeatable (challenges, index) == true));
 }
 
-static bool challenge_is_completable (const uint * special, const challenge_structure * challenges, uint index) {
+static bool challenge_is_completable (uint * special, challenge_structure * challenges, uint index) {
 	if (challenge_is_available (challenges, index) == false) {
 		return (false);
 	}
@@ -52,7 +52,7 @@ static bool challenge_is_completable (const uint * special, const challenge_stru
 	return (true);
 }
 
-static void render_challenge_list (terminal_structure * terminal, const uint * special, const challenge_structure * challenges, uint x, uint y) {
+static void render_challenge_list (terminal_structure * terminal, uint * special, challenge_structure * challenges, uint x, uint y) {
 	uint   count = 0;
 	uint * array = allocate (challenges->count * sizeof (* array));
 
@@ -83,10 +83,10 @@ static void render_challenge_list (terminal_structure * terminal, const uint * s
 	array = deallocate (array);
 }
 
-static void render_special_attributes (terminal_structure * terminal, const uint * special, uint offset, uint selection) {
+static void render_special_attributes (terminal_structure * terminal, uint * special, uint offset, uint selection) {
 	for (uint index = 0; index < special_count; ++index) {
-		const uint effect = (selection == index) ? effect_bold : effect_normal;
-		const uint length = attribute_maximum + 3;
+		uint effect = (selection == index) ? effect_bold : effect_normal;
+		uint length = attribute_maximum + 3;
 
 		char name [32] = "";
 
@@ -104,7 +104,7 @@ static void prompt_special_attributes (uint * special) {
 	uint selection = 0;
 	bool show_help = false;
 
-	const char * main_messages [] = {
+	char * main_messages [] = {
 		"Press H or Tab to toggle help.",
 		"Press Q or Escape to use default settings.",
 		"Press S or Enter to save changes.",
@@ -112,7 +112,7 @@ static void prompt_special_attributes (uint * special) {
 		"Choose your SPECIAL attributes:"
 	};
 
-	const char * help_messages [] = {
+	char * help_messages [] = {
 		"Show help            - H or Tab",
 		"Use default settings - Q or Escape",
 		"Save and quit        - S or Enter",
@@ -137,7 +137,7 @@ static void prompt_special_attributes (uint * special) {
 
 		if (show_help == true) {
 			for (uint index = 0; index < array_length (help_messages); ++index) {
-				const uint offset = array_length  (main_messages) + special_count + 2;
+				uint offset = array_length  (main_messages) + special_count + 2;
 
 				terminal_render_string (terminal, help_messages [index], colour_white, effect_normal, 0, index + offset);
 			}
@@ -215,7 +215,7 @@ static void import_user_configuration (uint * special, uint challenge_count, uin
 	information = deallocate   (information);
 }
 
-static void export_user_configuration (const uint * special, const uint * daily_challenges, const bool * completition) {
+static void export_user_configuration (uint * special, uint * daily_challenges, bool * completition) {
 	char buffer [4096] = "";
 
 	for (uint index = 0; index < special_count; ++index) {
@@ -365,7 +365,7 @@ static void export_challenges (challenge_structure * challenges) {
 	file = file_close (file);
 }
 
-static uint generate_challenge (const uint * special, const challenge_structure * challenges) {
+static uint generate_challenge (uint * special, challenge_structure * challenges) {
 	uint index = urandomize (0, challenges->count - 1);
 	bool valid = false;
 
@@ -386,7 +386,7 @@ static uint generate_challenge (const uint * special, const challenge_structure
 	return (index);
 }
 
-static void generate_challenges (const uint * special, const challenge_structure * challenges, uint * * daily_challenges, bool * * completition) {
+static void generate_challenges (uint * special, challenge_structure * challenges, uint * * daily_challenges, bool * * completition) {
 	(* daily_challenges) = allocate (challenges_per_day * sizeof (* * daily_challenges));
 	(* completition)     = allocate (challenges_per_day * sizeof (* * completition));
 
@@ -395,14 +395,14 @@ static void generate_challenges (const uint * special, const challenge_structure
 	}
 }
 
-static void render_challenges (const uint * special, challenge_structure * challenges, uint * daily_challenges, bool * completition) {
+static void render_challenges (uint * special, challenge_structure * challenges, uint * daily_challenges, bool * completition) {
 	terminal_structure * terminal = terminal_initialize ();
 
 	uint selection = 0;
 	bool show_help = false;
 	bool show_list = false;
 
-	const char * main_messages [] = {
+	char * main_messages [] = {
 		"Press H or Tab to toggle help.",
 		"Press Q or Escape to quit the program without saving changes.",
 		"Press S or Enter to save changes and quit the program.",
@@ -410,7 +410,7 @@ static void render_challenges (const uint * special, challenge_structure * chall
 		"Your daily challenges:"
 	};
 
-	const char * help_messages [] = {
+	char * help_messages [] = {
 		"Show help          - H or Tab",
 		"Quit               - Q or Escape",
 		"Save and quit      - S or Enter",
@@ -434,11 +434,11 @@ static void render_challenges (const uint * special, challenge_structure * chall
 			char * class       = challenges->class       [daily_challenges [index]];
 			char * description = challenges->description [daily_challenges [index]];
 
-			const uint effect = (selection == index) ? effect_bold  : effect_normal;
+			uint effect = (selection == index) ? effect_bold  : effect_normal;
 
-			const uint offset = array_length (main_messages) + 2;
+			uint offset = array_length (main_messages) + 2;
 
-			const uint alignment = string_length (class) + 4;
+			uint alignment = string_length (class) + 4;
 
 			terminal_render_toggle (terminal, completition [index], 0, index + offset);
 
@@ -452,7 +452,7 @@ static void render_challenges (const uint * special, challenge_structure * chall
 		}
 
 		if (show_help == true) {
-			const uint offset = array_length (main_messages) + challenges_per_day + 3;
+			uint offset = array_length (main_messages) + challenges_per_day + 3;
 
 			for (uint index = 0; index < array_length (help_messages); ++index) {
 				terminal_render_string (terminal, help_messages [index], colour_white, effect_normal, 0, index + offset);
diff --git a/xhape.h b/xhape.h
new file mode 100644
index 0000000..f8fe666
--- /dev/null
+++ b/xhape.h
@@ -0,0 +1,175 @@
+///       _
+/// __  _| |__   __ _ _ __   ___
+/// \ \/ / '_ \ / _` | '_ \ / _ \
+///  >  <| | | | (_| | |_) |  __/
+/// /_/\_\_| |_|\__,_| .__/ \___|
+///                  |_|
+///
+/// Copyright (c) 1997 - Ognjen 'xolatile' Milan Robovic
+///
+/// xolatile@chud.cyou - xhape - Simplistic programmer art 3D model creator library.
+///
+/// This program is free software, free as in freedom and as in free beer, you can redistribute it and/or modify it under the terms of the GNU
+/// General Public License as published by the Free Software Foundation, either version 3 of the License, or any later version if you wish...
+///
+/// This program is distributed in the hope that it will be useful, but it is probably not, and without any warranty, without even the implied
+/// warranty of merchantability or fitness for a particular purpose, because it is pointless. Please see the GNU (Geenoo) General Public License
+/// for more details, if you dare, it is a lot of text that nobody wants to read...
+
+typedef struct {
+	uint    vertex_count;
+	uint    index_count;
+	uint    vertex_limit;
+	uint    index_limit;
+	float * vertex_array;
+	uint  * index_array;
+} shape_node;
+
+static shape_node * shape_allocate (uint vertex_limit, uint index_limit) {
+	shape_node * shape = allocate (sizeof (* shape));
+
+	shape->vertex_limit = vertex_limit;
+	shape->index_limit  = index_limit;
+
+	shape->vertex_array = allocate (vertex_limit * sizeof (* shape->vertex_array));
+	shape->index_array  = allocate (index_limit  * sizeof (* shape->index_array));
+
+	return (shape);
+}
+
+static shape_node * shape_deallocate (shape_node * shape) {
+	shape->vertex_array = deallocate (shape->vertex_array);
+	shape->index_array  = deallocate (shape->index_array);
+
+	return (deallocate (shape));
+}
+
+static void shape_add_vertex_unwrap_colour (shape_node * shape, float x, float y, float z, float u, float v, uint colour) {
+	fatal_failure (shape->vertex_count + 9 > shape->vertex_limit, "shape_add_vertex");
+
+	if (shape->vertex_count + 9 > shape->vertex_limit) return;
+
+	shape->vertex_array [shape->vertex_count + 0] = x;
+	shape->vertex_array [shape->vertex_count + 1] = y;
+	shape->vertex_array [shape->vertex_count + 2] = z;
+	shape->vertex_array [shape->vertex_count + 3] = u;
+	shape->vertex_array [shape->vertex_count + 4] = v;
+	shape->vertex_array [shape->vertex_count + 5] = normal_r (colour);
+	shape->vertex_array [shape->vertex_count + 6] = normal_g (colour);
+	shape->vertex_array [shape->vertex_count + 7] = normal_b (colour);
+	shape->vertex_array [shape->vertex_count + 8] = normal_a (colour);
+
+	shape->vertex_count += 9;
+}
+
+static void shape_add_index (shape_node * shape, uint a, uint b, uint c) {
+	fatal_failure (shape->index_count + 3 > shape->index_limit, "shape_add_index");
+
+	if (shape->index_count + 3 > shape->index_limit) return;
+
+	shape->index_array [shape->index_count + 0] = a;
+	shape->index_array [shape->index_count + 1] = b;
+	shape->index_array [shape->index_count + 2] = c;
+
+	shape->index_count += 3;
+}
+
+//~static shape_node * shape_tetrahedron_unwrap (float x, float y, float z, float scale) {
+//~static shape_node * shape_tetrahedron_unwrap_colour (float x, float y, float z, float scale, uint colour) {
+static shape_node * shape_tetrahedron_colour (float x, float y, float z, float scale, uint colour) {
+	shape_node * shape = shape_allocate (4 * 9, 4 * 3);
+
+	float vertices [12] = {
+		x + scale, y + scale, z + scale,
+		x - scale, y - scale, z + scale,
+		x - scale, y + scale, z - scale,
+		x + scale, y - scale, z - scale
+	};
+
+	for (uint vertex = 0; vertex < 4; ++vertex) {
+		float x = vertices [3 * vertex + 0];
+		float y = vertices [3 * vertex + 1];
+		float z = vertices [3 * vertex + 2];
+		float u = (binary_sign (vertex >> 0) + 1.0f) / 2.0f;
+		float v = (binary_sign (vertex >> 1) + 1.0f) / 2.0f;
+
+		shape_add_vertex_unwrap_colour (shape, x, y, z, u, v, colour);
+	}
+
+	shape_add_index (shape, 0, 1, 2);
+	shape_add_index (shape, 0, 3, 1);
+	shape_add_index (shape, 0, 2, 3);
+	shape_add_index (shape, 1, 3, 2);
+
+	return (shape);
+}
+
+//~static shape_node * shape_square (vector_3 * origin, float scale, uint colour) {
+	//~shape_node * shape = shape_allocate (4, 2 * 3);
+
+	//~shape_set_origin (shape, origin);
+
+	//~float central = square_root (2.0f) * scale / 2.0f;
+
+	//~vector_4 normal_colour = {
+		//~normal_r (colour),
+		//~normal_b (colour),
+		//~normal_g (colour),
+		//~normal_a (colour)
+	//~};
+
+	//~for (uint vertex = 0; vertex < 4; ++vertex) {
+		//~vector_3 point = {
+			//~origin->x + binary_sign (vertex >> 0) * central,
+			//~origin->y + binary_sign (vertex >> 1) * central,
+			//~origin->z
+		//~};
+
+		//~vector_2 unwrap = {
+			//~(binary_sign (vertex >> 0) + 1.0f) / 2.0f,
+			//~(binary_sign (vertex >> 1) + 1.0f) / 2.0f
+		//~};
+
+		//~shape_add_vertex (shape, & point, & unwrap, & normal_colour);
+	//~}
+
+	//~shape_add_index (shape, 0, 1, 2);
+	//~shape_add_index (shape, 1, 3, 2);
+
+	//~return (shape);
+//~}
+
+//~static shape_node * shape_cube (vector_3 * origin, float scale, uint colour) {
+	//~shape_node * shape = shape_allocate (8, 12 * 3);
+
+	//~shape_set_origin (shape, origin);
+
+	//~float central = square_root (3.0f) * scale / 2.0f;
+
+	//~vector_4 normal_colour = {
+		//~normal_r (colour),
+		//~normal_b (colour),
+		//~normal_g (colour),
+		//~normal_a (colour)
+	//~};
+
+	//~for (uint vertex = 0; vertex < 8; ++vertex) {
+		//~vector_3 point = {
+			//~origin->x + binary_sign (vertex >> 0) * central,
+			//~origin->y + binary_sign (vertex >> 1) * central,
+			//~origin->z + binary_sign (vertex >> 2) * central
+		//~};
+
+		//~vector_2 unwrap = {
+			//~0.0f,
+			//~0.0f
+		//~};
+
+		//~shape_add_vertex (shape, & point, & unwrap, & normal_colour);
+	//~}
+
+	//~shape_add_index (shape, 0, 1, 2);
+	//~shape_add_index (shape, 1, 3, 2);
+
+	//~return (shape);
+//~}
diff --git a/xiasma.h b/xiasma.h
index c699e27..de68aa4 100755
--- a/xiasma.h
+++ b/xiasma.h
@@ -313,7 +313,7 @@ static int build_single (int * array) {
 static int build_static_1 (int * array) {
 	int operation = array [0];
 
-	const unsigned char data  [] = {
+	unsigned char data  [] = {
 		0x90, 0xc3, 0xcb, 0xc9, 0x9d, 0x9c
 	};
 
@@ -325,7 +325,7 @@ static int build_static_1 (int * array) {
 static int build_static_2 (int * array) {
 	int operation = array [0];
 
-	const unsigned short data  [] = {
+	unsigned short data  [] = {
 		0x050f, 0xa20f, 0xd0d9, 0xe0d9, 0xe1d9, 0xe4d9, 0xe5d9, 0xe8d9,
 		0xe9d9, 0xead9, 0xebd9, 0xecd9, 0xedd9, 0xeed9, 0xf0d9, 0xf1d9,
 		0xf2d9, 0xf3d9, 0xf4d9, 0xf5d9, 0xf6d9, 0xf7d9, 0xf8d9, 0xf9d9,
diff --git a/xighlight.c b/xighlight.c
index aa792c6..c6178d3 100755
--- a/xighlight.c
+++ b/xighlight.c
@@ -44,13 +44,13 @@ static void print_help (void) {
 	print ("\t/6$ xighlight file.ext/-               /0---/- Language is automatically detected in this case.\n\n");
 	print ("Supported languages:\n\n");
 
-	for (uint index = 0; index < language_count; ++index) {
+	for (language_enumeration index = 0; index < language_count; ++index) {
 		char align [32] = "";
 
 		print ("\t/B/4%s/- /4%s/- /0---/- %s syntax highlighting\n",
-		       language_short_option (index),
-		       string_align_left (string_copy (align, language_long_option (index)), 9, ' '),
-		       language_identifier (index));
+		       language_short_option [index],
+		       string_align_left (string_copy (align, language_long_option [index]), 9, ' '),
+		       language_identifier [index]);
 	}
 }
 
@@ -78,8 +78,8 @@ int main (int argc, char * * argv) {
 		}
 
 		for (uint index = 0; index < language_count; ++index) {
-			if (argument_compare (argv [argument], language_short_option (index), language_long_option (index)) == true) {
-				(* (language_highlighter (index))) (language, syntax);
+			if (argument_compare (argv [argument], language_short_option [index], language_long_option [index]) == true) {
+				(* (language_highlighter [index])) (language, syntax);
 				select = index;
 				break;
 			}
diff --git a/xision.h b/xision.h
new file mode 100644
index 0000000..4e20795
--- /dev/null
+++ b/xision.h
@@ -0,0 +1,997 @@
+///       _     _
+/// __  _(_)___(_) ___  _ __
+/// \ \/ / / __| |/ _ \| '_ \
+///  >  <| \__ \ | (_) | | | |
+/// /_/\_\_|___/_|\___/|_| |_|
+///
+/// Copyright (c) 1997 - Ognjen 'xolatile' Milan Robovic
+///
+/// xolatile@chud.cyou - xision - General 3D GLFW, OpenGL and OpenAL wrapper library.
+///
+/// This program is free software, free as in freedom and as in free beer, you can redistribute it and/or modify it under the terms of the GNU
+/// General Public License as published by the Free Software Foundation, either version 3 of the License, or any later version if you wish...
+///
+/// This program is distributed in the hope that it will be useful, but it is probably not, and without any warranty, without even the implied
+/// warranty of merchantability or fitness for a particular purpose, because it is pointless. Please see the GNU (Geenoo) General Public License
+/// for more details, if you dare, it is a lot of text that nobody wants to read...
+
+#include <GLFW/glfw3.h>
+
+#define vision_font_width  (8)
+#define vision_font_height (16)
+
+typedef struct {
+	GLFWwindow * window;
+
+	PFNGLGENVERTEXARRAYSPROC         glGenVertexArrays;
+	PFNGLBINDVERTEXARRAYPROC         glBindVertexArray;
+	PFNGLGENBUFFERSPROC              glGenBuffers;
+	PFNGLBINDBUFFERPROC              glBindBuffer;
+	PFNGLCREATESHADERPROC            glCreateShader;
+	PFNGLSHADERSOURCEPROC            glShaderSource;
+	PFNGLCOMPILESHADERPROC           glCompileShader;
+	PFNGLCREATEPROGRAMPROC           glCreateProgram;
+	PFNGLATTACHSHADERPROC            glAttachShader;
+	PFNGLBINDFRAGDATALOCATIONPROC    glBindFragDataLocation;
+	PFNGLLINKPROGRAMPROC             glLinkProgram;
+	PFNGLUSEPROGRAMPROC              glUseProgram;
+	PFNGLGETATTRIBLOCATIONPROC       glGetAttribLocation;
+	PFNGLENABLEVERTEXATTRIBARRAYPROC glEnableVertexAttribArray;
+	PFNGLVERTEXATTRIBPOINTERPROC     glVertexAttribPointer;
+	PFNGLUNIFORM1IPROC               glUniform1i;
+	PFNGLUNIFORM1FPROC               glUniform1f;
+	PFNGLDELETEVERTEXARRAYSPROC      glDeleteVertexArrays;
+	PFNGLDELETEBUFFERSPROC           glDeleteBuffers;
+	PFNGLDELETESHADERPROC            glDeleteShader;
+	PFNGLDELETEPROGRAMPROC           glDeleteProgram;
+	PFNGLGETUNIFORMLOCATIONPROC      glGetUniformLocation;
+	PFNGLBUFFERDATAPROC              glBufferData;
+	PFNGLUNIFORMMATRIX4FVPROC        glUniformMatrix4fv;
+
+	bool signal [signal_count];
+	bool cursor [cursor_count];
+	int  cursor_x;
+	int  cursor_y;
+
+	bool      using_precomputed_spritesheet;
+	ulong     spritesheet_size;
+	ulong     vertex_limit;
+	ulong     index_limit;
+	uint      gameplay_framerate;
+	uint      animation_framerate;
+	uint      tab_width;
+	uint      default_font;
+	bool      active;
+	uint      window_width;
+	uint      window_height;
+	float     pixel_width;
+	float     pixel_height;
+	uint      framerate;
+	ulong     frame_time;
+	ulong     frame_begin;
+	ulong     frame_end;
+	uint      global_tick;
+	uint      gameplay_tick;
+	uint      animation_tick;
+	bool      freeze_cursor;
+	bool      freeze_signal;
+	uint      vertex_object;
+	uint      vertex_buffer;
+	uint      index_buffer;
+	uint      vertex_shader;
+	uint      fragment_shader;
+	uint      shader_program;
+	uint      spritesheet;
+	uint      vertex_count;
+	uint      index_count;
+	float   * vertex_array;
+	uint    * index_array;
+	uint      sprite_count;
+	uint      font_count;
+	uint    * spritesheet_data;
+	uint  * * sprite_data;
+	uint    * sprite_width;
+	uint    * sprite_height;
+	float   * sprite_u;
+	float   * sprite_v;
+	uint  * * font_index;
+	uint  * * font_width;
+	uint  * * font_height;
+	char    * font_begin;
+	char    * font_end;
+	float     projection_matrix [16];
+	float     movement_matrix   [16];
+	float     rotation_matrix   [16];
+	float     aspect_ratio;
+	float     field_of_view;
+	float     far_plane;
+	float     near_plane;
+	float     camera_x;
+	float     camera_y;
+	float     sensitivity;
+} vision_structure;
+
+static uint vision_sprite_raw_import (vision_structure * vision, uint * data, uint width, uint height) {
+	fatal_failure (vision->active == true, "vision_sprite_raw_import: OpenGL renderer is already initialized.");
+	fatal_failure (data           == null, "vision_sprite_raw_import: Data is null pointer.");
+	fatal_failure (width          == 0,    "vision_sprite_raw_import: Font image width is zero.");
+	fatal_failure (height         == 0,    "vision_sprite_raw_import: Font image height is zero.");
+
+	++vision->sprite_count;
+
+	vision->sprite_data   = reallocate (vision->sprite_data,   vision->sprite_count * sizeof (* vision->sprite_data));
+	vision->sprite_width  = reallocate (vision->sprite_width,  vision->sprite_count * sizeof (* vision->sprite_width));
+	vision->sprite_height = reallocate (vision->sprite_height, vision->sprite_count * sizeof (* vision->sprite_height));
+	vision->sprite_u      = reallocate (vision->sprite_u,      vision->sprite_count * sizeof (* vision->sprite_u));
+	vision->sprite_v      = reallocate (vision->sprite_v,      vision->sprite_count * sizeof (* vision->sprite_v));
+
+	vision->sprite_data   [vision->sprite_count - 1] = data;
+	vision->sprite_width  [vision->sprite_count - 1] = width;
+	vision->sprite_height [vision->sprite_count - 1] = height;
+	vision->sprite_u      [vision->sprite_count - 1] = 0;
+	vision->sprite_v      [vision->sprite_count - 1] = 0;
+
+	return (vision->sprite_count - 1);
+}
+
+static uint vision_font_raw_import (vision_structure * vision, uint * data, uint image_width, char begin, char end, uint empty) {
+	uint   pointer = 0;
+	uint   width   = 0;
+	uint   height  = 0;
+
+	fatal_failure (vision->active == true, "vision_font_raw_import: OpenGL renderer is already initialized.");
+	fatal_failure (data           == null, "vision_font_raw_import: Data is null pointer.");
+	fatal_failure (image_width    == 0,    "vision_font_raw_import: Font image width is zero.");
+	fatal_failure (begin          >= end,  "vision_font_raw_import: Font character range is inverted.");
+
+	++vision->font_count;
+
+	vision->font_index  = reallocate (vision->font_index,  vision->font_count * sizeof (* vision->font_index));
+	vision->font_width  = reallocate (vision->font_width,  vision->font_count * sizeof (* vision->font_width));
+	vision->font_height = reallocate (vision->font_height, vision->font_count * sizeof (* vision->font_height));
+	vision->font_begin  = reallocate (vision->font_begin,  vision->font_count * sizeof (* vision->font_begin));
+	vision->font_end    = reallocate (vision->font_end,    vision->font_count * sizeof (* vision->font_end));
+
+	vision->font_begin [vision->font_count - 1] = begin;
+	vision->font_end   [vision->font_count - 1] = end;
+
+	vision->font_index  [vision->font_count - 1] = allocate ((ulong) (end - begin + 1) * sizeof (* * vision->font_index));
+	vision->font_width  [vision->font_count - 1] = allocate ((ulong) (end - begin + 1) * sizeof (* * vision->font_width));
+	vision->font_height [vision->font_count - 1] = allocate ((ulong) (end - begin + 1) * sizeof (* * vision->font_height));
+
+	for (char index = begin; index <= end; ++index) {
+		for (          ; data [pointer]                        == empty; ++pointer);
+		for (width  = 0; data [pointer + width]                != empty; ++width);
+		for (height = 0; data [pointer + height * image_width] != empty; ++height);
+
+		uint * buffer = allocate (width * height * sizeof (* buffer));
+
+		for (uint y = 0; y < height; ++y) {
+			for (uint x = 0; x < width; ++x) {
+				buffer [y * width + x] = data [pointer + (y * image_width) + x];
+			}
+		}
+
+		vision->font_index  [vision->font_count - 1] [index - begin] = vision_sprite_raw_import (vision, buffer, width, height);
+		vision->font_width  [vision->font_count - 1] [index - begin] = width;
+		vision->font_height [vision->font_count - 1] [index - begin] = height;
+
+		pointer += width;
+
+		for (; data [pointer] == empty; ++pointer);
+
+		if (pointer % image_width == 2) {
+			pointer += height * image_width;
+		}
+	}
+
+	return (vision->font_count - 1);
+}
+
+static uint vision_sprite_import (vision_structure * vision, char * path) {
+	uint   width  = 0;
+	uint   height = 0;
+	uint * data   = null;
+
+	data = format_image_import (path, & width, & height);
+
+	return (vision_sprite_raw_import (vision, data, width, height));
+}
+
+static uint vision_font_import (vision_structure * vision, char * path, char begin, char end, uint colour) {
+	uint   width  = 0;
+	uint   height = 0;
+	uint   result = 0;
+	uint * data   = null;
+
+	data = format_image_import (path, & width, & height);
+
+	result = vision_font_raw_import (vision, data, width, begin, end, colour);
+
+	data = deallocate (data);
+
+	return (result);
+}
+
+static uint vision_sprite_width (vision_structure * vision, uint sprite) {
+	return (vision->sprite_width [sprite]);
+}
+
+static uint vision_sprite_height (vision_structure * vision, uint sprite) {
+	return (vision->sprite_height [sprite]);
+}
+
+static uint vision_center_x (vision_structure * vision, uint size) {
+	return ((vision->window_width - size) / 2);
+}
+
+static uint vision_center_y (vision_structure * vision, uint size) {
+	return ((vision->window_height - size) / 2);
+}
+
+static bool vision_cursor_inside (vision_structure * vision, int x, int y, uint width, uint height) {
+	return ((vision->cursor_x > x)               &&
+	        (vision->cursor_y > y)               &&
+	        (vision->cursor_x < x + (int) width) &&
+	        (vision->cursor_y < y + (int) height));
+}
+
+static bool vision_cursor_left_click (vision_structure * vision, int x, int y, uint width, uint height) {
+	if (vision->cursor [cursor_left] == true) {
+		vision->freeze_cursor = true;
+
+		return (vision_cursor_inside (vision, x, y, width, height) == true);
+	}
+
+	return (false);
+}
+
+static bool vision_cursor_right_click (vision_structure * vision, int x, int y, uint width, uint height) {
+	if (vision->cursor [cursor_right]) {
+		vision->freeze_cursor = true;
+
+		return (vision_cursor_inside (vision, x, y, width, height));
+	}
+
+	return (false);
+}
+
+static void vision_import_spritesheet (vision_structure * vision, char * data_file) {
+	int file = file_open (data_file, file_flag_read);
+
+	fatal_failure (vision->active == true, "vision_import_spritesheet: OpenGL renderer is already initialized.");
+
+	file_read (file, & vision->spritesheet_size, sizeof (vision->spritesheet_size));
+
+	file_read (file, & vision->sprite_count, sizeof (vision->sprite_count));
+
+	vision->sprite_width  = allocate (vision->sprite_count * sizeof (* vision->sprite_width));
+	vision->sprite_height = allocate (vision->sprite_count * sizeof (* vision->sprite_height));
+	vision->sprite_u      = allocate (vision->sprite_count * sizeof (* vision->sprite_u));
+	vision->sprite_v      = allocate (vision->sprite_count * sizeof (* vision->sprite_v));
+
+	file_read (file, vision->sprite_width,  vision->sprite_count * sizeof (* vision->sprite_width));
+	file_read (file, vision->sprite_height, vision->sprite_count * sizeof (* vision->sprite_height));
+	file_read (file, vision->sprite_u,      vision->sprite_count * sizeof (* vision->sprite_u));
+	file_read (file, vision->sprite_v,      vision->sprite_count * sizeof (* vision->sprite_v));
+
+	file_read (file, & vision->font_count, sizeof (vision->font_count));
+
+	vision->font_index  = allocate (vision->font_count * sizeof (* vision->font_index));
+	vision->font_width  = allocate (vision->font_count * sizeof (* vision->font_width));
+	vision->font_height = allocate (vision->font_count * sizeof (* vision->font_height));
+	vision->font_begin  = allocate (vision->font_count * sizeof (* vision->font_begin));
+	vision->font_end    = allocate (vision->font_count * sizeof (* vision->font_end));
+
+	file_read (file, vision->font_begin, vision->font_count * sizeof (* vision->font_begin));
+	file_read (file, vision->font_end,   vision->font_count * sizeof (* vision->font_end));
+
+	for (uint index = 0; index < vision->font_count; ++index) {
+		uint range = (uint) (vision->font_end [index] - vision->font_begin [index]) + 1;
+
+		vision->font_index  [index] = allocate (range * sizeof (* * vision->font_index));
+		vision->font_width  [index] = allocate (range * sizeof (* * vision->font_width));
+		vision->font_height [index] = allocate (range * sizeof (* * vision->font_height));
+
+		for (uint subindex = 0; subindex < range; ++subindex) {
+			file_read (file, & vision->font_index  [index] [subindex], sizeof (* * vision->font_index));
+			file_read (file, & vision->font_width  [index] [subindex], sizeof (* * vision->font_width));
+			file_read (file, & vision->font_height [index] [subindex], sizeof (* * vision->font_height));
+		}
+	}
+
+	file = file_close (file);
+
+	vision->sprite_count = 0;
+	vision->font_count   = 0;
+}
+
+static void vision_export_spritesheet (vision_structure * vision, char * data_file) {
+	int file = file_open (data_file, file_flag_write | file_flag_create | file_flag_truncate);
+
+	fatal_failure (vision->spritesheet_data == null, "vision_export_spritesheet: OpenGL renderer can't access spritesheet data.");
+
+	file_write (file, & vision->spritesheet_size, sizeof (vision->spritesheet_size));
+
+	file_write (file, & vision->sprite_count, sizeof (vision->sprite_count));
+
+	file_write (file, vision->sprite_width,  vision->sprite_count * sizeof (* vision->sprite_width));
+	file_write (file, vision->sprite_height, vision->sprite_count * sizeof (* vision->sprite_height));
+	file_write (file, vision->sprite_u,      vision->sprite_count * sizeof (* vision->sprite_u));
+	file_write (file, vision->sprite_v,      vision->sprite_count * sizeof (* vision->sprite_v));
+
+	file_write (file, & vision->font_count, sizeof (vision->font_count));
+
+	file_write (file, vision->font_begin, vision->font_count * sizeof (* vision->font_begin));
+	file_write (file, vision->font_end,   vision->font_count * sizeof (* vision->font_end));
+
+	for (uint index = 0; index < vision->font_count; ++index) {
+		for (uint subindex = 0; subindex < (uint) (vision->font_end [index] - vision->font_begin [index]) + 1; ++subindex) {
+			file_write (file, & vision->font_index  [index] [subindex], sizeof (* * vision->font_index));
+			file_write (file, & vision->font_width  [index] [subindex], sizeof (* * vision->font_width));
+			file_write (file, & vision->font_height [index] [subindex], sizeof (* * vision->font_height));
+		}
+	}
+
+	file = file_close (file);
+
+	print ("/c Exported internal binary data of OpenGL spritesheet.");
+}
+
+static vision_structure * vision_initialize (uint gameplay_framerate, uint animation_framerate, bool use_precomputed_spritesheet,
+                                             uint vertex_limit, uint index_limit, uint spritesheet_side) {
+	vision_structure * vision = allocate (sizeof (* vision));
+
+	vision->using_precomputed_spritesheet = use_precomputed_spritesheet;
+
+	vision->spritesheet_size    = spritesheet_side;
+	vision->gameplay_framerate  = gameplay_framerate;
+	vision->animation_framerate = animation_framerate;
+	vision->vertex_limit        = vertex_limit;
+	vision->index_limit         = index_limit;
+	vision->tab_width           = 4;
+	vision->default_font        = ~0u;
+	vision->field_of_view       = 2.0f;
+	vision->far_plane           = 100.0f;
+	vision->near_plane          = 0.1f;
+	vision->sensitivity         = 0.1f;
+
+	if (use_precomputed_spritesheet == true) {
+		print ("[/0Comment/-] Importing spritesheet image and information...\n");
+
+		vision_import_spritesheet (vision, "binary/spritesheet.bin");
+	}
+
+	print ("[/2Success/-] Initialized OpenGL renderer.\n");
+
+	return (vision);
+}
+
+static vision_structure * vision_deinitialize (vision_structure * vision) {
+	vision->active = false;
+
+	for (uint index = 0; index < vision->font_count; ++index) {
+		vision->font_index  [index] = deallocate (vision->font_index  [index]);
+		vision->font_width  [index] = deallocate (vision->font_width  [index]);
+		vision->font_height [index] = deallocate (vision->font_height [index]);
+	}
+
+	vision->font_index  = deallocate (vision->font_index);
+	vision->font_width  = deallocate (vision->font_width);
+	vision->font_height = deallocate (vision->font_height);
+	vision->font_begin  = deallocate (vision->font_begin);
+	vision->font_end    = deallocate (vision->font_end);
+
+	vision->sprite_width  = deallocate (vision->sprite_width);
+	vision->sprite_height = deallocate (vision->sprite_height);
+	vision->sprite_u      = deallocate (vision->sprite_u);
+	vision->sprite_v      = deallocate (vision->sprite_v);
+
+	if (vision->using_precomputed_spritesheet == false) {
+		vision->spritesheet_data = deallocate (vision->spritesheet_data);
+	}
+
+	vision->vertex_array = deallocate (vision->vertex_array);
+	vision->index_array  = deallocate (vision->index_array);
+
+	glDeleteTextures (1, & vision->spritesheet);
+
+	vision->glDeleteProgram (vision->shader_program);
+	vision->glDeleteShader  (vision->fragment_shader);
+	vision->glDeleteShader  (vision->vertex_shader);
+
+	vision->glDeleteBuffers      (1, & vision->index_buffer);
+	vision->glDeleteBuffers      (1, & vision->vertex_buffer);
+	vision->glDeleteVertexArrays (1, & vision->vertex_object);
+
+	glfwDestroyWindow (vision->window);
+
+	glfwTerminate ();
+
+	print ("[/2Success/-] Deinitialized OpenGL renderer.\n");
+
+	return (deallocate (vision));
+}
+
+static void vision_configure (vision_structure * vision, uint window_width, uint window_height, char * window_title) {
+	ulong font_bitmap [190] = {
+		0x0000000000000000, 0x0000000000000000, 0x0000101010101010, 0x1000101000000000, 0x0024242400000000, 0x0000000000000000,
+		0x00002424247e2424, 0x7e24242400000000, 0x0010107c9290907c, 0x1212927c10100000, 0x0000649468081010, 0x202c524c00000000,
+		0x000018242418304a, 0x4444443a00000000, 0x0010101000000000, 0x0000000000000000, 0x0000081020202020, 0x2020100800000000,
+		0x0000201008080808, 0x0808102000000000, 0x000000000024187e, 0x1824000000000000, 0x000000000010107c, 0x1010000000000000,
+		0x0000000000000000, 0x0000101020000000, 0x000000000000007e, 0x0000000000000000, 0x0000000000000000, 0x0000101000000000,
+		0x0000040408081010, 0x2020404000000000, 0x00003c4242464a52, 0x6242423c00000000, 0x0000081828080808, 0x0808083e00000000,
+		0x00003c4242020408, 0x1020407e00000000, 0x00003c4242021c02, 0x0242423c00000000, 0x000002060a122242, 0x7e02020200000000,
+		0x00007e4040407c02, 0x0202423c00000000, 0x00001c2040407c42, 0x4242423c00000000, 0x00007e0202040408, 0x0810101000000000,
+		0x00003c4242423c42, 0x4242423c00000000, 0x00003c424242423e, 0x0202043800000000, 0x0000000000101000, 0x0000101000000000,
+		0x0000000000101000, 0x0000101020000000, 0x0000000408102040, 0x2010080400000000, 0x00000000007e0000, 0x7e00000000000000,
+		0x0000004020100804, 0x0810204000000000, 0x00003c4242420408, 0x0800080800000000, 0x00007c829ea2a2a2, 0xa69a807e00000000,
+		0x00003c424242427e, 0x4242424200000000, 0x00007c4242427c42, 0x4242427c00000000, 0x00003c4242404040, 0x4042423c00000000,
+		0x0000784442424242, 0x4242447800000000, 0x00007e4040407840, 0x4040407e00000000, 0x00007e4040407840, 0x4040404000000000,
+		0x00003c424240404e, 0x4242423c00000000, 0x0000424242427e42, 0x4242424200000000, 0x0000381010101010, 0x1010103800000000,
+		0x00000e0404040404, 0x0444443800000000, 0x0000424448506060, 0x5048444200000000, 0x0000404040404040, 0x4040407e00000000,
+		0x000082c6aa929282, 0x8282828200000000, 0x000042424262524a, 0x4642424200000000, 0x00003c4242424242, 0x4242423c00000000,
+		0x00007c424242427c, 0x4040404000000000, 0x00003c4242424242, 0x42424a3c02000000, 0x00007c424242427c, 0x5048444200000000,
+		0x00003c4240403c02, 0x0242423c00000000, 0x0000fe1010101010, 0x1010101000000000, 0x0000424242424242, 0x4242423c00000000,
+		0x0000424242424224, 0x2424181800000000, 0x0000828282828292, 0x92aac68200000000, 0x0000424224241818, 0x2424424200000000,
+		0x0000828244442810, 0x1010101000000000, 0x00007e0202040810, 0x2040407e00000000, 0x0000382020202020, 0x2020203800000000,
+		0x0000404020201010, 0x0808040400000000, 0x0000380808080808, 0x0808083800000000, 0x0000102844000000, 0x0000000000000000,
+		0x0000000000000000, 0x0000007e00000000, 0x1008000000000000, 0x0000000000000000, 0x00000000003c023e, 0x4242423e00000000,
+		0x00004040407c4242, 0x4242427c00000000, 0x00000000003c4240, 0x4040423c00000000, 0x00000202023e4242, 0x4242423e00000000,
+		0x00000000003c4242, 0x7e40403c00000000, 0x00000e10107c1010, 0x1010101000000000, 0x00000000003e4242, 0x4242423e02023c00,
+		0x00004040407c4242, 0x4242424200000000, 0x0000101000301010, 0x1010103800000000, 0x00000404000c0404, 0x0404040444443800,
+		0x0000404040424448, 0x7048444200000000, 0x0000301010101010, 0x1010103800000000, 0x0000000000fc9292, 0x9292929200000000,
+		0x00000000007c4242, 0x4242424200000000, 0x00000000003c4242, 0x4242423c00000000, 0x00000000007c4242, 0x4242427c40404000,
+		0x00000000003e4242, 0x4242423e02020200, 0x00000000005e6040, 0x4040404000000000, 0x00000000003e4040, 0x3c02027c00000000,
+		0x00001010107c1010, 0x1010100e00000000, 0x0000000000424242, 0x4242423e00000000, 0x0000000000424242, 0x2424181800000000,
+		0x0000000000828292, 0x9292927c00000000, 0x0000000000424224, 0x1824424200000000, 0x0000000000424242, 0x4242423e02023c00,
+		0x00000000007e0408, 0x1020407e00000000, 0x00000c1010102010, 0x1010100c00000000, 0x0000101010101010, 0x1010101000000000,
+		0x0000300808080408, 0x0808083000000000, 0x000000000062928c, 0x0000000000000000
+	};
+
+	char * vertex_shader =
+		"#version 330 core\n"
+		"in  vec3 vertex_xyz;\n"
+		"in  vec2 vertex_uv;\n"
+		"in  vec4 vertex_rgba;\n"
+		"out vec2 fragment_uv;\n"
+		"out vec4 fragment_rgba;\n"
+		"uniform mat4 projection_matrix;\n"
+		"uniform mat4 movement_matrix;\n"
+		"uniform mat4 rotation_matrix;\n"
+		"void main () {\n"
+		"	gl_Position = movement_matrix * rotation_matrix * projection_matrix * vec4 (vertex_xyz, 1.0);\n"
+		"	fragment_uv = vertex_uv;\n"
+		"	fragment_rgba = vertex_rgba;\n"
+		"}\n";
+
+	char * fragment_shader =
+		"#version 330 core\n"
+		"uniform sampler2D texture_p;\n"
+		"in  vec2 fragment_uv;\n"
+		"in  vec4 fragment_rgba;\n"
+		"out vec4 data;\n"
+		"void main () {\n"
+		"	data = texture (texture_p, fragment_uv) * fragment_rgba;\n"
+		"}\n";
+
+	uint * dumb_buffer = null;
+	uint * order       = null;
+
+	uint xyz_attribute  = 0;
+	uint uv_attribute   = 0;
+	uint rgba_attribute = 0;
+
+	uint u = 0;
+	uint v = 0;
+
+	if (vision->using_precomputed_spritesheet == true) {
+		for (uint index = 0; index < 95; ++index) {
+			vision->font_index [vision->font_count] [index] = ++vision->sprite_count - 1;
+		}
+
+		++vision->sprite_count;
+		++vision->font_count;
+
+		goto ignore_import;
+	}
+
+	dumb_buffer = allocate (256 * sizeof (* dumb_buffer));
+
+	for (uint index = 0; index < 256; ++index) {
+		dumb_buffer [index] = 0xffffffff;
+	}
+
+	++vision->font_count;
+
+	uint current = vision->font_count - 1;
+
+	vision->font_index  = reallocate (vision->font_index,  vision->font_count * sizeof (* vision->font_index));
+	vision->font_width  = reallocate (vision->font_width,  vision->font_count * sizeof (* vision->font_width));
+	vision->font_height = reallocate (vision->font_height, vision->font_count * sizeof (* vision->font_height));
+	vision->font_begin  = reallocate (vision->font_begin,  vision->font_count * sizeof (* vision->font_begin));
+	vision->font_end    = reallocate (vision->font_end,    vision->font_count * sizeof (* vision->font_end));
+
+	vision->font_begin [vision->font_count - 1] = ' ';
+	vision->font_end   [vision->font_count - 1] = '~';
+
+	vision->font_index  [vision->font_count - 1] = allocate (95 * sizeof (* * vision->font_index));
+	vision->font_width  [vision->font_count - 1] = allocate (95 * sizeof (* * vision->font_width));
+	vision->font_height [vision->font_count - 1] = allocate (95 * sizeof (* * vision->font_height));
+
+	for (uint index = 0; index < 95; ++index) {
+		uint * buffer = allocate (vision_font_width * vision_font_height * sizeof (* buffer));
+
+		for (uint value = 0; value < 2; ++value) {
+			for (uint bit = 64; bit > 0; --bit) {
+				uint destination = ((value << 3) - ((bit - 1) >> 3) + 7) * vision_font_width - ((bit - 1) & 7) + 7;
+				uint source      = (font_bitmap [2 * index + value] >> (bit - 1)) & 1;
+
+				buffer [destination] = (source) ? 0xffffffff : 0x00000000;
+			}
+		}
+
+		vision->font_index  [current] [index] = vision_sprite_raw_import (vision, buffer, vision_font_width, vision_font_height);
+		vision->font_width  [current] [index] = vision_font_width;
+		vision->font_height [current] [index] = vision_font_height;
+	}
+
+	vision_sprite_raw_import (vision, dumb_buffer, 16, 16);
+
+	vision->spritesheet_data = allocate (vision->spritesheet_size * vision->spritesheet_size * sizeof (* vision->spritesheet_data));
+
+	order = allocate (vision->sprite_count * sizeof (* order));
+
+	for (uint index = 0; index < vision->sprite_count; ++index) {
+		order [index] = index;
+	}
+
+	for (uint index = 0; index < vision->sprite_count; ++index) {
+		for (uint subindex = 0; subindex < vision->sprite_count; ++subindex) {
+			if (vision->sprite_height [order [index]] < vision->sprite_height [order [subindex]]) {
+				uint temporary = order [index];
+
+				order [index]    = order [subindex];
+				order [subindex] = temporary;
+			}
+		}
+	}
+
+	for (uint index = 0; index < vision->sprite_count; ++index) {
+		if (u + vision->sprite_width [order [index]] >= vision->spritesheet_size) {
+			u *= 0;
+			v += vision->sprite_height [order [index]];
+		}
+
+		vision->sprite_u [order [index]] = (float) u / (float) vision->spritesheet_size;
+		vision->sprite_v [order [index]] = (float) v / (float) vision->spritesheet_size;
+
+		for (uint y = 0; y < vision->sprite_height [order [index]]; ++y) {
+			for (uint x = 0; x < vision->sprite_width [order [index]]; ++x) {
+				uint destination = (v + y) * vision->spritesheet_size + (u + x);
+				uint source      = y * vision->sprite_width [order [index]] + x;
+
+				vision->spritesheet_data [destination] = vision->sprite_data [order [index]] [source];
+			}
+		}
+
+		u += vision->sprite_width [order [index]];
+
+		vision->sprite_data [order [index]] = deallocate (vision->sprite_data [order [index]]);
+	}
+
+	vision->sprite_data = deallocate (vision->sprite_data);
+	order               = deallocate (order);
+
+	ignore_import:
+
+	vision->window_width  = window_width;
+	vision->window_height = window_height;
+
+	vision->aspect_ratio = (float) window_height / (float) window_width;
+
+	vision->pixel_width  = 2.0f / (float) window_width;
+	vision->pixel_height = 2.0f / (float) window_height;
+
+	glfwInit ();
+
+	glfwWindowHint (GLFW_CONTEXT_VERSION_MAJOR,   3);
+	glfwWindowHint (GLFW_CONTEXT_VERSION_MINOR,   3);
+	glfwWindowHint (GLFW_OPENGL_PROFILE,          GLFW_OPENGL_CORE_PROFILE);
+	glfwWindowHint (GLFW_OPENGL_FORWARD_COMPAT,   1);
+
+	vision->window = glfwCreateWindow ((int) window_width, (int) window_height, window_title, null, null);
+
+	fatal_failure (vision->window == null, "Failed to create GLFW window.\n");
+
+	glfwSetWindowSizeLimits (vision->window, 320, 240, 1920, 1080);
+
+	//~glfwSetInputMode (vision->window, GLFW_CURSOR, GLFW_CURSOR_HIDDEN);
+	//~glfwSetInputMode (vision->window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
+
+	glfwSetCursorPos (vision->window, (double) vision->window_width / 2.0, (double) vision->window_height / 2.0);
+
+	glfwMakeContextCurrent (vision->window);
+
+	vision->glGenVertexArrays         = (PFNGLGENVERTEXARRAYSPROC)         glfwGetProcAddress ("glGenVertexArrays");
+	vision->glBindVertexArray         = (PFNGLBINDVERTEXARRAYPROC)         glfwGetProcAddress ("glBindVertexArray");
+	vision->glGenBuffers              = (PFNGLGENBUFFERSPROC)              glfwGetProcAddress ("glGenBuffers");
+	vision->glBindBuffer              = (PFNGLBINDBUFFERPROC)              glfwGetProcAddress ("glBindBuffer");
+	vision->glCreateShader            = (PFNGLCREATESHADERPROC)            glfwGetProcAddress ("glCreateShader");
+	vision->glShaderSource            = (PFNGLSHADERSOURCEPROC)            glfwGetProcAddress ("glShaderSource");
+	vision->glCompileShader           = (PFNGLCOMPILESHADERPROC)           glfwGetProcAddress ("glCompileShader");
+	vision->glCreateProgram           = (PFNGLCREATEPROGRAMPROC)           glfwGetProcAddress ("glCreateProgram");
+	vision->glAttachShader            = (PFNGLATTACHSHADERPROC)            glfwGetProcAddress ("glAttachShader");
+	vision->glBindFragDataLocation    = (PFNGLBINDFRAGDATALOCATIONPROC)    glfwGetProcAddress ("glBindFragDataLocation");
+	vision->glLinkProgram             = (PFNGLLINKPROGRAMPROC)             glfwGetProcAddress ("glLinkProgram");
+	vision->glUseProgram              = (PFNGLUSEPROGRAMPROC)              glfwGetProcAddress ("glUseProgram");
+	vision->glGetAttribLocation       = (PFNGLGETATTRIBLOCATIONPROC)       glfwGetProcAddress ("glGetAttribLocation");
+	vision->glEnableVertexAttribArray = (PFNGLENABLEVERTEXATTRIBARRAYPROC) glfwGetProcAddress ("glEnableVertexAttribArray");
+	vision->glVertexAttribPointer     = (PFNGLVERTEXATTRIBPOINTERPROC)     glfwGetProcAddress ("glVertexAttribPointer");
+	vision->glUniform1i               = (PFNGLUNIFORM1IPROC)               glfwGetProcAddress ("glUniform1i");
+	vision->glUniform1f               = (PFNGLUNIFORM1FPROC)               glfwGetProcAddress ("glUniform1f");
+	vision->glDeleteVertexArrays      = (PFNGLDELETEVERTEXARRAYSPROC)      glfwGetProcAddress ("glDeleteVertexArrays");
+	vision->glDeleteBuffers           = (PFNGLDELETEBUFFERSPROC)           glfwGetProcAddress ("glDeleteBuffers");
+	vision->glDeleteShader            = (PFNGLDELETESHADERPROC)            glfwGetProcAddress ("glDeleteShader");
+	vision->glDeleteProgram           = (PFNGLDELETEPROGRAMPROC)           glfwGetProcAddress ("glDeleteProgram");
+	vision->glGetUniformLocation      = (PFNGLGETUNIFORMLOCATIONPROC)      glfwGetProcAddress ("glGetUniformLocation");
+	vision->glBufferData              = (PFNGLBUFFERDATAPROC)              glfwGetProcAddress ("glBufferData");
+	vision->glUniformMatrix4fv        = (PFNGLUNIFORMMATRIX4FVPROC)        glfwGetProcAddress ("glUniformMatrix4fv");
+
+	glViewport (0, 0, (int) window_width, (int) window_height);
+
+	glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+	glDepthFunc (GL_LESS);
+
+	glEnable (GL_DEPTH_TEST);
+	glEnable (GL_CULL_FACE);
+	glEnable (GL_BLEND);
+
+	vision->glGenVertexArrays (1, & vision->vertex_object);
+	vision->glBindVertexArray (vision->vertex_object);
+
+	vision->glGenBuffers (1, & vision->vertex_buffer);
+	vision->glBindBuffer (GL_ARRAY_BUFFER, vision->vertex_buffer);
+
+	vision->glGenBuffers (1, & vision->index_buffer);
+	vision->glBindBuffer (GL_ELEMENT_ARRAY_BUFFER, vision->index_buffer);
+
+	vision->vertex_shader = vision->glCreateShader (GL_VERTEX_SHADER);
+
+	vision->glShaderSource  (vision->vertex_shader, 1, & vertex_shader, null);
+	vision->glCompileShader (vision->vertex_shader);
+
+	vision->fragment_shader = vision->glCreateShader (GL_FRAGMENT_SHADER);
+
+	vision->glShaderSource  (vision->fragment_shader, 1, & fragment_shader, null);
+	vision->glCompileShader (vision->fragment_shader);
+
+	vision->shader_program = vision->glCreateProgram ();
+
+	vision->glAttachShader (vision->shader_program, vision->vertex_shader);
+	vision->glAttachShader (vision->shader_program, vision->fragment_shader);
+
+	vision->glBindFragDataLocation (vision->shader_program, 0, "data");
+
+	vision->glLinkProgram (vision->shader_program);
+	vision->glUseProgram  (vision->shader_program);
+
+	xyz_attribute = (uint) vision->glGetAttribLocation (vision->shader_program, "vertex_xyz");
+
+	vision->glEnableVertexAttribArray (xyz_attribute);
+
+	vision->glVertexAttribPointer (xyz_attribute, 3, GL_FLOAT, GL_FALSE, 9 * sizeof (float), (void *) 0);
+
+	uv_attribute = (uint) vision->glGetAttribLocation (vision->shader_program, "vertex_uv");
+
+	vision->glEnableVertexAttribArray (uv_attribute);
+
+	vision->glVertexAttribPointer (uv_attribute, 2, GL_FLOAT, GL_FALSE, 9 * sizeof (float), (void *) (3 * sizeof (float)));
+
+	rgba_attribute = (uint) vision->glGetAttribLocation (vision->shader_program, "vertex_rgba");
+
+	vision->glEnableVertexAttribArray (rgba_attribute);
+
+	vision->glVertexAttribPointer (rgba_attribute, 4, GL_FLOAT, GL_FALSE, 9 * sizeof (float), (void *) (5 * sizeof (float)));
+
+	vision->vertex_array = allocate (vision->vertex_limit * sizeof (vision->vertex_array));
+	vision->index_array  = allocate (vision->index_limit  * sizeof (vision->index_array));
+
+	for (uint index = 0; index < 16; ++index) {
+		vision->projection_matrix [index] = 0.0f;
+		vision->movement_matrix   [index] = 0.0f;
+		vision->rotation_matrix   [index] = 0.0f;
+	}
+
+	vision->movement_matrix [0] = vision->movement_matrix [5] = vision->movement_matrix [10] = vision->movement_matrix [15] = 1.0f;
+	vision->rotation_matrix [0] = vision->rotation_matrix [5] = vision->rotation_matrix [10] = vision->rotation_matrix [15] = 1.0f;
+
+	vision->projection_matrix [ 0] = vision->aspect_ratio / tangent (vision->field_of_view / 2.0f);
+	vision->projection_matrix [ 5] = 1.0f / tangent (vision->field_of_view / 2.0f);
+	vision->projection_matrix [10] = vision->far_plane / (vision->far_plane - vision->near_plane);
+	vision->projection_matrix [11] = 1.0f;
+	vision->projection_matrix [14] = (- vision->far_plane * vision->near_plane) / (vision->far_plane - vision->near_plane);
+
+	vision->glUniformMatrix4fv (vision->glGetUniformLocation (vision->shader_program, "projection_matrix"), 1, GL_FALSE,
+	                            vision->projection_matrix);
+
+	vision->glUniformMatrix4fv (vision->glGetUniformLocation (vision->shader_program, "movement_matrix"), 1, GL_FALSE,
+	                            vision->movement_matrix);
+
+	vision->glUniformMatrix4fv (vision->glGetUniformLocation (vision->shader_program, "rotation_matrix"), 1, GL_FALSE,
+	                            vision->rotation_matrix);
+
+	glGenTextures (1, & vision->spritesheet);
+
+	glBindTexture (GL_TEXTURE_2D, vision->spritesheet);
+
+	glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA, vision->spritesheet_size, vision->spritesheet_size, 0, GL_RGBA, GL_UNSIGNED_BYTE,
+	              vision->spritesheet_data);
+
+	vision->glUniform1i (vision->glGetUniformLocation (vision->shader_program, "texture_p"),    0);
+	//~vision->glUniform1f (vision->glGetUniformLocation (vision->shader_program, "aspect_ratio"), vision->aspect_ratio);
+
+	glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,     GL_REPEAT);
+	glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,     GL_REPEAT);
+	glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+	glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+
+	if (vision->using_precomputed_spritesheet == true) {
+		vision->spritesheet_data = deallocate (vision->spritesheet_data);
+	}
+
+	vision->active = true;
+
+	vision->frame_begin = nano_time ();
+
+	glClearColor (0.0f, 0.0f, 0.0f, 1.0f);
+
+	glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+	print ("[/2Success/-] Configured OpenGL renderer.\n");
+}
+
+static void vision_synchronize (vision_structure * vision, uint colour) {
+	int signal_code [signal_count] = {
+		0,
+		GLFW_KEY_A,                     GLFW_KEY_B,                     GLFW_KEY_C,                     GLFW_KEY_D,
+		GLFW_KEY_E,                     GLFW_KEY_F,                     GLFW_KEY_G,                     GLFW_KEY_H,
+		GLFW_KEY_I,                     GLFW_KEY_J,                     GLFW_KEY_K,                     GLFW_KEY_L,
+		GLFW_KEY_M,                     GLFW_KEY_N,                     GLFW_KEY_O,                     GLFW_KEY_P,
+		GLFW_KEY_Q,                     GLFW_KEY_R,                     GLFW_KEY_S,                     GLFW_KEY_T,
+		GLFW_KEY_U,                     GLFW_KEY_V,                     GLFW_KEY_W,                     GLFW_KEY_X,
+		GLFW_KEY_Y,                     GLFW_KEY_Z,                     GLFW_KEY_0,                     GLFW_KEY_1,
+		GLFW_KEY_2,                     GLFW_KEY_3,                     GLFW_KEY_4,                     GLFW_KEY_5,
+		GLFW_KEY_6,                     GLFW_KEY_7,                     GLFW_KEY_8,                     GLFW_KEY_9,
+		GLFW_KEY_ESCAPE,                GLFW_KEY_TAB,                   GLFW_KEY_ENTER,                 GLFW_KEY_ENTER,
+		GLFW_KEY_SLASH,                 GLFW_KEY_BACKSLASH,             GLFW_KEY_SEMICOLON,             GLFW_KEY_GRAVE_ACCENT,
+		GLFW_KEY_SPACE,                 GLFW_KEY_BACKSPACE,             GLFW_KEY_PERIOD,                GLFW_KEY_COMMA,
+		GLFW_KEY_APOSTROPHE,            GLFW_KEY_CAPS_LOCK,             GLFW_KEY_MINUS,                 GLFW_KEY_EQUAL,
+		GLFW_KEY_LEFT_BRACKET,          GLFW_KEY_RIGHT_BRACKET,         GLFW_KEY_LEFT_CONTROL,          GLFW_KEY_RIGHT_CONTROL,
+		GLFW_KEY_LEFT_SHIFT,            GLFW_KEY_RIGHT_SHIFT,           GLFW_KEY_LEFT_ALT,              GLFW_KEY_RIGHT_ALT,
+		GLFW_KEY_F1,                    GLFW_KEY_F2,                    GLFW_KEY_F3,                    GLFW_KEY_F4,
+		GLFW_KEY_F5,                    GLFW_KEY_F6,                    GLFW_KEY_F7,                    GLFW_KEY_F8,
+		GLFW_KEY_F9,                    GLFW_KEY_F10,                   GLFW_KEY_F11,                   GLFW_KEY_F12,
+		GLFW_KEY_UP,                    GLFW_KEY_DOWN,                  GLFW_KEY_LEFT,                  GLFW_KEY_RIGHT,
+		GLFW_KEY_NUM_LOCK,              GLFW_KEY_PAUSE,                 GLFW_KEY_INSERT,                GLFW_KEY_HOME,
+		GLFW_KEY_PAGE_UP,               GLFW_KEY_DELETE,                GLFW_KEY_END,                   GLFW_KEY_PAGE_DOWN,
+		GLFW_KEY_KP_ADD,                GLFW_KEY_KP_SUBTRACT,           GLFW_KEY_KP_MULTIPLY,           GLFW_KEY_KP_DIVIDE,
+		GLFW_KEY_KP_ENTER,              GLFW_KEY_KP_DECIMAL,            GLFW_KEY_KP_0,                  GLFW_KEY_KP_1,
+		GLFW_KEY_KP_2,                  GLFW_KEY_KP_3,                  GLFW_KEY_KP_4,                  GLFW_KEY_KP_5,
+		GLFW_KEY_KP_6,                  GLFW_KEY_KP_7,                  GLFW_KEY_KP_8,                  GLFW_KEY_KP_9
+	};
+
+	int new_window_width  = 0;
+	int new_window_height = 0;
+
+	glClearColor (normal_r (colour), normal_g (colour), normal_b (colour), normal_a (colour));
+
+	glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+	glfwPollEvents ();
+
+	glfwSetWindowShouldClose (vision->window, vision->active == false);
+
+	glfwGetWindowSize (vision->window, & new_window_width, & new_window_height);
+
+	if ((vision->window_width != (uint) new_window_width) || (vision->window_height != (uint) new_window_height)) {
+		if ((new_window_width <= 0) || (new_window_height <= 0)) return;
+
+		glViewport (0, 0, new_window_width, new_window_height);
+
+		vision->window_width  = (uint) new_window_width;
+		vision->window_height = (uint) new_window_height;
+
+		vision->pixel_width  = 2.0f / (float) new_window_width;
+		vision->pixel_height = 2.0f / (float) new_window_height;
+	}
+
+	vision->cursor [cursor_left]   = (bool) (glfwGetMouseButton (vision->window, GLFW_MOUSE_BUTTON_LEFT)   == GLFW_PRESS);
+	vision->cursor [cursor_middle] = (bool) (glfwGetMouseButton (vision->window, GLFW_MOUSE_BUTTON_MIDDLE) == GLFW_PRESS);
+	vision->cursor [cursor_right]  = (bool) (glfwGetMouseButton (vision->window, GLFW_MOUSE_BUTTON_RIGHT)  == GLFW_PRESS);
+
+	glfwSetCursorPos (vision->window, (double) vision->window_width / 2.0, (double) vision->window_height / 2.0);
+
+	if (vision->freeze_cursor == false) {
+		double x = 0.0;
+		double y = 0.0;
+
+		glfwGetCursorPos (vision->window, & x, & y);
+
+		vision->cursor_x = (int) x;
+		vision->cursor_y = (int) y;
+
+		//~float offset_x = vision->camera_x - x;
+
+		//~for (uint index = 0; index < 16; ++index) {
+			//~vision->rotation_matrix [index] = 0.0f;
+		//~}
+
+		//~offset_x *= vision->sensitivity;
+
+		//~vision->rotation_matrix [0] = vision->rotation_matrix [5] = vision->rotation_matrix [10] = vision->rotation_matrix [15] = 1.0f;
+
+		//~vision->rotation_matrix [5] = vision->rotation_matrix [10] = cosine (offset_x);
+		//~vision->rotation_matrix [6] = vision->rotation_matrix [ 9] = sine   (offset_x);
+
+		//~vision->rotation_matrix [6] *= - 1.0f;
+
+		//~vision->glUniformMatrix4fv (vision->glGetUniformLocation (vision->shader_program, "rotation_matrix"), 1, GL_FALSE,
+		                            //~vision->rotation_matrix);
+
+		//~vision->camera_x = x;
+	} else {
+		if ((vision->cursor [cursor_left]   == false)
+		&&  (vision->cursor [cursor_middle] == false)
+		&&  (vision->cursor [cursor_right]  == false)) {
+			vision->freeze_cursor = false;
+		}
+	}
+
+	if (vision->freeze_signal == false) {
+		for (uint index = 0; index < signal_count; ++index) {
+			vision->signal [index] = (bool) (glfwGetKey (vision->window, signal_code [index]) == GLFW_PRESS);
+		}
+	}
+
+	vision->glBufferData (GL_ARRAY_BUFFER,         vision->vertex_count * 4, vision->vertex_array, GL_DYNAMIC_DRAW);
+	vision->glBufferData (GL_ELEMENT_ARRAY_BUFFER, vision->index_count  * 4, vision->index_array,  GL_DYNAMIC_DRAW);
+
+	vision->glBindBuffer (GL_ARRAY_BUFFER, vision->vertex_buffer);
+
+	glDrawElements (GL_TRIANGLES, (int) vision->index_count * 4, GL_UNSIGNED_INT, null);
+
+	glfwSwapBuffers (vision->window);
+
+	vision->vertex_count = 0;
+	vision->index_count  = 0;
+
+	vision->frame_end = nano_time ();
+
+	vision->frame_time = vision->frame_end - vision->frame_begin;
+
+	if (vision->frame_time < 1000000000ul / vision->gameplay_framerate) {
+		nano_wait (1000000000ul / vision->gameplay_framerate - vision->frame_time);
+	}
+
+	if (vision->global_tick % vision->gameplay_framerate == 0) {
+		vision->framerate = (uint) (1000000000ul / vision->frame_time);
+	}
+
+	++vision->global_tick;
+
+	vision->global_tick    = vision->global_tick % (vision->gameplay_framerate * vision->animation_framerate);
+	vision->gameplay_tick  = vision->global_tick % (vision->gameplay_framerate);
+	vision->animation_tick = vision->global_tick / (vision->gameplay_framerate / vision->animation_framerate);
+
+	vision->frame_begin = nano_time ();
+}
+
+static void vision_render_base (vision_structure * vision, uint vertex_count, float * vertex_array, uint index_count,
+                                uint * index_array, uint sprite, uint colour) {
+	if (sprite                              >= vision->sprite_count) return;
+	if (vision->vertex_count + vertex_count >= vision->vertex_limit) return;
+	if (vision->index_count  + index_count  >= vision->index_limit)  return;
+
+	float unwrap_x = (float) vision->sprite_u [sprite] / (float) vision->spritesheet_size;
+	float unwrap_y = (float) vision->sprite_v [sprite] / (float) vision->spritesheet_size;
+
+	float unwrap_width  = (float) vision->sprite_width  [sprite] / (float) vision->spritesheet_size;
+	float unwrap_height = (float) vision->sprite_height [sprite] / (float) vision->spritesheet_size;
+
+	//~for (uint vertex = 0; vertex < vertex_count; ++vertex) {
+		//~uint destination = 9 * vertex + vision->vertex_count;
+		//~uint source      = 5 * vertex;
+
+		//~vision->vertex_array [destination + 0] = vertex_array [source + 0];
+		//~vision->vertex_array [destination + 1] = vertex_array [source + 1];
+		//~vision->vertex_array [destination + 2] = vertex_array [source + 2];
+		//~vision->vertex_array [destination + 3] = vertex_array [source + 3] * unwrap_width  + unwrap_x;
+		//~vision->vertex_array [destination + 4] = vertex_array [source + 4] * unwrap_height + unwrap_y;
+		//~vision->vertex_array [destination + 5] = normal_r (colour);
+		//~vision->vertex_array [destination + 6] = normal_g (colour);
+		//~vision->vertex_array [destination + 7] = normal_b (colour);
+		//~vision->vertex_array [destination + 8] = normal_a (colour);
+	//~}
+
+	for (uint vertex = 0; vertex < vertex_count; ++vertex) {
+		vision->vertex_array [vision->vertex_count + vertex] = vertex_array [vertex];
+	}
+
+		//~vision->vertex_array [destination + 3] = vertex_array [source + 3] * unwrap_width  + unwrap_x;
+		//~vision->vertex_array [destination + 4] = vertex_array [source + 4] * unwrap_height + unwrap_y;
+
+	for (uint index = 0; index < index_count; ++index) {
+		vision->index_array [vision->index_count + index] = index_array [index];
+	}
+
+	//~vision->vertex_count += 36 * vertex_count;
+	//~vision->index_count  +=  3 * index_count;
+	vision->vertex_count += vertex_count;
+	vision->index_count  += index_count;
+}
+
+//~static void vision_render_triangle (vision_structure * vision, float * vertex_array, uint colour) {
+	//~if (vision->vertex_count + 3 * 36 >= vision->vertex_limit) return;
+	//~if (vision->index_count  + 3      >= vision->index_limit)  return;
+
+	//~for (uint vertex = 0; vertex < 3; ++vertex) {
+		//~uint destination = 9 * vertex + vision->vertex_count;
+		//~uint source      = 5 * vertex;
+
+		//~vision->vertex_array [destination + 0] = vertex_array [source + 0];
+		//~vision->vertex_array [destination + 1] = vertex_array [source + 1];
+		//~vision->vertex_array [destination + 2] = vertex_array [source + 2];
+		//~vision->vertex_array [destination + 3] = (binary_sign (vertex >> 0) + 1.0f) / 2.0f;
+		//~vision->vertex_array [destination + 4] = (binary_sign (vertex >> 1) + 1.0f) / 2.0f;
+		//~vision->vertex_array [destination + 5] = normal_r (colour);
+		//~vision->vertex_array [destination + 6] = normal_g (colour);
+		//~vision->vertex_array [destination + 7] = normal_b (colour);
+		//~vision->vertex_array [destination + 8] = normal_a (colour);
+	//~}
+
+	//~for (uint index = 0; index < 3; ++index) {
+		//~vision->index_array [vision->index_count + index] = vision->vertex_array [vision->vertex_count / 9 + index];
+	//~}
+
+	//~vision->vertex_count += 108;
+	//~vision->index_count  += 3;
+//~}
+
+static void vision_change_field_of_view (vision_structure * vision, float change) {
+	vision->field_of_view += change;
+
+	vision->projection_matrix [ 0] = vision->aspect_ratio / tangent (vision->field_of_view / 2.0f);
+	vision->projection_matrix [ 5] = 1.0f / tangent (vision->field_of_view / 2.0f);
+
+	vision->glUniformMatrix4fv (vision->glGetUniformLocation (vision->shader_program, "projection_matrix"), 1, GL_FALSE,
+	                            vision->projection_matrix);
+}
+
+static void vision_change_translation (vision_structure * vision, float x, float y, float z) {
+	vision->movement_matrix [ 3] += x;
+	vision->movement_matrix [ 7] += y;
+	vision->movement_matrix [11] += z;
+
+	vision->glUniformMatrix4fv (vision->glGetUniformLocation (vision->shader_program, "movement_matrix"), 1, GL_FALSE,
+	                            vision->movement_matrix);
+}
+
+static void vision_change_rotation (vision_structure * vision, float vertical, float horizontal) {
+	for (uint index = 0; index < 16; ++index) {
+		vision->rotation_matrix [index] = 0.0f;
+	}
+
+	vision->rotation_matrix [0] = vision->rotation_matrix [5] = vision->rotation_matrix [10] = vision->rotation_matrix [15] = 1.0f;
+
+	vision->rotation_matrix [5] = vision->rotation_matrix [10] = cosine (vertical);
+	vision->rotation_matrix [6] = vision->rotation_matrix [ 9] = sine   (vertical);
+
+	vision->rotation_matrix [6] *= - 1.0f;
+
+	vision->glUniformMatrix4fv (vision->glGetUniformLocation (vision->shader_program, "rotation_matrix"), 1, GL_FALSE,
+	                            vision->rotation_matrix);
+}
+
+#undef vision_font_width
+#undef vision_font_height
diff --git a/xommon.h b/xommon.h
index 91ba248..da0aa01 100755
--- a/xommon.h
+++ b/xommon.h
@@ -77,15 +77,15 @@ typedef struct {
 	char    * font_end;
 } common_structure;
 
-static uint common_center_x (const common_structure * common, uint size) {
+static uint common_center_x (common_structure * common, uint size) {
 	return ((common->window_width - size) / 2);
 }
 
-static uint common_center_y (const common_structure * common, uint size) {
+static uint common_center_y (common_structure * common, uint size) {
 	return ((common->window_height - size) / 2);
 }
 
-static bool common_cursor_inside (const common_structure * common, int x, int y, uint width, uint height) {
+static bool common_cursor_inside (common_structure * common, int x, int y, uint width, uint height) {
 	return ((common->cursor_x > x)
 	     && (common->cursor_y > y)
 	     && (common->cursor_x < x + (int) width)
@@ -176,7 +176,7 @@ static uint common_font_raw_import (common_structure * common, uint * data, uint
 	return (common->font_count - 1);
 }
 
-static uint common_sprite_import (common_structure * common, const char * path) {
+static uint common_sprite_import (common_structure * common, char * path) {
 	uint   width  = 0;
 	uint   height = 0;
 	uint * data   = null;
@@ -200,7 +200,7 @@ static uint common_sprite_import (common_structure * common, const char * path)
 	return (common_sprite_raw_import (common, data, width, height));
 }
 
-static uint common_font_import (common_structure * common, const char * path, char begin, char end, uint colour) {
+static uint common_font_import (common_structure * common, char * path, char begin, char end, uint colour) {
 	uint   width  = 0;
 	uint   height = 0;
 	uint   result = 0;
@@ -229,11 +229,11 @@ static uint common_font_import (common_structure * common, const char * path, ch
 	return (result);
 }
 
-static uint common_sprite_width (const common_structure * common, uint sprite) {
+static uint common_sprite_width (common_structure * common, uint sprite) {
 	return (common->sprite_width [sprite]);
 }
 
-static uint common_sprite_height (const common_structure * common, uint sprite) {
+static uint common_sprite_height (common_structure * common, uint sprite) {
 	return (common->sprite_height [sprite]);
 }
 
@@ -275,8 +275,8 @@ static common_structure * common_deinitialize (common_structure * common) {
 	return (deallocate (common));
 }
 
-static void common_configure (common_structure * common, uint width, uint height, const char * title, uint window_flags) {
-	const ulong font_bitmap [190] = {
+static void common_configure (common_structure * common, uint width, uint height, char * title, uint window_flags) {
+	ulong font_bitmap [190] = {
 		0x0000000000000000, 0x0000000000000000, 0x0000101010101010, 0x1000101000000000, 0x0024242400000000, 0x0000000000000000,
 		0x00002424247e2424, 0x7e24242400000000, 0x0010107c9290907c, 0x1212927c10100000, 0x0000649468081010, 0x202c524c00000000,
 		0x000018242418304a, 0x4444443a00000000, 0x0010101000000000, 0x0000000000000000, 0x0000081020202020, 0x2020100800000000,
@@ -311,7 +311,7 @@ static void common_configure (common_structure * common, uint width, uint height
 		0x0000300808080408, 0x0808083000000000, 0x000000000062928c, 0x0000000000000000
 	};
 
-	const uint event_mask = XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK;
+	uint event_mask = XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK;
 
 	uint mask_window_flags [2] = { 0 };
 
@@ -407,7 +407,7 @@ static void common_configure (common_structure * common, uint width, uint height
 }
 
 static void common_synchronize (common_structure * common, uint colour) {
-	const uint signal_code [signal_count] = {
+	uint signal_code [signal_count] = {
 		0,
 		38,     56,     54,     40,     26,     41,     42,     43,     31,     44,     45,     46,     58,     57,     32,     33,
 		24,     27,     39,     28,     30,     55,     25,     53,     29,     52,     19,     10,     11,     12,     13,     14,
@@ -538,10 +538,10 @@ static void common_render_base (common_structure * common, uint sprite, int x, i
 
 	/// COLOUR INTERPOLATION WITH RBGA-ABGR CONVERSION
 	uint interpolate_pixels (uint pixel, uint modifier) {
-		const uint r = (((pixel & 0xff000000) >> 24) * ((modifier & 0x000000ff) >>  0)) / 0xff;
-		const uint g = (((pixel & 0x00ff0000) >> 16) * ((modifier & 0x0000ff00) >>  8)) / 0xff;
-		const uint b = (((pixel & 0x0000ff00) >>  8) * ((modifier & 0x00ff0000) >> 16)) / 0xff;
-		const uint a = (((pixel & 0x000000ff) >>  0) * ((modifier & 0xff000000) >> 24)) / 0xff;
+		uint r = (((pixel & 0xff000000) >> 24) * ((modifier & 0x000000ff) >>  0)) / 0xff;
+		uint g = (((pixel & 0x00ff0000) >> 16) * ((modifier & 0x0000ff00) >>  8)) / 0xff;
+		uint b = (((pixel & 0x0000ff00) >>  8) * ((modifier & 0x00ff0000) >> 16)) / 0xff;
+		uint a = (((pixel & 0x000000ff) >>  0) * ((modifier & 0xff000000) >> 24)) / 0xff;
 
 		return ((r << 24) | (g << 16) | (b << 8) | a);
 	}
@@ -556,8 +556,8 @@ static void common_render_base (common_structure * common, uint sprite, int x, i
 			if (horizontal + x >= common->window_width) break;
 			if (horizontal + u >= common->sprite_width [sprite]) break;
 
-			const uint pixel = common->sprite_data [sprite] [(vertical + v) * common->sprite_width [sprite] + horizontal + u];
-			const uint at = (y + vertical) * common->window_width + (x + horizontal);
+			uint pixel = common->sprite_data [sprite] [(vertical + v) * common->sprite_width [sprite] + horizontal + u];
+			uint at = (y + vertical) * common->window_width + (x + horizontal);
 
 			common->framebuffer [at] = (((pixel & 0xff000000) >> 24) > 0x77) ? interpolate_pixels (pixel, upper_left) : common->framebuffer [at];
 		}
@@ -617,7 +617,7 @@ static void common_render_sprite_control (common_structure * common, uint sprite
 	common_render_base (common, sprite, x, y, u, v, width, height, 1, 1, flip_x, flip_y, 0xffffffffu, 0xffffffffu, 0xffffffffu, 0xffffffffu);
 }
 
-static uint common_render_string_width (common_structure * common, const char * string, uint font, float scale) {
+static uint common_render_string_width (common_structure * common, char * string, uint font, float scale) {
 	uint length = 0;
 
 	if (string == null) {
@@ -633,7 +633,7 @@ static uint common_render_string_width (common_structure * common, const char *
 	return (length);
 }
 
-static void common_render_string (common_structure * common, const char * string, uint font, int x, int y, float scale, uint colour) {
+static void common_render_string (common_structure * common, char * string, uint font, int x, int y, float scale, uint colour) {
 	int offset = x;
 
 	if (string == null) return;
diff --git a/xormat.h b/xormat.h
index 992d710..cb9b030 100644
--- a/xormat.h
+++ b/xormat.h
@@ -31,48 +31,48 @@
 #include <xolatile/xormat/tga.h>
 #endif
 
-static void * format_image_import (const char * path, uint * width, uint * height) {
+static void * format_image_import (char * path, uint * width, uint * height) {
 	uint * data = null;
 
-#ifdef use_png_library
-	if (data == null) {
-		char buffer [256] = "";
+//~#ifdef use_png_library
+	//~if (data == null) {
+		//~char buffer [256] = "";
 
-		if (file_exists (string_concatenate (string_copy (buffer, path), ".png")) == true) {
-			data = png_image_import (buffer, width, height);
-		}
-	}
-#endif
+		//~if (file_exists (string_concatenate (string_copy (buffer, path), ".png")) == true) {
+			//~data = png_image_import (buffer, width, height);
+		//~}
+	//~}
+//~#endif
 
-#ifdef use_jxl_library
-	if (data == null) {
-		char buffer [256] = "";
+//~#ifdef use_jxl_library
+	//~if (data == null) {
+		//~char buffer [256] = "";
 
-		if (file_exists (string_concatenate (string_copy (buffer, path), ".jxl")) == true) {
-			data = jxl_image_import (buffer, width, height);
-		}
-	}
-#endif
+		//~if (file_exists (string_concatenate (string_copy (buffer, path), ".jxl")) == true) {
+			//~data = jxl_image_import (buffer, width, height);
+		//~}
+	//~}
+//~#endif
 
-#ifdef use_jpg_library
-	if (data == null) {
-		char buffer [256] = "";
+//~#ifdef use_jpg_library
+	//~if (data == null) {
+		//~char buffer [256] = "";
 
-		if (file_exists (string_concatenate (string_copy (buffer, path), ".jpg")) == true) {
-			data = jpg_image_import (buffer, width, height);
-		}
-	}
-#endif
+		//~if (file_exists (string_concatenate (string_copy (buffer, path), ".jpg")) == true) {
+			//~data = jpg_image_import (buffer, width, height);
+		//~}
+	//~}
+//~#endif
 
-#ifdef use_tga_library
-	if (data == null) {
-		char buffer [256] = "";
+//~#ifdef use_tga_library
+	//~if (data == null) {
+		//~char buffer [256] = "";
 
-		if (file_exists (string_concatenate (string_copy (buffer, path), ".tga")) == true) {
-			data = tga_image_import (buffer, width, height);
-		}
-	}
-#endif
+		//~if (file_exists (string_concatenate (string_copy (buffer, path), ".tga")) == true) {
+			//~data = tga_image_import (buffer, width, height);
+		//~}
+	//~}
+//~#endif
 
 	if (data == null) {
 		switch (file_type (path)) {
diff --git a/xormat/jxl.h b/xormat/jxl.h
index 91754ad..37932c5 100644
--- a/xormat/jxl.h
+++ b/xormat/jxl.h
@@ -4,7 +4,7 @@
 #define use_jxl_library
 #endif
 
-static void * jxl_image_import (const char * path, uint * width, uint * height) {
+static void * jxl_image_import (char * path, uint * width, uint * height) {
 	JxlDecoder       * decoder     = null;
 	JxlBasicInfo       information = { 0 };
 	JxlPixelFormat     format      = { 4, JXL_TYPE_UINT8, JXL_NATIVE_ENDIAN, 0 };
diff --git a/xormat/ply.h b/xormat/ply.h
new file mode 100644
index 0000000..e19efa9
--- /dev/null
+++ b/xormat/ply.h
@@ -0,0 +1,6 @@
+
+#ifndef use_ply_library
+#define use_ply_library
+#endif
+
+
diff --git a/xormat/png.h b/xormat/png.h
index e7b5bdb..cb1f52c 100644
--- a/xormat/png.h
+++ b/xormat/png.h
@@ -5,7 +5,7 @@
 #define use_png_library
 #endif
 
-static void * png_image_import (const char * path, uint * width, uint * height) {
+static void * png_image_import (char * path, uint * width, uint * height) {
 	FILE * file;
 	uint * data;
 	uint   index;
@@ -87,7 +87,7 @@ static void * png_image_import (const char * path, uint * width, uint * height)
 	return (data);
 }
 
-static void png_image_export (const char * path, uint * data, uint width, uint height) {
+static void png_image_export (char * path, uint * data, uint width, uint height) {
 	png_image image = { 0 };
 
 	fatal_failure (path   == null, "png_image_export: File path is null pointer.");
diff --git a/xpengl.h b/xpengl.h
index 125b6ca..6e8dd2d 100755
--- a/xpengl.h
+++ b/xpengl.h
@@ -184,7 +184,7 @@ static uint opengl_font_raw_import (opengl_structure * opengl, uint * data, uint
 	return (opengl->font_count - 1);
 }
 
-static uint opengl_sprite_import (opengl_structure * opengl, const char * path) {
+static uint opengl_sprite_import (opengl_structure * opengl, char * path) {
 	uint   width  = 0;
 	uint   height = 0;
 	uint * data   = null;
@@ -214,7 +214,7 @@ static uint opengl_sprite_import (opengl_structure * opengl, const char * path)
 	return (opengl_sprite_raw_import (opengl, data, width, height));
 }
 
-static uint opengl_font_import (opengl_structure * opengl, const char * path, char begin, char end, uint colour) {
+static uint opengl_font_import (opengl_structure * opengl, char * path, char begin, char end, uint colour) {
 	uint   width  = 0;
 	uint   height = 0;
 	uint   result = 0;
@@ -296,7 +296,7 @@ static bool opengl_cursor_right_click (opengl_structure * opengl, int x, int y,
 	return (false);
 }
 
-static void opengl_import_spritesheet (opengl_structure * opengl, const char * data_file) {
+static void opengl_import_spritesheet (opengl_structure * opengl, char * data_file) {
 	int file = file_open (data_file, file_flag_read);
 
 	fatal_failure (opengl->active == true, "opengl_import_spritesheet: OpenGL renderer is already initialized.");
@@ -346,7 +346,7 @@ static void opengl_import_spritesheet (opengl_structure * opengl, const char * d
 	opengl->font_count   = 0;
 }
 
-static void opengl_export_spritesheet (opengl_structure * opengl, const char * data_file) {
+static void opengl_export_spritesheet (opengl_structure * opengl, char * data_file) {
 	int file = file_open (data_file, file_flag_write | file_flag_create | file_flag_truncate);
 
 	fatal_failure (opengl->spritesheet_data == null, "opengl_export_spritesheet: OpenGL renderer can't access spritesheet data.");
@@ -449,8 +449,8 @@ static opengl_structure * opengl_deinitialize (opengl_structure * opengl) {
 	return (deallocate (opengl));
 }
 
-static void opengl_configure (opengl_structure * opengl, uint window_width, uint window_height, const char * window_title) {
-	const ulong font_bitmap [190] = {
+static void opengl_configure (opengl_structure * opengl, uint window_width, uint window_height, char * window_title) {
+	ulong font_bitmap [190] = {
 		0x0000000000000000, 0x0000000000000000, 0x0000101010101010, 0x1000101000000000, 0x0024242400000000, 0x0000000000000000,
 		0x00002424247e2424, 0x7e24242400000000, 0x0010107c9290907c, 0x1212927c10100000, 0x0000649468081010, 0x202c524c00000000,
 		0x000018242418304a, 0x4444443a00000000, 0x0010101000000000, 0x0000000000000000, 0x0000081020202020, 0x2020100800000000,
@@ -485,7 +485,7 @@ static void opengl_configure (opengl_structure * opengl, uint window_width, uint
 		0x0000300808080408, 0x0808083000000000, 0x000000000062928c, 0x0000000000000000
 	};
 
-	const char * vertex_shader =
+	char * vertex_shader =
 		"# version 330 core\n"
 		"in  vec2 vertex_xy;\n"
 		"in  vec2 vertex_uv;\n"
@@ -498,7 +498,7 @@ static void opengl_configure (opengl_structure * opengl, uint window_width, uint
 		"  fragment_rgba = vertex_rgba;\n"
 		"}\n";
 
-	const char * fragment_shader =
+	char * fragment_shader =
 		"# version 330 core\n"
 		"uniform sampler2D texture_p;\n"
 		"in  vec2 fragment_uv;\n"
@@ -538,7 +538,7 @@ static void opengl_configure (opengl_structure * opengl, uint window_width, uint
 
 	++opengl->font_count;
 
-	const uint current = opengl->font_count - 1;
+	uint current = opengl->font_count - 1;
 
 	opengl->font_index  = reallocate (opengl->font_index,  opengl->font_count * sizeof (* opengl->font_index));
 	opengl->font_width  = reallocate (opengl->font_width,  opengl->font_count * sizeof (* opengl->font_width));
@@ -756,7 +756,7 @@ static void opengl_configure (opengl_structure * opengl, uint window_width, uint
 }
 
 static void opengl_synchronize (opengl_structure * opengl, uint colour) {
-	const int signal_code [signal_count] = {
+	int signal_code [signal_count] = {
 		0,
 		GLFW_KEY_A,                     GLFW_KEY_B,                     GLFW_KEY_C,                     GLFW_KEY_D,
 		GLFW_KEY_E,                     GLFW_KEY_F,                     GLFW_KEY_G,                     GLFW_KEY_H,
@@ -948,12 +948,12 @@ static void opengl_render_base (opengl_structure * opengl, uint sprite, int x, i
 	opengl->vertex_array [opengl->vertex_count + 30] = normal_b (colour_lower_right);
 	opengl->vertex_array [opengl->vertex_count + 31] = normal_a (colour_lower_right);
 
-	opengl->index_array [opengl->index_count + 0] = (opengl->vertex_count >> 3) + 2;
-	opengl->index_array [opengl->index_count + 1] = (opengl->vertex_count >> 3) + 1;
-	opengl->index_array [opengl->index_count + 2] = (opengl->vertex_count >> 3) + 0;
-	opengl->index_array [opengl->index_count + 3] = (opengl->vertex_count >> 3) + 1;
-	opengl->index_array [opengl->index_count + 4] = (opengl->vertex_count >> 3) + 2;
-	opengl->index_array [opengl->index_count + 5] = (opengl->vertex_count >> 3) + 3;
+	opengl->index_array [opengl->index_count + 0] = (opengl->vertex_count / 8) + 2;
+	opengl->index_array [opengl->index_count + 1] = (opengl->vertex_count / 8) + 1;
+	opengl->index_array [opengl->index_count + 2] = (opengl->vertex_count / 8) + 0;
+	opengl->index_array [opengl->index_count + 3] = (opengl->vertex_count / 8) + 1;
+	opengl->index_array [opengl->index_count + 4] = (opengl->vertex_count / 8) + 2;
+	opengl->index_array [opengl->index_count + 5] = (opengl->vertex_count / 8) + 3;
 
 	opengl->vertex_count += 32;
 	opengl->index_count  +=  6;
@@ -1017,7 +1017,7 @@ static uint opengl_render_character_width (opengl_structure * opengl, char chara
 	if ((character < opengl->font_begin [font]) || (character > opengl->font_end [font])) {
 		return (0);
 	} else {
-		const uint index = opengl->font_index [font] [character - opengl->font_begin [font]];
+		uint index = opengl->font_index [font] [character - opengl->font_begin [font]];
 
 		return ((uint) (scale * (float) opengl->sprite_width [index]));
 	}
@@ -1027,13 +1027,13 @@ static uint opengl_render_character_height (opengl_structure * opengl, char char
 	if ((character < opengl->font_begin [font]) || (character > opengl->font_end [font])) {
 		return (0);
 	} else {
-		const uint index = opengl->font_index [font] [character - opengl->font_begin [font]];
+		uint index = opengl->font_index [font] [character - opengl->font_begin [font]];
 
 		return ((uint) (scale * (float) opengl->sprite_height [index]));
 	}
 }
 
-static uint opengl_render_string_width (opengl_structure * opengl, const char * string, uint font, float scale) {
+static uint opengl_render_string_width (opengl_structure * opengl, char * string, uint font, float scale) {
 	uint width = 0;
 	uint match = 0;
 
@@ -1055,7 +1055,7 @@ static uint opengl_render_string_width (opengl_structure * opengl, const char *
 	return (maximum (width, match));
 }
 
-static uint opengl_render_string_height (opengl_structure * opengl, const char * string, uint font, float scale) {
+static uint opengl_render_string_height (opengl_structure * opengl, char * string, uint font, float scale) {
 	uint height = opengl_render_character_height (opengl, ' ', font, scale);
 
 	if ((string == null) || (string [0] == '\0')) {
@@ -1079,9 +1079,9 @@ static void opengl_render_character_base (opengl_structure * opengl, char charac
 		font = opengl->font_count - 1;
 	}
 
-	const uint index  = opengl->font_index    [font] [character - opengl->font_begin [font]];
-	const uint width  = opengl->sprite_width  [index];
-	const uint height = opengl->sprite_height [index];
+	uint index  = opengl->font_index    [font] [character - opengl->font_begin [font]];
+	uint width  = opengl->sprite_width  [index];
+	uint height = opengl->sprite_height [index];
 
 	opengl_render_base (opengl, index, x, y, 0, 0, width, height, scale, scale, 0, 0, colour_upper_left, colour_upper_right,
 	                    colour_lower_left, colour_lower_right);
@@ -1101,7 +1101,7 @@ static void opengl_render_character_horizontal_gradient (opengl_structure * open
 	opengl_render_character_base (opengl, character, font, x, y, scale, colour_left, colour_right, colour_left, colour_right);
 }
 
-static void opengl_render_string_base (opengl_structure * opengl, const char * string, uint font, int x, int y, float scale,
+static void opengl_render_string_base (opengl_structure * opengl, char * string, uint font, int x, int y, float scale,
                                        uint colour_upper_left, uint colour_upper_right, uint colour_lower_left, uint colour_lower_right) {
 	int offset = x;
 
@@ -1124,28 +1124,28 @@ static void opengl_render_string_base (opengl_structure * opengl, const char * s
 	}
 }
 
-static void opengl_render_string (opengl_structure * opengl, const char * string, uint font, int x, int y, float scale, uint colour) {
+static void opengl_render_string (opengl_structure * opengl, char * string, uint font, int x, int y, float scale, uint colour) {
 	opengl_render_string_base (opengl, string, font, x, y, scale, colour, colour, colour, colour);
 }
 
-static void opengl_render_string_vertical_gradient (opengl_structure * opengl, const char * string, uint font, int x, int y, float scale,
+static void opengl_render_string_vertical_gradient (opengl_structure * opengl, char * string, uint font, int x, int y, float scale,
                                                     uint colour_up, uint colour_down) {
 	opengl_render_string_base (opengl, string, font, x, y, scale, colour_up, colour_up, colour_down, colour_down);
 }
 
-static void opengl_render_string_horizontal_gradient (opengl_structure * opengl, const char * string, uint font, int x, int y, float scale,
+static void opengl_render_string_horizontal_gradient (opengl_structure * opengl, char * string, uint font, int x, int y, float scale,
                                                       uint colour_left, uint colour_right) {
 	opengl_render_string_base (opengl, string, font, x, y, scale, colour_left, colour_right, colour_left, colour_right);
 }
 
-static void opengl_render_string_full_vertical_gradient (opengl_structure * opengl, const char * string, uint font, int x, int y, float scale,
+static void opengl_render_string_full_vertical_gradient (opengl_structure * opengl, char * string, uint font, int x, int y, float scale,
                                                          uint colour_up, uint colour_down) {
 	int  offset = x;
 	uint back   = 0;
 	uint up     = 0;
 	uint down   = 0;
 
-	const float interpolator = 1.0f / (float) string_full_height (string);
+	float interpolator = 1.0f / (float) string_full_height (string);
 
 	if (string == null) return;
 
@@ -1169,14 +1169,14 @@ static void opengl_render_string_full_vertical_gradient (opengl_structure * open
 	}
 }
 
-static void opengl_render_string_full_horizontal_gradient (opengl_structure * opengl, const char * string, uint font, int x, int y, float scale,
+static void opengl_render_string_full_horizontal_gradient (opengl_structure * opengl, char * string, uint font, int x, int y, float scale,
                                                            uint colour_left, uint colour_right) {
 	int  offset = x;
 	uint back   = 0;
 	uint left   = 0;
 	uint right  = 0;
 
-	const float interpolator = 1.0f / (float) string_full_width (string, opengl->tab_width);
+	float interpolator = 1.0f / (float) string_full_width (string, opengl->tab_width);
 
 	if (string == null) return;
 
diff --git a/xphere.h b/xphere.h
index 813c8c5..44e72d3 100755
--- a/xphere.h
+++ b/xphere.h
@@ -47,16 +47,16 @@ static float sphere_y (float vertical, float z) {
 }
 
 static float sphere_z (float distance, float horizontal, float vertical) {
-	const float x_over_z = tangent (horizontal);
-	const float y_over_z = tangent (vertical);
+	float x_over_z = tangent (horizontal);
+	float y_over_z = tangent (vertical);
 
 	return (distance * square_root (1.0f / (x_over_z * x_over_z + y_over_z * y_over_z + 1.0f)));
 }
 
 static void sphere_transpose_x (float * distance, float * horizontal, float x) {
-	const float origin = (* distance) * (* distance);
-	const float offset = x * x;
-	const float square = origin + offset + 2 * x * (* distance) * cosine (* horizontal);
+	float origin = (* distance) * (* distance);
+	float offset = x * x;
+	float square = origin + offset + 2 * x * (* distance) * cosine (* horizontal);
 
 	* distance = square_root (square);
 
@@ -64,17 +64,17 @@ static void sphere_transpose_x (float * distance, float * horizontal, float x) {
 }
 
 static void sphere_transpose_y (float * distance, float * vertical, float y) {
-	const float origin = (* distance) * (* distance);
-	const float offset = y * y;
+	float origin = (* distance) * (* distance);
+	float offset = y * y;
 
 	* distance = square_root (origin + offset + 2 * y * (* distance) * cosine (* vertical));
 }
 
 static void sphere_transpose_z (float * distance, float * horizontal, float * vertical, float z) {
-	const float origin = (* distance) * (* distance);
-	const float offset = z * z;
-	const float side_a = secant (* vertical);
-	const float side_b = tangent (* horizontal);
+	float origin = (* distance) * (* distance);
+	float offset = z * z;
+	float side_a = secant (* vertical);
+	float side_b = tangent (* horizontal);
 
 	* distance = square_root (origin + offset + 2 * z * (* distance) * square_root (1.0f / (side_a * side_a + sibe_b * side_b)));
 }
diff --git a/xprite.h b/xprite.h
index 8753a9e..78665b9 100755
--- a/xprite.h
+++ b/xprite.h
@@ -85,7 +85,7 @@ static void * sprite_import (char * path, int * width, int * height) {
 	return (data);
 }
 
-static void sprite_export (const char * path, int width, int height, unsigned int * data) {
+static void sprite_export (char * path, int width, int height, unsigned int * data) {
 	int file, move;
 
 	file = file_open (path, file_flag_edit | file_flag_truncate | file_flag_create);
diff --git a/xrena.h b/xrena.h
index df32779..79ed962 100755
--- a/xrena.h
+++ b/xrena.h
@@ -74,7 +74,7 @@ static void * arena_add (ulong size) {
 	return ((void*) & arena->block_array [current]->buffer [arena->block_array [current]->count - size]);
 }
 
-static char * arena_add_data (const void * data, ulong size) {
+static char * arena_add_data (void * data, ulong size) {
 	void * pointer = arena_add (size);
 
 	memory_copy (pointer, data, size);
@@ -82,7 +82,7 @@ static char * arena_add_data (const void * data, ulong size) {
 	return (pointer);
 }
 
-static char * arena_add_file (const char * path, uint flag, bool null_terminate) {
+static char * arena_add_file (char * path, uint flag, bool null_terminate) {
 	int     file = -1;
 	ulong   size = 0;
 	char  * data = null;
diff --git a/xrocessor.h b/xrocessor.h
index 6b606b1..8934d7c 100755
--- a/xrocessor.h
+++ b/xrocessor.h
@@ -19,38 +19,38 @@
 //~#include <xolatile/xtandard.h>
 //~#include <xolatile/xrena.h>
 
-static int  parse_comment (const char * buffer);
-static int  parse_include (const char * buffer);
-static int  parse_use     (const char * buffer);
-static int  parse_alias   (const char * buffer);
-static int  parse_macro   (const char * buffer);
-static int  parse_scope   (const char * buffer);
-static int  parse_unscope (const char * buffer);
-static int  parse_default (const char * buffer);
-static void parse_buffer  (const char * buffer, int limit);
+static int  parse_comment (char * buffer);
+static int  parse_include (char * buffer);
+static int  parse_use     (char * buffer);
+static int  parse_alias   (char * buffer);
+static int  parse_macro   (char * buffer);
+static int  parse_scope   (char * buffer);
+static int  parse_unscope (char * buffer);
+static int  parse_default (char * buffer);
+static void parse_buffer  (char * buffer, int limit);
 
 enum {
 	token_comment,  token_include,  token_use,      token_alias,    token_macro,    token_scope,    token_unscope,  token_default
 };
 
-static const char * token_key [token_default] = {
+static char * token_key [token_default] = {
 	"---",          "include ",     "use ",         "alias ",       "macro ",       "scope ",       "unscope "
 };
 
-static int (* parse_key [token_default + 1]) (const char * buffer) = {
+static int (* parse_key [token_default + 1]) (char * buffer) = {
 	parse_comment,  parse_include,  parse_use,      parse_alias,    parse_macro,    parse_scope,    parse_unscope,  parse_default
 };
 
 static int token_count = 0;
 
 static struct {
-	const char * data;
+	char * data;
 	int          size;
 	int          type;
 } * token_array [token_limit],
   * token_value [token_limit];
 
-static int parse_default (const char * buffer) {
+static int parse_default (char * buffer) {
 	int select;
 
 	for (select = 0; select < token_count; ++select) {
@@ -80,7 +80,7 @@ static int parse_default (const char * buffer) {
 	return (1);
 }
 
-static int parse_comment (const char * buffer) {
+static int parse_comment (char * buffer) {
 	int offset;
 
 	for (offset = 3; buffer [offset] != '\0'; ++offset) {
@@ -90,7 +90,7 @@ static int parse_comment (const char * buffer) {
 	return (offset + 1);
 }
 
-static int parse_use (const char * buffer) {
+static int parse_use (char * buffer) {
 	int offset;
 	int length;
 
@@ -110,7 +110,7 @@ static int parse_use (const char * buffer) {
 	return (offset + length + 1);
 }
 
-static int parse_include (const char * buffer) {
+static int parse_include (char * buffer) {
 	int    length;
 	int    offset;
 	char * data;
@@ -137,7 +137,7 @@ static int parse_include (const char * buffer) {
 	return (offset + length + 1);
 }
 
-static int parse_alias (const char * buffer) {
+static int parse_alias (char * buffer) {
 	int offset;
 	int length;
 
@@ -167,7 +167,7 @@ static int parse_alias (const char * buffer) {
 	return (offset + length + 1);
 }
 
-static int parse_macro (const char * buffer) {
+static int parse_macro (char * buffer) {
 	int offset;
 	int length;
 
@@ -201,7 +201,7 @@ static int parse_macro (const char * buffer) {
 	return (offset + length + 9 + 1);
 }
 
-static int parse_scope (const char * buffer) {
+static int parse_scope (char * buffer) {
 	int offset;
 	int length;
 	int select;
@@ -223,7 +223,7 @@ static int parse_scope (const char * buffer) {
 	return (offset + length + 1);
 }
 
-static int parse_unscope (const char * buffer) {
+static int parse_unscope (char * buffer) {
 	int offset;
 	int length;
 	int select;
@@ -247,7 +247,7 @@ static int parse_unscope (const char * buffer) {
 	return (offset + length + 1);
 }
 
-static void parse_buffer (const char * buffer, int limit) {
+static void parse_buffer (char * buffer, int limit) {
 	int offset;
 	int length;
 	int select;
diff --git a/xscii.c b/xscii.c
index ad22a13..0dff01e 100755
--- a/xscii.c
+++ b/xscii.c
@@ -19,7 +19,7 @@ static void echo_base (int character, int base, int colour, int effect) {
 }
 
 static void echo_code (int character) {
-	const char * code [] = {
+	char * code [] = {
 		"NUL",  "SOH",  "STX",  "ETX",  "EOT",  "ENQ",  "ACK",  "BEL",  "BS",   "HT",   "LF",   "VT",   "FF",   "CR",   "SO",   "SI",
 		"DLE",  "DC1",  "DC2",  "DC3",  "DC4",  "NAK",  "SYN",  "ETB",  "CAN",  "EM",   "SUB",  "ESC",  "FS",   "GS",   "RS",   "US",
 		"  "
@@ -38,7 +38,7 @@ static void echo_code (int character) {
 }
 
 static void echo_name (int character) {
-	const char * name [] = {
+	char * name [] = {
 		"Null",                         "Start of heading",             "Start of text",                "End of text",
 		"End of transmission",          "Enquiry",                      "Acknowledge",                  "Bell",
 		"Backspace",                    "Horizontal tab",               "Line feed",                    "Vertical tab",
diff --git a/xtandard.h b/xtandard.h
index b0be1ab..94f75a2 100755
--- a/xtandard.h
+++ b/xtandard.h
@@ -145,14 +145,14 @@ typedef enum {
 	signal_count
 } signal_enumeration;
 
-static const char * cursor_name [cursor_count] = {
+static char * cursor_name [cursor_count] = {
 	"---",
 	"Left button",                  "Middle button",                "Right button",
 	"Scroll up",                    "Scroll down"
 
 };
 
-static const char * signal_name [signal_count] = {
+static char * signal_name [signal_count] = {
 	"---",
 	"A",                            "B",                            "C",                            "D",
 	"E",                            "F",                            "G",                            "H",
@@ -209,7 +209,7 @@ static void input (void * data, ulong size) {
 	read (standard_input, data, size);
 }
 
-static void output (const void * data, ulong size) {
+static void output (void * data, ulong size) {
 	write (standard_output, data, size);
 }
 
@@ -218,7 +218,7 @@ static void clean_up (void (* procedure) (void)) {
 }
 
 #ifdef use_fatal_failure
-static void fatal_failure (bool condition, const char * message) {
+static void fatal_failure (bool condition, char * message) {
 	if (condition == true) {
 		echo ("[\x1b[1;31m FATAL \x1b[0m] ");
 
@@ -235,7 +235,7 @@ static void fatal_failure (bool condition, const char * message) {
 #define fatal_failure(...)
 #endif
 
-static void execute (const char * command) {
+static void execute (char * command) {
 	int status = 0;
 
 	system (command);
@@ -358,7 +358,7 @@ static void * record (void) {
 	return (buffer);
 }
 
-static bool character_compare_array (char character, const char * character_array) {
+static bool character_compare_array (char character, char * character_array) {
 	for (ulong index = 0; character_array [index] != '\0'; ++index) {
 		if (character == character_array [index]) {
 			return (true);
@@ -433,7 +433,7 @@ static char * lowercase (char * string) {
 	return (string);
 }
 
-static ulong string_length (const char * string) {
+static ulong string_length (char * string) {
 	ulong length = 0;
 
 	fatal_failure (string == null, "string_length: String is null pointer.");
@@ -472,7 +472,7 @@ static char * string_reverse (char * string) {
 	return (string_reverse_limit (string, string_length (string)));
 }
 
-static bool string_compare_limit (const char * string_a, const char * string_b, ulong limit) {
+static bool string_compare_limit (char * string_a, char * string_b, ulong limit) {
 	fatal_failure (string_a == null, "string_compare_limit: First source string is null pointer.");
 	fatal_failure (string_b == null, "string_compare_limit: Second source string is null pointer.");
 	fatal_failure (limit    <= 0,    "string_compare_limit: Limit is equal or below zero.");
@@ -486,11 +486,11 @@ static bool string_compare_limit (const char * string_a, const char * string_b,
 	return (true);
 }
 
-static bool string_compare (const char * string_a, const char * string_b) {
+static bool string_compare (char * string_a, char * string_b) {
 	return (string_compare_limit (string_a, string_b, string_length (string_a) + 1));
 }
 
-static char * string_copy_limit (char * destination, const char * source, ulong limit) {
+static char * string_copy_limit (char * destination, char * source, ulong limit) {
 	fatal_failure (destination == null, "string_copy_limit: Destination string is null pointer.");
 	fatal_failure (source      == null, "string_copy_limit: Source string is null pointer.");
 	fatal_failure (limit       <= 0,    "string_copy_limit: Limit is equal or below zero.");
@@ -502,11 +502,11 @@ static char * string_copy_limit (char * destination, const char * source, ulong
 	return (destination);
 }
 
-static char * string_copy (char * destination, const char * source) {
+static char * string_copy (char * destination, char * source) {
 	return (string_copy_limit (destination, source, string_length (source) + 1));
 }
 
-static char * string_concatenate_limit (char * destination, const char * source, ulong limit) {
+static char * string_concatenate_limit (char * destination, char * source, ulong limit) {
 	ulong offset = string_length (destination);
 
 	fatal_failure (destination == null, "string_concatenate_limit: Destination string is null pointer.");
@@ -520,11 +520,11 @@ static char * string_concatenate_limit (char * destination, const char * source,
 	return (destination);
 }
 
-static char * string_concatenate (char * destination, const char * source) {
+static char * string_concatenate (char * destination, char * source) {
 	return (string_concatenate_limit (destination, source, string_length (source) + 1));
 }
 
-static char * string_duplicate (const char * string) {
+static char * string_duplicate (char * string) {
 	char * duplicate = null;
 
 	duplicate = allocate ((string_length (string) + 1) * sizeof (* duplicate));
@@ -534,7 +534,7 @@ static char * string_duplicate (const char * string) {
 	return (duplicate);
 }
 
-static char * string_duplicate_limit (const char * string, uint limit) {
+static char * string_duplicate_limit (char * string, uint limit) {
 	char * duplicate = null;
 
 	duplicate = allocate ((limit + 1) * sizeof (* duplicate));
@@ -566,9 +566,9 @@ static void memory_nullify (void * memory, ulong size) {
 	}
 }
 
-static int memory_compare (void * memory_0, const void * memory_1, ulong size) {
+static int memory_compare (void * memory_0, void * memory_1, ulong size) {
 	      char * cast_0 = (      char *) memory_0;
-	const char * cast_1 = (const char *) memory_1;
+	char * cast_1 = (char *) memory_1;
 
 	fatal_failure (memory_0 == null, "memory_compare: Memory is null pointer.");
 	fatal_failure (memory_1 == null, "memory_compare: Source is null pointer.");
@@ -582,9 +582,9 @@ static int memory_compare (void * memory_0, const void * memory_1, ulong size) {
 	return (true);
 }
 
-static void memory_copy (void * destination, const void * source, ulong size) {
+static void memory_copy (void * destination, void * source, ulong size) {
 	      char * cast_0 = (      char *) destination;
-	const char * cast_1 = (const char *) source;
+	char * cast_1 = (char *) source;
 
 	fatal_failure (destination == null, "memory_copy: Destination is null pointer.");
 	fatal_failure (source      == null, "memory_copy: Source is null pointer.");
@@ -629,7 +629,7 @@ static void show_cursor (bool show) {
 	}
 }
 
-static int file_open (const char * path, int mode) {
+static int file_open (char * path, int mode) {
 	fatal_failure (path == null, "file_open: File path is null pointer.");
 
 	return (open (path, mode, 0777));
@@ -651,7 +651,7 @@ static void file_read (int file, void * data, ulong size) {
 	read (file, data, size);
 }
 
-static void file_write (int file, const void * data, ulong size) {
+static void file_write (int file, void * data, ulong size) {
 	fatal_failure (file <= -1,   "file_write: File descriptor is closed or invalid.");
 	fatal_failure (data == null, "file_write: Data is null pointer.");
 	fatal_failure (size == 0,    "file_write: Size is zero.");
@@ -659,7 +659,7 @@ static void file_write (int file, const void * data, ulong size) {
 	write (file, data, size);
 }
 
-static void file_echo (int file, const char * data) {
+static void file_echo (int file, char * data) {
 	file_write (file, data, string_length (data));
 }
 
@@ -669,7 +669,7 @@ static ulong file_seek (int file, int whence) {
 	return ((ulong) lseek (file, 0, whence));
 }
 
-static ulong file_size (const char * path) {
+static ulong file_size (char * path) {
 	struct stat data = { 0 };
 
 	fatal_failure (path == null, "file_size: File path is null pointer.");
@@ -679,8 +679,8 @@ static ulong file_size (const char * path) {
 	return ((ulong) data.st_size);
 }
 
-static file_type_enumeration file_type (const char * path) {
-	const char * extensions [file_type_count] = {
+static file_type_enumeration file_type (char * path) { /// SHIT BREAKS ON "./THIS/THAT.EXT"...
+	char * extensions [file_type_count] = {
 		".c",           ".h",           ".adb",         ".ads",         ".cpp",         ".hpp",         ".f90",         ".mod",
 		".pas",         ".d",           ".go",          ".jai",         ".asm",         ".eax",         ".gas",         ".fasm",
 		".hs",          ".el",          ".cfg",         ".lua",         ".sh",          ".py",          ".tcl",         ".4th",
@@ -703,17 +703,17 @@ static file_type_enumeration file_type (const char * path) {
 	return (~ 0u);
 }
 
-static bool file_exists (const char * path) {
+static bool file_exists (char * path) {
 	fatal_failure (path == null, "file_record: File path is null pointer.");
 
 	return ((access (path, F_OK) == 0) ? true : false);
 }
 
-static void file_remove (const char * path) {
+static void file_remove (char * path) {
 	unlink (path);
 }
 
-static void * file_record (const char * path) {
+static void * file_record (char * path) {
 	int     file = -1;
 	ulong   size = 0;
 	char  * data = null;
@@ -731,7 +731,7 @@ static void * file_record (const char * path) {
 	return (data);
 }
 
-static char * file_import (const char * path) {
+static char * file_import (char * path) {
 	int     file = -1;
 	ulong   size = 0;
 	char  * data = null;
@@ -751,7 +751,7 @@ static char * file_import (const char * path) {
 	return (data);
 }
 
-static void file_export (const char * path, const char * data) {
+static void file_export (char * path, char * data) {
 	int file = -1;
 
 	fatal_failure (path == null, "file_export: File path is null pointer.");
@@ -764,7 +764,7 @@ static void file_export (const char * path, const char * data) {
 	file = file_close (file);
 }
 
-static void * folder_open (const char * path) {
+static void * folder_open (char * path) {
 	DIR * folder = null;
 
 	fatal_failure (path == null, "folder_open: Folder path is null pointer.");
@@ -800,7 +800,7 @@ static void * folder_close (void * handle) {
 	return (null);
 }
 
-static char * * folder_create_path_list (const char * folder, uint * path_count, bool sort) {
+static char * * folder_create_path_list (char * folder, uint * path_count, bool sort) {
 	void   * handle     = null;
 	char * * path_array = 0;
 
@@ -836,7 +836,7 @@ static char * * folder_remove_path_list (char * * path_array, uint path_count) {
 	return (deallocate (path_array));
 }
 
-static char * configuration_format (const char * path) {
+static char * configuration_format (char * path) {
 	static char buffer [512] = "";
 
 	string_copy (buffer, getenv ("HOME"));
@@ -846,27 +846,27 @@ static char * configuration_format (const char * path) {
 	return (buffer);
 }
 
-static bool configuration_exists (const char * path) {
+static bool configuration_exists (char * path) {
 	return (file_exists (configuration_format (path)));
 }
 
-static void configuration_remove (const char * path) {
+static void configuration_remove (char * path) {
 	file_remove (configuration_format (path));
 }
 
-static char * configuration_import (const char * path) {
+static char * configuration_import (char * path) {
 	return (file_import (configuration_format (path)));
 }
 
-static void configuration_export (const char * path, const char * data) {
+static void configuration_export (char * path, char * data) {
 	file_export (configuration_format (path), data);
 }
 
-static bool argument_compare (const char * argument, const char * short_option, const char * long_option) {
+static bool argument_compare (char * argument, char * short_option, char * long_option) {
 	return ((string_compare (argument, short_option) == true) || (string_compare (argument, long_option) == true));
 }
 
-static uint string_full_width (const char * string, uint tab_width) {
+static uint string_full_width (char * string, uint tab_width) {
 	uint width = 0;
 	uint count = 0;
 
@@ -884,7 +884,7 @@ static uint string_full_width (const char * string, uint tab_width) {
 	return (width - 1);
 }
 
-static uint string_full_height (const char * string) {
+static uint string_full_height (char * string) {
 	uint height = 0;
 
 	do {
@@ -896,7 +896,7 @@ static uint string_full_height (const char * string) {
 	return (height + 1);
 }
 
-static uint string_limit_to_number (const char * string, uint limit) {
+static uint string_limit_to_number (char * string, uint limit) {
 	uint number = 0;
 
 	for (uint index = 0; (string [index] != '\0') && (index < limit); ++index) {
@@ -907,7 +907,7 @@ static uint string_limit_to_number (const char * string, uint limit) {
 	return (number);
 }
 
-static uint string_to_number (const char * string) {
+static uint string_to_number (char * string) {
 	return (string_limit_to_number (string, string_length (string)));
 }
 
@@ -988,7 +988,7 @@ static char * format_to_string (int number, bool sign, uint base, ulong amount,
 	return (string);
 }
 
-static char * format (const char * base, ...) {
+static char * format (char * base, ...) {
 	static char string [1024];
 
 	va_list list;
@@ -1019,7 +1019,7 @@ static char * format (const char * base, ...) {
 	return (string);
 }
 
-static void print (const char * format, ...) {
+static void print (char * format, ...) {
 	va_list list;
 
 	va_start (list, format);
@@ -1036,6 +1036,14 @@ static void print (const char * format, ...) {
 						char * string = number_to_string (va_arg (list, int));
 						output (string, string_length (string));
 					} break;
+					case ('f'): {
+						float   number = (float) va_arg (list, double);
+						char  * upper  = number_to_string ((int) number);
+						char  * lower  = number_to_string ((int) (number * 1000.0f) % 1000);
+						output (upper, string_length (upper));
+						output (".", 1);
+						output (lower, string_length (lower));
+					} break;
 					case ('t'): {
 						int toggle = (va_arg (list, int));
 						echo_colour ((toggle == true) ? colour_green : colour_red, effect_normal);
@@ -1116,7 +1124,8 @@ static void float_exchange (float * a, float * b) {
 
 #define pi (3.14159265f)
 
-static float sign (float x) { return ((x > 0.0f) ? +1.0f : -1.0f); }
+static float sign        (float x) { return ((x > 0.0f) ? + 1.0f : - 1.0f); }
+static float binary_sign (uint  x) { return ((x > 0)    ? + 1.0f : - 1.0f); }
 
 static float square_root (float x) { return (sqrtf (x)); }
 static float cube_root   (float x) { return (cbrtf (x)); }
diff --git a/xui.h b/xui.h
index 4c4ee36..db61906 100755
--- a/xui.h
+++ b/xui.h
@@ -73,7 +73,7 @@ typedef struct {
 } ui_structure;
 
 static ui_structure * ui_initialize (cross_structure * cross) {
-	const char * subtype_file_name [ui_subcount] = {
+	char * subtype_file_name [ui_subcount] = {
 		"window_left",                  "window_right",                 "window_upper",                 "window_lower",
 		"window_upper_left",            "window_upper_right",           "window_lower_left",            "window_lower_right",
 		"frame_left",                   "frame_right",                  "frame_upper",                  "frame_lower",
@@ -113,7 +113,7 @@ static ui_structure * ui_initialize (cross_structure * cross) {
 	ui->monofont = cross_font_import (cross, configuration_format ("xui/monospace"), ' ', '~', 0xffeeee00u);
 
 	for (uint index = 0; index < ui_subcount; ++index) {
-		const char * file_name = configuration_format (format ("xui/%s", subtype_file_name [index]));
+		char * file_name = configuration_format (format ("xui/%s", subtype_file_name [index]));
 
 		ui->sprite [index] = cross_sprite_import (cross, file_name);
 
@@ -142,15 +142,15 @@ static ui_structure * ui_deinitialize (ui_structure * ui) {
 	return (deallocate (ui));
 }
 
-static int ui_offset_x (const cross_structure * cross, const ui_structure * ui) {
+static int ui_offset_x (cross_structure * cross, ui_structure * ui) {
 	return (ui->camera_x - cross->window_width / 2);
 }
 
-static int ui_offset_y (const cross_structure * cross, const ui_structure * ui) {
+static int ui_offset_y (cross_structure * cross, ui_structure * ui) {
 	return (ui->camera_y - cross->window_height / 2);
 }
 
-static uint ui_side_panel (const ui_structure * ui) {
+static uint ui_side_panel (ui_structure * ui) {
 	return (ui->side_panel); /// MAKE IT WINDOW SIZE DEPENDENT?
 }
 
@@ -159,24 +159,24 @@ static void ui_camera_lower (ui_structure * ui) { ui->freeview = true; ui->camer
 static void ui_camera_left  (ui_structure * ui) { ui->freeview = true; ui->camera_x -= ui->camera_speed; }
 static void ui_camera_right (ui_structure * ui) { ui->freeview = true; ui->camera_x += ui->camera_speed; }
 
-static void ui_render (cross_structure * cross, const ui_structure * ui, ui_subtype index, int x, int y) {
+static void ui_render (cross_structure * cross, ui_structure * ui, ui_subtype index, int x, int y) {
 	cross_render_sprite (cross, ui->sprite [index], x, y);
 }
 
-static void ui_render_colour (cross_structure * cross, const ui_structure * ui, ui_subtype index, uint colour, int x, int y) {
+static void ui_render_colour (cross_structure * cross, ui_structure * ui, ui_subtype index, uint colour, int x, int y) {
 	cross_render_sprite_colour (cross, ui->sprite [index], colour, x, y);
 }
 
-static void ui_subrender (cross_structure * cross, const ui_structure * ui, ui_subtype index, int x, int y, uint u, uint v, uint width, uint height) {
+static void ui_subrender (cross_structure * cross, ui_structure * ui, ui_subtype index, int x, int y, uint u, uint v, uint width, uint height) {
 	cross_render_sprite_crop (cross, ui->sprite [index], x, y, u, v, width, height);
 }
 
-static void ui_subrender_colour (cross_structure * cross, const ui_structure * ui, ui_subtype index, uint colour, int x, int y, uint u, uint v, uint width, uint height) {
+static void ui_subrender_colour (cross_structure * cross, ui_structure * ui, ui_subtype index, uint colour, int x, int y, uint u, uint v, uint width, uint height) {
 	cross_render_sprite_crop_colour (cross, ui->sprite [index], colour, x, y, u, v, width, height);
 }
 
-static void ui_render_horizontal (cross_structure * cross, const ui_structure * ui, ui_subtype index, int x, int y, uint width) {
-	const int entire = (width / ui->width [index]) * ui->width [index];
+static void ui_render_horizontal (cross_structure * cross, ui_structure * ui, ui_subtype index, int x, int y, uint width) {
+	int entire = (width / ui->width [index]) * ui->width [index];
 
 	for (uint margin = 0; margin < width / ui->width [index]; ++margin) {
 		ui_render (cross, ui, index, x + margin * ui->width [index], y);
@@ -187,8 +187,8 @@ static void ui_render_horizontal (cross_structure * cross, const ui_structure *
 	}
 }
 
-static void ui_render_horizontal_colour (cross_structure * cross, const ui_structure * ui, ui_subtype index, uint colour, int x, int y, uint width) {
-	const int entire = (width / ui->width [index]) * ui->width [index];
+static void ui_render_horizontal_colour (cross_structure * cross, ui_structure * ui, ui_subtype index, uint colour, int x, int y, uint width) {
+	int entire = (width / ui->width [index]) * ui->width [index];
 
 	for (uint margin = 0; margin < width / ui->width [index]; ++margin) {
 		ui_render_colour (cross, ui, index, colour, x + margin * ui->width [index], y);
@@ -199,8 +199,8 @@ static void ui_render_horizontal_colour (cross_structure * cross, const ui_struc
 	}
 }
 
-static void ui_render_vertical (cross_structure * cross, const ui_structure * ui, ui_subtype index, int x, int y, uint height) {
-	const int entire = (height / ui->height [index]) * ui->height [index];
+static void ui_render_vertical (cross_structure * cross, ui_structure * ui, ui_subtype index, int x, int y, uint height) {
+	int entire = (height / ui->height [index]) * ui->height [index];
 
 	for (uint margin = 0; margin < height / ui->height [index]; ++margin) {
 		ui_render (cross, ui, index, x, y + margin * ui->height [index]);
@@ -211,12 +211,12 @@ static void ui_render_vertical (cross_structure * cross, const ui_structure * ui
 	}
 }
 
-static void ui_render_background (cross_structure * cross, const ui_structure * ui, ui_subtype index, int x, int y, uint width, uint height) {
-	const uint offset_x = (width  / ui->width  [index]) * ui->width  [index];
-	const uint offset_y = (height / ui->height [index]) * ui->height [index];
+static void ui_render_background (cross_structure * cross, ui_structure * ui, ui_subtype index, int x, int y, uint width, uint height) {
+	uint offset_x = (width  / ui->width  [index]) * ui->width  [index];
+	uint offset_y = (height / ui->height [index]) * ui->height [index];
 
-	const uint cutoff_x = width  % ui->width  [index];
-	const uint cutoff_y = height % ui->height [index];
+	uint cutoff_x = width  % ui->width  [index];
+	uint cutoff_y = height % ui->height [index];
 
 	for (uint vertical = 0; vertical < height / ui->height [index]; ++vertical) {
 		for (uint horizontal = 0; horizontal < width / ui->width [index]; ++horizontal) {
@@ -242,24 +242,24 @@ static void ui_screen_overlay (cross_structure * cross) {
 	cross_render_rectangle_vertical_gradient (cross, 0, cross->window_height / 2, cross->window_width, cross->window_height / 2, 0x00, 0xcc);
 }
 
-static void ui_render_grid (cross_structure * cross, const ui_structure * ui, ui_type element, int x, int y, uint width, uint height, uint margin, bool background) {
-	const uint upper_length = width  - ui->width  [element + 4] - ui->width  [element + 5];
-	const uint lower_length = width  - ui->width  [element + 6] - ui->width  [element + 7];
-	const uint left_length  = height - ui->height [element + 4] - ui->height [element + 6];
-	const uint right_length = height - ui->height [element + 5] - ui->height [element + 7];
+static void ui_render_grid (cross_structure * cross, ui_structure * ui, ui_type element, int x, int y, uint width, uint height, uint margin, bool background) {
+	uint upper_length = width  - ui->width  [element + 4] - ui->width  [element + 5];
+	uint lower_length = width  - ui->width  [element + 6] - ui->width  [element + 7];
+	uint left_length  = height - ui->height [element + 4] - ui->height [element + 6];
+	uint right_length = height - ui->height [element + 5] - ui->height [element + 7];
 
-	const int upper_offset_x =          ui->width  [element + 4];
-	const int lower_offset_x =          ui->width  [element + 6];
-	const int lower_offset_y = height - ui->height [element + 3];
+	int upper_offset_x =          ui->width  [element + 4];
+	int lower_offset_x =          ui->width  [element + 6];
+	int lower_offset_y = height - ui->height [element + 3];
 
-	const int right_offset_x = width - ui->width  [element + 1];
-	const int left_offset_y  =         ui->height [element + 4];
-	const int right_offset_y =         ui->height [element + 5];
+	int right_offset_x = width - ui->width  [element + 1];
+	int left_offset_y  =         ui->height [element + 4];
+	int right_offset_y =         ui->height [element + 5];
 
-	const int upper_right_offset_x = width  - ui->width  [element + 5];
-	const int lower_right_offset_x = width  - ui->width  [element + 7];
-	const int lower_left_offset_y  = height - ui->height [element + 6];
-	const int lower_right_offset_y = height - ui->height [element + 7];
+	int upper_right_offset_x = width  - ui->width  [element + 5];
+	int lower_right_offset_x = width  - ui->width  [element + 7];
+	int lower_left_offset_y  = height - ui->height [element + 6];
+	int lower_right_offset_y = height - ui->height [element + 7];
 
 	if ((background == true) && (width > 2 * margin) && (height > 2 * margin)) {
 		ui_render_background (cross, ui, element + 8, x + margin, y + margin, width - 2 * margin, height - 2 * margin);
@@ -277,29 +277,29 @@ static void ui_render_grid (cross_structure * cross, const ui_structure * ui, ui
 	ui_render (cross, ui, element + 7, x + lower_right_offset_x, y + lower_right_offset_y);
 }
 
-static void ui_render_window (cross_structure * cross, const ui_structure * ui, int x, int y, uint width, uint height) {
+static void ui_render_window (cross_structure * cross, ui_structure * ui, int x, int y, uint width, uint height) {
 	ui_render_grid (cross, ui, ui_window, x, y, width, height, 0, false);
 }
 
-static void ui_render_frame (cross_structure * cross, const ui_structure * ui, int x, int y, uint width, uint height) {
+static void ui_render_frame (cross_structure * cross, ui_structure * ui, int x, int y, uint width, uint height) {
 	ui_render_grid (cross, ui, ui_frame, x, y, width, height, 0, false);
 }
 
-static void ui_render_status (cross_structure * cross, const ui_structure * ui, int x, int y, uint width, uint height) {
+static void ui_render_status (cross_structure * cross, ui_structure * ui, int x, int y, uint width, uint height) {
 	ui_render_grid (cross, ui, ui_status, x, y, width, height, 16, true);
 }
 
-static void ui_render_menu (cross_structure * cross, const ui_structure * ui, int x, int y, uint width, uint height) {
+static void ui_render_menu (cross_structure * cross, ui_structure * ui, int x, int y, uint width, uint height) {
 	ui_render_grid (cross, ui, ui_menu, x, y, width, height, 24, true);
 }
 
-static void ui_render_button (cross_structure * cross, const ui_structure * ui, int x, int y, uint width, uint height) {
+static void ui_render_button (cross_structure * cross, ui_structure * ui, int x, int y, uint width, uint height) {
 	ui_render_grid (cross, ui, ui_button, x, y, width, height, 16, true);
 }
 
-static void ui_render_separator (cross_structure * cross, const ui_structure * ui, int x, int y, uint width) {
-	const uint margin =                  ui->width [ui_separator_left];
-	const uint length = width - margin - ui->width [ui_separator_right];
+static void ui_render_separator (cross_structure * cross, ui_structure * ui, int x, int y, uint width) {
+	uint margin =                  ui->width [ui_separator_left];
+	uint length = width - margin - ui->width [ui_separator_right];
 
 	ui_render (cross, ui, ui_separator_left, x, y);
 
@@ -310,9 +310,9 @@ static void ui_render_separator (cross_structure * cross, const ui_structure * u
 	ui_render (cross, ui, ui_separator_center, x + (width - ui->width [ui_separator_center]) / 2, y);
 }
 
-static void ui_render_title_bar (cross_structure * cross, const ui_structure * ui, const char * title, int x, int y, uint width) {
-	const uint margin =                  ui->width [ui_title_bar_left];
-	const uint length = width - margin - ui->width [ui_title_bar_right];
+static void ui_render_title_bar (cross_structure * cross, ui_structure * ui, char * title, int x, int y, uint width) {
+	uint margin =                  ui->width [ui_title_bar_left];
+	uint length = width - margin - ui->width [ui_title_bar_right];
 
 	ui_render (cross, ui, ui_title_bar_left, x, y);
 
@@ -323,15 +323,15 @@ static void ui_render_title_bar (cross_structure * cross, const ui_structure * u
 	cross_render_string (cross, title, ui->font, x + margin + 8, y + 8, 1, 0x112233ff);
 }
 
-static void ui_render_icon_and_text (cross_structure * cross, const ui_structure * ui, const char * title, uint icon, int x, int y) {
+static void ui_render_icon_and_text (cross_structure * cross, ui_structure * ui, char * title, uint icon, int x, int y) {
 	cross_render_sprite (cross, icon, x, y);
 
 	cross_render_string (cross, title, ui->font, x - 2 + ui->icon_size, y + 2, 1, 0x112233ffu);
 }
 
-static void ui_render_scroll_bar (cross_structure * cross, const ui_structure * ui, float slider, int x, int y, uint height) {
-	const uint margin =                   ui->height [ui_scroll_bar_upper];
-	const uint length = height - margin - ui->height [ui_scroll_bar_lower];
+static void ui_render_scroll_bar (cross_structure * cross, ui_structure * ui, float slider, int x, int y, uint height) {
+	uint margin =                   ui->height [ui_scroll_bar_upper];
+	uint length = height - margin - ui->height [ui_scroll_bar_lower];
 
 	ui_render (cross, ui, ui_scroll_bar_upper, x, y);
 
@@ -342,9 +342,9 @@ static void ui_render_scroll_bar (cross_structure * cross, const ui_structure *
 	ui_render (cross, ui, ui_scroll_bar_slider, x, y + margin + (uint) (slider * (float) (length - ui->height [ui_scroll_bar_slider])));
 }
 
-static void ui_render_fill_bar (cross_structure * cross, const ui_structure * ui, float fill, uint colour, int x, int y, uint width) {
-	const uint margin =                  ui->width [ui_fill_bar_left];
-	const uint length = width - margin - ui->width [ui_fill_bar_right];
+static void ui_render_fill_bar (cross_structure * cross, ui_structure * ui, float fill, uint colour, int x, int y, uint width) {
+	uint margin =                  ui->width [ui_fill_bar_left];
+	uint length = width - margin - ui->width [ui_fill_bar_right];
 
 	ui_render (cross, ui, ui_fill_bar_left, x, y);
 
@@ -355,7 +355,7 @@ static void ui_render_fill_bar (cross_structure * cross, const ui_structure * ui
 	ui_render_horizontal_colour (cross, ui, ui_fill_bar_base, colour, x + margin, y, (uint) (fill * (float) length));
 }
 
-static void ui_render_icon (cross_structure * cross, const ui_structure * ui, uint icon, int x, int y) {
+static void ui_render_icon (cross_structure * cross, ui_structure * ui, uint icon, int x, int y) {
 	cross_render_sprite (cross, ui->sprite [ui_icon_frame], x, y);
 
 	if (icon != ui->ignore) {
@@ -363,7 +363,7 @@ static void ui_render_icon (cross_structure * cross, const ui_structure * ui, ui
 	}
 }
 
-static void ui_render_overicon (cross_structure * cross, const ui_structure * ui, uint icon, int x, int y) {
+static void ui_render_overicon (cross_structure * cross, ui_structure * ui, uint icon, int x, int y) {
 	if (icon != ui->ignore) {
 		cross_render_sprite (cross, icon, x, y);
 	}
@@ -371,7 +371,7 @@ static void ui_render_overicon (cross_structure * cross, const ui_structure * ui
 	cross_render_sprite (cross, ui->sprite [ui_overicon_frame], x, y);
 }
 
-static void ui_render_ubericon (cross_structure * cross, const ui_structure * ui, uint icon, int x, int y) {
+static void ui_render_ubericon (cross_structure * cross, ui_structure * ui, uint icon, int x, int y) {
 	cross_render_sprite (cross, ui->sprite [ui_ubericon_frame], x, y);
 
 	if (icon != ui->ignore) {
@@ -379,8 +379,8 @@ static void ui_render_ubericon (cross_structure * cross, const ui_structure * ui
 	}
 }
 
-static void ui_render_menu_full (cross_structure * cross, const ui_structure * ui, const char * title, int x, int y, uint width, uint height) {
-	const uint margin = 24;
+static void ui_render_menu_full (cross_structure * cross, ui_structure * ui, char * title, int x, int y, uint width, uint height) {
+	uint margin = 24;
 
 	ui_screen_overlay (cross);
 
diff --git a/xulkan.h b/xulkan.h
index 4a3b2fc..6603ee1 100755
--- a/xulkan.h
+++ b/xulkan.h
@@ -118,7 +118,7 @@ typedef struct {
 	uint                            layout_height;
 } vulkan_structure;
 
-static const char * vulkan_continue_execution [] = {
+static char * vulkan_continue_execution [] = {
 	"/s Commands successfully completed.\n",
 	"/w Fence or query hasn't yet completed.\n",
 	"/w Wait operation hasn't completed in the specified time.\n",
@@ -127,7 +127,7 @@ static const char * vulkan_continue_execution [] = {
 	"/w Return array was too small for the result.\n"
 };
 
-static const char * vulkan_break_execution [] = {
+static char * vulkan_break_execution [] = {
 	"/f Host memory allocation has failed.\n",
 	"/f Device memory allocation has failed.\n",
 	"/f Initialization of an object couldn't be completed.\n",
@@ -342,7 +342,7 @@ static void vulkan_end_command_buffer (vulkan_structure * vulkan) {
 	vulkan->transfer_buffer = VK_NULL_HANDLE;
 }
 
-static void vulkan_create_window (vulkan_structure * vulkan, const char * application) {
+static void vulkan_create_window (vulkan_structure * vulkan, char * application) {
 	uint window_flags [2] = { 0 };
 
 	vulkan->time = tick_tock ();
@@ -383,7 +383,7 @@ static void vulkan_create_window (vulkan_structure * vulkan, const char * applic
 	print ("/c Time approximation: /6%i/-\n", tick_tock () - vulkan->time);
 }
 
-static void vulkan_create_instance (vulkan_structure * vulkan, const char * application) {
+static void vulkan_create_instance (vulkan_structure * vulkan, char * application) {
 	uint current = 0;
 	uint general = 0;
 
@@ -397,17 +397,17 @@ static void vulkan_create_instance (vulkan_structure * vulkan, const char * appl
 	uint                  * instance_extension_index = null;
 	VkExtensionProperties * instance_extension_array = null;
 
-	const uint default_instance_layer_count     = (uint) (vulkan->validation_layers == true);
-	const uint default_instance_extension_count = 2;
+	uint default_instance_layer_count     = (uint) (vulkan->validation_layers == true);
+	uint default_instance_extension_count = 2;
 
-	const char * default_instance_layer_array [VK_MAX_EXTENSION_NAME_SIZE] = {
+	char * default_instance_layer_array [VK_MAX_EXTENSION_NAME_SIZE] = {
 		"VK_LAYER_KHRONOS_validation"
 		//~"VK_LAYER_LUNARG_parameter_validation",
 		//~"VK_LAYER_LUNARG_core_validation",
 		//~"VK_LAYER_LUNARG_standard_validation"
 	};
 
-	const char * default_instance_extension_array [VK_MAX_EXTENSION_NAME_SIZE] = {
+	char * default_instance_extension_array [VK_MAX_EXTENSION_NAME_SIZE] = {
 		VK_KHR_SURFACE_EXTENSION_NAME,
 		VK_KHR_XCB_SURFACE_EXTENSION_NAME
 	};
@@ -511,11 +511,11 @@ static void vulkan_create_device (vulkan_structure * vulkan) {
 	VkPhysicalDevice * physical_device_array = null;
 	VkBool32         * support               = null;
 
-	const float queue_priorities [1] = { 1 };
+	float queue_priorities [1] = { 1 };
 
-	const uint default_device_extension_count = 1;
+	uint default_device_extension_count = 1;
 
-	const char * default_device_extension_array [VK_MAX_EXTENSION_NAME_SIZE] = {
+	char * default_device_extension_array [VK_MAX_EXTENSION_NAME_SIZE] = {
 		VK_KHR_SWAPCHAIN_EXTENSION_NAME
 	};
 
@@ -949,7 +949,7 @@ static void vulkan_create_descriptor_set_layout (vulkan_structure * vulkan) {
 }
 
 static void vulkan_create_vertex_shader (vulkan_structure * vulkan) {
-	const uint vertex_shader_code [] = {
+	uint vertex_shader_code [] = {
 		0x07230203,     0x00010000,     0x000d000b,     0x00000028,     0x00000000,     0x00020011,     0x00000001,     0x0006000b,
 		0x00000001,     0x4c534c47,     0x6474732e,     0x3035342e,     0x00000000,     0x0003000e,     0x00000000,     0x00000001,
 		0x000b000f,     0x00000000,     0x00000004,     0x6e69616d,     0x00000000,     0x0000000d,     0x00000012,     0x00000021,
@@ -1007,7 +1007,7 @@ static void vulkan_create_vertex_shader (vulkan_structure * vulkan) {
 }
 
 static void vulkan_create_fragment_shader (vulkan_structure * vulkan) {
-	const uint fragment_shader_code [] = {
+	uint fragment_shader_code [] = {
 		0x07230203,     0x00010000,     0x000d000b,     0x00000018,     0x00000000,     0x00020011,     0x00000001,     0x0006000b,
 		0x00000001,     0x4c534c47,     0x6474732e,     0x3035342e,     0x00000000,     0x0003000e,     0x00000000,     0x00000001,
 		0x0008000f,     0x00000004,     0x00000004,     0x6e69616d,     0x00000000,     0x00000009,     0x00000011,     0x00000015,
@@ -1818,7 +1818,7 @@ static void vulkan_bundle_layout (vulkan_structure * vulkan) {
 	order               = deallocate (order);
 }
 
-static void vulkan_configure (vulkan_structure * vulkan, int width, int height, const char * application) {
+static void vulkan_configure (vulkan_structure * vulkan, int width, int height, char * application) {
 	int index = 0;
 
 	uint * dumb_buffer = null;
@@ -2013,7 +2013,7 @@ static void vulkan_render_rectangle_gradient_h (vulkan_structure * vulkan, int x
 	vulkan_render_core (vulkan, vulkan->sprite_count - 1, x, y, 0, 0, 16, 16, (float) width / 16, (float) height / 16, 0, 0, colour_left, colour_right, colour_left, colour_right);
 }
 
-static int vulkan_string_width (vulkan_structure * vulkan, const char * string, int font, float scale) {
+static int vulkan_string_width (vulkan_structure * vulkan, char * string, int font, float scale) {
 	int length = 0;
 
 	for (uint index = 0; string [index] != '\0'; ++index) {
@@ -2034,7 +2034,7 @@ static int vulkan_string_width (vulkan_structure * vulkan, const char * string,
 	return (length);
 }
 
-static void vulkan_render_string (vulkan_structure * vulkan, const char * string, int font, int x, int y, uint colour) {
+static void vulkan_render_string (vulkan_structure * vulkan, char * string, int font, int x, int y, uint colour) {
 	int offset = x;
 
 	for (uint index = 0; string [index] != '\0'; ++index) {
@@ -2057,7 +2057,7 @@ static void vulkan_render_string (vulkan_structure * vulkan, const char * string
 	}
 }
 
-static void vulkan_render_string_scale (vulkan_structure * vulkan, const char * string, int font, int x, int y, float scale, uint colour) {
+static void vulkan_render_string_scale (vulkan_structure * vulkan, char * string, int font, int x, int y, float scale, uint colour) {
 	int offset = x;
 
 	for (uint index = 0; string [index] != '\0'; ++index) {
@@ -2081,7 +2081,7 @@ static void vulkan_render_string_scale (vulkan_structure * vulkan, const char *
 	}
 }
 
-static void vulkan_render_string_offset (vulkan_structure * vulkan, const char * string, uint length, uint font, uint offset, int * x, int * y, uint colour) {
+static void vulkan_render_string_offset (vulkan_structure * vulkan, char * string, uint length, uint font, uint offset, int * x, int * y, uint colour) {
 	for (uint index = 0; (string [index] != '\0') && (index < length); ++index) {
 		uint character = vulkan->font_index [font] [string [index] - vulkan->font_begin [font]];
 
@@ -2102,7 +2102,7 @@ static void vulkan_render_string_offset (vulkan_structure * vulkan, const char *
 	}
 }
 
-static void vulkan_render_string_gradient_v (vulkan_structure * vulkan, const char * string, int font, int x, int y, float scale, uint colour_up, uint colour_down) {
+static void vulkan_render_string_gradient_v (vulkan_structure * vulkan, char * string, int font, int x, int y, float scale, uint colour_up, uint colour_down) {
 	int offset = x;
 
 	for (uint index = 0; string [index] != '\0'; ++index) {
@@ -2126,7 +2126,7 @@ static void vulkan_render_string_gradient_v (vulkan_structure * vulkan, const ch
 	}
 }
 
-static void vulkan_render_string_gradient_h (vulkan_structure * vulkan, const char * string, int font, int x, int y, float scale, uint colour_left, uint colour_right) {
+static void vulkan_render_string_gradient_h (vulkan_structure * vulkan, char * string, int font, int x, int y, float scale, uint colour_left, uint colour_right) {
 	int offset = x;
 
 	for (uint index = 0; string [index] != '\0'; ++index) {
@@ -2151,7 +2151,7 @@ static void vulkan_render_string_gradient_h (vulkan_structure * vulkan, const ch
 }
 
 static void vulkan_handle_events (vulkan_structure * vulkan) {
-	static const int signal_code [signal_count] = {
+	static int signal_code [signal_count] = {
 		0,
 		38,     56,     54,     40,     26,     41,     42,     43,     31,     44,     45,     46,     58,     57,     32,     33,
 		24,     27,     39,     28,     30,     55,     25,     53,     29,     52,     19,     10,     11,     12,     13,     14,
@@ -2178,7 +2178,7 @@ static void vulkan_handle_events (vulkan_structure * vulkan) {
 			xcb_flush (vulkan->connection);
 		} break;
 		/*case (XCB_CONFIGURE_NOTIFY): {
-			const xcb_configure_notify_event_t * reconfigure = (const xcb_configure_notify_event_t *) generic_event;
+			xcb_configure_notify_event_t * reconfigure = (xcb_configure_notify_event_t *) generic_event;
 			if ((reconfigure->width != vulkan->width) || (reconfigure->height != vulkan->height)) {
 				vulkan->width  = reconfigure->width;
 				vulkan->height = reconfigure->height;
@@ -2235,7 +2235,7 @@ static void vulkan_synchronize (vulkan_structure * vulkan, uint clear_colour) {
 
 	void * ubo_void = null;
 
-	const VkPipelineStageFlags wait_stages [1] = { VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT} ;
+	VkPipelineStageFlags wait_stages [1] = { VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT} ;
 
 	VkSubmitInfo     submit_information  = { 0 };
 	VkPresentInfoKHR present_information = { 0 };
diff --git a/xungeon.h b/xungeon.h
index b88cf7a..745176e 100755
--- a/xungeon.h
+++ b/xungeon.h
@@ -84,7 +84,7 @@ typedef struct {
 	dungeon_item_definition      * item_array;
 } * dungeon_structure;
 
-static uint dungeon_biome_define (dungeon_structure dungeon, const char * name, uint temperature, uint humidity) {
+static uint dungeon_biome_define (dungeon_structure dungeon, char * name, uint temperature, uint humidity) {
 	dungeon_biome_definition biome = arena_add (sizeof (* biome));
 
 	fatal_failure (dungeon == null, "biome_define: Dungeon is not configured.");
@@ -106,7 +106,7 @@ static char * dungeon_biome_name        (dungeon_structure dungeon, uint index)
 static uint   dungeon_biome_temperature (dungeon_structure dungeon, uint index) { return (dungeon->biome_array [index]->temperature); }
 static uint   dungeon_biome_humidity    (dungeon_structure dungeon, uint index) { return (dungeon->biome_array [index]->humidity);    }
 
-static uint dungeon_landmark_define (dungeon_structure dungeon, const char * name, uint biome, bool clip) {
+static uint dungeon_landmark_define (dungeon_structure dungeon, char * name, uint biome, bool clip) {
 	dungeon_landmark_definition landmark = arena_add (sizeof (* landmark));
 
 	fatal_failure (dungeon == null, "landmark_define: Dungeon is not configured.");
@@ -128,7 +128,7 @@ static char * dungeon_landmark_name  (dungeon_structure dungeon, uint index) { r
 static uint   dungeon_landmark_biome (dungeon_structure dungeon, uint index) { return (dungeon->landmark_array [index]->biome); }
 static bool   dungeon_landmark_clip  (dungeon_structure dungeon, uint index) { return (dungeon->landmark_array [index]->clip);  }
 
-static uint dungeon_expertise_define (dungeon_structure dungeon, const char * name) {
+static uint dungeon_expertise_define (dungeon_structure dungeon, char * name) {
 	dungeon_expertise_definition expertise = arena_add (sizeof (* expertise));
 
 	fatal_failure (dungeon == null, "expertise_define: Dungeon is not configured.");
@@ -145,7 +145,7 @@ static uint dungeon_expertise_define (dungeon_structure dungeon, const char * na
 
 static char * dungeon_expertise_name (dungeon_structure dungeon, uint index) { return (dungeon->expertise_array [index]->name); }
 
-static uint dungeon_attribute_define (dungeon_structure dungeon, const char * name, uint base, uint limit) {
+static uint dungeon_attribute_define (dungeon_structure dungeon, char * name, uint base, uint limit) {
 	dungeon_attribute_definition attribute = arena_add (sizeof (* attribute));
 
 	fatal_failure (dungeon == null, "attribute_define: Dungeon is not configured.");
@@ -167,7 +167,7 @@ static char * dungeon_attribute_name  (dungeon_structure dungeon, uint index) {
 static uint   dungeon_attribute_base  (dungeon_structure dungeon, uint index) { return (dungeon->attribute_array [index]->base);  }
 static uint   dungeon_attribute_limit (dungeon_structure dungeon, uint index) { return (dungeon->attribute_array [index]->limit); }
 
-static uint dungeon_skill_define (dungeon_structure dungeon, const char * name, uint base, uint limit) {
+static uint dungeon_skill_define (dungeon_structure dungeon, char * name, uint base, uint limit) {
 	dungeon_skill_definition skill = arena_add (sizeof (* skill));
 
 	fatal_failure (dungeon == null, "skill_define: Dungeon is not configured.");
@@ -189,7 +189,7 @@ static char * dungeon_skill_name  (dungeon_structure dungeon, uint index) { retu
 static uint   dungeon_skill_base  (dungeon_structure dungeon, uint index) { return (dungeon->skill_array [index]->base);  }
 static uint   dungeon_skill_limit (dungeon_structure dungeon, uint index) { return (dungeon->skill_array [index]->limit); }
 
-static uint dungeon_resource_define (dungeon_structure dungeon, const char * name, uint base, uint limit, uint value, uint trade) {
+static uint dungeon_resource_define (dungeon_structure dungeon, char * name, uint base, uint limit, uint value, uint trade) {
 	dungeon_resource_definition resource = arena_add (sizeof (* resource));
 
 	fatal_failure (dungeon == null, "resource_define: Dungeon is not configured.");
@@ -215,7 +215,7 @@ static uint   dungeon_resource_limit (dungeon_structure dungeon, uint index) { r
 static uint   dungeon_resource_value (dungeon_structure dungeon, uint index) { return (dungeon->resource_array [index]->value); }
 static uint   dungeon_resource_trade (dungeon_structure dungeon, uint index) { return (dungeon->resource_array [index]->trade); }
 
-static uint dungeon_item_slot_define (dungeon_structure dungeon, const char * name) {
+static uint dungeon_item_slot_define (dungeon_structure dungeon, char * name) {
 	dungeon_item_slot_definition item_slot = arena_add (sizeof (* item_slot));
 
 	fatal_failure (dungeon == null, "item_slot_define: Dungeon is not configured.");
@@ -232,7 +232,7 @@ static uint dungeon_item_slot_define (dungeon_structure dungeon, const char * na
 
 static char * dungeon_item_slot_name (dungeon_structure dungeon, uint index) { return (dungeon->item_slot_array [index]->name); }
 
-static uint dungeon_item_define (dungeon_structure dungeon, const char * name, uint slot, uint effect) {
+static uint dungeon_item_define (dungeon_structure dungeon, char * name, uint slot, uint effect) {
 	dungeon_item_definition item = arena_add (sizeof (* item));
 
 	fatal_failure (dungeon == null, "item_define: Dungeon is not configured.");
diff --git a/xuxuxu.c b/xuxuxu.c
index ee77e9c..3e929ec 100755
--- a/xuxuxu.c
+++ b/xuxuxu.c
@@ -19,7 +19,7 @@ static uint x      = 0;
 static uint y      = 0;
 
 static void render_character (char character) {
-	const ulong font_code [font_count] = {
+	ulong font_code [font_count] = {
 		0x0000000000000000,             0x00180018183c3c18,             0x0000000000363636,             0x006c6cfe6cfe6c6c,
 		0x00187ed07c16fc30,             0x0060660c18306606,             0x00dc66b61c36361c,             0x0000000000181818,
 		0x0030180c0c0c1830,             0x000c18303030180c,             0x0000187e3c7e1800,             0x000018187e181800,
@@ -56,7 +56,7 @@ static void render_character (char character) {
 	x += font_width + 1;
 }
 
-static void render_string (const char * string, uint length) {
+static void render_string (char * string, uint length) {
 	for (uint offset = 0; offset < length; ++offset) {
 		if (string [offset] == '\t') {
 			x += font_width * font_indent;
@@ -74,9 +74,9 @@ int main (void) {
 	uint   length = 0;
 	char * buffer = null;
 
-	const char separator [] = ".,:;<=>+-*/%!&~^()[]{}'\" \t\r\n";
+	char separator [] = ".,:;<=>+-*/%!&~^()[]{}'\" \t\r\n";
 
-	const char * keywords [] = {
+	char * keywords [] = {
 		"register", "volatile", "auto",     "const",    "static",   "extern",   "if",       "else",
 		"do",       "while",    "for",      "continue", "switch",   "case",     "default",  "break",
 		"enum",     "union",    "struct",   "typedef",  "goto",     "void",     "return",   "sizeof",
diff --git a/xyntax.h b/xyntax.h
index 849d44c..eed650c 100755
--- a/xyntax.h
+++ b/xyntax.h
@@ -63,7 +63,7 @@ static syntax_structure * syntax_deinitialize (syntax_structure * syntax) {
 	return (deallocate (syntax));
 }
 
-static uint syntax_define (syntax_structure * syntax, bool enrange, bool derange, const char * begin, const char * end, char escape,
+static uint syntax_define (syntax_structure * syntax, bool enrange, bool derange, char * begin, char * end, char escape,
                            uint colour, uint effect) {
 	++syntax->count;
 
@@ -99,7 +99,7 @@ static uint syntax_define (syntax_structure * syntax, bool enrange, bool derange
 	return (current);
 }
 
-static uint syntax_select (syntax_structure * syntax, const char * string, uint * length) {
+static uint syntax_select (syntax_structure * syntax, char * string, uint * length) {
 	uint offset = 0;
 	uint subset = 0;
 	uint select = 0;
-- 
2.39.5