diff --git a/ports/port.script b/ports/port.script
index 3bb66f9..4e34d1b 100644
--- a/ports/port.script
+++ b/ports/port.script
@@ -334,8 +334,8 @@ void PortGCC() {
 				"gl_cv_func_working_mkstemp", "gl_cv_func_working_mktime", "gl_cv_func_working_strerror"
 			];
 
-			for int i = 0; i < variables:len(); i += 1 {
-				SystemSetEnvironmentVariable(variables[i], "yes");
+			for str variable in variables {
+				SystemSetEnvironmentVariable(variable, "yes");
 			}
 		}
 
@@ -486,10 +486,10 @@ void PortHarfBuzz() {
 		if SystemGetHostName() == "Darwin" sed = "gsed";
 		str[] headers = [ "assert", "atomic", "builtins", "float", "locale", "math", "stdio", "stdlib", "string", "unistd", "xlocale" ];
 
-		for int i = 0; i < headers:len(); i += 1 {
+		for str header in headers {
 			// TODO Replace this.
 			assert SystemShellExecuteWithWorkingDirectory("bin/harfbuzz/src", 
-					"find . -type f -exec %sed% -i 's/#include <%headers[i]%.h>/#include <essence.h>/g' {} \\;");
+					"find . -type f -exec %sed% -i 's/#include <%header%.h>/#include <essence.h>/g' {} \\;");
 		}
 	}
 
@@ -517,13 +517,13 @@ void PortHarfBuzz() {
 		str link = "%toolchainPrefix%-ar cr libharfbuzz.a ";
 		int[] tasks = new int[];
 
-		for int i = 0; i < sources:len(); i += 1 {
+		for str source in sources {
 			if tasks:len() == processorCount { tasks:find_and_delete(await tasks); }
-			str command = "%toolchainPrefix%-gcc -c %sources[i]%.cc -o %sources[i]%.o "
+			str command = "%toolchainPrefix%-gcc -c %source%.cc -o %source%.o "
 				+ "-DHAVE_CONFIG_H -I. -I.. -ffreestanding -fno-rtti -g -O3 -DHB_TINY -fno-exceptions -fno-threadsafe-statics "
 				+ "-fvisibility-inlines-hidden -DHB_NO_PRAGMA_GCC_DIAGNOSTIC_ERROR -I%posixRoot%/include";
 			tasks:add(SystemShellExecuteWithWorkingDirectory:curry("bin/harfbuzz/src"):curry(command):assert():async());
-			link += sources[i] + ".o ";
+			link += source + ".o ";
 		}
 
 		while tasks:len() != 0 { tasks:find_and_delete(await tasks); }
@@ -620,8 +620,8 @@ void Start() {
 	if portName == "" {
 		LogInfo("Available ports:");
 
-		for int i = 0; i < portNames:len(); i += 1 {
-			Log("\t%portNames[i]%");
+		for str port in portNames {
+			Log("\t%port%");
 		}
 	} else {
 		assert targetName      != "";
diff --git a/util/script.c b/util/script.c
index 5b22ed8..86a1373 100644
--- a/util/script.c
+++ b/util/script.c
@@ -1,12 +1,11 @@
 // TODO Basic missing features:
 // 	- Other list operations: insert_many, delete_many.
-// 	- Maps: map[int, T], map[str, T].
+// 	- Maps: T[int], T[str].
 // 	- Control flow: break, continue.
 // 	- Other operators: remainder, bitwise shifts, bitwise AND/OR/XOR/NOT, ternary.
-// 	- Enums, bitsets.
+// 	- inttype.
 // 	- Named optional arguments with default values.
 // 	- Accessing structs and functypes from inline modules.
-// 	- Error types.
 
 // TODO Larger missing features:
 // 	- Serialization.
@@ -95,6 +94,8 @@
 #define T_DECL_GROUP_AND_SET  (88)
 #define T_SET_GROUP           (89)
 #define T_FOR_EACH            (90)
+#define T_ERR_CAST            (91)
+#define T_IF_ERR              (92)
 
 #define T_EXIT_SCOPE          (100)
 #define T_END_FUNCTION        (101)
@@ -146,32 +147,38 @@
 #define T_OP_FIND             (156)
 #define T_OP_FIND_AND_DEL_STR (157)
 #define T_OP_FIND_STR         (158)
+#define T_OP_ASSERT_ERR       (159)
+#define T_OP_SUCCESS          (160)
+#define T_OP_ERROR            (161)
+#define T_OP_DEFAULT          (162)
 
-#define T_IF                  (160)
-#define T_WHILE               (161)
-#define T_FOR                 (162)
-#define T_INT                 (163)
-#define T_FLOAT               (164)
-#define T_BOOL                (165)
-#define T_VOID                (166)
-#define T_RETURN              (167)
-#define T_ELSE                (168)
-#define T_EXTCALL             (169)
-#define T_STR                 (170)
-#define T_FUNCTYPE            (171)
-#define T_NULL                (172)
-#define T_FALSE               (173)
-#define T_TRUE                (174)
-#define T_ASSERT              (175)
-#define T_PERSIST             (176)
-#define T_STRUCT              (177)
-#define T_NEW                 (178)
-#define T_OPTION              (179)
-#define T_IMPORT              (180)
-#define T_INLINE              (181)
-#define T_AWAIT               (182)
-#define T_TUPLE               (183)
-#define T_IN                  (184)
+#define T_IF                  (170)
+#define T_WHILE               (171)
+#define T_FOR                 (172)
+#define T_INT                 (173)
+#define T_FLOAT               (174)
+#define T_BOOL                (175)
+#define T_VOID                (176)
+#define T_RETURN              (177)
+#define T_ELSE                (178)
+#define T_EXTCALL             (179)
+#define T_STR                 (180)
+#define T_FUNCTYPE            (181)
+#define T_NULL                (182)
+#define T_FALSE               (183)
+#define T_TRUE                (184)
+#define T_ASSERT              (185)
+#define T_PERSIST             (186)
+#define T_STRUCT              (187)
+#define T_NEW                 (188)
+#define T_OPTION              (189)
+#define T_IMPORT              (190)
+#define T_INLINE              (191)
+#define T_AWAIT               (192)
+#define T_TUPLE               (193)
+#define T_IN                  (194)
+#define T_ERR                 (195)
+#define T_SUCCESS             (196)
 
 #define STACK_READ_STRING(textVariable, bytesVariable, stackIndex) \
 	if (context->c->stackPointer < stackIndex) return -1; \
@@ -311,6 +318,11 @@ typedef struct HeapEntry {
 			uint32_t concat1, concat2;
 			size_t concatBytes;
 		};
+
+		struct {
+			bool success;
+			Value errorValue;
+		};
 	};
 } HeapEntry;
 
@@ -387,6 +399,7 @@ Node globalExpressionTypeFloat = { .type = T_FLOAT };
 Node globalExpressionTypeBool = { .type = T_BOOL };
 Node globalExpressionTypeStr = { .type = T_STR };
 Node globalExpressionTypeIntList = { .type = T_LIST, .firstChild = &globalExpressionTypeInt };
+Node globalExpressionTypeErrVoid = { .type = T_ERR, .firstChild = &globalExpressionTypeVoid };
 
 // Global variables:
 const char *startFunction = "Start";
@@ -909,10 +922,12 @@ Token TokenNext(Tokenizer *tokenizer) {
 			else if KEYWORD("#inline") token.type = T_INLINE;
 			else if KEYWORD("#option") token.type = T_OPTION;
 			else if KEYWORD("#persist") token.type = T_PERSIST;
+			else if KEYWORD("#success") token.type = T_SUCCESS;
 			else if KEYWORD("assert") token.type = T_ASSERT;
 			else if KEYWORD("await") token.type = T_AWAIT;
 			else if KEYWORD("bool") token.type = T_BOOL;
 			else if KEYWORD("else") token.type = T_ELSE;
+			else if KEYWORD("err") token.type = T_ERR;
 			else if KEYWORD("false") token.type = T_FALSE;
 			else if KEYWORD("float") token.type = T_FLOAT;
 			else if KEYWORD("for") token.type = T_FOR;
@@ -1031,6 +1046,7 @@ Node *ParseType(Tokenizer *tokenizer, bool maybe, bool allowVoid, bool allowTupl
 			|| node->token.type == T_BOOL 
 			|| node->token.type == T_VOID 
 			|| node->token.type == T_TUPLE
+			|| node->token.type == T_ERR
 			|| node->token.type == T_IDENTIFIER) {
 		node->type = node->token.type;
 
@@ -1094,6 +1110,24 @@ Node *ParseType(Tokenizer *tokenizer, bool maybe, bool allowVoid, bool allowTupl
 				if (!maybe) PrintError2(tokenizer, node, "A tuple must have at least two types in its list.\n");
 				return NULL;
 			}
+		} else if (node->type == T_ERR) {
+			Token token = TokenNext(tokenizer);
+
+			if (token.type != T_LEFT_SQUARE) {
+				if (!maybe) PrintError2(tokenizer, node, "Expected a '[' after 'err'.\n");
+				return NULL;
+			}
+
+			Node *n = ParseType(tokenizer, maybe, true /* allow void */, false);
+			if (!n) return NULL;
+			node->firstChild = n;
+
+			token = TokenNext(tokenizer);
+
+			if (token.type != T_RIGHT_SQUARE) {
+				if (!maybe) PrintError2(tokenizer, node, "Expected a ']' after the type of 'err'.\n");
+				return NULL;
+			}
 		}
 
 		bool first = true;
@@ -1137,7 +1171,7 @@ Node *ParseType(Tokenizer *tokenizer, bool maybe, bool allowVoid, bool allowTupl
 
 		return node;
 	} else if (!maybe) {
-		PrintError2(tokenizer, node, "Expected a type. This can be 'int', 'float', 'bool', 'void', 'str', 'tuple', or an identifier.\n");
+		PrintError2(tokenizer, node, "Expected a type. This can be a builtin type or an identifier.\n");
 		return NULL;
 	} else {
 		return NULL;
@@ -1246,7 +1280,7 @@ Node *ParseExpression(Tokenizer *tokenizer, bool allowAssignment, uint8_t preced
 				string->token.textBytes++;
 			}
 		}
-	} else if (node->token.type == T_NUMERIC_LITERAL
+	} else if (node->token.type == T_NUMERIC_LITERAL || node->token.type == T_SUCCESS
 			|| node->token.type == T_TRUE || node->token.type == T_FALSE || node->token.type == T_NULL) {
 		node->type = node->token.type;
 	} else if (node->token.type == T_LOGICAL_NOT || node->token.type == T_MINUS) {
@@ -1268,6 +1302,11 @@ Node *ParseExpression(Tokenizer *tokenizer, bool allowAssignment, uint8_t preced
 		node->firstChild = ParseType(tokenizer, false, false /* allow void */, false /* allow tuple */);
 		node->expressionType = node->firstChild;
 		if (!node->firstChild) return NULL;
+
+		if (node->firstChild->type == T_ERR) {
+			node->firstChild->sibling = ParseExpression(tokenizer, false, 255);
+			if (!node->firstChild->sibling) return NULL;
+		}
 	} else if (node->token.type == T_LEFT_SQUARE) {
 		node->type = T_LIST_LITERAL;
 		Node **link = &node->firstChild;
@@ -1411,25 +1450,61 @@ Node *ParseIf(Tokenizer *tokenizer) {
 	Node *node = (Node *) AllocateFixed(sizeof(Node));
 	node->type = T_IF;
 	node->token = TokenNext(tokenizer);
-	node->firstChild = ParseExpression(tokenizer, false, 0);
-	if (!node->firstChild) return NULL;
+	Node **link = &node->firstChild;
+
+	{
+		Tokenizer copy = *tokenizer;
+		Node *type = ParseType(tokenizer, true /* maybe */, false, false);
+
+		if (tokenizer->error) {
+			return NULL;
+		} else if (type) {
+			Token name = TokenNext(tokenizer);
+
+			if (tokenizer->error) {
+				return NULL;
+			} else if (name.type == T_IDENTIFIER) {
+				Token in = TokenNext(tokenizer);
+
+				if (tokenizer->error) {
+					return NULL;
+				} else if (in.type == T_IN) {
+					node->type = T_IF_ERR;
+
+					Node *declaration = (Node *) AllocateFixed(sizeof(Node));
+					declaration->type = T_DECLARE;
+					declaration->token = name;
+					declaration->firstChild = type;
+					node->firstChild = declaration;
+					link = &declaration->sibling;
+				}
+			}
+		}
+
+		if (node->type != T_IF_ERR) {
+			*tokenizer = copy;
+		}
+	}
+
+	*link = ParseExpression(tokenizer, false, 0);
+	if (!(*link)) return NULL;
 	Token token = TokenPeek(tokenizer);
 
 	if (token.type == T_LEFT_FANCY) {
 		TokenNext(tokenizer);
-		node->firstChild->sibling = ParseBlock(tokenizer, false);
-		if (!node->firstChild->sibling) return NULL;
+		(*link)->sibling = ParseBlock(tokenizer, false);
+		if (!(*link)->sibling) return NULL;
 	} else {
 		Node *wrapper = (Node *) AllocateFixed(sizeof(Node));
 		wrapper->type = T_BLOCK;
 		wrapper->firstChild = ParseExpression(tokenizer, true, 0);
 		if (!wrapper->firstChild) return NULL;
-		node->firstChild->sibling = wrapper;
+		(*link)->sibling = wrapper;
 
 		Token semicolon = TokenNext(tokenizer);
 
 		if (semicolon.type != T_SEMICOLON) {
-			PrintError2(tokenizer, node->firstChild->sibling, "Expected a semicolon at the end of the expression.\n");
+			PrintError2(tokenizer, (*link)->sibling, "Expected a semicolon at the end of the expression.\n");
 			return NULL;
 		}
 	}
@@ -1441,26 +1516,31 @@ Node *ParseIf(Tokenizer *tokenizer) {
 		token = TokenPeek(tokenizer);
 
 		if (token.type == T_IF) {
-			node->firstChild->sibling->sibling = ParseIf(tokenizer);
-			if (!node->firstChild->sibling->sibling) return NULL;
+			(*link)->sibling->sibling = ParseIf(tokenizer);
+			if (!(*link)->sibling->sibling) return NULL;
 		} else if (token.type == T_LEFT_FANCY) {
 			TokenNext(tokenizer);
-			node->firstChild->sibling->sibling = ParseBlock(tokenizer, false);
-			if (!node->firstChild->sibling->sibling) return NULL;
+			(*link)->sibling->sibling = ParseBlock(tokenizer, false);
+			if (!(*link)->sibling->sibling) return NULL;
 		} else {
-			node->firstChild->sibling->sibling = ParseExpression(tokenizer, true, 0);
-			if (!node->firstChild->sibling->sibling) return NULL;
+			(*link)->sibling->sibling = ParseExpression(tokenizer, true, 0);
+			if (!(*link)->sibling->sibling) return NULL;
 
 			Token semicolon = TokenNext(tokenizer);
 
 			if (semicolon.type != T_SEMICOLON) {
-				PrintError2(tokenizer, node->firstChild->sibling, "Expected a semicolon at the end of the expression.\n");
+				PrintError2(tokenizer, (*link)->sibling, "Expected a semicolon at the end of the expression.\n");
 				return NULL;
 			}
 		}
 	}
 
-	return node;
+	// Make sure that the if-err variable has its own scope.
+	Node *wrapper = (Node *) AllocateFixed(sizeof(Node));
+	wrapper->type = T_BLOCK;
+	wrapper->token = node->token;
+	wrapper->firstChild = node;
+	return wrapper;
 }
 
 Node *ParseVariableDeclarationOrExpression(Tokenizer *tokenizer, bool replMode, bool allowIn) {
@@ -2388,7 +2468,7 @@ bool ASTMatching(Node *left, Node *right) {
 }
 
 bool ASTIsManagedType(Node *node) {
-	return node->type == T_STR || node->type == T_LIST || node->type == T_STRUCT || node->type == T_FUNCPTR || node->type == T_FUNCPTR;
+	return node->type == T_STR || node->type == T_LIST || node->type == T_STRUCT || node->type == T_FUNCPTR || node->type == T_FUNCPTR || node->type == T_ERR;
 }
 
 int ASTGetTypePopCount(Node *node) {
@@ -2457,6 +2537,20 @@ bool ASTLookupTypeIdentifiers(Tokenizer *tokenizer, Node *node) {
 	return true;
 }
 
+Node *ASTImplicitCastToErr(Tokenizer *tokenizer, Node *parent, Node *expression) {
+	if (!expression->expressionType || ASTMatching(expression->expressionType, &globalExpressionTypeVoid)) {
+		PrintError2(tokenizer, parent, "You cannot assign a value of 'void' to 'err[void]'.\nInstead, use the constant '#success'.\n");
+		return NULL;
+	}
+
+	Node *cast = (Node *) AllocateFixed(sizeof(Node));
+	cast->type = T_ERR_CAST;
+	cast->scope = parent->scope;
+	cast->parent = parent;
+	cast->firstChild = expression;
+	return cast;
+}
+
 bool ASTSetTypes(Tokenizer *tokenizer, Node *node) {
 	Node *child = node->firstChild;
 
@@ -2467,7 +2561,8 @@ bool ASTSetTypes(Tokenizer *tokenizer, Node *node) {
 	}
 
 	if (node->type == T_ROOT || node->type == T_BLOCK
-			|| node->type == T_INT || node->type == T_FLOAT || node->type == T_STR || node->type == T_LIST || node->type == T_TUPLE
+			|| node->type == T_INT || node->type == T_FLOAT || node->type == T_STR 
+			|| node->type == T_LIST || node->type == T_TUPLE || node->type == T_ERR
 			|| node->type == T_BOOL || node->type == T_VOID || node->type == T_IDENTIFIER
 			|| node->type == T_ARGUMENTS || node->type == T_ARGUMENT
 			|| node->type == T_STRUCT || node->type == T_FUNCTYPE || node->type == T_IMPORT || node->type == T_IMPORT_PATH
@@ -2492,6 +2587,8 @@ bool ASTSetTypes(Tokenizer *tokenizer, Node *node) {
 		}
 	} else if (node->type == T_TRUE || node->type == T_FALSE) {
 		node->expressionType = &globalExpressionTypeBool;
+	} else if (node->type == T_SUCCESS) {
+		node->expressionType = &globalExpressionTypeErrVoid;
 	} else if (node->type == T_NULL) {
 		node->expressionType = node;
 	} else if (node->type == T_STRING_LITERAL) {
@@ -2565,7 +2662,13 @@ bool ASTSetTypes(Tokenizer *tokenizer, Node *node) {
 			node->expressionType = node->firstChild->expressionType;
 		}
 	} else if (node->type == T_DECLARE) {
-		if (node->firstChild->sibling && !ASTMatching(node->firstChild, node->firstChild->sibling->expressionType)) {
+		if (node->firstChild->sibling && node->firstChild && node->firstChild->type == T_ERR 
+				&& ASTMatching(node->firstChild->firstChild, node->firstChild->sibling->expressionType)) {
+			// Allow the implicit cast to an error type.
+			Node *cast = ASTImplicitCastToErr(tokenizer, node, node->firstChild->sibling);
+			if (!cast) return false;
+			node->firstChild->sibling = cast;
+		} else if (node->firstChild->sibling && !ASTMatching(node->firstChild, node->firstChild->sibling->expressionType)) {
 			PrintError2(tokenizer, node, "The type of the variable being assigned does not match the expression.\n");
 			return false;
 		}
@@ -2627,7 +2730,13 @@ bool ASTSetTypes(Tokenizer *tokenizer, Node *node) {
 			return false;
 		}
 	} else if (node->type == T_EQUALS) {
-		if (!ASTMatching(node->firstChild->expressionType, node->firstChild->sibling->expressionType)) {
+		if (node->firstChild->expressionType && node->firstChild->expressionType->type == T_ERR 
+				&& ASTMatching(node->firstChild->expressionType->firstChild, node->firstChild->sibling->expressionType)) {
+			// Allow the implicit cast to an error type.
+			Node *cast = ASTImplicitCastToErr(tokenizer, node, node->firstChild->sibling);
+			if (!cast) return false;
+			node->firstChild->sibling = cast;
+		} else if (!ASTMatching(node->firstChild->expressionType, node->firstChild->sibling->expressionType)) {
 			PrintError2(tokenizer, node, "The type of the variable being assigned does not match the expression.\n");
 			return false;
 		}
@@ -2663,8 +2772,9 @@ bool ASTSetTypes(Tokenizer *tokenizer, Node *node) {
 			}
 		}
 	} else if (node->type == T_ASSERT) {
-		if (!ASTMatching(node->firstChild->expressionType, &globalExpressionTypeBool)) {
-			PrintError2(tokenizer, node, "The asserted expression must evaluate to a boolean.\n");
+		if (!ASTMatching(node->firstChild->expressionType, &globalExpressionTypeBool)
+				&& !(node->firstChild->expressionType && node->firstChild->expressionType->type == T_ERR)) {
+			PrintError2(tokenizer, node, "The asserted expression must evaluate to a boolean or error value.\n");
 			return false;
 		}
 	} else if (node->type == T_RETURN) {
@@ -2721,11 +2831,27 @@ bool ASTSetTypes(Tokenizer *tokenizer, Node *node) {
 			PrintError2(tokenizer, node, "The type of the expression does not match the declared return type of the function.\n");
 			return false;
 		}
-	} else if (node->type == T_IF || node->type == T_WHILE) {
+	} else if (node->type == T_IF) {
+		if (!ASTMatching(node->firstChild->expressionType, &globalExpressionTypeBool)
+				&& !(node->firstChild->expressionType && node->firstChild->expressionType->type == T_ERR)) {
+			PrintError2(tokenizer, node, "The expression used for the condition must evaluate to a boolean or error value.\n");
+			return false;
+		}
+	} else if (node->type == T_WHILE) {
 		if (!ASTMatching(node->firstChild->expressionType, &globalExpressionTypeBool)) {
 			PrintError2(tokenizer, node, "The expression used for the condition must evaluate to a boolean.\n");
 			return false;
 		}
+	} else if (node->type == T_IF_ERR) {
+		if (!node->firstChild->sibling->expressionType || node->firstChild->sibling->expressionType->type != T_ERR) {
+			PrintError2(tokenizer, node, "The expression used for the condition must evaluate to a error type.\n");
+			return false;
+		}
+
+		if (!ASTMatching(node->firstChild->firstChild, node->firstChild->sibling->expressionType->firstChild)) {
+			PrintError2(tokenizer, node, "The variable declaration type must match the error value.\n");
+			return false;
+		}
 	} else if (node->type == T_FOR) {
 		if (!ASTMatching(node->firstChild->sibling->expressionType, &globalExpressionTypeBool)) {
 			PrintError2(tokenizer, node, "The expression used for the condition must evaluate to a boolean.\n");
@@ -2733,15 +2859,23 @@ bool ASTSetTypes(Tokenizer *tokenizer, Node *node) {
 		}
 	} else if (node->type == T_FOR_EACH) {
 		Node *listType = node->firstChild->sibling->expressionType;
+		bool isStr = listType && ASTMatching(listType, &globalExpressionTypeStr);
 
-		if (!listType || listType->type != T_LIST) {
-			PrintError2(tokenizer, node, "The expression on the right of 'in' must be a list.\n");
+		if (!listType || (listType->type != T_LIST && !isStr)) {
+			PrintError2(tokenizer, node, "The expression on the right of 'in' must be a list or string.\n");
 			return false;
 		}
 
-		if (!ASTMatching(node->firstChild->expressionType, listType->firstChild)) {
-			PrintError2(tokenizer, node, "The variable on the left of 'in' must match the type of the items in the list on the right.\n");
-			return false;
+		if (isStr) {
+			if (!ASTMatching(node->firstChild->expressionType, &globalExpressionTypeStr)) {
+				PrintError2(tokenizer, node, "The variable on the left of 'in' must be a 'str' when iterating over a string.\n");
+				return false;
+			}
+		} else {
+			if (!ASTMatching(node->firstChild->expressionType, listType->firstChild)) {
+				PrintError2(tokenizer, node, "The variable on the left of 'in' must match the type of the items in the list on the right.\n");
+				return false;
+			}
 		}
 	} else if (node->type == T_INDEX) {
 		if (!ASTMatching(node->firstChild->expressionType, &globalExpressionTypeStr)
@@ -2761,8 +2895,13 @@ bool ASTSetTypes(Tokenizer *tokenizer, Node *node) {
 			node->expressionType = node->firstChild->expressionType->firstChild;
 		}
 	} else if (node->type == T_NEW) {
-		if (node->firstChild->type != T_STRUCT && node->firstChild->type != T_LIST) {
-			PrintError2(tokenizer, node, "This type is not a struct or list. 'new' is used to create new instances of structs or lists.\n");
+		if (node->firstChild->type != T_STRUCT && node->firstChild->type != T_LIST && node->firstChild->type != T_ERR) {
+			PrintError2(tokenizer, node, "This type is not a struct, list or error. 'new' is used to create new instances of structs, lists and errors.\n");
+			return false;
+		}
+
+		if (node->firstChild->type == T_ERR && !ASTMatching(node->firstChild->sibling->expressionType, &globalExpressionTypeStr)) {
+			PrintError2(tokenizer, node, "The error message should be a string.\n");
 			return false;
 		}
 	} else if (node->type == T_DOT) {
@@ -2812,15 +2951,16 @@ bool ASTSetTypes(Tokenizer *tokenizer, Node *node) {
 		bool isList = expressionType->type == T_LIST;
 		bool isStr = expressionType->type == T_STR;
 		bool isFuncPtr = expressionType->type == T_FUNCPTR;
+		bool isErr = expressionType->type == T_ERR;
 
-		if (!isList && !isStr & !isFuncPtr) {
+		if (!isList && !isStr & !isFuncPtr && !isErr) {
 			PrintError2(tokenizer, node, "This type does not have any ':' operations.\n");
 			return false;
 		}
 
 		Token token = node->token;
 		Node *arguments[2] = { 0 };
-		bool returnsItem = false, returnsInt = false, returnsBool = false, simple = true;
+		bool returnsItem = false, returnsInt = false, returnsBool = false, returnsStr = false, simple = true;
 		uint8_t op;
 
 		if (isList && KEYWORD("resize")) arguments[0] = &globalExpressionTypeInt, op = T_OP_RESIZE;
@@ -2836,6 +2976,10 @@ bool ASTSetTypes(Tokenizer *tokenizer, Node *node) {
 		else if (isList && KEYWORD("first")) returnsItem = true, op = T_OP_FIRST;
 		else if (isList && KEYWORD("last")) returnsItem = true, op = T_OP_LAST;
 		else if ((isList || isStr) && KEYWORD("len")) returnsInt = true, op = T_OP_LEN;
+		else if (isErr && KEYWORD("success")) returnsBool = true, op = T_OP_SUCCESS;
+		else if (isErr && KEYWORD("assert")) returnsItem = true, op = T_OP_ASSERT_ERR;
+		else if (isErr && KEYWORD("error")) returnsStr = true, op = T_OP_ERROR;
+		else if (isErr && KEYWORD("default")) arguments[0] = expressionType->firstChild, returnsItem = true, op = T_OP_DEFAULT; // TODO Warn if the expression has side effects.
 
 		else if (isFuncPtr && KEYWORD("async")) {
 			if (expressionType->firstChild->firstChild) {
@@ -2918,6 +3062,14 @@ bool ASTSetTypes(Tokenizer *tokenizer, Node *node) {
 			return false;
 		}
 
+		if (op == T_OP_DEFAULT && ASTMatching(arguments[0], &globalExpressionTypeVoid)) {
+			PrintError2(tokenizer, node, "The 'default' operation cannot be used with error values of type void.\n");
+			return false;
+		} else if (op == T_OP_ASSERT_ERR && ASTMatching(expressionType->firstChild, &globalExpressionTypeVoid)) {
+			PrintError2(tokenizer, node, "The 'assert' operation cannot be used with error values of type void.\n");
+			return false;
+		}
+
 		if (op == T_OP_FIND_AND_DELETE && ASTMatching(arguments[0], &globalExpressionTypeStr)) {
 			op = T_OP_FIND_AND_DEL_STR;
 		} else if (op == T_OP_FIND && ASTMatching(arguments[0], &globalExpressionTypeStr)) {
@@ -2947,6 +3099,7 @@ bool ASTSetTypes(Tokenizer *tokenizer, Node *node) {
 
 			node->expressionType = returnsItem ? expressionType->firstChild 
 				: returnsInt ? &globalExpressionTypeInt 
+				: returnsStr ? &globalExpressionTypeStr 
 				: returnsBool ? &globalExpressionTypeBool : NULL;
 		}
 
@@ -3028,7 +3181,7 @@ bool ASTCheckForReturnStatements(Tokenizer *tokenizer, Node *node) {
 
 		if (lastStatement && (lastStatement->type == T_RETURN || lastStatement->type == T_RETURN_TUPLE)) {
 			return true;
-		} else if (lastStatement && (lastStatement->type == T_IF || lastStatement->type == T_BLOCK)) {
+		} else if (lastStatement && (lastStatement->type == T_IF || lastStatement->type == T_IF_ERR || lastStatement->type == T_BLOCK)) {
 			return ASTCheckForReturnStatements(tokenizer, lastStatement);
 		} else {
 			PrintError2(tokenizer, node, "This block needs to end with a return statement.\n");
@@ -3042,6 +3195,14 @@ bool ASTCheckForReturnStatements(Tokenizer *tokenizer, Node *node) {
 
 		return ASTCheckForReturnStatements(tokenizer, node->firstChild->sibling)
 			&& ASTCheckForReturnStatements(tokenizer, node->firstChild->sibling->sibling);
+	} else if (node->type == T_IF_ERR) {
+		if (!node->firstChild->sibling->sibling->sibling) {
+			PrintError2(tokenizer, node, "This function returns a value, so this if statement needs an else block which ends with a return statement.\n");
+			return false;
+		}
+
+		return ASTCheckForReturnStatements(tokenizer, node->firstChild->sibling->sibling)
+			&& ASTCheckForReturnStatements(tokenizer, node->firstChild->sibling->sibling->sibling);
 	}
 
 	return true;
@@ -3316,6 +3477,7 @@ bool FunctionBuilderRecurse(Tokenizer *tokenizer, Node *node, FunctionBuilder *b
 		Node *declare = node->firstChild;
 		Node *list = node->firstChild->sibling;
 		Node *body = node->firstChild->sibling->sibling;
+		bool isStr = ASTMatching(list->expressionType, &globalExpressionTypeStr);
 
 		if (declare->type != T_DECLARE) {
 			PrintError2(tokenizer, node, "The left of a for-in statement must be a variable declaration.\n");
@@ -3385,7 +3547,7 @@ bool FunctionBuilderRecurse(Tokenizer *tokenizer, Node *node, FunctionBuilder *b
 		b = T_ROT3;
 		FunctionBuilderAppend(builder, &b, sizeof(b));
 		// Stack: index, list, list, index, ...
-		b = T_INDEX_LIST;
+		b = isStr ? T_INDEX : T_INDEX_LIST;
 		FunctionBuilderAppend(builder, &b, sizeof(b));
 		// Stack: list, index, ...
 
@@ -3435,6 +3597,12 @@ bool FunctionBuilderRecurse(Tokenizer *tokenizer, Node *node, FunctionBuilder *b
 		return true;
 	} else if (node->type == T_IF) {
 		if (!FunctionBuilderRecurse(tokenizer, node->firstChild, builder, false)) return false;
+
+		if (node->firstChild->expressionType->type == T_ERR) {
+			uint8_t b = T_OP_SUCCESS;
+			FunctionBuilderAppend(builder, &b, sizeof(b));
+		}
+
 		FunctionBuilderAddLineNumber(builder, node);
 		FunctionBuilderAppend(builder, &node->type, sizeof(node->type));
 		uintptr_t writeOffset = builder->dataBytes, writeOffsetElse = 0;
@@ -3458,6 +3626,53 @@ bool FunctionBuilderRecurse(Tokenizer *tokenizer, Node *node, FunctionBuilder *b
 			MemoryCopy(builder->data + writeOffsetElse, &delta, sizeof(delta));
 		}
 
+		return true;
+	} else if (node->type == T_IF_ERR) {
+		uint8_t b;
+		if (!FunctionBuilderRecurse(tokenizer, node->firstChild->sibling, builder, false)) return false;
+		FunctionBuilderAddLineNumber(builder, node);
+
+		b = T_DUP;
+		FunctionBuilderAppend(builder, &b, sizeof(b));
+		b = T_OP_SUCCESS;
+		FunctionBuilderAppend(builder, &b, sizeof(b));
+		b = T_IF;
+		FunctionBuilderAppend(builder, &b, sizeof(b));
+		uintptr_t writeOffset = builder->dataBytes, writeOffsetElse = 0;
+		uint32_t zero = 0;
+		FunctionBuilderAppend(builder, &zero, sizeof(zero));
+		b = T_OP_ASSERT_ERR;
+		FunctionBuilderAppend(builder, &b, sizeof(b));
+
+		Node *variableNode = (Node *) AllocateFixed(sizeof(Node));
+		variableNode->type = T_IDENTIFIER;
+		variableNode->token = node->firstChild->token;
+		variableNode->scope = node->scope;
+		variableNode->parent = node;
+		FunctionBuilderVariable(tokenizer, builder, variableNode, true);
+		b = T_EQUALS;
+		FunctionBuilderAppend(builder, &b, sizeof(b));
+		FunctionBuilderAppend(builder, &builder->scopeIndex, sizeof(builder->scopeIndex));
+
+		if (!FunctionBuilderRecurse(tokenizer, node->firstChild->sibling->sibling, builder, false)) return false;
+
+		b = T_BRANCH;
+		FunctionBuilderAppend(builder, &b, sizeof(b));
+		writeOffsetElse = builder->dataBytes;
+		FunctionBuilderAppend(builder, &zero, sizeof(zero));
+
+		int32_t delta = builder->dataBytes - writeOffset;
+		MemoryCopy(builder->data + writeOffset, &delta, sizeof(delta));
+
+		if (node->firstChild->sibling->sibling->sibling) {
+			if (!FunctionBuilderRecurse(tokenizer, node->firstChild->sibling->sibling->sibling, builder, false)) return false;
+		}
+
+		b = T_POP;
+		FunctionBuilderAppend(builder, &b, sizeof(b));
+		delta = builder->dataBytes - writeOffsetElse;
+		MemoryCopy(builder->data + writeOffsetElse, &delta, sizeof(delta));
+
 		return true;
 	} else if (node->type == T_LOGICAL_OR || node->type == T_LOGICAL_AND) {
 		if (!FunctionBuilderRecurse(tokenizer, node->firstChild, builder, false)) return false;
@@ -3470,12 +3685,18 @@ bool FunctionBuilderRecurse(Tokenizer *tokenizer, Node *node, FunctionBuilder *b
 		MemoryCopy(builder->data + writeOffset, &delta, sizeof(delta));
 		return true;
 	} else if (node->type == T_NEW) {
+		if (node->firstChild->type == T_ERR) {
+			FunctionBuilderRecurse(tokenizer, node->firstChild->sibling, builder, false);
+		}
+
 		FunctionBuilderAddLineNumber(builder, node);
 		FunctionBuilderAppend(builder, &node->type, sizeof(node->type));
 		int16_t fieldCount = 0;
 
 		if (node->firstChild->type == T_LIST) {
 			fieldCount = ASTIsManagedType(node->firstChild->firstChild) ? -2 : -1;
+		} else if (node->firstChild->type == T_ERR) {
+			fieldCount = ASTIsManagedType(node->firstChild->firstChild) ? -4 : -3;
 		} else {
 			Node *child = node->firstChild->firstChild;
 
@@ -3589,9 +3810,20 @@ bool FunctionBuilderRecurse(Tokenizer *tokenizer, Node *node, FunctionBuilder *b
 		uint8_t b = T_END_FUNCTION;
 		FunctionBuilderAddLineNumber(builder, node);
 		FunctionBuilderAppend(builder, &b, sizeof(b));
-	} else if (node->type == T_ASSERT || node->type == T_NULL || node->type == T_LOGICAL_NOT || node->type == T_AWAIT) {
+	} else if (node->type == T_NULL || node->type == T_LOGICAL_NOT || node->type == T_AWAIT || node->type == T_ERR_CAST) {
 		FunctionBuilderAddLineNumber(builder, node);
 		FunctionBuilderAppend(builder, &node->type, sizeof(node->type));
+	} else if (node->type == T_ASSERT) {
+		FunctionBuilderAddLineNumber(builder, node);
+
+		if (node->firstChild->expressionType->type == T_ERR) {
+			uint8_t b = T_OP_ASSERT_ERR;
+			FunctionBuilderAppend(builder, &b, sizeof(b));
+			b = T_POP;
+			FunctionBuilderAppend(builder, &b, sizeof(b));
+		} else {
+			FunctionBuilderAppend(builder, &node->type, sizeof(node->type));
+		}
 	} else if (node->type == T_ADD || node->type == T_MINUS || node->type == T_ASTERISK || node->type == T_SLASH || node->type == T_NEGATE) {
 		uint8_t b = node->expressionType->type == T_FLOAT ? node->type - T_ADD + T_FLOAT_ADD 
 			: node->expressionType->type == T_STR ? T_CONCAT : node->type;
@@ -3724,6 +3956,14 @@ bool FunctionBuilderRecurse(Tokenizer *tokenizer, Node *node, FunctionBuilder *b
 		Value v;
 		v.i = node->type == T_TRUE ? 1 : 0;
 		FunctionBuilderAppend(builder, &v, sizeof(v));
+	} else if (node->type == T_SUCCESS) {
+		uint8_t b = T_NUMERIC_LITERAL;
+		FunctionBuilderAppend(builder, &b, sizeof(b));
+		Value v;
+		v.i = 0;
+		FunctionBuilderAppend(builder, &v, sizeof(v));
+		b = T_ERR_CAST;
+		FunctionBuilderAppend(builder, &b, sizeof(b));
 	} else if (node->type == T_REPL_RESULT) {
 		if (!ASTMatching(node->firstChild->expressionType, &globalExpressionTypeVoid)) {
 			FunctionBuilderAppend(builder, &node->type, sizeof(node->type));
@@ -3855,6 +4095,10 @@ void HeapGarbageCollectMark(ExecutionContext *context, uintptr_t index) {
 		if (context->heap[index].internalValuesAreManaged) {
 			HeapGarbageCollectMark(context, context->heap[index].curryValue.i);
 		}
+	} else if (context->heap[index].type == T_ERR) {
+		if (context->heap[index].internalValuesAreManaged) {
+			HeapGarbageCollectMark(context, context->heap[index].errorValue.i);
+		}
 	} else {
 		Assert(false);
 	}
@@ -3869,7 +4113,7 @@ void HeapFreeEntry(ExecutionContext *context, uintptr_t i) {
 		AllocateResize(context->heap[i].list, 0);
 	} else if (context->heap[i].type == T_OP_DISCARD || context->heap[i].type == T_OP_ASSERT 
 			|| context->heap[i].type == T_FUNCPTR || context->heap[i].type == T_OP_CURRY
-			|| context->heap[i].type == T_CONCAT) {
+			|| context->heap[i].type == T_CONCAT || context->heap[i].type == T_ERR) {
 	} else {
 		Assert(false);
 	}
@@ -4647,6 +4891,101 @@ int ScriptExecuteFunction(uintptr_t instructionPointer, ExecutionContext *contex
 				PrintError4(context, instructionPointer - 1, "Assertion failed.\n");
 				return 0;
 			}
+		} else if (command == T_ERR_CAST) {
+			if (context->c->stackPointer < 1) return -1;
+
+			// TODO Handle memory allocation failures here.
+			uintptr_t index = HeapAllocate(context);
+			context->heap[index].type = T_ERR;
+			context->heap[index].success = true;
+			context->heap[index].internalValuesAreManaged = context->c->stackIsManaged[context->c->stackPointer - 1];;
+			context->heap[index].errorValue = context->c->stack[context->c->stackPointer - 1];
+
+			Value v;
+			v.i = index;
+			context->c->stackIsManaged[context->c->stackPointer - 1] = true;
+			context->c->stack[context->c->stackPointer - 1] = v;
+		} else if (command == T_OP_SUCCESS) {
+			if (context->c->stackPointer < 1) return -1;
+			if (!context->c->stackIsManaged[context->c->stackPointer - 1]) return -1;
+			uintptr_t index = context->c->stack[context->c->stackPointer - 1].i;
+			bool success = false;
+
+			if (index) {
+				if (context->heapEntriesAllocated <= index) return -1;
+				HeapEntry *entry = &context->heap[index];
+				if (entry->type != T_ERR) return -1;
+				success = entry->success;
+			}
+
+			context->c->stack[context->c->stackPointer - 1].i = success;
+			context->c->stackIsManaged[context->c->stackPointer - 1] = false;
+		} else if (command == T_OP_ASSERT_ERR) {
+			if (context->c->stackPointer < 1) return -1;
+			if (!context->c->stackIsManaged[context->c->stackPointer - 1]) return -1;
+			uintptr_t index = context->c->stack[context->c->stackPointer - 1].i;
+
+			if (index == 0) {
+				PrintError4(context, instructionPointer - 1, "Assertion failed. Unknown error.\n");
+				return 0;
+			} else {
+				if (context->heapEntriesAllocated <= index) return -1;
+				HeapEntry *entry = &context->heap[index];
+				if (entry->type != T_ERR) return -1;
+
+				if (!entry->success) {
+					if (!entry->internalValuesAreManaged) return -1;
+					size_t textBytes;
+					const char *text;
+					ScriptHeapEntryToString(context, &context->heap[entry->errorValue.i], &text, &textBytes);
+					PrintError4(context, instructionPointer - 1, "Assertion failed.\nThe error code is: '%.*s'.\n", textBytes, text);
+					return 0;
+				}
+
+				context->c->stack[context->c->stackPointer - 1] = entry->errorValue;
+				context->c->stackIsManaged[context->c->stackPointer - 1] = entry->internalValuesAreManaged;
+			}
+		} else if (command == T_OP_ERROR) {
+			if (context->c->stackPointer < 1) return -1;
+			if (!context->c->stackIsManaged[context->c->stackPointer - 1]) return -1;
+			uintptr_t index = context->c->stack[context->c->stackPointer - 1].i;
+
+			if (index == 0) {
+				index = HeapAllocate(context);
+				context->heap[index].type = T_STR;
+				context->heap[index].text = (char *) AllocateResize(NULL, 7);
+				context->heap[index].bytes = 7;
+				MemoryCopy(context->heap[index].text, "UNKNOWN", 7);
+			} else {
+				if (context->heapEntriesAllocated <= index) return -1;
+				HeapEntry *entry = &context->heap[index];
+				if (entry->type != T_ERR) return -1;
+				if (!entry->success && !entry->internalValuesAreManaged) return -1;
+				index = entry->success ? 0 : entry->errorValue.i;
+			}
+
+			context->c->stack[context->c->stackPointer - 1].i = index;
+			context->c->stackIsManaged[context->c->stackPointer - 1] = true;
+		} else if (command == T_OP_DEFAULT) {
+			if (context->c->stackPointer < 2) return -1;
+			if (!context->c->stackIsManaged[context->c->stackPointer - 2]) return -1;
+			uintptr_t index = context->c->stack[context->c->stackPointer - 2].i;
+
+			if (index) {
+				if (context->heapEntriesAllocated <= index) return -1;
+				HeapEntry *entry = &context->heap[index];
+				if (entry->type != T_ERR) return -1;
+				if (!entry->success && !entry->internalValuesAreManaged) return -1;
+
+				if (entry->success) {
+					context->c->stack[context->c->stackPointer - 1] = entry->errorValue;
+					context->c->stackIsManaged[context->c->stackPointer - 1] = entry->internalValuesAreManaged;
+				}
+			}
+
+			context->c->stack[context->c->stackPointer - 2] = context->c->stack[context->c->stackPointer - 1];
+			context->c->stackIsManaged[context->c->stackPointer - 2] = context->c->stackIsManaged[context->c->stackPointer - 1];
+			context->c->stackPointer--;
 		} else if (command == T_PERSIST) {
 			if (!ExternalPersistWrite(context, NULL)) {
 				return 0;
@@ -4660,7 +4999,7 @@ int ScriptExecuteFunction(uintptr_t instructionPointer, ExecutionContext *contex
 			int16_t fieldCount = functionData[instructionPointer + 0] + (functionData[instructionPointer + 1] << 8); 
 			instructionPointer += 2;
 			uintptr_t index = HeapAllocate(context);
-			context->heap[index].type = fieldCount < 0 ? T_LIST : T_STRUCT;
+			context->heap[index].type = fieldCount >= 0 ? T_STRUCT : fieldCount >= -2 ? T_LIST : T_ERR;
 
 			if (fieldCount >= 0) {
 				context->heap[index].fields = (Value *) ((uint8_t *) AllocateResize(NULL, fieldCount * (1 + sizeof(Value))) + fieldCount);
@@ -4673,10 +5012,18 @@ int ScriptExecuteFunction(uintptr_t instructionPointer, ExecutionContext *contex
 					// The first type they are set this will be updated.
 					((uint8_t *) context->heap[index].fields)[-1 - i] = false;
 				}
-			} else {
+			} else if (fieldCount >= -2) {
 				context->heap[index].internalValuesAreManaged = fieldCount == -2;
 				context->heap[index].length = context->heap[index].allocated = 0;
 				context->heap[index].list = NULL;
+			} else {
+				context->heap[index].internalValuesAreManaged = true;
+				context->heap[index].success = false;
+
+				if (context->c->stackPointer < 1) return -1;
+				if (!context->c->stackIsManaged[context->c->stackPointer - 1]) return -1;
+				context->heap[index].errorValue = context->c->stack[context->c->stackPointer - 1];
+				context->c->stackPointer--;
 			}
 
 			Value v;