diff --git a/README.md b/README.md
index ef03049..5769955 100644
--- a/README.md
+++ b/README.md
@@ -1,3 +1,6 @@
 # xarbon
 
-Static version of Xarbon...
\ No newline at end of file
+Static version of Xarbon...
+
+Compile: `sh compile.sh`
+Install: `sudo sh install.sh`
diff --git a/compile.sh b/compile.sh
new file mode 100755
index 0000000..9cae55a
--- /dev/null
+++ b/compile.sh
@@ -0,0 +1,7 @@
+#!/bin/bash
+
+set -xe
+
+gcc -std=gnu99 -Wall -Wno-comment -Wno-unused-variable -Wno-unused-function -Ofast -o xarbon xarbon.c -lpng
+
+exit
diff --git a/install.sh b/install.sh
new file mode 100755
index 0000000..94676bc
--- /dev/null
+++ b/install.sh
@@ -0,0 +1,7 @@
+#!/bin/bash
+
+set -xe
+
+cp -f xarbon /usr/local/bin/xarbon
+
+exit
diff --git a/xanguage.h b/xanguage.h
new file mode 100755
index 0000000..c30e6e2
--- /dev/null
+++ b/xanguage.h
@@ -0,0 +1,201 @@
+/// __  ____ _ _ __   __ _ _   _  __ _  __ _  ___
+/// \ \/ / _` | '_ \ / _` | | | |/ _` |/ _` |/ _ \
+///  >  < (_| | | | | (_| | |_| | (_| | (_| |  __/
+/// /_/\_\__,_|_| |_|\__, |\__,_|\__,_|\__, |\___|
+///                  |___/             |___/
+///
+/// Copyright (c) 1997 - Ognjen 'xolatile' Milan Robovic
+///
+/// xolatile@chud.cyou - xanguage - Syntax definitions of programming languages that I care about (and some that I don't care about).
+///
+/// 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 enum {
+	language_common,                language_ada,                   language_c,                     language_cpp,
+	language_d,                     language_eaxhla,                language_flat,                  language_fortran,
+	language_pascal,                language_python,                language_go,                    language_lua,
+	language_bash,                  language_haskell,               language_valgrind,
+	language_count
+} language_enumeration;
+
+typedef struct {
+	uint comment_colour;
+	uint processor_colour;
+	uint character_colour;
+	uint string_colour;
+	uint keyword_colour;
+	uint type_colour;
+	uint bracket_colour;
+	uint operator_colour;
+	uint number_colour;
+	uint lowercase_colour;
+	uint uppercase_colour;
+	uint underscore_colour;
+	uint register_colour;
+	uint extension_colour;
+	uint fatal_colour;
+	uint comment_effect;
+	uint processor_effect;
+	uint character_effect;
+	uint string_effect;
+	uint keyword_effect;
+	uint type_effect;
+	uint bracket_effect;
+	uint operator_effect;
+	uint number_effect;
+	uint lowercase_effect;
+	uint uppercase_effect;
+	uint underscore_effect;
+	uint register_effect;
+	uint extension_effect;
+	uint fatal_effect;
+} language_structure;
+
+#include "./xanguage/common.h"
+#include "./xanguage/ada.h"
+#include "./xanguage/c.h"
+#include "./xanguage/c++.h"
+#include "./xanguage/d.h"
+#include "./xanguage/eaxhla.h"
+#include "./xanguage/flat.h"
+#include "./xanguage/fortran.h"
+#include "./xanguage/pascal.h"
+#include "./xanguage/python.h"
+#include "./xanguage/go.h"
+#include "./xanguage/lua.h"
+#include "./xanguage/bash.h"
+#include "./xanguage/haskell.h"
+#include "./xanguage/valgrind.h"
+
+static language_structure * language_initialize (bool true_colour) {
+	language_structure * language = allocate (sizeof (* language));
+
+	if (true_colour == true) {
+		language->comment_colour    = 0xff777777u;
+		language->processor_colour  = 0xff3377aau;
+		language->character_colour  = 0xff7733ccu;
+		language->string_colour     = 0xffcc3377u;
+		language->keyword_colour    = 0xff33cceeu;
+		language->type_colour       = 0xff55cceeu;
+		language->bracket_colour    = 0xffee5533u;
+		language->operator_colour   = 0xffeeaa33u;
+		language->number_colour     = 0xffee33aau;
+		language->lowercase_colour  = 0xffccccccu;
+		language->uppercase_colour  = 0xffeeeeeeu;
+		language->underscore_colour = 0xffaaaaaau;
+		language->register_colour   = 0xff5577aau;
+		language->extension_colour  = 0xff55aaccu;
+		language->fatal_colour      = 0xffcc7755u;
+	} else {
+		language->comment_colour    = colour_grey;
+		language->processor_colour  = colour_cyan;
+		language->character_colour  = colour_pink;
+		language->string_colour     = colour_pink;
+		language->keyword_colour    = colour_yellow;
+		language->type_colour       = colour_yellow;
+		language->bracket_colour    = colour_blue;
+		language->operator_colour   = colour_cyan;
+		language->number_colour     = colour_pink;
+		language->lowercase_colour  = colour_white;
+		language->uppercase_colour  = colour_white;
+		language->underscore_colour = colour_white;
+		language->register_colour   = colour_cyan;
+		language->extension_colour  = colour_yellow;
+		language->fatal_colour      = colour_red;
+		language->comment_effect    = effect_bold;
+		language->processor_effect  = effect_italic;
+		language->character_effect  = effect_bold;
+		language->string_effect     = effect_normal;
+		language->keyword_effect    = effect_bold;
+		language->type_effect       = effect_normal;
+		language->bracket_effect    = effect_bold;
+		language->operator_effect   = effect_normal;
+		language->number_effect     = effect_bold;
+		language->lowercase_effect  = effect_normal;
+		language->uppercase_effect  = effect_bold;
+		language->underscore_effect = effect_italic;
+		language->register_effect   = effect_italic;
+		language->extension_effect  = effect_italic;
+		language->fatal_effect      = effect_bold;
+	}
+
+	return (language);
+}
+
+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 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 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 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 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) {
+	if (syntax->count == 0) {
+		if ((select == file_type_c_source) || (select == file_type_c_header)) {
+			language_highlight_c (language, syntax);
+		} else if ((select == file_type_ada_sexy_body) || (select == file_type_ada_specification)) {
+			language_highlight_ada (language, syntax);
+		} else if ((select == file_type_cpp_source) || (select == file_type_cpp_header)) {
+			language_highlight_cpp (language, syntax);
+		} else if (select == file_type_flat_assembly) {
+			language_highlight_flat (language, syntax);
+		} else if (select == file_type_fortran_90_source) {
+			language_highlight_fortran (language, syntax);
+		} else if (select == file_type_pascal_source) {
+			language_highlight_pascal (language, syntax);
+		} else if (select == file_type_eax_assembly) {
+			language_highlight_eaxhla (language, syntax);
+		} else if (select == file_type_python_script) {
+			language_highlight_python (language, syntax);
+		} else {
+			language_highlight_common (language, syntax);
+		}
+	}
+}
diff --git a/xanguage/ada.h b/xanguage/ada.h
new file mode 100755
index 0000000..0e453b1
--- /dev/null
+++ b/xanguage/ada.h
@@ -0,0 +1,31 @@
+static void language_highlight_ada (language_structure * language, syntax_structure * syntax) {
+	const char * separators = ".,:;<=>+-*/&|()\" \t\r\n";
+
+	const 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",
+		"and",          "for",          "out",          "array",        "function",     "at",           "tagged",       "generic",
+		"package",      "task",         "begin",        "goto",         "pragma",       "body",         "private",      "then",
+		"type",         "case",         "in",           "constant",     "until",        "is",           "raise",        "use",
+		"if",           "declare",      "range",        "delay",        "limited",      "record",       "when",         "delta",
+		"loop",         "rem",          "while",        "digits",       "renames",      "with",         "do",           "mod",
+		"requeue",      "xor",          "procedure",    "protected",    "interface",    "synchronized", "exception",    "overriding",
+		"terminate"
+	};
+
+	syntax_define (syntax, false, false, "--", "\n", '\0', language->comment_colour,   language->comment_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);
+	}
+
+	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);
+}
diff --git a/xanguage/bash.h b/xanguage/bash.h
new file mode 100755
index 0000000..351c2f3
--- /dev/null
+++ b/xanguage/bash.h
@@ -0,0 +1,24 @@
+static void language_highlight_bash (language_structure * language, syntax_structure * syntax) {
+	const char * separators = ".,:;<=>+-*/%!&~^?|@#$()[]{}'\" \t\r\n";
+
+	const char * keywords [] = {
+		"exit",         "set",          "elif",         "done",         "in",           "then",         "function",     "fi",
+		"if",           "else",         "do",           "while",        "for"
+	};
+
+	syntax_define (syntax, false, false, "#",   "\n", '\0', language->comment_colour, language->comment_effect);
+	syntax_define (syntax, false, false, "'",   "'",  '\0', language->string_colour,  language->string_effect);
+	syntax_define (syntax, false, false, "\"",  "\"", '\0', 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);
+	}
+
+	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/c++.h b/xanguage/c++.h
new file mode 100755
index 0000000..131176d
--- /dev/null
+++ b/xanguage/c++.h
@@ -0,0 +1,53 @@
+static void language_highlight_cpp (language_structure * language, syntax_structure * syntax) {
+	const char * separators = ".,:;<=>+-*/%!&~^?|()[]{}'\" \t\r\n";
+
+	const char * keywords [] = {
+		"alignas",      "alignof",      "and",          "asm",          "auto",         "break",        "case",
+		"catch",        "class",        "compl",        "concept",      "const",        "consteval",    "constexpr",
+		"constinit",    "continue",     "decltype",     "default",      "delete",       "do",           "else",
+		"enum",         "explicit",     "export",       "extern",       "false",        "for",          "friend",
+		"goto",         "if",           "inline",       "mutable",      "namespace",    "new",
+		"noexcept",     "not",          "nullptr",      "operator",     "or",           "private",      "protected",    "public",
+		"reflexpr",     "register",     "requires",     "return",       "sizeof",       "static",
+		"struct",       "switch",       "synchronized", "template",     "this",         "throw",        "true",         "try",
+		"typedef",      "typeid",       "typename",     "union",        "using",        "virtual",
+		"volatile",     "while",        "xor",          "final",        "override",     "import",       "module"
+	};
+
+	const 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 [] = {
+		"std",          "FILE",         "DIR",          "EOF",          "va_arg",       "va_start",     "va_end",       "va_copy"
+	};
+
+	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/c.h b/xanguage/c.h
new file mode 100755
index 0000000..8005724
--- /dev/null
+++ b/xanguage/c.h
@@ -0,0 +1,49 @@
+static void language_highlight_c (language_structure * language, syntax_structure * syntax) {
+	const char * separators = ".,:;<=>+-*/%!&~^?|()[]{}'\" \t\r\n";
+
+	const 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 [] = {
+		"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 [] = {
+		"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"
+	};
+
+	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/common.h b/xanguage/common.h
new file mode 100755
index 0000000..652b10b
--- /dev/null
+++ b/xanguage/common.h
@@ -0,0 +1,9 @@
+static void language_highlight_common (language_structure * language, syntax_structure * syntax) {
+	const 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);
+	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);
+}
diff --git a/xanguage/d.h b/xanguage/d.h
new file mode 100755
index 0000000..d5a043a
--- /dev/null
+++ b/xanguage/d.h
@@ -0,0 +1,49 @@
+static void language_highlight_d (language_structure * language, syntax_structure * syntax) {
+	const char * separators = ".,:;<=>+-*/%!&~^?|@()[]{}'\"` \t\r\n";
+
+	const 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",
+		"delegate",     "delete",       "deprecated",   "do",           "double",       "else",         "enum",         "export",
+		"extern",       "false",        "final",        "finally",      "float",        "for",          "foreach",      "with",
+		"function",     "goto",         "idouble",      "if",           "ifloat",       "immutable",    "import",       "in",
+		"inout",        "int",          "interface",    "invariant",    "ireal",        "is",           "lazy",         "long",
+		"macro",        "mixin",        "module",       "new",          "nothrow",      "null",         "out",          "override",
+		"package",      "pragma",       "private",      "protected",    "public",       "pure",         "real",         "ref",
+		"return",       "scope",        "shared",       "short",        "static",       "struct",       "super",        "switch",
+		"synchronized", "template",     "this",         "throw",        "true",         "try",          "typeid",       "typeof",
+		"ubyte",        "ucent",        "uint",         "ulong",        "union",        "unittest",     "ushort",       "version",
+		"void",         "wchar",        "while",        "foreach_reverse"
+	};
+
+	const 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",
+		"string"
+	};
+
+	syntax_define (syntax, false, false, "/+",  "+/", '\0', language->comment_colour,   language->comment_effect);
+	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, "'",   "'",  '\\', language->character_colour, language->character_effect);
+	syntax_define (syntax, false, false, "\"",  "\"", '\\', language->string_colour,    language->string_effect);
+	syntax_define (syntax, false, false, "`",   "`",  '\0', 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);
+	}
+
+	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/eaxhla.h b/xanguage/eaxhla.h
new file mode 100755
index 0000000..ca99f20
--- /dev/null
+++ b/xanguage/eaxhla.h
@@ -0,0 +1,79 @@
+static void language_highlight_eaxhla (language_structure * language, syntax_structure * syntax) {
+	const char * separators = ".,+-*/[]<>=; \t\r\n";
+
+	const 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 [] = {
+		"s8",           "s16",          "s32",          "s64",          "u8",           "u16",          "u32",          "u64",
+		"f32",          "f64",          "f80",          "v0",           "s128",         "u128",         "s256",         "u256",
+		"s512",         "u512"
+	};
+
+	const 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",
+		"cmovnpe",      "cmovpo",       "cmovnpo",      "cmovpe",       "cmovnb",        "cmovae",       "cmovnbe",       "cmova",
+		"cmovna",       "cmovbe",       "cmovnae",      "cmovb",        "cmovnl",        "cmovge",       "cmovnle",       "cmovg",
+		"setnpe",       "setpo",        "setnpo",       "setpe",        "setnb",         "setae",        "setnbe",        "seta",
+		"setna",        "setbe",        "setnae",       "setb",         "setnl",         "setge",        "setnle",        "setg",
+		"setng",        "setle",        "setnge",       "setl",         "enter",         "call",         "jmp",           "mov",
+		"add",          "or",           "adc",          "sbb",          "and",           "sub",          "xor",           "cmp",
+		"inc",          "dec",          "not",          "neg",          "mul",           "imul",         "div",           "idiv",
+		"fadd",         "fmul",         "fcom",         "fcomp",        "fsub",          "fsubr",        "fdiv",          "fdivr",
+		"rol",          "ror",          "rcl",          "rcr",          "sal",           "shr",          "shl",           "sar",
+		"nop",          "retn",         "retf",         "leave",        "popf",          "pushf",        "in",            "out",
+		"syscall",      "cpuid",        "fnop",         "fchs",         "fabs",          "ftst",         "fxam",          "fld1",
+		"fldl2t",       "fldl2e",       "fldpi",        "fldlg2",       "fldln2",        "fldz",         "f2xm1",         "fyl2x",
+		"fptan",        "fpatan",       "fxtract",      "fprem1",       "fdecstp",       "fincstp",      "fprem",         "fyl2xp1",
+		"fsqrt",        "fsincos",      "frndint",      "fscale",       "fsin",          "fcos",         "pop",           "push",
+		"bswap",        "bsf",          "bsr",          "loop",         "loope",         "loopne"
+	};
+
+	const 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",
+		"r8d",          "r9d",          "r10d",         "r11d",         "r12d",         "r13d",         "r14d",         "r15d",
+		"ax",           "cx",           "dx",           "bx",           "sp",           "bp",           "si",           "di",
+		"r8w",          "r9w",          "r10w",         "r11w",         "r12w",         "r13w",         "r14w",         "r15w",
+		"al",           "cl",           "dl",           "bl",           "spl",          "bpl",          "sil",          "dil",
+		"r8b",          "r9b",          "r10b",         "r11b",         "r12b",         "r13b",         "r14b",         "r15b"
+	};
+
+	int word;
+
+	syntax_define (syntax, false, false, "#",   "\n", '\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", '\0', language->comment_colour,   language->comment_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 (declarations); ++word) {
+		syntax_define (syntax, false, true, declarations [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 (instructions); ++word) {
+		syntax_define (syntax, false, true, instructions [word], separators, '\0', language->extension_colour, language->extension_effect);
+	}
+
+	for (ulong word = 0; word < array_length (registers); ++word) {
+		syntax_define (syntax, false, true, registers [word], separators, '\0', language->register_colour, language->register_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/flat.h b/xanguage/flat.h
new file mode 100755
index 0000000..eabf301
--- /dev/null
+++ b/xanguage/flat.h
@@ -0,0 +1,66 @@
+static void language_highlight_flat (language_structure * language, syntax_structure * syntax) {
+	const char * separators = ".,+-=:;(){}[]%$<> \t\r\n";
+
+	const char * declarations [] = {
+		"format",       "executable",   "readable",     "writable",     "segment",      "sector",       "entry",        "macro",
+		"db",           "dw",           "dd",           "dq",           "rb",           "rw",           "rd",           "rq"
+	};
+
+	const 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",
+		"cmovg",        "cmovng",       "cmovge",       "cmovnge",      "cmovl",        "cmovnl",       "cmovle",       "cmovnle",
+		"cmova",        "cmovna",       "cmovae",       "cmovnae",      "cmovb",        "cmovnb",       "cmovbe",       "cmovnbe",
+		"cmovs",        "cmovns",       "cmovo",        "cmovno",       "cmovp",        "cmovnp",       "cmovpo",       "cmovpe",
+		"cmp",          "cmps",         "cmpsb",        "cmpsw",        "cmpsd",        "cmpsq",        "cmpxchg",      "lea",
+		"monitor",      "cpuid",        "in",           "out",          "syscall",      "sysenter",     "sysret",       "sysexit",
+		"swap",         "bswap",        "pop",          "push",         "call",         "ret",          "enter",        "leave",
+		"and",          "or",           "not",          "neg",          "sal",          "sar",          "shl",          "shr",
+		"inc",          "dec",          "add",          "sub",          "mul",          "div",          "imul",         "idiv",
+		"nop",          "fnop",         "adc",          "sbb",          "aaa",          "aas",          "aam",          "aad",
+		"jmp",          "jrcxz",        "jc",           "jnc",          "je",           "jne",          "jz",           "jnz",
+		"jg",           "jng",          "jge",          "jnge",         "jl",           "jnl",          "jle",          "jnle",
+		"ja",           "jna",          "jae",          "jnae",         "jb",           "jnb",          "jbe",          "jnbe",
+		"js",           "jns",          "jo",           "jno",          "jp",           "jnp",          "jpo",          "jpe",
+		"rep",          "repe",         "repz",         "repne",        "repnz",        "loop",         "loope",        "loopne"
+	};
+
+	const 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",
+		"r8d",          "r9d",          "r10d",         "r11d",         "r12d",         "r13d",         "r14d",         "r15d",
+		"ax",           "cx",           "dx",           "bx",           "sp",           "bp",           "si",           "di",
+		"r8w",          "r9w",          "r10w",         "r11w",         "r12w",         "r13w",         "r14w",         "r15w",
+		"al",           "cl",           "dl",           "bl",           "spl",          "bpl",          "sil",          "dil",
+		"r8b",          "r9b",          "r10b",         "r11b",         "r12b",         "r13b",         "r14b",         "r15b",
+		"ah",           "ch",           "dh",           "bh"
+	};
+
+	int word;
+
+	syntax_define (syntax, false, false, ";",  "\n", '\0', language->comment_colour, language->comment_effect);
+	syntax_define (syntax, false, false, "'",  "'",  '\\', language->string_colour,  language->string_effect);
+	syntax_define (syntax, false, false, "\"", "\"", '\\', language->string_colour,  language->string_effect);
+
+	for (ulong word = 0; word < array_length (declarations); ++word) {
+		syntax_define (syntax, false, true, declarations [word], separators, '\0', language->keyword_colour, language->keyword_effect);
+	}
+
+	for (ulong word = 0; word < array_length (instructions); ++word) {
+		syntax_define (syntax, false, true, instructions [word], separators, '\0', language->extension_colour, language->extension_effect);
+	}
+
+	for (ulong word = 0; word < array_length (registers); ++word) {
+		syntax_define (syntax, false, true, registers [word], separators, '\0', language->register_colour, language->register_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/fortran.h b/xanguage/fortran.h
new file mode 100755
index 0000000..e24923a
--- /dev/null
+++ b/xanguage/fortran.h
@@ -0,0 +1,47 @@
+static void language_highlight_fortran (language_structure * language, syntax_structure * syntax) {
+	const char * separators = ",:<=>+-*/&()[]\"\' \t\r\n";
+
+	const 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",
+		"forall",       "format",       "function",     "goto",         "if",           "implicit",     "inquire",      "intent",
+		"intrinsic",    "module",       "namelist",     "none",         "nullify",      "only",         "open",         "optional",
+		"parameter",    "pointer",      "print",        "private",      "program",      "public",       "read",         "recursive",
+		"return",       "rewind",       "save",         "select",       "sequence",     "stop",         "subroutine",   "target",
+		"then",         "to",           "type",         "use",          "where",        "write"
+	};
+
+	const char * types [] = {
+		"character",    "integer",      "logical",      "real",         "complex"
+	};
+
+	const char * subkeywords [] = {
+		".and.",        ".or.",         ".not.",        ".true.",       ".false.",      "in",           "out",          "len",
+		"dimension",    "modulo",       "advance"
+	};
+
+	syntax_define (syntax, false, false, "!",  "\n", '\0', language->comment_colour,   language->comment_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 (subkeywords); ++word) {
+		syntax_define (syntax, false, true, subkeywords [word], separators, '\0', language->processor_colour, language->processor_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);
+	}
+
+	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/go.h b/xanguage/go.h
new file mode 100755
index 0000000..38919e8
--- /dev/null
+++ b/xanguage/go.h
@@ -0,0 +1,46 @@
+static void language_highlight_go (language_structure * language, syntax_structure * syntax) {
+	const char * separators = ".,:;<=>+-*/%!&~^?|()[]{}'\"` \t\r\n";
+
+	const 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 [] = {
+		"map",          "uint",         "int",          "uintptr",      "uint8",        "uint16",       "uint32",       "uint64",
+		"int8",         "int16",        "int32",        "int64",        "float32",      "float64",      "complex64",    "complex128",
+		"byte",         "rune",         "string",       "chan",         "bool"
+
+	};
+
+	const char * commons [] = {
+		"true",         "false",        "nil",          "err"
+	};
+
+	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, "'",   "'",  '\\', language->character_colour, language->character_effect);
+	syntax_define (syntax, false, false, "\"",  "\"", '\\', language->string_colour,    language->string_effect);
+	syntax_define (syntax, false, false, "`",   "`",  '\0', 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/haskell.h b/xanguage/haskell.h
new file mode 100755
index 0000000..5766d29
--- /dev/null
+++ b/xanguage/haskell.h
@@ -0,0 +1,34 @@
+static void language_highlight_haskell (language_structure * language, syntax_structure * syntax) {
+	const char * separators = ".,:;<=>+-*/%!@#$&~^?|()[]{}'\" \t\r\n";
+
+	const 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 [] = {
+		"Int",          "Integer",      "String",       "Char",         "Float",        "Boolean"
+	};
+
+	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, "'",   "'",  '\\', 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);
+	}
+
+	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
new file mode 100755
index 0000000..1509e86
--- /dev/null
+++ b/xanguage/lua.h
@@ -0,0 +1,50 @@
+static void language_highlight_lua (language_structure * language, syntax_structure * syntax) {
+	const char * separators = ".,:;<=>+-*/%~^#|()[]{}'\" \t\r\n";
+
+	const 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 [] = {
+		"boolean",      "number",       "string",       "userdata",     "function",     "thread",       "table"
+	};
+
+	const 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",
+		"rad",          "sqrt",         "acos",         "cos",          "fmod",         "max",          "random",       "tan",
+		"asin",         "cosh",         "frexp",        "min",          "randomseed",   "tanh",         "atan",         "deg",
+		"ldexp",        "modf",         "sin",          "atan2",        "sinh",         "exp",          "log",          "pow",
+		"open",         "close",        "read",         "write",        "input",        "output",       "format",       "lines",
+		"upper",        "lower",        "find",         "gfind",        "match",        "gmatch",       "sub",          "gsub",
+		"len",          "rep",          "char",         "dump",         "reverse",      "byte"
+	};
+
+	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, "'",     "'",  '\\', 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/pascal.h b/xanguage/pascal.h
new file mode 100755
index 0000000..21bac25
--- /dev/null
+++ b/xanguage/pascal.h
@@ -0,0 +1,29 @@
+static void language_highlight_pascal (language_structure * language, syntax_structure * syntax) {
+	const char * separators = ".,:;<=>+-*/&@#$%^()[] \t\r\n";
+
+	const 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",
+		"label",        "mod",          "nil",          "not",          "object",       "of",           "operator",     "or",
+		"packed",       "procedure",    "program",      "record",       "reintroduce",  "repeat",       "self",         "set",
+		"shl",          "shr",          "string",       "then",         "to",           "type",         "unit",         "until",
+		"uses",         "var",          "while",        "with"
+	};
+
+	syntax_define (syntax, false, false, "//", "\n", '\0', language->comment_colour, language->comment_effect);
+	syntax_define (syntax, false, false, "(*", "*)", '\0', language->comment_colour, language->comment_effect);
+	syntax_define (syntax, false, false, "{",  "}",  '\0', language->comment_colour, language->comment_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);
+	}
+
+	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);
+}
diff --git a/xanguage/python.h b/xanguage/python.h
new file mode 100755
index 0000000..ccd8dcd
--- /dev/null
+++ b/xanguage/python.h
@@ -0,0 +1,47 @@
+static void language_highlight_python (language_structure * language, syntax_structure * syntax) {
+	const char * separators = ".,:;<=>+-*/%!&~^?|()[]{}'\" \t\r\n";
+
+	const 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",
+		"or",           "pass",         "raise",        "return",       "True",         "try",          "while",        "with",
+		"yield",        "async",        "await"
+	};
+
+	const 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",
+		"divmod",       "enumerate",    "eval",         "execfile",     "exit",         "file",         "filter",       "float",
+		"format",       "frozenset",    "getattr",      "globals",      "hasattr",      "hash",         "help",         "hex",
+		"id",           "input",        "int",          "intern",       "isinstance",   "issubclass",   "iter",         "len",
+		"license",      "list",         "locals",       "long",         "map",          "max",          "memoryview",   "min",
+		"next",         "object",       "oct",          "open",         "ord",          "pow",          "property",     "quit",
+		"range",        "raw_input",    "reduce",       "reload",       "repr",         "reversed",     "round",        "set",
+		"setattr",      "slice",        "sorted",       "staticmethod", "str",          "sum",          "super",        "tuple",
+		"type",         "unichr",       "unicode",      "vars",         "xrange",       "zip"
+	};
+
+	syntax_define (syntax, false, false, "#",       "\n",     '\0', language->comment_colour,   language->comment_effect);
+	syntax_define (syntax, false, false, "'''",     "'''",    '\0', language->comment_colour,   language->comment_effect);
+	syntax_define (syntax, false, false, "\"\"\"",  "\"\"\"", '\0', language->comment_colour,   language->comment_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 (subkeywords); ++word) {
+		syntax_define (syntax, false, true, subkeywords [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/valgrind.h b/xanguage/valgrind.h
new file mode 100755
index 0000000..411f580
--- /dev/null
+++ b/xanguage/valgrind.h
@@ -0,0 +1,25 @@
+static void language_highlight_valgrind (language_structure * language, syntax_structure * syntax) {
+	const char * separators = ".,:;<=>+-*/%!&~^?|@#$()[]{}'\" \t\r\n";
+
+	const char * titles [] = {
+		//~"exit",         "set",          "elif",         "done",         "in",           "then",         "function",     "fi",
+		"HEAP",         "LEAK",         "ERROR",        "SUMMARY"
+	};
+
+	syntax_define (syntax, false, false, "==",  "==", '\0', language->comment_colour,   language->comment_effect);
+	syntax_define (syntax, false, false, "\"",  "\"", '\0', language->string_colour,    language->string_effect);
+	syntax_define (syntax, false, false, "(",   ")",  '\0', language->lowercase_colour, language->lowercase_effect);
+	syntax_define (syntax, false, false, "0x",  ":",  '\0', language->string_colour,    language->string_effect);
+
+	for (ulong word = 0; word < array_length (titles); ++word) {
+		syntax_define (syntax, false, true, titles [word], separators, '\0', language->fatal_colour, language->fatal_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",                 ": ()\t\r\n", '\0', language->number_colour,    language->number_effect);
+	syntax_define (syntax, true, true, "abcdefghijklmnopqrstuvwxyz", separators,   '\0', language->uppercase_colour, language->uppercase_effect);
+	syntax_define (syntax, true, true, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", separators,   '\0', language->uppercase_colour, language->uppercase_effect);
+	syntax_define (syntax, true, true, "_",                          separators,   '\0', language->uppercase_colour, language->uppercase_effect);
+}
diff --git a/xarbon b/xarbon
new file mode 100755
index 0000000..3841447
Binary files /dev/null and b/xarbon differ
diff --git a/xarbon.c b/xarbon.c
new file mode 100755
index 0000000..ac07d7a
--- /dev/null
+++ b/xarbon.c
@@ -0,0 +1,276 @@
+///                 _
+/// __  ____ _ _ __| |__   ___  _ __
+/// \ \/ / _` | '__| '_ \ / _ \| '_ |
+///  >  < (_| | |  | |_) | (_) | | | |
+/// /_/\_\__,_|_|  |_.__/ \___/|_| |_|
+///
+/// Copyright (c) 1997 - Ognjen 'xolatile' Milan Robovic
+///
+/// xolatile@chud.cyou - xarbon - Source code renderer to PNG image, very slow but self-contained, hardcoded font.
+///
+/// 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...
+
+#define use_png_library
+
+#include "./xtandard.h"
+#include "./xyntax.h"
+#include "./xanguage.h"
+#include "./xormat.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 * render_image  = null;
+static uint   render_width  = 0;
+static uint   render_height = 0;
+static uint   line_number   = 0;
+static uint   line_digits   = 0;
+
+static void conditionally_exit (language_structure * language, syntax_structure * syntax, bool terminate) {
+	syntax   = syntax_deinitialize   (syntax);
+	language = language_deinitialize (language);
+
+	if (terminate == true) {
+		exit (log_success);
+	}
+}
+
+static void print_common (void) {
+	print ("/B/4xarbon/-: /4Source code PNG renderer/-\n\n");
+	print ("\tAuthor:  /4Ognjen 'xolatile' Milan Robovic/-\n");
+	print ("\tLicense: /4GNU//GPLv3/-\n\n");
+}
+
+static void print_help (void) {
+	print_common ();
+
+	print ("Example usage:\n\n");
+	print ("\t/6$ cat file.ext | xarbon [flags]/- /0---/- You need to pass language flag in this case.\n");
+	print ("\t/6$ xarbon [flags] < file.ext/-     /0---/- You need to pass language flag in this case.\n");
+	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) {
+		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));
+	}
+}
+
+static void print_version (void) {
+	print_common ();
+
+	print ("\tVersion: /40 (Zero)/-\n");
+}
+
+static uint fetch_width (const char * data) {
+	uint image_width = 0;
+	uint count       = 0;
+
+	do {
+		if (* data == '\t') {
+			count += tab_width;
+		} else if (* data == '\n') {
+			image_width = (++count > image_width) ? count : image_width;
+			count = 0;
+		} else {
+			++count;
+		}
+	} while (* (++data) != '\0');
+
+	return (image_width - 1);
+}
+
+static uint fetch_height (const char * data) {
+	uint image_height = 0;
+	uint count        = 0;
+
+	do {
+		if (* data == '\n') {
+			++image_height;
+		}
+	} while (* (++data) != '\0');
+
+	count = image_height + 1;
+
+	do {
+		++line_digits;
+
+		count /= 10;
+	} while (count > 0);
+
+	return (image_height + 1);
+}
+
+static void render_character (char character, uint * x, uint * y, uint colour) {
+	const ulong glyphmap [192] = {
+		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, 0x0000000000000000, 0x0000000000000000
+	};
+
+	for (ulong index = 0; index < 2; ++index) {
+		for (ulong bit = 64; bit > 0; --bit) {
+			ulong destination = (* y + (index << 3) - ((bit - 1) >> 3) + 7) * render_width + (* x - ((bit - 1) & 7) + 7);
+			ulong source      = (glyphmap [2 * (ulong) (character - ' ') + index] >> (bit - 1)) & 1;
+
+			render_image [destination] = (source) ? colour : background;
+		}
+	}
+
+	* x += font_width;
+}
+
+static void render_string (char * string, uint length, uint * x, uint * y, uint colour) {
+	for (uint offset = 0; offset < length; ++offset) {
+		if (string [offset] == '\t') {
+			* x += font_width * tab_width;
+		} else if (string [offset] == '\n') {
+			* y += font_height;
+			* x  = render_border;
+
+			render_string (format_to_string ((int) ++line_number, false, 10, (int) line_digits, ' '), line_digits, x, y, foreground);
+
+			* x += font_width;
+		} else {
+			render_character (string [offset], x, y, colour);
+		}
+	}
+}
+
+int main (int argc, char * * argv) {
+	uint   select = language_count;
+	uint   offset = 0;
+	uint   length = 0;
+	uint   x      = render_border;
+	uint   y      = render_border;
+	char * buffer = null;
+	char * dump   = null;
+
+	syntax_structure   * syntax   = syntax_initialize   (666);
+	language_structure * language = language_initialize (true);
+
+	for (int argument = 1; argument < argc; ++argument) {
+		if (argument_compare (argv [argument], "-h", "--help") == true) {
+			print_help         ();
+			conditionally_exit (language, syntax, true);
+		} else if (argument_compare (argv [argument], "-v", "--version") == true) {
+			print_version      ();
+			conditionally_exit (language, syntax, true);
+		} else if (argument_compare (argv [argument], "-o", "--output") == true) {
+			if (argument + 1 >= argc) {
+				print ("/f Expected output file name: /1%s/-\n", argv [argument]);
+				conditionally_exit (language, syntax, true);
+			}
+			++argument;
+			dump = string_duplicate (argv [argument]);
+			continue;
+		}
+
+		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);
+				select = index;
+				break;
+			}
+		}
+
+		if (file_exists (argv [argument]) == true) {
+			if (select == language_count) {
+				select = (uint) file_type (argv [argument]);
+			}
+			if (buffer == null) {
+				buffer = file_import (argv [argument]);
+			} continue;
+		} else {
+			print ("/f Unrecognized command line argument: /1%s/-\n", argv [argument]);
+			conditionally_exit (language, syntax, true);
+		}
+	}
+
+	if (dump == null) {
+		dump = string_duplicate ("xarbon.png");
+	}
+
+	if (select == language_count) {
+		select = language_common;
+	}
+
+	if (buffer == null) {
+		buffer = record ();
+	}
+
+	language_conditionally_select (language, syntax, select);
+
+	render_width  = fetch_width  (buffer) * font_width  + 2 * render_border;
+	render_height = fetch_height (buffer) * font_height + 2 * render_border;
+
+	render_width += (line_digits + 1) * font_width;
+
+	render_image = allocate (render_width * render_height * sizeof (* render_image));
+
+	for (offset = 0; offset < render_width * render_height; ++offset) {
+		render_image [offset] = background;
+	}
+
+	render_string (format_to_string ((int) ++line_number, false, 10, (int) line_digits, ' '), line_digits, & x, & y, foreground);
+
+	x += font_width;
+
+	for (offset = 0; buffer [offset] != '\0'; offset += length) {
+		select = syntax_select (syntax, & buffer [offset], & length);
+
+		render_string (& buffer [offset], length, & x, & y, (select >= syntax->count) ? background : (uint) syntax->colour [select]);
+	}
+
+	png_image_export (dump, render_image, render_width, render_height);
+
+	conditionally_exit (language, syntax, false);
+
+	render_image = deallocate (render_image);
+	buffer       = deallocate (buffer);
+	dump         = deallocate (dump);
+
+	return (log_success);
+}
diff --git a/xormat.h b/xormat.h
new file mode 100644
index 0000000..275fd8d
--- /dev/null
+++ b/xormat.h
@@ -0,0 +1,122 @@
+///                                 _
+/// __  _____  _ __ _ __ ___   __ _| |_
+/// \ \/ / _ \| '__| '_ ` _ \ / _` | __|
+///  >  < (_) | |  | | | | | | (_| | |_
+/// /_/\_\___/|_|  |_| |_| |_|\__,_|\__|
+///
+/// Copyright (c) 1997 - Ognjen 'xolatile' Milan Robovic
+///
+/// xolatile@chud.cyou - xormat - Very simple file format wrapper for things I hate but have to use anyway...
+///
+/// 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...
+
+#ifdef use_png_library
+#include "./xormat/png.h"
+#endif
+
+#ifdef use_jxl_library
+#include "./xormat/jxl.h"
+#endif
+
+#ifdef use_jpg_library
+#include "./xormat/jpg.h"
+#endif
+
+#ifdef use_tga_library
+#include "./xormat/tga.h"
+#endif
+
+static void * format_image_import (const char * path, uint * width, uint * height) {
+	uint * data = null;
+
+#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
+
+#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
+
+#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
+
+#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 (data == null) {
+		switch (file_type (path)) {
+#ifdef use_png_library
+			case (file_type_png_image): {
+				if (file_exists (path) == true) {
+					data = png_image_import (path, width, height);
+				} else {
+					print ("/w File '/3%s/-' doesn't exist.\n", path);
+				}
+			} break;
+#endif
+#ifdef use_jxl_library
+			case (file_type_jxl_image): {
+				if (file_exists (path) == true) {
+					data = jxl_image_import (path, width, height);
+				} else {
+					print ("/w File '/3%s/-' doesn't exist.\n", path);
+				}
+			} break;
+#endif
+#ifdef use_jpg_library
+			case (file_type_jpg_image): {
+				if (file_exists (path) == true) {
+					data = jpg_image_import (path, width, height);
+				} else {
+					print ("/w File '/3%s/-' doesn't exist.\n", path);
+				}
+			} break;
+#endif
+#ifdef use_tga_library
+			case (file_type_tga_image): {
+				if (file_exists (path) == true) {
+					data = tga_image_import (path, width, height);
+				} else {
+					print ("/w File '/3%s/-' doesn't exist.\n", path);
+				}
+			} break;
+#endif
+			default: {
+				print ("/w File '/3%s/-' doesn't exist or file type isn't supported.\n", path);
+			} break;
+		}
+	}
+
+	return (data);
+}
diff --git a/xormat/jxl.h b/xormat/jxl.h
new file mode 100644
index 0000000..91754ad
--- /dev/null
+++ b/xormat/jxl.h
@@ -0,0 +1,68 @@
+#include <jxl/decode.h>
+
+#ifndef use_jxl_library
+#define use_jxl_library
+#endif
+
+static void * jxl_image_import (const char * path, uint * width, uint * height) {
+	JxlDecoder       * decoder     = null;
+	JxlBasicInfo       information = { 0 };
+	JxlPixelFormat     format      = { 4, JXL_TYPE_UINT8, JXL_NATIVE_ENDIAN, 0 };
+	JxlDecoderStatus   status      = JXL_DEC_ERROR;
+
+	fatal_failure (path   == null, "jxl_image_import: File path is null pointer.");
+	fatal_failure (width  == null, "jxl_image_import: Width is null pointer.");
+	fatal_failure (height == null, "jxl_image_import: Height is null pointer.");
+
+	ulong   size        = file_size   (path);
+	uchar * data        = file_record (path);
+	uint  * pixel_array = null;
+	ulong   output_size = 0;
+
+	decoder = JxlDecoderCreate (null);
+
+	fatal_failure (decoder == null, "jxl_image_import: Failed to create a decoder.");
+
+	status = JxlDecoderSubscribeEvents (decoder, JXL_DEC_BASIC_INFO | JXL_DEC_FULL_IMAGE);
+
+	fatal_failure (status != JXL_DEC_SUCCESS, "jxl_image_import: Failed to subscribe decoder basic information and full image events.");
+
+	status = JxlDecoderSetInput (decoder, data, size);
+
+	fatal_failure (status != JXL_DEC_SUCCESS, "jxl_image_import: Failed to set decoder input data and size.");
+
+	for (status = JxlDecoderProcessInput (decoder); true; status = JxlDecoderProcessInput (decoder)) {
+		fatal_failure (status == JXL_DEC_ERROR,           "jxl_image_import: Decoder internal error.");
+		fatal_failure (status == JXL_DEC_NEED_MORE_INPUT, "jxl_image_import: Decoder needs more input data.");
+
+		if (status == JXL_DEC_BASIC_INFO) {
+			status = JxlDecoderGetBasicInfo(decoder, &information);
+			fatal_failure (status != JXL_DEC_SUCCESS, "jxl_image_import: Failed to get basic image information.");
+			continue;
+		}
+
+		if (status == JXL_DEC_NEED_IMAGE_OUT_BUFFER) {
+			status = JxlDecoderImageOutBufferSize(decoder, & format, & output_size);
+			fatal_failure (status != JXL_DEC_SUCCESS, "jxl_image_import: Failed to get image output buffer size.");
+			if (pixel_array != null) {
+				pixel_array = deallocate (pixel_array);
+			}
+			pixel_array = allocate (output_size);
+			status = JxlDecoderSetImageOutBuffer(decoder, & format, pixel_array, output_size);
+			fatal_failure (status != JXL_DEC_SUCCESS, "jxl_image_import: Failed to set image output buffer data.");
+			continue;
+		}
+
+		if (status == JXL_DEC_FULL_IMAGE) continue;
+		if (status == JXL_DEC_SUCCESS)    break;
+	}
+
+	* width  = information.xsize;
+	* height = information.ysize;
+
+	JxlDecoderDestroy (decoder);
+
+	data = deallocate (data);
+
+	return (pixel_array);
+}
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
new file mode 100644
index 0000000..e7b5bdb
--- /dev/null
+++ b/xormat/png.h
@@ -0,0 +1,106 @@
+#include <stdio.h>
+#include <png.h>
+
+#ifndef use_png_library
+#define use_png_library
+#endif
+
+static void * png_image_import (const char * path, uint * width, uint * height) {
+	FILE * file;
+	uint * data;
+	uint   index;
+
+	png_byte    colour_type  = 0;
+	png_byte    bit_depth    = 0;
+	png_bytep * row_pointers = null;
+
+	png_structp structure   = null;
+	png_infop   information = null;
+
+	fatal_failure (path   == null, "png_image_import: File path is null pointer.");
+	fatal_failure (width  == null, "png_image_import: Width is null pointer.");
+	fatal_failure (height == null, "png_image_import: Height is null pointer.");
+
+	file = fopen (path, "rb");
+
+	fatal_failure (file == null, path);
+
+	structure   = png_create_read_struct (PNG_LIBPNG_VER_STRING, null, null, null);
+	information = png_create_info_struct (structure);
+
+	png_init_io   (structure, file);
+	png_read_info (structure, information);
+
+	* width       = png_get_image_width  (structure, information);
+	* height      = png_get_image_height (structure, information);
+	  colour_type = png_get_color_type   (structure, information);
+	  bit_depth   = png_get_bit_depth    (structure, information);
+
+	if (bit_depth == 16) {
+		png_set_strip_16 (structure);
+	}
+
+	if (colour_type == PNG_COLOR_TYPE_PALETTE) {
+		png_set_palette_to_rgb (structure);
+	}
+
+	if ((colour_type == PNG_COLOR_TYPE_GRAY) && (bit_depth < 8)) {
+		png_set_expand_gray_1_2_4_to_8 (structure);
+	}
+
+	if (png_get_valid (structure, information, PNG_INFO_tRNS)) {
+		png_set_tRNS_to_alpha (structure);
+	}
+
+	if ((colour_type == PNG_COLOR_TYPE_RGB) || (colour_type == PNG_COLOR_TYPE_GRAY) || (colour_type == PNG_COLOR_TYPE_PALETTE)) {
+		png_set_filler (structure, 0xff, PNG_FILLER_AFTER);
+	}
+
+	if ((colour_type == PNG_COLOR_TYPE_GRAY) || (colour_type == PNG_COLOR_TYPE_GRAY_ALPHA)) {
+		png_set_gray_to_rgb (structure);
+	}
+
+	png_read_update_info (structure, information);
+
+	row_pointers = allocate ((* height) * sizeof (* row_pointers));
+
+	for (index = 0; index < (* height); ++index) {
+		row_pointers [index] = allocate (png_get_rowbytes (structure, information));
+	}
+
+	png_read_image (structure, row_pointers);
+
+	fclose (file);
+
+	data = allocate ((* width) * (* height) * sizeof (* data));
+
+	for (index = 0; index < (* height); ++index) {
+		memory_copy (& data [index * (* width)], row_pointers [index], (* width) * sizeof (* data));
+
+		row_pointers [index] = deallocate (row_pointers [index]);
+	}
+
+	row_pointers = deallocate (row_pointers);
+
+	png_destroy_read_struct (& structure, & information, null);
+
+	return (data);
+}
+
+static void png_image_export (const char * path, uint * data, uint width, uint height) {
+	png_image image = { 0 };
+
+	fatal_failure (path   == null, "png_image_export: File path is null pointer.");
+	fatal_failure (data   == null, "png_image_export: Data is null pointer.");
+	fatal_failure (width  == 0,    "png_image_export: Width is equal to zero.");
+	fatal_failure (height == 0,    "png_image_export: Height is equal to zero.");
+
+	image.version = PNG_IMAGE_VERSION;
+	image.format  = PNG_FORMAT_RGBA;
+	image.width   = width;
+	image.height  = height;
+
+	png_image_write_to_file (& image, path, 0, data, 0, null);
+
+	png_image_free (& image);
+}
diff --git a/xtandard.h b/xtandard.h
new file mode 100755
index 0000000..b0be1ab
--- /dev/null
+++ b/xtandard.h
@@ -0,0 +1,1136 @@
+///       _                  _               _
+///      | |                | |             | |
+/// __  _| |_ __ _ _ __   __| | __ _ _ __ __| |
+/// \ \/ / __/ _` | '_ \ / _` |/ _` | '__/ _` |
+///  >  <| || (_| | | | | (_| | (_| | | | (_| |
+/// /_/\_\\__\__,_|_| |_|\__,_|\__,_|_|  \__,_|
+///
+/// Copyright (c) 1997 - Ognjen 'xolatile' Milan Robovic
+///
+/// xolatile@chud.cyou - xtandard - Tiny, safe and somewhat sane unity header for what GNU/Linux already provides.
+///
+/// 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...
+
+#define _GNU_SOURCE
+
+#include <sys/stat.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <time.h>
+#include <dirent.h>
+
+#define null ((void *) 0)
+
+#define standard_input  (STDIN_FILENO)
+#define standard_output (STDOUT_FILENO)
+#define standard_error  (STDERR_FILENO)
+
+#define file_flag_read     (O_RDONLY)
+#define file_flag_write    (O_WRONLY)
+#define file_flag_edit     (O_RDWR)
+#define file_flag_create   (O_CREAT)
+#define file_flag_append   (O_APPEND)
+#define file_flag_truncate (O_TRUNC)
+
+#define file_seek_current (SEEK_CUR)
+#define file_seek_set     (SEEK_SET)
+#define file_seek_end     (SEEK_END)
+
+#define echo(text) output ((text), sizeof ((text)) - 1)
+
+#define maximum(x, y) (((x) > (y)) ? (x) : (y))
+#define minimum(x, y) (((x) < (y)) ? (x) : (y))
+
+#define array_length(array) (sizeof ((array)) / sizeof (* (array)))
+
+typedef unsigned char  uchar;
+typedef unsigned short ushort;
+typedef unsigned int   uint;
+typedef unsigned long  ulong;
+
+typedef char pstring [256];
+
+typedef enum {
+	false,
+	true
+} bool;
+
+typedef enum {
+	log_success,                    log_warning,                    log_failure,                    log_comment,
+	log_count
+} log_enumeration;
+
+typedef enum {
+	file_type_c_source,             file_type_c_header,             file_type_ada_sexy_body,        file_type_ada_specification,
+	file_type_cpp_source,           file_type_cpp_header,           file_type_fortran_90_source,    file_type_fortran_90_module,
+	file_type_pascal_source,        file_type_d_source,             file_type_go_source,            file_type_jai_source,
+	file_type_assembly,             file_type_eax_assembly,         file_type_gnu_assembly,         file_type_flat_assembly,
+	file_type_haskell_script,       file_type_perl_script,          file_type_cube_script,          file_type_lua_script,
+	file_type_shell_script,         file_type_python_script,        file_type_tcl_script,           file_type_forth_source,
+	file_type_text,                 file_type_markdown,             file_type_html,                 file_type_glsl,
+	file_type_xrocessor,            file_type_xhla,                 file_type_xcript,               file_type_xocument,
+	file_type_xiri,                 file_type_xofya,                file_type_xienna,               file_type_xenka,
+	file_type_xiyagi,               file_type_xoule,                file_type_xikoku,               file_type_xdo,
+	file_type_png_image,            file_type_jxl_image,            file_type_jpg_image,            file_type_tga_image,
+	file_type_wav_sound,            file_type_ogg_sound,            file_type_flac_sound,           file_type_mp3_sound,
+	file_type_obj_model,            file_type_iqm_model,            file_type_md5_model,            file_type_ply_model,
+	file_type_elf_object,           file_type_spir_v_bytecode,
+	file_type_count
+} file_type_enumeration;
+
+typedef enum {
+	effect_normal,                  effect_bold,                    effect_italic,                  effect_undefined_code,
+	effect_underline,               effect_blink,                   effect_reverse,                 effect_invisible_text,
+	effect_count
+} effect_enumeration;
+
+typedef enum {
+	colour_grey,                    colour_red,                     colour_green,                   colour_yellow,
+	colour_blue,                    colour_pink,                    colour_cyan,                    colour_white,
+	colour_count
+} colour_enumeration;
+
+typedef enum {
+	character_null,                 character_start_header,         character_start_text,           character_end_text,
+	character_end_transmission,     character_enquiry,              character_acknowledge,          character_bell,
+	character_backspace,            character_tab_horizontal,       character_line_feed,            character_tab_vertical,
+	character_form_feed,            character_carriage_return,      character_shift_out,            character_shift_in,
+	character_data_link_escape,     character_device_control_1,     character_device_control_2,     character_device_control_3,
+	character_device_control_4,     character_not_acknowledge,      character_synchronous_idle,     character_end_transmission_block,
+	character_cancel,               character_end_medium,           character_substitute,           character_escape,
+	character_file_separator,       character_group_separator,      character_record_separator,     character_unit_separator
+} character_enumeration;
+
+typedef enum {
+	cursor_none,
+	cursor_left,                    cursor_middle,                  cursor_right,
+	cursor_wheel_up,                cursor_wheel_down,
+	cursor_count
+} cursor_enumeration;
+
+typedef enum {
+	signal_none,
+	signal_a,                       signal_b,                       signal_c,                       signal_d,
+	signal_e,                       signal_f,                       signal_g,                       signal_h,
+	signal_i,                       signal_j,                       signal_k,                       signal_l,
+	signal_m,                       signal_n,                       signal_o,                       signal_p,
+	signal_q,                       signal_r,                       signal_s,                       signal_t,
+	signal_u,                       signal_v,                       signal_w,                       signal_x,
+	signal_y,                       signal_z,                       signal_0,                       signal_1,
+	signal_2,                       signal_3,                       signal_4,                       signal_5,
+	signal_6,                       signal_7,                       signal_8,                       signal_9,
+	signal_escape,                  signal_tabulator,               signal_return,                  signal_new_line,
+	signal_slash,                   signal_backslash,               signal_semicolon,               signal_backquote,
+	signal_space,                   signal_backspace,               signal_dot,                     signal_comma,
+	signal_cite,                    signal_caps_lock,               signal_minus,                   signal_equal,
+	signal_left_bracket,            signal_right_bracket,           signal_left_control,            signal_right_control,
+	signal_left_shift,              signal_right_shift,             signal_left_alt,                signal_right_alt,
+	signal_f1,                      signal_f2,                      signal_f3,                      signal_f4,
+	signal_f5,                      signal_f6,                      signal_f7,                      signal_f8,
+	signal_f9,                      signal_f10,                     signal_f11,                     signal_f12,
+	signal_arrow_up,                signal_arrow_down,              signal_arrow_left,              signal_arrow_right,
+	signal_num_lock,                signal_pause_break,             signal_insert,                  signal_home,
+	signal_page_up,                 signal_delete,                  signal_end,                     signal_page_down,
+	signal_key_add,                 signal_key_subtract,            signal_key_multiply,            signal_key_divide,
+	signal_key_enter,               signal_key_dot,                 signal_key_0,                   signal_key_1,
+	signal_key_2,                   signal_key_3,                   signal_key_4,                   signal_key_5,
+	signal_key_6,                   signal_key_7,                   signal_key_8,                   signal_key_9,
+	signal_count
+} signal_enumeration;
+
+static const char * cursor_name [cursor_count] = {
+	"---",
+	"Left button",                  "Middle button",                "Right button",
+	"Scroll up",                    "Scroll down"
+
+};
+
+static const char * signal_name [signal_count] = {
+	"---",
+	"A",                            "B",                            "C",                            "D",
+	"E",                            "F",                            "G",                            "H",
+	"I",                            "J",                            "K",                            "L",
+	"M",                            "N",                            "O",                            "P",
+	"Q",                            "R",                            "S",                            "T",
+	"U",                            "V",                            "W",                            "X",
+	"Y",                            "Z",                            "0",                            "1",
+	"2",                            "3",                            "4",                            "5",
+	"6",                            "7",                            "8",                            "9",
+	"Escape",                       "Tabulator",                    "Return",                       "New line",
+	"Slash",                        "Backslash",                    "Semicolon",                    "Backquote",
+	"Space",                        "Backspace",                    "Dot",                          "Comma",
+	"Cite",                         "Caps lock",                    "Minus",                        "Equal",
+	"Left bracket",                 "Right bracket",                "Left control",                 "Right control",
+	"Left shift",                   "Right shift",                  "Left alt",                     "Right alt",
+	"F1",                           "F2",                           "F3",                           "F4",
+	"F5",                           "F6",                           "F7",                           "F8",
+	"F9",                           "F10",                          "F11",                          "F12",
+	"Arrow up",                     "Arrow down",                   "Arrow left",                   "Arrow right",
+	"Num lock",                     "Pause break",                  "Insert",                       "Home",
+	"Page up",                      "Delete",                       "End",                          "Page down",
+	"Key add",                      "Key subtract",                 "Key multiply",                 "Key divide",
+	"Key enter",                    "Key dot",                      "Key 0",                        "Key 1",
+	"Key 2",                        "Key 3",                        "Key 4",                        "Key 5",
+	"Key 6",                        "Key 7",                        "Key 8",                        "Key 9"
+};
+
+static void randomize_seed_by_time (void) {
+	srand ((uint) time (null));
+}
+
+static int randomize (int from, int to) {
+	return (rand () % (to - from + 1) + from);
+}
+
+static uint urandomize (uint from, uint to) {
+	return ((uint) rand () % (to - from + 1) + from);
+}
+
+static float frandomize (float from, float to) {
+	return (((float) rand () / (float) RAND_MAX) * (to - from) + from);
+}
+
+static int upper_bound (int a, int b) {
+	return ((a > b) ? a : b);
+}
+
+static int lower_bound (int a, int b) {
+	return ((a < b) ? a : b);
+}
+
+static void input (void * data, ulong size) {
+	read (standard_input, data, size);
+}
+
+static void output (const void * data, ulong size) {
+	write (standard_output, data, size);
+}
+
+static void clean_up (void (* procedure) (void)) {
+	atexit (procedure);
+}
+
+#ifdef use_fatal_failure
+static void fatal_failure (bool condition, const char * message) {
+	if (condition == true) {
+		echo ("[\x1b[1;31m FATAL \x1b[0m] ");
+
+		for (int index = 0; message [index] != '\0'; ++index) {
+			output (& message [index], 1);
+		}
+
+		echo ("\n");
+
+		exit (log_failure);
+	}
+}
+#else
+#define fatal_failure(...)
+#endif
+
+static void execute (const char * command) {
+	int status = 0;
+
+	system (command);
+
+	fatal_failure (status != 0, "execute: System returned an error code.");
+}
+
+static uint tick_tock (void) {
+	return ((uint) clock ());
+}
+
+static ulong nano_time (void) {
+	struct timespec time = { 0 };
+
+	ulong result = 0;
+
+	clock_gettime (CLOCK_MONOTONIC, & time);
+
+	result = 1000000000ul * (ulong) time.tv_sec + (ulong) time.tv_nsec;
+
+	return (result);
+}
+
+static void nano_wait (ulong time) {
+	struct timespec wait = {
+		time / 1000000000,
+		time % 1000000000
+	};
+
+	while (nanosleep (& wait, null)) continue;
+}
+
+static float normal_r (uint colour) { return ((float) ((colour >> 24) & 0xff) / 255.0f); }
+static float normal_g (uint colour) { return ((float) ((colour >> 16) & 0xff) / 255.0f); }
+static float normal_b (uint colour) { return ((float) ((colour >>  8) & 0xff) / 255.0f); }
+static float normal_a (uint colour) { return ((float) ((colour >>  0) & 0xff) / 255.0f); }
+
+static uint channel_r (uint colour) { return ((colour >> 24) & 0xff); }
+static uint channel_g (uint colour) { return ((colour >> 16) & 0xff); }
+static uint channel_b (uint colour) { return ((colour >>  8) & 0xff); }
+static uint channel_a (uint colour) { return ((colour >>  0) & 0xff); }
+
+static uint colour_channel_reverse (uint colour) {
+	uint r = channel_r (colour);
+	uint g = channel_g (colour);
+	uint b = channel_b (colour);
+	uint a = channel_a (colour);
+
+	return ((a << 24) | (b << 16) | (g << 8) | (r << 0));
+}
+
+static uint colour_linear_interpolation (uint colour_a, uint colour_b, float scale) {
+	if (scale <= 0.0f) {
+		return (colour_a);
+	}
+
+	if (scale >= 1.0f) {
+		return (colour_b);
+	}
+
+	uint r = (uint) ((1.0f - scale) * channel_r (colour_a) + scale * channel_r (colour_b));
+	uint g = (uint) ((1.0f - scale) * channel_g (colour_a) + scale * channel_g (colour_b));
+	uint b = (uint) ((1.0f - scale) * channel_b (colour_a) + scale * channel_b (colour_b));
+	uint a = (uint) ((1.0f - scale) * channel_a (colour_a) + scale * channel_a (colour_b));
+
+	return ((r << 24) | (g << 16) | (b << 8) | (a << 0));
+}
+
+static void * allocate (ulong size) {
+	char * data = null;
+
+	fatal_failure (size <= 0, "allocate: Size is equal or below zero.");
+
+	data = calloc (size, sizeof (* data));
+
+	fatal_failure (data == null, "allocate: Function 'calloc' returned null pointer.");
+
+	return (data);
+}
+
+static void * reallocate (void * data, ulong size) {
+	fatal_failure (size <= 0, "reallocate: Size is equal or below zero.");
+
+	data = realloc (data, size);
+
+	fatal_failure (data == null, "reallocate: Function 'realloc' returned null pointer.");
+
+	return (data);
+}
+
+static void * deallocate (void * data) {
+	fatal_failure (data == null, "deallocate: Data is null pointer.");
+
+	free (data);
+
+	return (null);
+}
+
+static void * record (void) {
+	char  * buffer = null;
+	ulong   offset = 0;
+	ulong   memory = 64 * 1024;
+
+	buffer = reallocate (buffer, memory);
+
+	do {
+		if ((offset + 1) % memory == 0) {
+			buffer = reallocate (buffer, ((offset + 1) / memory + 1) * memory);
+		}
+
+		buffer [offset] = '\0';
+
+		input (& buffer [offset], sizeof (* buffer));
+
+		++offset;
+	} while (buffer [offset - 1] != '\0');
+
+	buffer [offset - 1] = '\0';
+
+	return (buffer);
+}
+
+static bool character_compare_array (char character, const char * character_array) {
+	for (ulong index = 0; character_array [index] != '\0'; ++index) {
+		if (character == character_array [index]) {
+			return (true);
+		}
+	}
+
+	return (false);
+}
+
+static bool character_is_uppercase (char character) {
+	return ((character >= 'A') && (character <= 'Z'));
+}
+
+static bool character_is_lowercase (char character) {
+	return ((character >= 'a') && (character <= 'z'));
+}
+
+static bool character_is_digit (char character) {
+	return ((character >= '0') && (character <= '9'));
+}
+
+static bool character_is_letter (char character) {
+	return (((character >= 'A') && (character <= 'Z')) || ((character >= 'a') && (character <= 'z')));
+}
+
+static bool character_is_blank (char character) {
+	return ((character == ' ') || (character == '\t') || (character == '\r') || (character == '\n'));
+}
+
+static bool character_is_symbol (char character) {
+	return (((character >= '!') && (character <= '/')) || ((character >= ':') && (character <= '@'))
+	     || ((character >= '[') && (character <= '`')) || ((character >= '{') && (character <= '~')));
+}
+
+static bool character_is_separator (char character) {
+	return ((character != '_') && ((character_is_blank (character) == true) || (character_is_symbol (character) == true)));
+}
+
+static bool character_is_identifier (char character) {
+	return ((character == '_') || (character_is_letter (character) == true) || (character_is_digit (character) == true));
+}
+
+static bool character_is_visible (char character) {
+	return ((character >= '!') && (character <= '~'));
+}
+
+static char * capitalize (char * string) {
+	fatal_failure (string == null, "capitalize: String is null pointer.");
+
+	string [0] -= (character_is_lowercase (string [0]) == true) ? ' ' : '\0';
+
+	return (string);
+}
+
+static char * uppercase (char * string) {
+	fatal_failure (string == null, "uppercase: String is null pointer.");
+
+	for (uint index = 0; string [index] != '\0'; ++index) {
+		string [index] += (character_is_lowercase (string [index]) == true) ? ' ' : '\0';
+	}
+
+	return (string);
+}
+
+static char * lowercase (char * string) {
+	fatal_failure (string == null, "lowercase: String is null pointer.");
+
+	for (uint index = 0; string [index] != '\0'; ++index) {
+		string [index] -= (character_is_uppercase (string [index]) == true) ? ' ' : '\0';
+	}
+
+	return (string);
+}
+
+static ulong string_length (const char * string) {
+	ulong length = 0;
+
+	fatal_failure (string == null, "string_length: String is null pointer.");
+
+	for (length = 0; string [length] != '\0'; ++length);
+
+	return (length);
+}
+
+static char * string_nullify (char * string, ulong length) {
+	fatal_failure (string == null, "string_nullify: String is null pointer.");
+	fatal_failure (length <= 0,    "string_nullify: Length is equal or below zero.");
+
+	for (ulong index = 0; index < length; ++index) {
+		string [index] = '\0';
+	}
+
+	return (string);
+}
+
+static char * string_reverse_limit (char * string, ulong limit) {
+	fatal_failure (string == null, "string_reverse_limit: String is null pointer.");
+	fatal_failure (limit  <= 0,    "string_reverse_limit: Limit is equal or below zero.");
+
+	for (ulong index = 0; index < limit / 2; ++index) {
+		char temporary = string [index];
+
+		string [index]             = string [limit - 1 - index];
+		string [limit - 1 - index] = temporary;
+	}
+
+	return (string);
+}
+
+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) {
+	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.");
+
+	for (ulong index = 0; index < limit; ++index) {
+		if (string_a [index] != string_b [index]) {
+			return (false);
+		}
+	}
+
+	return (true);
+}
+
+static bool string_compare (const char * string_a, const 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) {
+	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.");
+
+	for (ulong index = 0; index < limit; ++index) {
+		destination [index] = source [index];
+	}
+
+	return (destination);
+}
+
+static char * string_copy (char * destination, const char * source) {
+	return (string_copy_limit (destination, source, string_length (source) + 1));
+}
+
+static char * string_concatenate_limit (char * destination, const char * source, ulong limit) {
+	ulong offset = string_length (destination);
+
+	fatal_failure (destination == null, "string_concatenate_limit: Destination string is null pointer.");
+	fatal_failure (source      == null, "string_concatenate_limit: Source string is null pointer.");
+	fatal_failure (limit       <= 0,    "string_concatenate_limit: Limit is equal or below zero.");
+
+	for (ulong index = 0; index < limit; ++index) {
+		destination [offset + index] = source [index];
+	}
+
+	return (destination);
+}
+
+static char * string_concatenate (char * destination, const char * source) {
+	return (string_concatenate_limit (destination, source, string_length (source) + 1));
+}
+
+static char * string_duplicate (const char * string) {
+	char * duplicate = null;
+
+	duplicate = allocate ((string_length (string) + 1) * sizeof (* duplicate));
+
+	string_copy (duplicate, string);
+
+	return (duplicate);
+}
+
+static char * string_duplicate_limit (const char * string, uint limit) {
+	char * duplicate = null;
+
+	duplicate = allocate ((limit + 1) * sizeof (* duplicate));
+
+	string_copy_limit (duplicate, string, limit);
+
+	return (duplicate);
+}
+
+static char * string_align_left (char * string, ulong amount, char character) {
+	ulong length = string_length (string);
+
+	for (ulong offset = length; offset < amount; ++offset) {
+		string [offset] = character;
+	}
+
+	string [amount] = '\0';
+
+	return (string);
+}
+
+static void memory_nullify (void * memory, ulong size) {
+	char * cast = (char *) memory;
+
+	fatal_failure (memory == null, "memory_nullify: Memory is null pointer.");
+
+	for (ulong offset = 0; offset < size; ++offset) {
+		cast [offset] = (char) 0;
+	}
+}
+
+static int memory_compare (void * memory_0, const void * memory_1, ulong size) {
+	      char * cast_0 = (      char *) memory_0;
+	const char * cast_1 = (const 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.");
+
+	for (ulong offset = 0; offset < size; ++offset) {
+		if (cast_0 [offset] != cast_1 [offset]) {
+			return (false);
+		}
+	}
+
+	return (true);
+}
+
+static void memory_copy (void * destination, const void * source, ulong size) {
+	      char * cast_0 = (      char *) destination;
+	const char * cast_1 = (const char *) source;
+
+	fatal_failure (destination == null, "memory_copy: Destination is null pointer.");
+	fatal_failure (source      == null, "memory_copy: Source is null pointer.");
+
+	for (ulong offset = 0; offset < size; ++offset) {
+		cast_0 [offset] = cast_1 [offset];
+	}
+}
+
+static char * string_remove_extension (char * string) {
+	ulong length = string_length (string);
+
+	for (--length; string [length] != '.'; --length);
+
+	string [length] = '\0';
+
+	return (string);
+}
+
+static void echo_clear (void) {
+	echo ("\033[2J\033[H");
+}
+
+static void echo_colour (colour_enumeration colour, effect_enumeration effect) {
+	char format [8] = "\033[ ;3 m";
+
+	format [2] = (char) (effect % effect_count) + '0';
+	format [5] = (char) (colour % colour_count) + '0';
+
+	echo (format);
+}
+
+static void echo_cancel (void) {
+	echo ("\033[0m");
+}
+
+static void show_cursor (bool show) {
+	if (show == true) {
+		echo ("\033[?25h");
+	} else {
+		echo ("\033[?25l");
+	}
+}
+
+static int file_open (const char * path, int mode) {
+	fatal_failure (path == null, "file_open: File path is null pointer.");
+
+	return (open (path, mode, 0777));
+}
+
+static int file_close (int file) {
+	fatal_failure (file == -1, "file_close: Invalid file descriptor.");
+
+	close (file);
+
+	return (-1);
+}
+
+static void file_read (int file, void * data, ulong size) {
+	fatal_failure (file <= -1,   "file_read: File descriptor is closed or invalid.");
+	fatal_failure (data == null, "file_read: Data is null pointer.");
+	fatal_failure (size == 0,    "file_read: Size is zero.");
+
+	read (file, data, size);
+}
+
+static void file_write (int file, const 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.");
+
+	write (file, data, size);
+}
+
+static void file_echo (int file, const char * data) {
+	file_write (file, data, string_length (data));
+}
+
+static ulong file_seek (int file, int whence) {
+	fatal_failure (file == -1, "file_seek: Invalid file descriptor.");
+
+	return ((ulong) lseek (file, 0, whence));
+}
+
+static ulong file_size (const char * path) {
+	struct stat data = { 0 };
+
+	fatal_failure (path == null, "file_size: File path is null pointer.");
+
+	lstat (path, & data);
+
+	return ((ulong) data.st_size);
+}
+
+static file_type_enumeration file_type (const char * path) {
+	const 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",
+		".txt",         ".md",          ".html",        ".glsl",        ".x",           ".xhla",        ".xs",          ".xd",
+		".xiri",        ".xofya",       ".xienna",      ".xenka",       ".xiyagi",      ".xoule",       ".xikoku",      ".xdo",
+		".png",         ".jxl",         ".jpg",         ".tga",         ".wav",         ".ogg",         ".flac",        ".mp3",
+		".obj",         ".iqm",         ".md5",         ".ply",         ".o",           ".spv"
+	};
+
+	fatal_failure (path == null, "file_type: File path is null pointer.");
+
+	for (; * path != '.'; ++path);
+
+	for (file_type_enumeration type = 0; type != file_type_count; ++type) {
+		if (string_compare (path, extensions [type])) {
+			return (type);
+		}
+	}
+
+	return (~ 0u);
+}
+
+static bool file_exists (const 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) {
+	unlink (path);
+}
+
+static void * file_record (const char * path) {
+	int     file = -1;
+	ulong   size = 0;
+	char  * data = null;
+
+	fatal_failure (path == null, "file_record: File path is null pointer.");
+
+	file = file_open (path, file_flag_read);
+	size = file_size (path);
+	data = allocate  (size);
+
+	file_read (file, data, size);
+
+	file = file_close (file);
+
+	return (data);
+}
+
+static char * file_import (const char * path) {
+	int     file = -1;
+	ulong   size = 0;
+	char  * data = null;
+
+	fatal_failure (path == null, "file_import: File path is null pointer.");
+
+	file = file_open (path, file_flag_edit);
+	size = file_size (path) + 1;
+	data = allocate  (size);
+
+	file_read (file, data, size - 1);
+
+	data [size - 1] = '\0';
+
+	file = file_close (file);
+
+	return (data);
+}
+
+static void file_export (const char * path, const char * data) {
+	int file = -1;
+
+	fatal_failure (path == null, "file_export: File path is null pointer.");
+	fatal_failure (data == null, "file_export: Data is null pointer.");
+
+	file = file_open (path, file_flag_write | file_flag_create | file_flag_truncate);
+
+	file_write (file, data, string_length (data));
+
+	file = file_close (file);
+}
+
+static void * folder_open (const char * path) {
+	DIR * folder = null;
+
+	fatal_failure (path == null, "folder_open: Folder path is null pointer.");
+
+	folder = opendir (path);
+
+	return ((void *) folder);
+}
+
+static char * folder_read (void * handle) {
+	struct dirent * file = null;
+
+	DIR * folder = (DIR *) handle;
+
+	fatal_failure (handle == null, "folder_read: Folder handle is null pointer.");
+
+	file = readdir (folder);
+
+	if (file == null) {
+		return (null);
+	} else {
+		return (file->d_name);
+	}
+}
+
+static void * folder_close (void * handle) {
+	DIR * folder = (DIR *) handle;
+
+	fatal_failure (handle == null, "folder_read: Folder handle is null pointer.");
+
+	closedir (folder);
+
+	return (null);
+}
+
+static char * * folder_create_path_list (const char * folder, uint * path_count, bool sort) {
+	void   * handle     = null;
+	char * * path_array = 0;
+
+	(void) sort;
+
+	fatal_failure (folder     == null, "folder_create_path_list: Folder handle is null pointer.");
+	fatal_failure (path_count == null, "folder_create_path_list: Path count address is null pointer.");
+
+	handle = folder_open (folder);
+
+	for (char * path = folder_read (handle); path != null; path = folder_read (handle)) {
+		if (path [0] != '.') {
+			(* path_count) += 1;
+
+			path_array = reallocate (path_array, (* path_count) * sizeof (* path_array));
+
+			path_array [(* path_count) - 1] = allocate ((string_length (path) + 1) * sizeof (* * path_array));
+
+			string_copy (path_array [(* path_count) - 1], path);
+		}
+	}
+
+	handle = folder_close (handle);
+
+	return (path_array);
+}
+
+static char * * folder_remove_path_list (char * * path_array, uint path_count) {
+	for (uint index = 0; index < path_count; ++index) {
+		path_array [index] = deallocate (path_array [index]);
+	}
+
+	return (deallocate (path_array));
+}
+
+static char * configuration_format (const char * path) {
+	static char buffer [512] = "";
+
+	string_copy (buffer, getenv ("HOME"));
+	string_concatenate (buffer, "/.config/xolatile/");
+	string_concatenate (buffer, path);
+
+	return (buffer);
+}
+
+static bool configuration_exists (const char * path) {
+	return (file_exists (configuration_format (path)));
+}
+
+static void configuration_remove (const char * path) {
+	file_remove (configuration_format (path));
+}
+
+static char * configuration_import (const char * path) {
+	return (file_import (configuration_format (path)));
+}
+
+static void configuration_export (const char * path, const char * data) {
+	file_export (configuration_format (path), data);
+}
+
+static bool argument_compare (const char * argument, const char * short_option, const 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) {
+	uint width = 0;
+	uint count = 0;
+
+	do {
+		if (* string == '\t') {
+			count += tab_width;
+		} else if (* string == '\n') {
+			width = (++count > width) ? count : width;
+			count = 0;
+		} else {
+			++count;
+		}
+	} while (* (++string) != '\0');
+
+	return (width - 1);
+}
+
+static uint string_full_height (const char * string) {
+	uint height = 0;
+
+	do {
+		if (* string == '\n') {
+			++height;
+		}
+	} while (* (++string) != '\0');
+
+	return (height + 1);
+}
+
+static uint string_limit_to_number (const char * string, uint limit) {
+	uint number = 0;
+
+	for (uint index = 0; (string [index] != '\0') && (index < limit); ++index) {
+		number *= 10;
+		number += (uint) (string [index] - '0');
+	}
+
+	return (number);
+}
+
+static uint string_to_number (const char * string) {
+	return (string_limit_to_number (string, string_length (string)));
+}
+
+static char * number_to_string (int number) {
+	static char string [34] = "";
+
+	uint index = 0;
+	bool sign  = false;
+
+	string_nullify (string, sizeof (string));
+
+	if (number == 0) {
+		string [0] = '0';
+		string [1] = '\0';
+		return (string);
+	}
+
+	if (number < 0) {
+		number *= -1;
+		sign = true;
+	} else {
+		sign = false;
+	}
+
+	for (index = 0; (number != 0) && (index < (uint) sizeof (string) - 1); ++index) {
+		string [index] = (char) (number % 10) + '0';
+		number /= 10;
+	}
+
+	if (sign == true) {
+		string [index] = '-';
+		++index;
+	}
+
+	string [index] = '\0';
+
+	string_reverse (string);
+
+	return (string);
+}
+
+static char * format_to_string (int number, bool sign, uint base, ulong amount, char character) {
+	static char string [36];
+
+	int i;
+
+	string_nullify (string, sizeof (string));
+
+	if (number == 0) {
+		string [0] = '0';
+		string [1] = '\0';
+
+		string_align_left (string, amount, character);
+
+		return (string);
+	}
+
+	if (number < 0) {
+		number *= -1;
+	}
+
+	for (i = (string [0] == '-'); number != 0; ++i) {
+		string [i] = "0123456789ABCDEF" [number % base];
+		number /= base;
+	}
+
+	if (sign == true) {
+		string [i] = '-';
+		++i;
+	}
+
+	string [i] = '\0';
+
+	string_reverse (string);
+
+	string_align_left (string, amount, character);
+
+	return (string);
+}
+
+static char * format (const char * base, ...) {
+	static char string [1024];
+
+	va_list list;
+
+	string_nullify (string, 1024);
+
+	va_start (list, base);
+
+	for (; * base != character_null; ++base) {
+		switch (* base) {
+			case ('%'): {
+				++base;
+				switch (* base) {
+					case ('%'): string_concatenate (string, "%");                                   break;
+					case ('i'): string_concatenate (string, number_to_string (va_arg (list, int))); break;
+					case ('s'): string_concatenate (string, va_arg (list, char *));                 break;
+					default:    string_concatenate (string, "?");                                   break;
+				}
+			} break;
+			default: {
+				string_concatenate_limit (string, base, 1);
+			} break;
+		}
+	}
+
+	va_end (list);
+
+	return (string);
+}
+
+static void print (const char * format, ...) {
+	va_list list;
+
+	va_start (list, format);
+
+	for (; * format != character_null; ++format) {
+		switch (* format) {
+			case ('%'): {
+				++format;
+				switch (* format) {
+					case ('%'): {
+						output ("%", 1);
+					} break;
+					case ('i'): {
+						char * string = number_to_string (va_arg (list, int));
+						output (string, string_length (string));
+					} break;
+					case ('t'): {
+						int toggle = (va_arg (list, int));
+						echo_colour ((toggle == true) ? colour_green : colour_red, effect_normal);
+						output ((toggle == true) ? "+" : "-", 1);
+						echo_cancel ();
+					} break;
+					case ('b'): {
+						int boolean = (va_arg (list, int));
+						output ((boolean == true) ? "true" : "false", (boolean == true) ? 4 : 5);
+					} break;
+					case ('c'): {
+						char character = (char) va_arg (list, int);
+						output (& character, 1);
+					} break;
+					case ('s'): {
+						char * string = va_arg (list, char *);
+						output (string, string_length (string));
+					} break;
+					default: {
+						output ("?", 1);
+					} break;
+				}
+			} break;
+			case ('/'): {
+				++format;
+				switch (* format) {
+					case ('/'): echo ("/");                          break;
+					case ('s'): echo ("[\x1b[1;32mSuccess\x1b[0m]"); break;
+					case ('f'): echo ("[\x1b[1;31mFailure\x1b[0m]"); break;
+					case ('w'): echo ("[\x1b[1;33mWarning\x1b[0m]"); break;
+					case ('c'): echo ("[\x1b[1;30mComment\x1b[0m]"); break;
+					case ('A'): echo ("\x1b[0m");                    break;
+					case ('B'): echo ("\x1b[1m");                    break;
+					case ('C'): echo ("\x1b[2m");                    break;
+					case ('D'): echo ("\x1b[3m");                    break;
+					case ('E'): echo ("\x1b[4m");                    break;
+					case ('F'): echo ("\x1b[5m");                    break;
+					case ('G'): echo ("\x1b[6m");                    break;
+					case ('H'): echo ("\x1b[7m");                    break;
+					case ('0'): echo ("\x1b[30m");                   break;
+					case ('1'): echo ("\x1b[31m");                   break;
+					case ('2'): echo ("\x1b[32m");                   break;
+					case ('3'): echo ("\x1b[33m");                   break;
+					case ('4'): echo ("\x1b[34m");                   break;
+					case ('5'): echo ("\x1b[35m");                   break;
+					case ('6'): echo ("\x1b[36m");                   break;
+					case ('7'): echo ("\x1b[37m");                   break;
+					case ('-'): echo ("\x1b[0m");                    break;
+					default:    echo ("?");                          break;
+				}
+			} break;
+			default: {
+				output (format, 1);
+			} break;
+		}
+	}
+
+	va_end (list);
+}
+
+static void uint_exchange (uint * a, uint * b) {
+	uint c = * a;
+
+	* a = * b;
+	* b =   c;
+}
+
+static void float_exchange (float * a, float * b) {
+	float c = * a;
+
+	* a = * b;
+	* b =   c;
+}
+
+#ifdef use_mathematics
+
+#include <math.h>
+
+#define pi (3.14159265f)
+
+static float sign (float x) { return ((x > 0.0f) ? +1.0f : -1.0f); }
+
+static float square_root (float x) { return (sqrtf (x)); }
+static float cube_root   (float x) { return (cbrtf (x)); }
+
+static float sine    (float x) { return (sinf (x)); }
+static float cosine  (float x) { return (cosf (x)); }
+static float tangent (float x) { return (tanf (x)); }
+
+static float arc_sine    (float x) { return (asinf (x)); }
+static float arc_cosine  (float x) { return (acosf (x)); }
+static float arc_tangent (float x) { return (atanf (x)); }
+
+static float cosecant  (float x) { return (1.0f / sinf (x)); }
+static float secant    (float x) { return (1.0f / cosf (x)); }
+static float cotangent (float x) { return (1.0f / tanf (x)); }
+
+#endif
diff --git a/xyntax.h b/xyntax.h
new file mode 100755
index 0000000..849d44c
--- /dev/null
+++ b/xyntax.h
@@ -0,0 +1,175 @@
+///                   _
+/// __  ___   _ _ __ | |_ __ ___  __
+/// \ \/ / | | | '_ \| __/ _` \ \/ /
+///  >  <| |_| | | | | || (_| |>  <
+/// /_/\_\\__, |_| |_|\__\__,_/_/\_\
+///       |___/
+///
+/// Copyright (c) 1997 - Ognjen 'xolatile' Milan Robovic
+///
+/// xolatile@chud.cyou - xyntax - Tiny, unsafe and somewhat insane unity header for generic syntax definition.
+///
+/// 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     count;
+	uint     limit;
+	bool   * enrange;
+	bool   * derange;
+	char * * begin;
+	char * * end;
+	char   * escape;
+	uint   * colour;
+	uint   * effect;
+} syntax_structure;
+
+static syntax_structure * syntax_initialize (uint limit) {
+	syntax_structure * syntax = allocate (sizeof (* syntax));
+
+	syntax->limit = limit;
+
+	if (limit != 0) {
+		syntax->enrange = allocate (syntax->limit * sizeof (* syntax->enrange));
+		syntax->derange = allocate (syntax->limit * sizeof (* syntax->derange));
+		syntax->begin   = allocate (syntax->limit * sizeof (* syntax->begin));
+		syntax->end     = allocate (syntax->limit * sizeof (* syntax->end));
+		syntax->escape  = allocate (syntax->limit * sizeof (* syntax->escape));
+		syntax->colour  = allocate (syntax->limit * sizeof (* syntax->colour));
+		syntax->effect  = allocate (syntax->limit * sizeof (* syntax->effect));
+	}
+
+	return (syntax);
+}
+
+static syntax_structure * syntax_deinitialize (syntax_structure * syntax) {
+	for (uint index = 0; index < syntax->count; ++index) {
+		syntax->begin [index] = deallocate (syntax->begin [index]);
+		syntax->end   [index] = deallocate (syntax->end   [index]);
+	}
+
+	syntax->enrange = deallocate (syntax->enrange);
+	syntax->derange = deallocate (syntax->derange);
+	syntax->begin   = deallocate (syntax->begin);
+	syntax->end     = deallocate (syntax->end);
+	syntax->escape  = deallocate (syntax->escape);
+	syntax->colour  = deallocate (syntax->colour);
+	syntax->effect  = deallocate (syntax->effect);
+
+	return (deallocate (syntax));
+}
+
+static uint syntax_define (syntax_structure * syntax, bool enrange, bool derange, const char * begin, const char * end, char escape,
+                           uint colour, uint effect) {
+	++syntax->count;
+
+	uint current = syntax->count - 1;
+
+	fatal_failure (begin == null, "syntax_define: Begin string is null pointer.");
+	fatal_failure (end   == null, "syntax_define: End string is null pointer.");
+
+	fatal_failure (syntax->count >= syntax->limit, "syntax_define: Reached the hardcoded limit.");
+
+	if (syntax->limit == 0) {
+		syntax->enrange = reallocate (syntax->enrange, syntax->count * sizeof (* syntax->enrange));
+		syntax->derange = reallocate (syntax->derange, syntax->count * sizeof (* syntax->derange));
+		syntax->begin   = reallocate (syntax->begin,   syntax->count * sizeof (* syntax->begin));
+		syntax->end     = reallocate (syntax->end,     syntax->count * sizeof (* syntax->end));
+		syntax->escape  = reallocate (syntax->escape,  syntax->count * sizeof (* syntax->escape));
+		syntax->colour  = reallocate (syntax->colour,  syntax->count * sizeof (* syntax->colour));
+		syntax->effect  = reallocate (syntax->effect,  syntax->count * sizeof (* syntax->effect));
+	}
+
+	syntax->begin [current] = allocate ((string_length (begin) + 1) * sizeof (* * syntax->begin));
+	syntax->end   [current] = allocate ((string_length (end)   + 1) * sizeof (* * syntax->end));
+
+	syntax->enrange [current] = enrange;
+	syntax->derange [current] = derange;
+	syntax->escape  [current] = escape;
+	syntax->colour  [current] = colour;
+	syntax->effect  [current] = effect;
+
+	string_copy (syntax->begin [current], begin);
+	string_copy (syntax->end   [current], end);
+
+	return (current);
+}
+
+static uint syntax_select (syntax_structure * syntax, const char * string, uint * length) {
+	uint offset = 0;
+	uint subset = 0;
+	uint select = 0;
+
+	ulong begin_length = 0;
+	ulong end_length   = 0;
+
+	for (; select != syntax->count; ++select) {
+		begin_length = string_length (syntax->begin [select]);
+
+		if (! syntax->enrange [select]) {
+			if (! syntax->derange [select]) {
+				if (string_compare_limit (string, syntax->begin [select], begin_length)) {
+					break;
+				}
+			} else {
+				if ((string_compare_limit    (string, syntax->begin [select], begin_length))
+				&&  (character_compare_array (string [offset + begin_length], syntax->end [select]))) {
+					break;
+				}
+			}
+		} else {
+			for (subset = 0; subset != begin_length; ++subset) {
+				if (string [offset] == syntax->begin [select] [subset]) {
+					goto selected;
+				}
+			}
+		}
+	}
+
+	selected:
+
+	if (select >= syntax->count) {
+		* length = 1;
+
+		return (syntax->count);
+	}
+
+	end_length = string_length (syntax->end [select]);
+
+	for (offset = 1; string [offset - 1] != character_null; ++offset) {
+		if (string [offset] == syntax->escape [select]) {
+			++offset;
+			continue;
+		}
+
+		if (syntax->derange [select]) {
+			subset = 0;
+			if (end_length == 0) {
+				break;
+			} do {
+				if (string [offset] == syntax->end [select] [subset]) {
+					* length = offset;
+					goto finished;
+				}
+			} while (++subset != end_length);
+		} else {
+			if (end_length != 0) {
+				if (string_compare_limit (& string [offset], syntax->end [select], end_length)) {
+					* length = offset + end_length;
+					return (select);
+				}
+			} else {
+				* length = 1;
+				return (select);
+			}
+		}
+	}
+
+	finished:
+
+	return (select);
+}