diff --git a/README.md b/README.md
index b8761c944..976dc5a56 100644
--- a/README.md
+++ b/README.md
@@ -131,7 +131,7 @@ fn void main()
 - Value methods
 - Associated enum data
 - No preprocessor
-- Less undefined behaviour and runtime checks in "safe" mode
+- Less undefined behaviour and added runtime checks in "safe" mode
 - Limited operator overloading to enable userland dynamic arrays
 - Optional pre and post conditions
 
diff --git a/lib/std/collections/enummap.c3 b/lib/std/collections/enummap.c3
index 7d84b5969..60e7e3c31 100644
--- a/lib/std/collections/enummap.c3
+++ b/lib/std/collections/enummap.c3
@@ -2,15 +2,15 @@ module std::collections::enummap(<Enum, ValueType>);
 
 struct EnumMap
 {
-    ValueType[Enum.len] values;
+	ValueType[Enum.len] values;
 }
 
 fn void EnumMap.init(&self, ValueType init_value)
 {
-    foreach(&a : self.values)
-    {
-        *a = init_value;
-    }
+	foreach(&a : self.values)
+	{
+		*a = init_value;
+	}
 }
 
 
diff --git a/lib/std/collections/enumset.c3 b/lib/std/collections/enumset.c3
index 80beb06e1..4d37966cd 100644
--- a/lib/std/collections/enumset.c3
+++ b/lib/std/collections/enumset.c3
@@ -17,7 +17,7 @@ fn void EnumSet.add(&self, Enum v)
 	$if IS_CHAR_ARRAY:
 		(*self)[(usz)v / 8] |= (char)(1u << ((usz)v % 8));
 	$else
-        *self = (EnumSet)((EnumSetType)*self | 1u << (EnumSetType)v);
+		*self = (EnumSet)((EnumSetType)*self | 1u << (EnumSetType)v);
 	$endif
 }
 
@@ -26,7 +26,7 @@ fn void EnumSet.clear(&self)
 	$if IS_CHAR_ARRAY:
 		*self = {};
 	$else
-        *self = 0;
+		*self = 0;
 	$endif
 }
 
@@ -37,10 +37,10 @@ fn bool EnumSet.remove(&self, Enum v)
 		(*self)[(usz)v / 8] &= (char)~(1u << ((usz)v % 8));
 		return true;
 	$else
-        EnumSetType old = (EnumSetType)*self;
-        EnumSetType new = old & ~(1u << (EnumSetType)v);
-        *self = (EnumSet)new;
-        return old != new;
+		EnumSetType old = (EnumSetType)*self;
+		EnumSetType new = old & ~(1u << (EnumSetType)v);
+		*self = (EnumSet)new;
+		return old != new;
 	$endif
 }
 
@@ -49,7 +49,7 @@ fn bool EnumSet.has(&self, Enum v)
 	$if IS_CHAR_ARRAY:
 		return (bool)(((*self)[(usz)v / 8] << ((usz)v % 8)) & 0x01);
 	$else
-        return ((EnumSetType)*self & (1u << (EnumSetType)v)) != 0;
+		return ((EnumSetType)*self & (1u << (EnumSetType)v)) != 0;
 	$endif
 }
 
@@ -58,7 +58,7 @@ fn void EnumSet.add_all(&self, EnumSet s)
 	$if IS_CHAR_ARRAY:
 		foreach (i, c : s) (*self)[i] |= c;
 	$else
-        *self = (EnumSet)((EnumSetType)*self | (EnumSetType)s);
+		*self = (EnumSet)((EnumSetType)*self | (EnumSetType)s);
 	$endif
 }
 
@@ -67,7 +67,7 @@ fn void EnumSet.retain_all(&self, EnumSet s)
 	$if IS_CHAR_ARRAY:
 		foreach (i, c : s) (*self)[i] &= c;
 	$else
-        *self = (EnumSet)((EnumSetType)*self & (EnumSetType)s);
+		*self = (EnumSet)((EnumSetType)*self & (EnumSetType)s);
 	$endif
 }
 
@@ -76,7 +76,7 @@ fn void EnumSet.remove_all(&self, EnumSet s)
 	$if IS_CHAR_ARRAY:
 		foreach (i, c : s) (*self)[i] &= ~c;
 	$else
-        *self = (EnumSet)((EnumSetType)*self & ~(EnumSetType)s);
+		*self = (EnumSet)((EnumSetType)*self & ~(EnumSetType)s);
 	$endif
 }
 
@@ -87,7 +87,7 @@ fn EnumSet EnumSet.and_of(&self, EnumSet s)
 		copy.retain_all(s);
 		return copy;
 	$else
-        return (EnumSet)((EnumSetType)*self & (EnumSetType)s);
+		return (EnumSet)((EnumSetType)*self & (EnumSetType)s);
 	$endif
 }
 
@@ -98,7 +98,7 @@ fn EnumSet EnumSet.or_of(&self, EnumSet s)
 		copy.add_all(s);
 		return copy;
 	$else
-        return (EnumSet)((EnumSetType)*self | (EnumSetType)s);
+		return (EnumSet)((EnumSetType)*self | (EnumSetType)s);
 	$endif
 }
 
@@ -110,7 +110,7 @@ fn EnumSet EnumSet.diff_of(&self, EnumSet s)
 		copy.remove_all(s);
 		return copy;
 	$else
-        return (EnumSet)((EnumSetType)*self & ~(EnumSetType)s);
+		return (EnumSet)((EnumSetType)*self & ~(EnumSetType)s);
 	$endif
 }
 
@@ -121,7 +121,7 @@ fn EnumSet EnumSet.xor_of(&self, EnumSet s)
 		foreach (i, c : s) copy[i] ^= c;
 		return copy;
 	$else
-        return (EnumSet)((EnumSetType)*self ^ (EnumSetType)s);
+		return (EnumSet)((EnumSetType)*self ^ (EnumSetType)s);
 	$endif
 }
 
diff --git a/lib/std/collections/linkedlist.c3 b/lib/std/collections/linkedlist.c3
index 040ea4c00..dcbfc23a4 100644
--- a/lib/std/collections/linkedlist.c3
+++ b/lib/std/collections/linkedlist.c3
@@ -5,22 +5,22 @@ module std::collections::linkedlist(<Type>);
 
 struct Node @private
 {
-    Node *next;
-    Node *prev;
-    Type value;
+	Node *next;
+	Node *prev;
+	Type value;
 }
 
 struct LinkedList
 {
-    Allocator *allocator;
-    usz size;
-    Node *_first;
-    Node *_last;
+	Allocator *allocator;
+	usz size;
+	Node *_first;
+	Node *_last;
 }
 
 fn void LinkedList.push(&self, Type value)
 {
-    self.link_first(value);
+	self.link_first(value);
 }
 
 fn void LinkedList.push_last(&self, Type value)
@@ -50,36 +50,36 @@ macro Node* LinkedList.alloc_node(&self) @private
 
 fn void LinkedList.link_first(&self, Type value) @private
 {
-    Node *first = self._first;
-    Node *new_node = self.alloc_node();
-    *new_node = { .next = first, .value = value };
-    self._first = new_node;
-    if (!first)
-    {
-        self._last = new_node;
-    }
-    else
-    {
-        first.prev = new_node;
-    }
-    self.size++;
+	Node *first = self._first;
+	Node *new_node = self.alloc_node();
+	*new_node = { .next = first, .value = value };
+	self._first = new_node;
+	if (!first)
+	{
+		self._last = new_node;
+	}
+	else
+	{
+		first.prev = new_node;
+	}
+	self.size++;
 }
 
 fn void LinkedList.link_last(&self, Type value) @private
 {
-    Node *last = self._last;
-    Node *new_node = self.alloc_node();
-    *new_node = { .prev = last, .value = value };
-    self._last = new_node;
-    if (!last)
-    {
-        self._first = new_node;
-    }
-    else
-    {
-        last.next = new_node;
-    }
-    self.size++;
+	Node *last = self._last;
+	Node *new_node = self.alloc_node();
+	*new_node = { .prev = last, .value = value };
+	self._last = new_node;
+	if (!last)
+	{
+		self._first = new_node;
+	}
+	else
+	{
+		last.next = new_node;
+	}
+	self.size++;
 }
 
 fn Type! LinkedList.peek(&self) => self.first() @inline;
@@ -101,15 +101,15 @@ fn void LinkedList.free(&self) => self.clear() @inline;
 
 fn void LinkedList.clear(&self)
 {
-    for (Node* node = self._first; node != null;)
-    {
-        Node* next = node.next;
-        self.free_node(node);
-        node = next;
-    }
-    self._first = null;
-    self._last = null;
-    self.size = 0;
+	for (Node* node = self._first; node != null;)
+	{
+		Node* next = node.next;
+		self.free_node(node);
+		node = next;
+	}
+	self._first = null;
+	self._last = null;
+	self.size = 0;
 }
 
 fn usz LinkedList.len(&self) @inline => self.size;
@@ -121,14 +121,14 @@ macro Node* LinkedList.node_at_index(&self, usz index)
 {
 	if (index * 2 >= self.size)
 	{
-	    Node* node = self._last;
-	    index = self.size - index - 1;
-        while (index--) node = node.prev;
-        return node;
+		Node* node = self._last;
+		index = self.size - index - 1;
+		while (index--) node = node.prev;
+		return node;
 	}
-    Node* node = self._first;
-    while (index--) node = node.next;
-    return node;
+	Node* node = self._first;
+	while (index--) node = node.next;
+	return node;
 }
 /**
  * @require index < self.size
@@ -174,19 +174,19 @@ fn void LinkedList.insert(&self, usz index, Type element)
  **/
 fn void LinkedList.link_before(&self, Node *succ, Type value) @private
 {
-    Node* pred = succ.prev;
-    Node* new_node = malloc(Node);
-    *new_node = { .prev = pred, .next = succ, .value = value };
-    succ.prev = new_node;
-    if (!pred)
-    {
-        self._first = new_node;
-    }
-    else
-    {
-        pred.next = new_node;
-    }
-    self.size++;
+	Node* pred = succ.prev;
+	Node* new_node = malloc(Node);
+	*new_node = { .prev = pred, .next = succ, .value = value };
+	succ.prev = new_node;
+	if (!pred)
+	{
+		self._first = new_node;
+	}
+	else
+	{
+		pred.next = new_node;
+	}
+	self.size++;
 }
 
 /**
@@ -195,44 +195,44 @@ fn void LinkedList.link_before(&self, Node *succ, Type value) @private
 fn void LinkedList.unlink_first(&self) @private
 {
 	Node* f = self._first;
-    Node* next = f.next;
-    self.free_node(f);
-    self._first = next;
-    if (!next)
-    {
-        self._last = null;
-    }
-    else
-    {
-        next.prev = null;
-    }
-    self.size--;
+	Node* next = f.next;
+	self.free_node(f);
+	self._first = next;
+	if (!next)
+	{
+		self._last = null;
+	}
+	else
+	{
+		next.prev = null;
+	}
+	self.size--;
 }
 
 fn bool LinkedList.remove_value(&self, Type t)
 {
-    for (Node* node = self._first; node != null; node = node.next)
-    {
-        if (node.value == t)
-        {
-            self.unlink(node);
-            return true;
-        }
-    }
-    return false;
+	for (Node* node = self._first; node != null; node = node.next)
+	{
+		if (node.value == t)
+		{
+			self.unlink(node);
+			return true;
+		}
+	}
+	return false;
 }
 
 fn bool LinkedList.remove_last_value(&self, Type t)
 {
-    for (Node* node = self._last; node != null; node = node.prev)
-    {
-        if (node.value == t)
-        {
-            self.unlink(node);
-            return true;
-        }
-    }
-    return false;
+	for (Node* node = self._last; node != null; node = node.prev)
+	{
+		if (node.value == t)
+		{
+			self.unlink(node);
+			return true;
+		}
+	}
+	return false;
 }
 
 fn Type! LinkedList.pop(&self)
@@ -260,18 +260,18 @@ fn void! LinkedList.remove_first(&self)
 fn void LinkedList.unlink_last(&self) @inline @private
 {
 	Node* l = self._last;
-    Node* prev = l.prev;
-    self._last = prev;
-    self.free_node(l);
-    if (!prev)
-    {
-        self._first = null;
-    }
-    else
-    {
-        prev.next = null;
-    }
-    self.size--;
+	Node* prev = l.prev;
+	self._last = prev;
+	self.free_node(l);
+	if (!prev)
+	{
+		self._first = null;
+	}
+	else
+	{
+		prev.next = null;
+	}
+	self.size--;
 }
 
 /**
@@ -279,24 +279,24 @@ fn void LinkedList.unlink_last(&self) @inline @private
  **/
 fn void LinkedList.unlink(&self, Node* x) @private
 {
-    Node* next = x.next;
-    Node* prev = x.prev;
-    if (!prev)
-    {
-        self._first = next;
-    }
-    else
-    {
-        prev.next = next;
-    }
-    if (!next)
-    {
-        self._last = prev;
-    }
-    else
-    {
-        next.prev = prev;
-    }
-    self.free_node(x);
-    self.size--;
+	Node* next = x.next;
+	Node* prev = x.prev;
+	if (!prev)
+	{
+		self._first = next;
+	}
+	else
+	{
+		prev.next = next;
+	}
+	if (!next)
+	{
+		self._last = prev;
+	}
+	else
+	{
+		next.prev = prev;
+	}
+	self.free_node(x);
+	self.size--;
 }
diff --git a/lib/std/collections/list.c3 b/lib/std/collections/list.c3
index 4e69e0903..5c498a254 100644
--- a/lib/std/collections/list.c3
+++ b/lib/std/collections/list.c3
@@ -10,10 +10,10 @@ const ELEMENT_IS_POINTER = Type.kindof == POINTER;
 
 struct List
 {
-    usz size;
-    usz capacity;
-    Allocator *allocator;
-    Type *entries;
+	usz size;
+	usz capacity;
+	Allocator *allocator;
+	Type *entries;
 }
 
 /**
@@ -66,13 +66,13 @@ fn String List.to_string(&self, Allocator* using = mem::heap()) @dynamic
 
 fn void List.push(&self, Type element) @inline
 {
-    self.append(element);
+	self.append(element);
 }
 
 fn void List.append(&self, Type element)
 {
-    self.ensure_capacity();
-    self.entries[self.size++] = element;
+	self.ensure_capacity();
+	self.entries[self.size++] = element;
 }
 
 /**
@@ -80,12 +80,12 @@ fn void List.append(&self, Type element)
  */
 fn Type List.pop(&self)
 {
-    return self.entries[--self.size];
+	return self.entries[--self.size];
 }
 
 fn void List.clear(&self)
 {
-    self.size = 0;
+	self.size = 0;
 }
 
 /**
@@ -93,18 +93,18 @@ fn void List.clear(&self)
  */
 fn Type List.pop_first(&self)
 {
-    Type value = self.entries[0];
-    self.remove_at(0);
-    return value;
+	Type value = self.entries[0];
+	self.remove_at(0);
+	return value;
 }
 
 fn void List.remove_at(&self, usz index)
 {
-    for (usz i = index + 1; i < self.size; i++)
-    {
-        self.entries[i - 1] = self.entries[i];
-    }
-    self.size--;
+	for (usz i = index + 1; i < self.size; i++)
+	{
+		self.entries[i - 1] = self.entries[i];
+	}
+	self.size--;
 }
 
 fn void List.add_all(&self, List* other_list)
@@ -113,7 +113,7 @@ fn void List.add_all(&self, List* other_list)
 	self.reserve(other_list.size);
 	foreach (&value : other_list)
 	{
-	    self.entries[self.size++] = *value;
+		self.entries[self.size++] = *value;
 	}
 }
 
@@ -151,24 +151,24 @@ fn void List.add_array(&self, Type[] array)
 	self.reserve(array.len);
 	foreach (&value : array)
 	{
-	    self.entries[self.size++] = *value;
+		self.entries[self.size++] = *value;
 	}
 }
 
 fn void List.push_front(&self, Type type) @inline
 {
-    self.insert_at(0, type);
+	self.insert_at(0, type);
 }
 
 fn void List.insert_at(&self, usz index, Type type)
 {
-    self.ensure_capacity();
-    for (usz i = self.size; i > index; i--)
-    {
-        self.entries[i] = self.entries[i - 1];
-    }
-    self.size++;
-    self.entries[index] = type;
+	self.ensure_capacity();
+	for (usz i = self.size; i > index; i--)
+	{
+		self.entries[i] = self.entries[i - 1];
+	}
+	self.size++;
+	self.entries[index] = type;
 }
 
 /**
@@ -176,51 +176,51 @@ fn void List.insert_at(&self, usz index, Type type)
  **/
 fn void List.set_at(&self, usz index, Type type)
 {
-    self.entries[index] = type;
+	self.entries[index] = type;
 }
 
 fn void List.remove_last(&self)
 {
-    self.size--;
+	self.size--;
 }
 
 fn void List.remove_first(&self)
 {
-    self.remove_at(0);
+	self.remove_at(0);
 }
 
 fn Type* List.first(&self)
 {
-    return self.size ? &self.entries[0] : null;
+	return self.size ? &self.entries[0] : null;
 }
 
 fn Type* List.last(&self)
 {
-    return self.size ? &self.entries[self.size - 1] : null;
+	return self.size ? &self.entries[self.size - 1] : null;
 }
 
 fn bool List.is_empty(&self) @inline
 {
-    return !self.size;
+	return !self.size;
 }
 
 fn usz List.len(&self) @operator(len) @inline
 {
-    return self.size;
+	return self.size;
 }
 
 fn Type List.get(&self, usz index) @inline
 {
-    return self.entries[index];
+	return self.entries[index];
 }
 
 fn void List.free(&self)
 {
 	if (!self.allocator) return;
-    free_aligned(self.entries, .using = self.allocator);
-    self.capacity = 0;
-    self.size = 0;
-    self.entries = null;
+	free_aligned(self.entries, .using = self.allocator);
+	self.capacity = 0;
+	self.size = 0;
+	self.entries = null;
 }
 
 fn void List.swap(&self, usz i, usz j)
@@ -276,29 +276,29 @@ fn void List.reserve(&self, usz min_capacity)
 	if (self.capacity >= min_capacity) return;
 	if (!self.allocator) self.allocator = mem::heap();
 	min_capacity = math::next_power_of_2(min_capacity);
-    self.entries = realloc_aligned(self.entries, Type.sizeof * min_capacity, .alignment = Type[1].alignof, .using = self.allocator) ?? null;
+	self.entries = realloc_aligned(self.entries, Type.sizeof * min_capacity, .alignment = Type[1].alignof, .using = self.allocator) ?? null;
 	self.capacity = min_capacity;
 }
 
 macro Type List.@item_at(&self, usz index) @operator([])
 {
-    return self.entries[index];
+	return self.entries[index];
 }
 
 fn Type* List.get_ref(&self, usz index) @operator(&[]) @inline
 {
-    return &self.entries[index];
+	return &self.entries[index];
 }
 
 fn void List.set(&self, usz index, Type value) @operator([]=)
 {
-    self.entries[index] = value;
+	self.entries[index] = value;
 }
 
 fn void List.ensure_capacity(&self, usz added = 1) @inline @private
 {
 	usz new_size = self.size + added;
-    if (self.capacity > new_size) return;
+	if (self.capacity > new_size) return;
 
 	assert(new_size < usz.max / 2U);
 	usz new_capacity = self.capacity ? 2U * self.capacity : 16U;
diff --git a/lib/std/collections/map.c3 b/lib/std/collections/map.c3
index f925b506e..f05399855 100644
--- a/lib/std/collections/map.c3
+++ b/lib/std/collections/map.c3
@@ -74,7 +74,7 @@ fn bool HashMap.is_empty(&map) @inline
 
 fn usz HashMap.len(&map) @inline
 {
-    return map.count;
+	return map.count;
 }
 
 fn Value*! HashMap.get_ref(&map, Key key)
@@ -204,14 +204,14 @@ macro HashMap.@each(map; @body(key, value))
 {
 	if (map.count)
 	{
-        foreach (Entry* entry : map.table)
-        {
-            while (entry)
-            {
-                @body(entry.key, entry.value);
-                entry = entry.next;
-            }
-        }
+		foreach (Entry* entry : map.table)
+		{
+			while (entry)
+			{
+				@body(entry.key, entry.value);
+				entry = entry.next;
+			}
+		}
 	}
 }
 
@@ -260,7 +260,7 @@ fn void HashMap.add_entry(&map, uint hash, Key key, Value value, uint bucket_ind
 	if (map.count++ >= map.threshold)
 	{
 		map.resize(map.table.len * 2);
-    }
+	}
 }
 
 fn void HashMap.resize(&map, uint new_capacity) @private
@@ -281,8 +281,8 @@ fn void HashMap.resize(&map, uint new_capacity) @private
 
 fn uint rehash(uint hash) @inline @private
 {
-    hash ^= (hash >> 20) ^ (hash >> 12);
-    return hash ^ ((hash >> 7) ^ (hash >> 4));
+	hash ^= (hash >> 20) ^ (hash >> 12);
+	return hash ^ ((hash >> 7) ^ (hash >> 4));
 }
 
 macro uint index_for(uint hash, uint capacity) @private
@@ -293,36 +293,36 @@ macro uint index_for(uint hash, uint capacity) @private
 fn void HashMap.transfer(&map, Entry*[] new_table) @private
 {
 	Entry*[] src = map.table;
-    uint new_capacity = new_table.len;
-    foreach (uint j, Entry *e : src)
-    {
-        if (!e) continue;
-        do
-        {
-            Entry* next = e.next;
-            uint i = index_for(e.hash, new_capacity);
-            e.next = new_table[i];
-            new_table[i] = e;
-            e = next;
-        }
-        while (e);
-    }
+	uint new_capacity = new_table.len;
+	foreach (uint j, Entry *e : src)
+	{
+		if (!e) continue;
+		do
+		{
+			Entry* next = e.next;
+			uint i = index_for(e.hash, new_capacity);
+			e.next = new_table[i];
+			new_table[i] = e;
+			e = next;
+		}
+		while (e);
+	}
 }
 
 fn void HashMap.put_all_for_create(&map, HashMap* other_map) @private
 {
 	if (!other_map.count) return;
-    foreach (Entry *e : other_map.table)
-    {
-        if (!e) continue;
-        map.put_for_create(e.key, e.value);
-    }
+	foreach (Entry *e : other_map.table)
+	{
+		if (!e) continue;
+		map.put_for_create(e.key, e.value);
+	}
 }
 
 fn void HashMap.put_for_create(&map, Key key, Value value) @private
 {
-    uint hash = rehash(key.hash());
-    uint i = index_for(hash, map.table.len);
+	uint hash = rehash(key.hash());
+	uint i = index_for(hash, map.table.len);
 	for (Entry *e = map.table[i]; e != null; e = e.next)
 	{
 		if (e.hash == hash && equals(key, e.key))
diff --git a/lib/std/collections/priorityqueue.c3 b/lib/std/collections/priorityqueue.c3
index 825d3fec6..cc42c7d8e 100644
--- a/lib/std/collections/priorityqueue.c3
+++ b/lib/std/collections/priorityqueue.c3
@@ -38,12 +38,12 @@ struct PrivatePriorityQueue
 
 fn void PrivatePriorityQueue.init(&self, usz initial_capacity = 16, Allocator* using = mem::heap()) @inline
 {
-    self.heap.init(initial_capacity, using);
+	self.heap.init(initial_capacity, using);
 }
 
 fn void PrivatePriorityQueue.tinit(&self, usz initial_capacity = 16) @inline
 {
-    self.init(initial_capacity, mem::temp());
+	self.init(initial_capacity, mem::temp());
 }
 
 fn void PrivatePriorityQueue.push(&self, Type element)
@@ -56,13 +56,13 @@ fn void PrivatePriorityQueue.push(&self, Type element)
 		Type item = self.heap[i];
 		Type parent_item = self.heap[parent];
 		$if MAX:
-		    bool ok = greater(item, parent_item);
+			bool ok = greater(item, parent_item);
 		$else
-		    bool ok = less(item, parent_item);
+			bool ok = less(item, parent_item);
 		$endif
 		if (!ok) break;
-        self.heap.swap(i, parent);
-        i = parent;
+		self.heap.swap(i, parent);
+		i = parent;
 	}
 }
 
@@ -79,26 +79,26 @@ fn Type! PrivatePriorityQueue.pop(&self)
 	while ((2 * i + 1) < newCount)
 	{
 		usz j = 2 * i + 1;
-        Type itemj = self.heap[j];
+		Type itemj = self.heap[j];
 		if ((j + 1) < newCount)
 		{
-		    Type nextj = self.heap[j + 1];
-		    $if MAX:
-                bool ok = greater(nextj, itemj);
-            $else
-                bool ok = less(nextj, itemj);
-            $endif
-            if (ok) j++;
+			Type nextj = self.heap[j + 1];
+			$if MAX:
+				bool ok = greater(nextj, itemj);
+			$else
+				bool ok = less(nextj, itemj);
+			$endif
+			if (ok) j++;
 		}
 		Type item = self.heap[i];
-        $if MAX:
-            bool ok = less(item, itemj);
-        $else
-            bool ok = greater(item, itemj);
-        $endif
-        if (!ok) break;
-        self.heap.swap(i, j);
-        i = j;
+		$if MAX:
+			bool ok = less(item, itemj);
+		$else
+			bool ok = greater(item, itemj);
+		$endif
+		if (!ok) break;
+		self.heap.swap(i, j);
+		i = j;
 	}
 
 	return self.heap.pop();
diff --git a/lib/std/collections/range.c3 b/lib/std/collections/range.c3
index 1169043df..694e4fc61 100644
--- a/lib/std/collections/range.c3
+++ b/lib/std/collections/range.c3
@@ -26,7 +26,7 @@ fn bool Range.contains(&self, Type value) @inline
  **/
 fn Type Range.get(&self, usz index) @operator([])
 {
-    return self.start + (Type)index;
+	return self.start + (Type)index;
 }
 
 fn String Range.to_string(&self, Allocator* using = mem::heap()) @dynamic
@@ -71,5 +71,5 @@ fn String ExclusiveRange.to_string(&self, Allocator* using = mem::heap()) @dynam
  **/
 fn Type ExclusiveRange.get(&self, usz index) @operator([])
 {
-    return self.start + (Type)index;
+	return self.start + (Type)index;
 }
diff --git a/lib/std/core/allocators/arena_allocator.c3 b/lib/std/core/allocators/arena_allocator.c3
index 5813c44ae..a16af1a75 100644
--- a/lib/std/core/allocators/arena_allocator.c3
+++ b/lib/std/core/allocators/arena_allocator.c3
@@ -55,7 +55,7 @@ fn void*! arena_allocator_function(Allocator* data, usz size, usz alignment, usz
 			alignment = alignment_for_allocation(alignment);
 			void* mem = arena._alloc(size, alignment, offset)!;
 			if (clear) mem::clear(mem, size, mem::DEFAULT_MEM_ALIGNMENT);
-        	return mem;
+			return mem;
 		case ALIGNED_REALLOC:
 		case REALLOC:
 			if (!size) nextcase FREE;
@@ -69,12 +69,12 @@ fn void*! arena_allocator_function(Allocator* data, usz size, usz alignment, usz
 			ArenaAllocatorHeader* header = old_pointer - ArenaAllocatorHeader.sizeof;
 			// Reclaim memory if it's the last element.
 			if (old_pointer + header.size == &arena.data[arena.used])
-        	{
-        		arena.used -= header.size + ArenaAllocatorHeader.sizeof;
-        	}
-        	return null;
-        case MARK:
-            return (void*)(uptr)arena.used;
+			{
+				arena.used -= header.size + ArenaAllocatorHeader.sizeof;
+			}
+			return null;
+		case MARK:
+			return (void*)(uptr)arena.used;
 		case RESET:
 			arena.used = size;
 			return null;
@@ -94,7 +94,7 @@ fn void*! ArenaAllocator._alloc(&self, usz size, usz alignment, usz offset)
 {
 	usz total_len = self.data.len;
 	if (size > total_len) return AllocationFailure.CHUNK_TOO_LARGE?;
-    void* start_mem = self.data.ptr;
+	void* start_mem = self.data.ptr;
 	void* unaligned_pointer_to_offset = start_mem + self.used + ArenaAllocatorHeader.sizeof + offset;
 	void* aligned_pointer_to_offset = mem::aligned_pointer(unaligned_pointer_to_offset, alignment);
 	usz end = (usz)(aligned_pointer_to_offset - self.data.ptr) + size - offset;
@@ -126,17 +126,17 @@ fn void*! ArenaAllocator._realloc(&self, void *old_pointer, usz size, usz alignm
 	if (&self.data[self.used] == old_pointer + old_size && mem::ptr_is_aligned(old_pointer + offset, alignment))
 	{
 		if (old_size >= size)
-        {
-        	self.used -= old_size - size;
-        }
-        else
-        {
-	        usz new_used = self.used + size - old_size;
-            if (new_used > total_len) return AllocationFailure.OUT_OF_MEMORY?;
-            self.used = new_used;
-        }
-        header.size = size;
-        return old_pointer;
+		{
+			self.used -= old_size - size;
+		}
+		else
+		{
+			usz new_used = self.used + size - old_size;
+			if (new_used > total_len) return AllocationFailure.OUT_OF_MEMORY?;
+			self.used = new_used;
+		}
+		header.size = size;
+		return old_pointer;
 	}
 	// Otherwise just allocate new memory.
 	void* mem = self._alloc(size, alignment, offset)!;
diff --git a/lib/std/core/allocators/dynamic_arena.c3 b/lib/std/core/allocators/dynamic_arena.c3
index cf8ede153..fef911e2d 100644
--- a/lib/std/core/allocators/dynamic_arena.c3
+++ b/lib/std/core/allocators/dynamic_arena.c3
@@ -110,16 +110,16 @@ fn void DynamicArenaAllocator.reset(&self) @private
 {
 	DynamicArenaPage* page = self.page;
 	DynamicArenaPage** unused_page_ptr = &self.unused_page;
-    while (page)
-    {
-        DynamicArenaPage* next_page = page.prev_arena;
-        page.used = 0;
-        DynamicArenaPage* prev_unused = *unused_page_ptr;
-        *unused_page_ptr = page;
-        page.prev_arena = prev_unused;
-        page = next_page;
-    }
-    self.page = page;
+	while (page)
+	{
+		DynamicArenaPage* next_page = page.prev_arena;
+		page.used = 0;
+		DynamicArenaPage* prev_unused = *unused_page_ptr;
+		*unused_page_ptr = page;
+		page.prev_arena = prev_unused;
+		page = next_page;
+	}
+	self.page = page;
 }
 
 /**
@@ -139,11 +139,11 @@ fn void*! DynamicArenaAllocator._alloc_new(&self, usz size, usz alignment, usz o
 		free(mem, .using = self.backing_allocator);
 		return err?;
 	}
-    page.memory = mem;
-    void* mem_start = mem::aligned_pointer(mem + offset + DynamicArenaChunk.sizeof, alignment) - offset;
-    assert(mem_start + size < mem + page_size);
-    DynamicArenaChunk* chunk = (DynamicArenaChunk*)mem_start - 1;
-    chunk.size = size;
+	page.memory = mem;
+	void* mem_start = mem::aligned_pointer(mem + offset + DynamicArenaChunk.sizeof, alignment) - offset;
+	assert(mem_start + size < mem + page_size);
+	DynamicArenaChunk* chunk = (DynamicArenaChunk*)mem_start - 1;
+	chunk.size = size;
 	page.prev_arena = self.page;
 	page.total = page_size;
 	page.used = mem_start + size - page.memory;
@@ -166,32 +166,32 @@ fn void*! DynamicArenaAllocator._alloc(&self, usz size, usz alignment, usz offse
 		self.unused_page = page.prev_arena;
 		page.prev_arena = null;
 	}
-    if (!page) return self._alloc_new(size, alignment, offset);
-    void* start = mem::aligned_pointer(page.memory + page.used + DynamicArenaChunk.sizeof + offset, alignment) - offset;
-    usz new_used = start - page.memory + size;
-    if ALLOCATE_NEW: (new_used > page.total)
-    {
-        if ((page = self.unused_page))
-        {
-            start = mem::aligned_pointer(page.memory + page.used + DynamicArenaChunk.sizeof + offset, alignment) - offset;
-            new_used = start + size - page.memory;
-            if (page.total >= new_used)
-            {
-	    		self.unused_page = page.prev_arena;
-    	    	page.prev_arena = self.page;
-    		    self.page = page;
-    		    break ALLOCATE_NEW;
-            }
-        }
- 	    return self._alloc_new(size, alignment, offset);
-    }
+	if (!page) return self._alloc_new(size, alignment, offset);
+	void* start = mem::aligned_pointer(page.memory + page.used + DynamicArenaChunk.sizeof + offset, alignment) - offset;
+	usz new_used = start - page.memory + size;
+	if ALLOCATE_NEW: (new_used > page.total)
+	{
+		if ((page = self.unused_page))
+		{
+			start = mem::aligned_pointer(page.memory + page.used + DynamicArenaChunk.sizeof + offset, alignment) - offset;
+			new_used = start + size - page.memory;
+			if (page.total >= new_used)
+			{
+				self.unused_page = page.prev_arena;
+				page.prev_arena = self.page;
+				self.page = page;
+				break ALLOCATE_NEW;
+			}
+		}
+		return self._alloc_new(size, alignment, offset);
+	}
 
-    page.used = new_used;
+	page.used = new_used;
 	assert(start + size == page.memory + page.used);
-    void* mem = start;
-    DynamicArenaChunk* chunk = (DynamicArenaChunk*)mem - 1;
-    chunk.size = size;
-    return mem;
+	void* mem = start;
+	DynamicArenaChunk* chunk = (DynamicArenaChunk*)mem - 1;
+	chunk.size = size;
+	return mem;
 }
 
 /**
diff --git a/lib/std/core/allocators/heap_allocator.c3 b/lib/std/core/allocators/heap_allocator.c3
index 86f3e2b48..258077e56 100644
--- a/lib/std/core/allocators/heap_allocator.c3
+++ b/lib/std/core/allocators/heap_allocator.c3
@@ -33,33 +33,33 @@ fn void*! simple_heap_allocator_function(Allocator* this, usz size, usz alignmen
 {
 	SimpleHeapAllocator* heap = (SimpleHeapAllocator*)this;
 	switch (kind)
-    {
-        case ALIGNED_ALLOC:
-            return @aligned_alloc(heap._alloc, size, alignment, offset);
+	{
+		case ALIGNED_ALLOC:
+			return @aligned_alloc(heap._alloc, size, alignment, offset);
 		case ALLOC:
-            return heap._alloc(size);
-        case ALIGNED_CALLOC:
-            return @aligned_calloc(heap._calloc, size, alignment, offset);
-    	case CALLOC:
-            return heap._calloc(size);
-        case ALIGNED_REALLOC:
-            if (!size) nextcase ALIGNED_FREE;
-            if (!old_pointer) nextcase ALIGNED_CALLOC;
-            return @aligned_realloc(heap._calloc, heap._free, old_pointer, size, alignment, offset);
-        case REALLOC:
-            if (!size) nextcase FREE;
-            if (!old_pointer) nextcase CALLOC;
-            return heap._realloc(old_pointer, size);
-        case RESET:
-            unreachable("Reset unsupported");
-        case ALIGNED_FREE:
-            @aligned_free(heap._free, old_pointer)!;
-            return null;
-        case FREE:
-            heap._free(old_pointer);
-            return null;
-        default:
-            unreachable();
+			return heap._alloc(size);
+		case ALIGNED_CALLOC:
+			return @aligned_calloc(heap._calloc, size, alignment, offset);
+		case CALLOC:
+			return heap._calloc(size);
+		case ALIGNED_REALLOC:
+			if (!size) nextcase ALIGNED_FREE;
+			if (!old_pointer) nextcase ALIGNED_CALLOC;
+			return @aligned_realloc(heap._calloc, heap._free, old_pointer, size, alignment, offset);
+		case REALLOC:
+			if (!size) nextcase FREE;
+			if (!old_pointer) nextcase CALLOC;
+			return heap._realloc(old_pointer, size);
+		case RESET:
+			unreachable("Reset unsupported");
+		case ALIGNED_FREE:
+			@aligned_free(heap._free, old_pointer)!;
+			return null;
+		case FREE:
+			heap._free(old_pointer);
+			return null;
+		default:
+			unreachable();
 	}
 }
 
@@ -88,10 +88,10 @@ fn void*! SimpleHeapAllocator._calloc(&self, usz bytes) @local
 fn void*! SimpleHeapAllocator._alloc(&self, usz bytes) @local
 {
 	usz aligned_bytes = mem::aligned_offset(bytes, mem::DEFAULT_MEM_ALIGNMENT);
-    if (!self.free_list)
-    {
+	if (!self.free_list)
+	{
 		self.add_block(aligned_bytes)!;
-    }
+	}
 
 	Header* current = self.free_list;
 	Header* previous = current;
@@ -107,10 +107,10 @@ fn void*! SimpleHeapAllocator._alloc(&self, usz bytes) @local
 				else
 				{
 					previous.next = current.next;
-                }
-                current.next = null;
-                return current + 1;
-            case current.size > aligned_bytes:
+				}
+				current.next = null;
+				return current + 1;
+			case current.size > aligned_bytes:
 				Header* unallocated = (Header*)((char*)current + aligned_bytes + Header.sizeof);
 				unallocated.size = current.size - aligned_bytes;
 				unallocated.next = current.next;
@@ -178,18 +178,18 @@ fn void SimpleHeapAllocator._free(&self, void* ptr) @local
 	if (current)
 	{
 		// Insert after the current block.
-        // Are the blocks adjacent?
-        if (current == (Header*)((char*)(block + 1) + block.size))
-        {
-            // Merge
-    		block.size += current.size + Header.sizeof;
-            block.next = current.next;
-        }
-        else
-        {
-            // Chain to current
-            block.next = current;
-        }
+		// Are the blocks adjacent?
+		if (current == (Header*)((char*)(block + 1) + block.size))
+		{
+			// Merge
+			block.size += current.size + Header.sizeof;
+			block.next = current.next;
+		}
+		else
+		{
+			// Chain to current
+			block.next = current;
+		}
 	}
 	if (prev == current)
 	{
@@ -201,13 +201,13 @@ fn void SimpleHeapAllocator._free(&self, void* ptr) @local
 		// Prev adjacent?
 		if (block == (Header*)((char*)(prev + 1) + prev.size))
 		{
-    		prev.size += block.size + Header.sizeof;
+			prev.size += block.size + Header.sizeof;
 			prev.next = block.next;
 		}
 		else
 		{
-	        // Link prev to block
-	        prev.next = block;
+			// Link prev to block
+			prev.next = block;
 		}
 	}
 }
@@ -217,7 +217,7 @@ union Header @local
 	struct
 	{
 		Header* next;
-  	    usz size;
-    }
-    usz align;
+		usz size;
+	}
+	usz align;
 }
diff --git a/lib/std/core/allocators/mem_allocator_fn.c3 b/lib/std/core/allocators/mem_allocator_fn.c3
index f41014f1d..1b3546816 100644
--- a/lib/std/core/allocators/mem_allocator_fn.c3
+++ b/lib/std/core/allocators/mem_allocator_fn.c3
@@ -13,11 +13,11 @@ fn void*! null_allocator_fn(Allocator* this, usz bytes, usz alignment, usz offse
 	switch (kind)
 	{
 		case ALLOC:
-        case CALLOC:
-        case REALLOC:
-        case ALIGNED_ALLOC:
-        case ALIGNED_REALLOC:
-        case ALIGNED_CALLOC:
+		case CALLOC:
+		case REALLOC:
+		case ALIGNED_ALLOC:
+		case ALIGNED_REALLOC:
+		case ALIGNED_CALLOC:
 			return AllocationFailure.OUT_OF_MEMORY?;
 		default:
 			return null;
@@ -42,7 +42,7 @@ macro void*! @aligned_alloc(#alloc_fn, usz bytes, usz alignment, usz offset)
 	$else
 		void* data = #alloc_fn(header + bytes);
 	$endif
-    void* mem = mem::aligned_pointer(data + header + offset, alignment) - offset;
+	void* mem = mem::aligned_pointer(data + header + offset, alignment) - offset;
 	assert(mem > data);
 	AlignedBlock* desc = (AlignedBlock*)mem - 1;
 	*desc = { bytes, data };
@@ -76,7 +76,7 @@ macro void*! @aligned_realloc(#calloc_fn, #free_fn, void* old_pointer, usz bytes
 {
 	AlignedBlock* desc = (AlignedBlock*)old_pointer - 1;
 	void* data_start = desc.start;
-    void* new_data = @aligned_calloc(#calloc_fn, bytes, alignment, offset)!;
+	void* new_data = @aligned_calloc(#calloc_fn, bytes, alignment, offset)!;
 	mem::copy(new_data, old_pointer, desc.len > bytes ? desc.len : bytes, mem::DEFAULT_MEM_ALIGNMENT, mem::DEFAULT_MEM_ALIGNMENT);
 	$if $checks(#free_fn(data_start)!):
 	#free_fn(data_start)!;
@@ -101,36 +101,36 @@ fn void*! libc_allocator_fn(Allocator* unused, usz bytes, usz alignment, usz off
 	if (!alignment) alignment = mem::DEFAULT_MEM_ALIGNMENT;
 	assert(math::is_power_of_2(alignment), "Alignment was not a power of 2");
 
-    void* data;
-    switch (kind)
-    {
-        case ALIGNED_ALLOC:
-            data = @aligned_alloc(libc::malloc, bytes, alignment, offset)!!;
-        case ALLOC:
-            data = libc::malloc(bytes);
-        case ALIGNED_CALLOC:
-            data = @aligned_calloc(fn void*(usz bytes) => libc::calloc(bytes, 1), bytes, alignment, offset)!!;
+	void* data;
+	switch (kind)
+	{
+		case ALIGNED_ALLOC:
+			data = @aligned_alloc(libc::malloc, bytes, alignment, offset)!!;
+		case ALLOC:
+			data = libc::malloc(bytes);
+		case ALIGNED_CALLOC:
+			data = @aligned_calloc(fn void*(usz bytes) => libc::calloc(bytes, 1), bytes, alignment, offset)!!;
 		case CALLOC:
-            data = libc::calloc(bytes, 1);
-        case ALIGNED_REALLOC:
-            if (!bytes) nextcase ALIGNED_FREE;
-            if (!old_pointer) nextcase ALIGNED_CALLOC;
-            data = @aligned_realloc(fn void*(usz bytes) => libc::calloc(bytes, 1), libc::free, old_pointer, bytes, alignment, offset)!!;
-        case REALLOC:
-            if (!bytes) nextcase FREE;
-            if (!old_pointer) nextcase CALLOC;
-            data = libc::realloc(old_pointer, bytes);
-        case RESET:
+			data = libc::calloc(bytes, 1);
+		case ALIGNED_REALLOC:
+			if (!bytes) nextcase ALIGNED_FREE;
+			if (!old_pointer) nextcase ALIGNED_CALLOC;
+			data = @aligned_realloc(fn void*(usz bytes) => libc::calloc(bytes, 1), libc::free, old_pointer, bytes, alignment, offset)!!;
+		case REALLOC:
+			if (!bytes) nextcase FREE;
+			if (!old_pointer) nextcase CALLOC;
+			data = libc::realloc(old_pointer, bytes);
+		case RESET:
 			unreachable("Reset unsupported");
-        case ALIGNED_FREE:
-            @aligned_free(libc::free, old_pointer)!!;
-            return null;
-        case FREE:
-            libc::free(old_pointer);
-            return null;
-        default:
-            unreachable();
-    }
-    if (!data) return AllocationFailure.OUT_OF_MEMORY?;
-    return data;
+		case ALIGNED_FREE:
+			@aligned_free(libc::free, old_pointer)!!;
+			return null;
+		case FREE:
+			libc::free(old_pointer);
+			return null;
+		default:
+			unreachable();
+	}
+	if (!data) return AllocationFailure.OUT_OF_MEMORY?;
+	return data;
 }
diff --git a/lib/std/core/allocators/on_stack_allocator.c3 b/lib/std/core/allocators/on_stack_allocator.c3
index 985849e70..1dbb5871e 100644
--- a/lib/std/core/allocators/on_stack_allocator.c3
+++ b/lib/std/core/allocators/on_stack_allocator.c3
@@ -92,8 +92,8 @@ fn void*! on_stack_allocator_function(Allocator* data, usz size, usz alignment,
 			{
 				allocator.backing_allocator.free(old_pointer)!;
 			}
-        	return null;
-        case MARK:
+			return null;
+		case MARK:
 		case RESET:
 			unreachable("Reset unsupported");
 	}
@@ -174,7 +174,7 @@ fn void*! on_stack_allocator_alloc(OnStackAllocator* a, usz size, usz alignment,
 {
 	alignment = alignment_for_allocation(alignment);
 	usz total_len = a.data.len;
-    void* start_mem = a.data.ptr;
+	void* start_mem = a.data.ptr;
 	void* unaligned_pointer_to_offset = start_mem + a.used + OnStackAllocatorHeader.sizeof + offset;
 	void* aligned_pointer_to_offset = mem::aligned_pointer(unaligned_pointer_to_offset, alignment);
 	usz end = (usz)(aligned_pointer_to_offset - a.data.ptr) + size - offset;
diff --git a/lib/std/core/allocators/temp_allocator.c3 b/lib/std/core/allocators/temp_allocator.c3
index e92ad6a21..0b771841b 100644
--- a/lib/std/core/allocators/temp_allocator.c3
+++ b/lib/std/core/allocators/temp_allocator.c3
@@ -76,9 +76,9 @@ fn void*! temp_allocator_function(Allocator* data, usz size, usz alignment, usz
 		case ALIGNED_FREE:
 			if (!old_pointer) return null;
 			arena._free(old_pointer)!;
-        	return null;
-        case MARK:
-            return (void*)(uptr)arena.used;
+			return null;
+		case MARK:
+			return (void*)(uptr)arena.used;
 		case RESET:
 			arena._reset(size)!;
 			return null;
@@ -89,9 +89,9 @@ fn void! TempAllocator._free(&self, void* old_pointer) @local
 {
 	usz old_size = *(usz*)(old_pointer - DEFAULT_SIZE_PREFIX);
 	if (old_pointer + old_size == &self.data[self.used])
-    {
-        self.used -= old_size;
-    }
+	{
+		self.used -= old_size;
+	}
 }
 fn void! TempAllocator._reset(&self, usz mark) @local
 {
@@ -180,10 +180,10 @@ fn void*! TempAllocator._alloc(&self, usz size, usz alignment, usz offset, bool
 	if (new_usage <= self.capacity)
 	{
 		TempAllocatorChunk* chunk_start = mem - TempAllocatorChunk.sizeof;
-    	chunk_start.size = size;
-    	self.used = new_usage;
-    	if (clear) mem::clear(mem, size, mem::DEFAULT_MEM_ALIGNMENT);
-    	return mem;
+		chunk_start.size = size;
+		self.used = new_usage;
+		if (clear) mem::clear(mem, size, mem::DEFAULT_MEM_ALIGNMENT);
+		return mem;
 	}
 
 	// Fallback to backing allocator
@@ -194,7 +194,7 @@ fn void*! TempAllocator._alloc(&self, usz size, usz alignment, usz offset, bool
 	{
 		// This is actually simpler, since it will create the offset for us.
 		usz total_alloc_size = TempAllocatorPage.sizeof + size;
-    	if (clear)
+		if (clear)
 		{
 			page = self.backing_allocator.calloc_aligned(total_alloc_size, alignment, TempAllocatorPage.sizeof + offset)!;
 		}
diff --git a/lib/std/core/bitorder.c3 b/lib/std/core/bitorder.c3
index 4fdec515e..9239ee595 100644
--- a/lib/std/core/bitorder.c3
+++ b/lib/std/core/bitorder.c3
@@ -93,14 +93,14 @@ bitstruct UInt128LE : uint128 @littleendian
  **/
 macro read(bytes, $Type)
 {
-    char[] s;
-    $switch ($typeof(bytes).kindof)
-    $case POINTER:
-        s = (*bytes)[:$Type.sizeof];
-    $default:
-        s = bytes[:$Type.sizeof];
-    $endswitch
-    return bitcast(*(char[$Type.sizeof]*)s.ptr, $Type).val;
+	char[] s;
+	$switch ($typeof(bytes).kindof)
+	$case POINTER:
+		s = (*bytes)[:$Type.sizeof];
+	$default:
+		s = bytes[:$Type.sizeof];
+	$endswitch
+	return bitcast(*(char[$Type.sizeof]*)s.ptr, $Type).val;
 }
 
 /**
@@ -109,72 +109,72 @@ macro read(bytes, $Type)
  **/
 macro write(x, bytes, $Type)
 {
-    char[] s;
-    $switch ($typeof(bytes).kindof)
-    $case POINTER:
-        s = (*bytes)[:$Type.sizeof];
-    $default:
-        s = bytes[:$Type.sizeof];
-    $endswitch
-    *($typeof(x)*)s.ptr = bitcast(x, $Type).val;
+	char[] s;
+	$switch ($typeof(bytes).kindof)
+	$case POINTER:
+		s = (*bytes)[:$Type.sizeof];
+	$default:
+		s = bytes[:$Type.sizeof];
+	$endswitch
+	*($typeof(x)*)s.ptr = bitcast(x, $Type).val;
 }
 
 macro is_bitorder($Type)
 {
-    $switch ($Type)
-    $case UShortLE:
-    $case ShortLE:
-    $case UIntLE:
-    $case IntLE:
-    $case ULongLE:
-    $case LongLE:
-    $case UInt128LE:
-    $case Int128LE:
-    $case UShortBE:
-    $case ShortBE:
-    $case UIntBE:
-    $case IntBE:
-    $case ULongBE:
-    $case LongBE:
-    $case UInt128BE:
-    $case Int128BE:
-        return true;
-    $default:
-        return false;
-    $endswitch
+	$switch ($Type)
+	$case UShortLE:
+	$case ShortLE:
+	$case UIntLE:
+	$case IntLE:
+	$case ULongLE:
+	$case LongLE:
+	$case UInt128LE:
+	$case Int128LE:
+	$case UShortBE:
+	$case ShortBE:
+	$case UIntBE:
+	$case IntBE:
+	$case ULongBE:
+	$case LongBE:
+	$case UInt128BE:
+	$case Int128BE:
+		return true;
+	$default:
+		return false;
+	$endswitch
 }
 
 macro bool is_array_or_sub_of_char(bytes)
 {
-    $switch ($typeof(bytes).kindof)
-    $case POINTER:
-        var $Inner = $typefrom($typeof(bytes).inner);
-        $if $Inner.kindof == ARRAY:
-            var $Inner2 = $typefrom($Inner.inner);
-            return $Inner2.typeid == char.typeid;
-        $endif
-    $case ARRAY:
-    $case SUBARRAY:
-        var $Inner = $typefrom($typeof(bytes).inner);
-        return $Inner.typeid == char.typeid;
-    $default:
-	    return false;
-    $endswitch
+	$switch ($typeof(bytes).kindof)
+	$case POINTER:
+		var $Inner = $typefrom($typeof(bytes).inner);
+		$if $Inner.kindof == ARRAY:
+			var $Inner2 = $typefrom($Inner.inner);
+			return $Inner2.typeid == char.typeid;
+		$endif
+	$case ARRAY:
+	$case SUBARRAY:
+		var $Inner = $typefrom($typeof(bytes).inner);
+		return $Inner.typeid == char.typeid;
+	$default:
+		return false;
+	$endswitch
 }
 
 macro bool is_arrayptr_or_sub_of_char(bytes)
 {
-    $switch ($typeof(bytes).kindof)
-    $case POINTER:
-        var $Inner = $typefrom($typeof(bytes).inner);
-        $if $Inner.kindof == ARRAY:
-            var $Inner2 = $typefrom($Inner.inner);
-            return $Inner2.typeid == char.typeid;
-        $endif
-    $case SUBARRAY:
-        var $Inner = $typefrom($typeof(bytes).inner);
-        return $Inner.typeid == char.typeid;
-    $default:
-	    return false;
-    $endswitch
+	$switch ($typeof(bytes).kindof)
+	$case POINTER:
+		var $Inner = $typefrom($typeof(bytes).inner);
+		$if $Inner.kindof == ARRAY:
+			var $Inner2 = $typefrom($Inner.inner);
+			return $Inner2.typeid == char.typeid;
+		$endif
+	$case SUBARRAY:
+		var $Inner = $typefrom($typeof(bytes).inner);
+		return $Inner.typeid == char.typeid;
+	$default:
+		return false;
+	$endswitch
 }
\ No newline at end of file
diff --git a/lib/std/core/builtin.c3 b/lib/std/core/builtin.c3
index 01201a149..ceb56d39c 100644
--- a/lib/std/core/builtin.c3
+++ b/lib/std/core/builtin.c3
@@ -210,11 +210,11 @@ macro bool @unlikely(bool #value, $probability = 1.0) @builtin
  **/
 macro @expect(#value, expected, $probability = 1.0) @builtin
 {
-    $if $probability == 1.0:
+	$if $probability == 1.0:
 		return $$expect(#value, ($typeof(#value))expected);
-    $else
+	$else
 		return $$expect_with_probability(#value, expected, $probability);
-    $endif
+	$endif
 }
 
 /**
@@ -264,13 +264,13 @@ macro bool @convertible(#expr, $To) @builtin
 macro anyfault @catchof(#expr) @builtin
 {
 	if (catch f = #expr) return f;
-    return anyfault {};
+	return anyfault {};
 }
 
 macro bool @ok(#expr) @builtin
 {
 	if (catch #expr) return false;
-    return true;
+	return true;
 }
 
 macro uint int.hash(int i) => i;
diff --git a/lib/std/core/builtin_comparison.c3 b/lib/std/core/builtin_comparison.c3
index aef0c5292..7dc2270ec 100644
--- a/lib/std/core/builtin_comparison.c3
+++ b/lib/std/core/builtin_comparison.c3
@@ -82,33 +82,33 @@ macro bool equals(a, b) @builtin
 
 macro min(x, ...) @builtin
 {
-    $if $vacount == 1:
-        return less(x, $vaarg(0)) ? x : $vaarg(0);
-    $else
-        var result = x;
-        $for (var $i = 0; $i < $vacount; $i++)
-            if (less($vaarg($i), result))
-            {
-                 result = $vaarg($i);
-            }
-        $endfor
-        return result;
-    $endif
+	$if $vacount == 1:
+		return less(x, $vaarg(0)) ? x : $vaarg(0);
+	$else
+		var result = x;
+		$for (var $i = 0; $i < $vacount; $i++)
+			if (less($vaarg($i), result))
+			{
+				 result = $vaarg($i);
+			}
+		$endfor
+		return result;
+	$endif
 }
 
 macro max(x, ...) @builtin
 {
-    $if $vacount == 1:
-        return greater(x, $vaarg(0)) ? x : $vaarg(0);
-    $else
-        var result = x;
-        $for (var $i = 0; $i < $vacount; $i++)
-            if (greater($vaarg($i), result))
-            {
-                 result = $vaarg($i);
-            }
-        $endfor
-        return result;
-    $endif
+	$if $vacount == 1:
+		return greater(x, $vaarg(0)) ? x : $vaarg(0);
+	$else
+		var result = x;
+		$for (var $i = 0; $i < $vacount; $i++)
+			if (greater($vaarg($i), result))
+			{
+				 result = $vaarg($i);
+			}
+		$endfor
+		return result;
+	$endif
 }
 
diff --git a/lib/std/core/conv.c3 b/lib/std/core/conv.c3
index 01a5302ca..62356ff3d 100644
--- a/lib/std/core/conv.c3
+++ b/lib/std/core/conv.c3
@@ -23,26 +23,26 @@ fn usz! char32_to_utf8(Char32 c, char* output, usz available)
 			output[0] = (char)c;
 			return 1;
 		case c <= 0x7ff:
-	        if (available < 2) return UnicodeResult.CONVERSION_FAILED?;
+			if (available < 2) return UnicodeResult.CONVERSION_FAILED?;
 			output[0] = (char)(0xC0 | c >> 6);
-            output[1] = (char)(0x80 | (c & 0x3F));
-            return 2;
-        case c <= 0xffff:
-	        if (available < 3) return UnicodeResult.CONVERSION_FAILED?;
-            output[0] = (char)(0xE0 | c >> 12);
-            output[1] = (char)(0x80 | (c >> 6 & 0x3F));
-            output[2] = (char)(0x80 | (c & 0x3F));
-            return 3;
-        case c <= 0x10ffff:
-	        if (available < 4) return UnicodeResult.CONVERSION_FAILED?;
-		    output[0] = (char)(0xF0 | c >> 18);
-            output[1] = (char)(0x80 | (c >> 12 & 0x3F));
-            output[2] = (char)(0x80 | (c >> 6 & 0x3F));
-            output[3] = (char)(0x80 | (c & 0x3F));
-            return 4;
-        default:
-            // 0x10FFFF and above is not defined.
-            return UnicodeResult.CONVERSION_FAILED?;
+			output[1] = (char)(0x80 | (c & 0x3F));
+			return 2;
+		case c <= 0xffff:
+			if (available < 3) return UnicodeResult.CONVERSION_FAILED?;
+			output[0] = (char)(0xE0 | c >> 12);
+			output[1] = (char)(0x80 | (c >> 6 & 0x3F));
+			output[2] = (char)(0x80 | (c & 0x3F));
+			return 3;
+		case c <= 0x10ffff:
+			if (available < 4) return UnicodeResult.CONVERSION_FAILED?;
+			output[0] = (char)(0xF0 | c >> 18);
+			output[1] = (char)(0x80 | (c >> 12 & 0x3F));
+			output[2] = (char)(0x80 | (c >> 6 & 0x3F));
+			output[3] = (char)(0x80 | (c & 0x3F));
+			return 4;
+		default:
+			// 0x10FFFF and above is not defined.
+			return UnicodeResult.CONVERSION_FAILED?;
 	}
 }
 
@@ -83,7 +83,7 @@ fn void! char16_to_utf8_unsafe(Char16 *ptr, usz *available, char** output)
 		*available = 1;
 		return;
 	}
-    // Low surrogate first is an error
+	// Low surrogate first is an error
 	if (high & UTF16_SURROGATE_MASK != UTF16_SURROGATE_HIGH_VALUE) return UnicodeResult.INVALID_UTF16?;
 
 	// Unmatched high surrogate is an error
@@ -94,10 +94,10 @@ fn void! char16_to_utf8_unsafe(Char16 *ptr, usz *available, char** output)
 	// Unmatched high surrogate, invalid
 	if (low & UTF16_SURROGATE_MASK != UTF16_SURROGATE_LOW_VALUE) return UnicodeResult.INVALID_UTF16?;
 
-    // The high bits of the codepoint are the value bits of the high surrogate
-    // The low bits of the codepoint are the value bits of the low surrogate
-    Char32 uc = (high & UTF16_SURROGATE_CODEPOINT_MASK) << UTF16_SURROGATE_BITS
-                | (low & UTF16_SURROGATE_CODEPOINT_MASK) + UTF16_SURROGATE_OFFSET;
+	// The high bits of the codepoint are the value bits of the high surrogate
+	// The low bits of the codepoint are the value bits of the low surrogate
+	Char32 uc = (high & UTF16_SURROGATE_CODEPOINT_MASK) << UTF16_SURROGATE_BITS
+				| (low & UTF16_SURROGATE_CODEPOINT_MASK) + UTF16_SURROGATE_OFFSET;
 	char32_to_utf8_unsafe(uc, output);
 	*available = 2;
 }
@@ -113,16 +113,16 @@ fn void char32_to_utf8_unsafe(Char32 c, char** output)
 			(*output)++[0] = (char)c;
 		case c < 0x7ff:
 			(*output)++[0] = (char)(0xC0 | c >> 6);
-            (*output)++[0] = (char)(0x80 | (c & 0x3F));
-        case c < 0xffff:
-	        (*output)++[0] = (char)(0xE0 | c >> 12);
-            (*output)++[0] = (char)(0x80 | (c >> 6 & 0x3F));
-            (*output)++[0] = (char)(0x80 | (c & 0x3F));
-        default:
-	 	    (*output)++[0] = (char)(0xF0 | c >> 18);
-            (*output)++[0] = (char)(0x80 | (c >> 12 & 0x3F));
-            (*output)++[0] = (char)(0x80 | (c >> 6 & 0x3F));
-            (*output)++[0] = (char)(0x80 | (c & 0x3F));
+			(*output)++[0] = (char)(0x80 | (c & 0x3F));
+		case c < 0xffff:
+			(*output)++[0] = (char)(0xE0 | c >> 12);
+			(*output)++[0] = (char)(0x80 | (c >> 6 & 0x3F));
+			(*output)++[0] = (char)(0x80 | (c & 0x3F));
+		default:
+			(*output)++[0] = (char)(0xF0 | c >> 18);
+			(*output)++[0] = (char)(0x80 | (c >> 12 & 0x3F));
+			(*output)++[0] = (char)(0x80 | (c >> 6 & 0x3F));
+			(*output)++[0] = (char)(0x80 | (c & 0x3F));
 	}
 }
 
@@ -137,26 +137,26 @@ fn Char32! utf8_to_char32(char* ptr, usz* size)
 	if (max_size < 1) return UnicodeResult.INVALID_UTF8?;
 	char c = (ptr++)[0];
 
-    if ((c & 0x80) == 0)
-    {
-        *size = 1;
-        return c;
-    }
-    if ((c & 0xE0) == 0xC0)
-    {
+	if ((c & 0x80) == 0)
+	{
+		*size = 1;
+		return c;
+	}
+	if ((c & 0xE0) == 0xC0)
+	{
 		if (max_size < 2) return UnicodeResult.INVALID_UTF8?;
-        *size = 2;
-        Char32 uc = (c & 0x1F) << 6;
-        c = *ptr;
-        // Overlong sequence or invalid second.
+		*size = 2;
+		Char32 uc = (c & 0x1F) << 6;
+		c = *ptr;
+		// Overlong sequence or invalid second.
 		if (!uc || c & 0xC0 != 0x80) return UnicodeResult.INVALID_UTF8?;
 		return uc + c & 0x3F;
-    }
-    if ((c & 0xF0) == 0xE0)
-    {
+	}
+	if ((c & 0xF0) == 0xE0)
+	{
 		if (max_size < 3) return UnicodeResult.INVALID_UTF8?;
-        *size = 3;
-        Char32 uc = (c & 0x0F) << 12;
+		*size = 3;
+		Char32 uc = (c & 0x0F) << 12;
 		c = ptr++[0];
 		if (c & 0xC0 != 0x80) return UnicodeResult.INVALID_UTF8?;
 		uc += (c & 0x3F) << 6;
@@ -164,11 +164,11 @@ fn Char32! utf8_to_char32(char* ptr, usz* size)
 		// Overlong sequence or invalid last
 		if (!uc || c & 0xC0 != 0x80) return UnicodeResult.INVALID_UTF8?;
 		return uc + c & 0x3F;
-    }
-    if (max_size < 4) return UnicodeResult.INVALID_UTF8?;
-    if ((c & 0xF8) != 0xF0) return UnicodeResult.INVALID_UTF8?;
-    *size = 4;
-    Char32 uc = (c & 0x07) << 18;
+	}
+	if (max_size < 4) return UnicodeResult.INVALID_UTF8?;
+	if ((c & 0xF8) != 0xF0) return UnicodeResult.INVALID_UTF8?;
+	*size = 4;
+	Char32 uc = (c & 0x07) << 18;
 	c = ptr++[0];
 	if (c & 0xC0 != 0x80) return UnicodeResult.INVALID_UTF8?;
 	uc += (c & 0x3F) << 12;
@@ -272,8 +272,8 @@ fn usz utf16len_for_utf8(String utf8)
 		if (c & 0xF0 == 0xE0) continue;
 		i++;
 		len16++;
-    }
-    return len16;
+	}
+	return len16;
 }
 
 /**
@@ -308,7 +308,7 @@ fn usz! utf32to8(Char32[] utf32, String utf8_buffer)
 		ptr += used;
 	}
 	// Zero terminate if there is space.
-    if (len > 0) ptr[0] = 0;
+	if (len > 0) ptr[0] = 0;
 	return utf8_buffer.len - len;
 }
 
@@ -323,19 +323,19 @@ fn usz! utf8to32(String utf8, Char32[] utf32_buffer)
 {
 	usz len = utf8.len;
 	Char32* ptr = utf32_buffer.ptr;
-    usz len32 = 0;
-    usz buf_len = utf32_buffer.len;
-    for (usz i = 0; i < len;)
-    {
-        if (len32 == buf_len) return UnicodeResult.CONVERSION_FAILED?;
-        usz width = len - i;
-    	Char32 uc = utf8_to_char32(&utf8[i], &width) @inline!;
-    	i += width;
-    	ptr[len32++] = uc;
-    }
-    // Zero terminate if possible
-    if (len32 + 1 < buf_len) ptr[len32] = 0;
-    return len32;
+	usz len32 = 0;
+	usz buf_len = utf32_buffer.len;
+	for (usz i = 0; i < len;)
+	{
+		if (len32 == buf_len) return UnicodeResult.CONVERSION_FAILED?;
+		usz width = len - i;
+		Char32 uc = utf8_to_char32(&utf8[i], &width) @inline!;
+		i += width;
+		ptr[len32++] = uc;
+	}
+	// Zero terminate if possible
+	if (len32 + 1 < buf_len) ptr[len32] = 0;
+	return len32;
 }
 
 /**
@@ -369,12 +369,12 @@ fn void! utf8to32_unsafe(String utf8, Char32* utf32_buffer)
 {
 	usz len = utf8.len;
 	for (usz i = 0; i < len;)
-    {
-        usz width = len - i;
-    	Char32 uc = utf8_to_char32(&utf8[i], &width) @inline!;
-    	i += width;
-    	(utf32_buffer++)[0] = uc;
-    }
+	{
+		usz width = len - i;
+		Char32 uc = utf8_to_char32(&utf8[i], &width) @inline!;
+		i += width;
+		(utf32_buffer++)[0] = uc;
+	}
 }
 
 /**
@@ -388,13 +388,13 @@ fn void! utf8to32_unsafe(String utf8, Char32* utf32_buffer)
 fn void! utf8to16_unsafe(String utf8, Char16* utf16_buffer)
 {
 	usz len = utf8.len;
-    for (usz i = 0; i < len;)
-    {
-        usz width = len - i;
-    	Char32 uc = utf8_to_char32(&utf8[i], &width) @inline!;
-        char32_to_utf16_unsafe(uc, &utf16_buffer) @inline;
-        i += width;
-    }
+	for (usz i = 0; i < len;)
+	{
+		usz width = len - i;
+		Char32 uc = utf8_to_char32(&utf8[i], &width) @inline!;
+		char32_to_utf16_unsafe(uc, &utf16_buffer) @inline;
+		i += width;
+	}
 }
 
 /**
diff --git a/lib/std/core/dstring.c3 b/lib/std/core/dstring.c3
index 50a747449..e9bb4eb0f 100644
--- a/lib/std/core/dstring.c3
+++ b/lib/std/core/dstring.c3
@@ -124,7 +124,7 @@ fn void DString.append_repeat(&self, char c, usz times)
 	StringData* data = self.data();
 	for (usz i = 0; i < times; i++)
 	{
-        data.chars[data.len++] = c;
+		data.chars[data.len++] = c;
 	}
 }
 
@@ -137,32 +137,32 @@ fn void DString.append_char32(&self, Char32 c)
 	{
 		self.reserve(1);
 		StringData* data = self.data();
-        data.chars[data.len++] = (char)c;
-        return;
-    }
-    if (c < 0x7ff)
-    {
+		data.chars[data.len++] = (char)c;
+		return;
+	}
+	if (c < 0x7ff)
+	{
 		self.reserve(2);
 		StringData* data = self.data();
 		data.chars[data.len++] = (char)(0xC0 | c >> 6);
-        data.chars[data.len++] = (char)(0x80 | (c & 0x3F));
-        return;
-    }
-    if (c < 0xffff)
-    {
+		data.chars[data.len++] = (char)(0x80 | (c & 0x3F));
+		return;
+	}
+	if (c < 0xffff)
+	{
 		self.reserve(3);
 		StringData* data = self.data();
 		data.chars[data.len++] = (char)(0xE0 | c >> 12);
-        data.chars[data.len++] = (char)(0x80 | (c >> 6 & 0x3F));
-        data.chars[data.len++] = (char)(0x80 | (c & 0x3F));
-        return;
-    }
+		data.chars[data.len++] = (char)(0x80 | (c >> 6 & 0x3F));
+		data.chars[data.len++] = (char)(0x80 | (c & 0x3F));
+		return;
+	}
 	self.reserve(4);
 	StringData* data = self.data();
 	data.chars[data.len++] = (char)(0xF0 | c >> 18);
-    data.chars[data.len++] = (char)(0x80 | (c >> 12 & 0x3F));
-    data.chars[data.len++] = (char)(0x80 | (c >> 6 & 0x3F));
-    data.chars[data.len++] = (char)(0x80 | (c & 0x3F));
+	data.chars[data.len++] = (char)(0x80 | (c >> 12 & 0x3F));
+	data.chars[data.len++] = (char)(0x80 | (c >> 6 & 0x3F));
+	data.chars[data.len++] = (char)(0x80 | (c & 0x3F));
 }
 
 fn DString DString.tcopy(&self) => self.copy(mem::temp());
diff --git a/lib/std/core/env.c3 b/lib/std/core/env.c3
index 4158e7669..4a5817f75 100644
--- a/lib/std/core/env.c3
+++ b/lib/std/core/env.c3
@@ -5,10 +5,10 @@ module std::core::env;
 import libc;
 enum CompilerOptLevel
 {
-    O0,
-    O1,
-    O2,
-    O3
+	O0,
+	O1,
+	O2,
+	O3
 }
 
 enum MemoryEnvironment
diff --git a/lib/std/core/mem.c3 b/lib/std/core/mem.c3
index 4a6b52033..3c45695bb 100644
--- a/lib/std/core/mem.c3
+++ b/lib/std/core/mem.c3
@@ -9,7 +9,7 @@ const DEFAULT_MEM_ALIGNMENT = (void*.alignof) * 2;
 
 macro @volatile_load(&x) @builtin
 {
-    return $$volatile_load(x);
+	return $$volatile_load(x);
 }
 
 /**
@@ -17,7 +17,7 @@ macro @volatile_load(&x) @builtin
  **/
 macro @volatile_store(&x, y) @builtin
 {
-    return $$volatile_store(x, ($typeof(*x))y);
+	return $$volatile_store(x, ($typeof(*x))y);
 }
 
 enum AtomicOrdering : int
@@ -152,7 +152,7 @@ macro bool equals(a, b, isz len = -1, usz $align = 0)
 
 	if (!len) return true;
 	var $Type;
-    $switch ($align)
+	$switch ($align)
 		$case 1:
 			$Type = char;
 		$case 2:
@@ -395,20 +395,20 @@ macro void @stack_pool(usz $size; @body) @builtin
 
 macro void @pool(TempAllocator* #other_temp = null; @body) @builtin
 {
-    TempAllocator* current = temp();
-    var $has_arg = !$checks(var $x = #other_temp);
-    $if $has_arg:
-        TempAllocator* original = current;
-        if (current == #other_temp) current = temp_allocator_next();
-    $endif
-    usz mark = current.used;
-    defer
-    {
-	    current.reset(mark);
-	    $if $has_arg:
-	        thread_temp_allocator = original;
-	    $endif;
-    }
+	TempAllocator* current = temp();
+	var $has_arg = !$checks(var $x = #other_temp);
+	$if $has_arg:
+		TempAllocator* original = current;
+		if (current == #other_temp) current = temp_allocator_next();
+	$endif
+	usz mark = current.used;
+	defer
+	{
+		current.reset(mark);
+		$if $has_arg:
+			thread_temp_allocator = original;
+		$endif;
+	}
 	@body();
 }
 
@@ -434,27 +434,27 @@ fn TempAllocator *temp_allocator_next() @private
 {
 	if (!thread_temp_allocator)
 	{
-	    init_default_temp_allocators();
-	    return thread_temp_allocator;
+		init_default_temp_allocators();
+		return thread_temp_allocator;
 	}
-    usz index = thread_temp_allocator == temp_allocator_pair[0] ? 1 : 0;
-    return thread_temp_allocator = temp_allocator_pair[index];
+	usz index = thread_temp_allocator == temp_allocator_pair[0] ? 1 : 0;
+	return thread_temp_allocator = temp_allocator_pair[index];
 }
 
 import libc;
 
 fn void init_default_temp_allocators() @private
 {
-    temp_allocator_pair[0] = create_default_sized_temp_allocator();
-    temp_allocator_pair[1] = create_default_sized_temp_allocator();
-    thread_temp_allocator = temp_allocator_pair[0];
+	temp_allocator_pair[0] = create_default_sized_temp_allocator();
+	temp_allocator_pair[1] = create_default_sized_temp_allocator();
+	thread_temp_allocator = temp_allocator_pair[0];
 }
 
 macro TempAllocator* temp()
 {
 	if (!thread_temp_allocator)
 	{
-	    init_default_temp_allocators();
+		init_default_temp_allocators();
 	}
 	return thread_temp_allocator;
 }
diff --git a/lib/std/core/mem_allocator.c3 b/lib/std/core/mem_allocator.c3
index e8386ae85..3bcd40a5c 100644
--- a/lib/std/core/mem_allocator.c3
+++ b/lib/std/core/mem_allocator.c3
@@ -37,27 +37,27 @@ macro bool is_valid_aligned_allocator($Type)
 
 struct Allocator
 {
-    AllocatorFunction function;
+	AllocatorFunction function;
 }
 
 enum AllocationKind
 {
-    ALLOC,
-    CALLOC,
-    REALLOC,
-    FREE,
-    ALIGNED_ALLOC,
-    ALIGNED_CALLOC,
-    ALIGNED_REALLOC,
-    ALIGNED_FREE,
-    RESET,
-    MARK,
+	ALLOC,
+	CALLOC,
+	REALLOC,
+	FREE,
+	ALIGNED_ALLOC,
+	ALIGNED_CALLOC,
+	ALIGNED_REALLOC,
+	ALIGNED_FREE,
+	RESET,
+	MARK,
 }
 
 fault AllocationFailure
 {
-    OUT_OF_MEMORY,
-    CHUNK_TOO_LARGE,
+	OUT_OF_MEMORY,
+	CHUNK_TOO_LARGE,
 }
 
 
diff --git a/lib/std/core/os/wasm_memory.c3 b/lib/std/core/os/wasm_memory.c3
index 5665452ed..bf1db6935 100644
--- a/lib/std/core/os/wasm_memory.c3
+++ b/lib/std/core/os/wasm_memory.c3
@@ -18,7 +18,7 @@ fn char[]! WasmMemory.allocate_block(&self, usz bytes)
 		self.allocation = $$wasm_memory_size(0) * WASM_BLOCK_SIZE;
 	}
 	isz bytes_required = bytes + self.use - self.allocation;
-    if (bytes_required <= 0)
+	if (bytes_required <= 0)
 	{
 		defer self.use += bytes;
 		return ((char*)self.use)[:bytes];
diff --git a/lib/std/core/private/main_stub.c3 b/lib/std/core/private/main_stub.c3
index 703afd257..fb8f40277 100644
--- a/lib/std/core/private/main_stub.c3
+++ b/lib/std/core/private/main_stub.c3
@@ -101,14 +101,14 @@ macro int @win_to_err_main_args(#m, void* handle, Char16* cmd_line, int show_cmd
 	String[] args = win_command_line_to_strings(cmd_line);
 	defer release_wargs(args);
 	if (catch #m(args)) return 1;
-    return 0;
+	return 0;
 }
 
 macro int @win_to_int_main_args(#m, void* handle, Char16* cmd_line, int show_cmd)
 {
 	String[] args = win_command_line_to_strings(cmd_line);
 	defer release_wargs(args);
-    return #m(args);
+	return #m(args);
 }
 
 macro int @win_to_void_main_args(#m, void* handle, Char16* cmd_line, int show_cmd)
@@ -124,14 +124,14 @@ macro int @win_to_err_main(#m, void* handle, Char16* cmd_line, int show_cmd)
 	String[] args = win_command_line_to_strings(cmd_line);
 	defer release_wargs(args);
 	if (catch #m(handle, args, show_cmd)) return 1;
-    return 0;
+	return 0;
 }
 
 macro int @win_to_int_main(#m, void* handle, Char16* cmd_line, int show_cmd)
 {
 	String[] args = win_command_line_to_strings(cmd_line);
 	defer release_wargs(args);
-    return #m(handle, args, show_cmd);
+	return #m(handle, args, show_cmd);
 }
 
 macro int @win_to_void_main(#m, void* handle, Char16* cmd_line, int show_cmd)
@@ -154,7 +154,7 @@ macro int @wmain_to_int_main_args(#m, int argc, Char16** argv)
 {
 	String[] args = wargs_strings(argc, argv);
 	defer release_wargs(args);
-    return #m(args);
+	return #m(args);
 }
 
 macro int @wmain_to_void_main_args(#m, int argc, Char16** argv)
diff --git a/lib/std/core/runtime.c3 b/lib/std/core/runtime.c3
index 0e117839b..c80918d18 100644
--- a/lib/std/core/runtime.c3
+++ b/lib/std/core/runtime.c3
@@ -13,14 +13,14 @@ struct StackTrace
 
 struct VirtualAny
 {
-    void* ptr;
-    typeid type_id;
+	void* ptr;
+	typeid type_id;
 }
 
 struct SubArrayContainer
 {
-    void* ptr;
-    usz len;
+	void* ptr;
+	usz len;
 }
 
 def TestFn = fn void!();
diff --git a/lib/std/core/string.c3 b/lib/std/core/string.c3
index b0324f06f..141f130d4 100644
--- a/lib/std/core/string.c3
+++ b/lib/std/core/string.c3
@@ -213,11 +213,11 @@ fn bool String.contains(s, String needle)
  **/
 fn usz! String.index_of_char(s, char needle)
 {
-    foreach (i, c : s)
-    {
-        if (c == needle) return i;
-    }
-    return SearchResult.MISSING?;
+	foreach (i, c : s)
+	{
+		if (c == needle) return i;
+	}
+	return SearchResult.MISSING?;
 }
 
 /**
@@ -231,11 +231,11 @@ fn usz! String.index_of_char(s, char needle)
  **/
 fn usz! String.rindex_of_char(s, char needle)
 {
-    foreach_r (i, c : s)
-    {
-        if (c == needle) return i;
-    }
-    return SearchResult.MISSING?;
+	foreach_r (i, c : s)
+	{
+		if (c == needle) return i;
+	}
+	return SearchResult.MISSING?;
 }
 
 /**
@@ -331,30 +331,30 @@ fn usz ZString.char_len(str)
 fn usz ZString.len(str)
 {
 	usz len = 0;
-    char* ptr = (char*)str;
-    while (char c = ptr++[0]) len++;
-    return len;
+	char* ptr = (char*)str;
+	while (char c = ptr++[0]) len++;
+	return len;
 }
 
 
 fn ZString String.zstr_copy(s, Allocator* using = mem::heap())
 {
-    usz len = s.len;
-    char* str = malloc(len + 1, .using = using);
-    mem::copy(str, s.ptr, len);
-    str[len] = 0;
-    return (ZString)str;
+	usz len = s.len;
+	char* str = malloc(len + 1, .using = using);
+	mem::copy(str, s.ptr, len);
+	str[len] = 0;
+	return (ZString)str;
 }
 
 fn String String.concat(s1, String s2, Allocator* using = mem::heap())
 {
-    usz full_len = s1.len + s2.len;
-    char* str = malloc(full_len + 1, .using = using);
-    usz s1_len = s1.len;
-    mem::copy(str, s1.ptr, s1_len);
-    mem::copy(str + s1_len, s2.ptr, s2.len);
-    str[full_len] = 0;
-    return (String)str[:full_len];
+	usz full_len = s1.len + s2.len;
+	char* str = malloc(full_len + 1, .using = using);
+	usz s1_len = s1.len;
+	mem::copy(str, s1.ptr, s1_len);
+	mem::copy(str + s1_len, s2.ptr, s2.len);
+	str[full_len] = 0;
+	return (String)str[:full_len];
 }
 
 fn String String.tconcat(s1, String s2) => s1.concat(s2, mem::temp());
@@ -364,11 +364,11 @@ fn ZString String.zstr_tcopy(s) => s.zstr_copy(mem::temp()) @inline;
 
 fn String String.copy(s, Allocator* using = mem::heap())
 {
-    usz len = s.len;
-    char* str = malloc(len + 1, .using = using);
-    mem::copy(str, s.ptr, len);
-    str[len] = 0;
-    return (String)str[:len];
+	usz len = s.len;
+	char* str = malloc(len + 1, .using = using);
+	mem::copy(str, s.ptr, len);
+	str[len] = 0;
+	return (String)str[:len];
 }
 
 fn String String.tcopy(s) => s.copy(mem::temp()) @inline;
diff --git a/lib/std/core/string_to_real.c3 b/lib/std/core/string_to_real.c3
index dabaef323..d970b591a 100644
--- a/lib/std/core/string_to_real.c3
+++ b/lib/std/core/string_to_real.c3
@@ -105,7 +105,7 @@ macro double! decfloat(char[] chars, int $bits, int $emin, int sign)
 				got_digit = true;
 			default:
 				dc++;
-        		if (c != '0') x[KMAX - 4] |= 1;
+				if (c != '0') x[KMAX - 4] |= 1;
 
 		}
 		if (index == last_char) break;
@@ -235,7 +235,7 @@ macro double! decfloat(char[] chars, int $bits, int $emin, int sign)
 			carry = (1000000000 >> sh) * tmp;
 			if (k == a && !x[k])
 			{
-			 	a = (a + 1) & MASK;
+				a = (a + 1) & MASK;
 				i--;
 				rp -= 9;
 			}
@@ -404,7 +404,7 @@ macro double! hexfloat(char[] chars, int $bits, int $emin, int sign)
 	if ((c | 32) == 'p')
 	{
 		long e2val = String.to_long((String)chars[index + 1..]) ?? (NumberConversion.MALFORMED_FLOAT?)!;
-    	e2 = e2val;
+		e2 = e2val;
 	}
 	e2 += 4 * rp - 32;
 	if (!x) return sign * 0.0;
@@ -465,18 +465,18 @@ macro String.to_real(chars, $Type) @private
 		$error "Unexpected type";
 	$endswitch
 
- 	while (chars.len && chars[0] == ' ') chars = chars[1..];
- 	if (!chars.len) return NumberConversion.MALFORMED_FLOAT?;
- 	switch (chars[0])
- 	{
- 	    case '-':
- 	        sign = -1;
- 	        nextcase;
- 	    case '+':
- 	        chars = chars[1..];
- 	}
- 	if (chars == "infinity" || chars == "INFINITY") return sign * $Type.inf;
- 	if (chars == "NAN" || chars == "nan") return $Type.nan;
+	while (chars.len && chars[0] == ' ') chars = chars[1..];
+	if (!chars.len) return NumberConversion.MALFORMED_FLOAT?;
+	switch (chars[0])
+	{
+		case '-':
+			sign = -1;
+			nextcase;
+		case '+':
+			chars = chars[1..];
+	}
+	if (chars == "infinity" || chars == "INFINITY") return sign * $Type.inf;
+	if (chars == "NAN" || chars == "nan") return $Type.nan;
 
 	if (chars.len > 2 && chars[0] == '0' && (chars[1] | 32) == 'x')
 	{
diff --git a/lib/std/core/types.c3 b/lib/std/core/types.c3
index 38e8f1ea0..6dd019f59 100644
--- a/lib/std/core/types.c3
+++ b/lib/std/core/types.c3
@@ -183,7 +183,7 @@ macro bool @has_same(#a, #b, ...)
 {
 	var $type_a = $typeof(#a).typeid;
 	$if $type_a != $typeof(#b).typeid:
-	    return false;
+		return false;
 	$endif
 	$for (var $i = 0; $i < $vacount; $i++)
 		$if $typeof($vaexpr($i)).typeid != $type_a:
@@ -245,26 +245,26 @@ macro bool is_comparable_value(value)
 
 enum TypeKind : char
 {
-    VOID,
-    BOOL,
-    SIGNED_INT,
-    UNSIGNED_INT,
-    FLOAT,
-    TYPEID,
-    ANYFAULT,
-    ANY,
-    ENUM,
-    FAULT,
-    STRUCT,
-    UNION,
-    BITSTRUCT,
-    FUNC,
-    OPTIONAL,
-    ARRAY,
-    SUBARRAY,
-    VECTOR,
-    DISTINCT,
-    POINTER,
+	VOID,
+	BOOL,
+	SIGNED_INT,
+	UNSIGNED_INT,
+	FLOAT,
+	TYPEID,
+	ANYFAULT,
+	ANY,
+	ENUM,
+	FAULT,
+	STRUCT,
+	UNION,
+	BITSTRUCT,
+	FUNC,
+	OPTIONAL,
+	ARRAY,
+	SUBARRAY,
+	VECTOR,
+	DISTINCT,
+	POINTER,
 }
 
 struct TypeEnum
diff --git a/lib/std/encoding/base64.c3 b/lib/std/encoding/base64.c3
index 48f8cf85a..1b962cd8b 100644
--- a/lib/std/encoding/base64.c3
+++ b/lib/std/encoding/base64.c3
@@ -12,17 +12,17 @@ const MASK @private = 0b111111;
 
 struct Base64Encoder
 {
-    int padding;
-    String alphabet;
+	int padding;
+	String alphabet;
 }
 
 fault Base64Error
 {
-    DUPLICATE_IN_ALPHABET,
-    PADDING_IN_ALPHABET,
-    DESTINATION_TOO_SMALL,
-    INVALID_PADDING,
-    INVALID_CHARACTER,
+	DUPLICATE_IN_ALPHABET,
+	PADDING_IN_ALPHABET,
+	DESTINATION_TOO_SMALL,
+	INVALID_PADDING,
+	INVALID_CHARACTER,
 }
 
 /**
@@ -34,8 +34,8 @@ fault Base64Error
  **/
 fn void! Base64Encoder.init(&self, String alphabet, int padding = '=')
 {
-    check_alphabet(alphabet, padding)!;
-    *self = { .padding = padding, .alphabet = alphabet };
+	check_alphabet(alphabet, padding)!;
+	*self = { .padding = padding, .alphabet = alphabet };
 }
 
 /**
@@ -45,9 +45,9 @@ fn void! Base64Encoder.init(&self, String alphabet, int padding = '=')
  **/
 fn usz Base64Encoder.encode_len(&self, usz n)
 {
-    if (self.padding >= 0) return (n + 2) / 3 * 4;
-    usz trailing = n % 3;
-    return n / 3 * 4 + (trailing * 4 + 2) / 3;
+	if (self.padding >= 0) return (n + 2) / 3 * 4;
+	usz trailing = n % 3;
+	return n / 3 * 4 + (trailing * 4 + 2) / 3;
 }
 
 /**
@@ -59,57 +59,57 @@ fn usz Base64Encoder.encode_len(&self, usz n)
  **/
 fn usz! Base64Encoder.encode(&self, char[] src, char[] dst)
 {
-    if (src.len == 0) return 0;
-    usz dn = self.encode_len(src.len);
-    if (dst.len < dn) return Base64Error.DESTINATION_TOO_SMALL?;
-    usz trailing = src.len % 3;
-    char[] src3 = src[:^trailing];
+	if (src.len == 0) return 0;
+	usz dn = self.encode_len(src.len);
+	if (dst.len < dn) return Base64Error.DESTINATION_TOO_SMALL?;
+	usz trailing = src.len % 3;
+	char[] src3 = src[:^trailing];
 
-    while (src3.len > 0)
-    {
-        uint group = (uint)src3[0] << 16 | (uint)src3[1] << 8 | (uint)src3[2];
-        dst[0] = self.alphabet[group >> 18 & MASK];
-        dst[1] = self.alphabet[group >> 12 & MASK];
-        dst[2] = self.alphabet[group >> 6 & MASK];
-        dst[3] = self.alphabet[group & MASK];
-        dst = dst[4..];
-        src3 = src3[3..];
-    }
+	while (src3.len > 0)
+	{
+		uint group = (uint)src3[0] << 16 | (uint)src3[1] << 8 | (uint)src3[2];
+		dst[0] = self.alphabet[group >> 18 & MASK];
+		dst[1] = self.alphabet[group >> 12 & MASK];
+		dst[2] = self.alphabet[group >> 6 & MASK];
+		dst[3] = self.alphabet[group & MASK];
+		dst = dst[4..];
+		src3 = src3[3..];
+	}
 
-    // Encode the remaining bytes according to:
-    // https://www.rfc-editor.org/rfc/rfc4648#section-3.5
-    switch (trailing)
-    {
-        case 1:
-            uint group = (uint)src[^1] << 16;
-            dst[0] = self.alphabet[group >> 18 & MASK];
-            dst[1] = self.alphabet[group >> 12 & MASK];
-            if (self.padding >= 0)
-            {
-                char pad = (char)self.padding;
-                dst[2] = pad;
-                dst[3] = pad;
-            }
-        case 2:
-            uint group = (uint)src[^2] << 16 | (uint)src[^1] << 8;
-            dst[0] = self.alphabet[group >> 18 & MASK];
-            dst[1] = self.alphabet[group >> 12 & MASK];
-            dst[2] = self.alphabet[group >> 6 & MASK];
-            if (self.padding >= 0)
-            {
-                char pad = (char)self.padding;
-                dst[3] = pad;
-            }
-    }
-    return dn;
+	// Encode the remaining bytes according to:
+	// https://www.rfc-editor.org/rfc/rfc4648#section-3.5
+	switch (trailing)
+	{
+		case 1:
+			uint group = (uint)src[^1] << 16;
+			dst[0] = self.alphabet[group >> 18 & MASK];
+			dst[1] = self.alphabet[group >> 12 & MASK];
+			if (self.padding >= 0)
+			{
+				char pad = (char)self.padding;
+				dst[2] = pad;
+				dst[3] = pad;
+			}
+		case 2:
+			uint group = (uint)src[^2] << 16 | (uint)src[^1] << 8;
+			dst[0] = self.alphabet[group >> 18 & MASK];
+			dst[1] = self.alphabet[group >> 12 & MASK];
+			dst[2] = self.alphabet[group >> 6 & MASK];
+			if (self.padding >= 0)
+			{
+				char pad = (char)self.padding;
+				dst[3] = pad;
+			}
+	}
+	return dn;
 }
 
 struct Base64Decoder
 {
-    int padding;
-    String alphabet;
-    char[256] reverse;
-    char invalid;
+	int padding;
+	String alphabet;
+	char[256] reverse;
+	char invalid;
 }
 
 /**
@@ -121,30 +121,30 @@ struct Base64Decoder
  **/
 fn void! Base64Decoder.init(&self, String alphabet, int padding = '=')
 {
-    check_alphabet(alphabet, padding)!;
-    *self = { .padding = padding, .alphabet = alphabet };
+	check_alphabet(alphabet, padding)!;
+	*self = { .padding = padding, .alphabet = alphabet };
 
-    bool[256] checked;
-    foreach (i, c : alphabet)
-    {
-        checked[c] = true;
-        self.reverse[c] = (char)i;
-    }
-    if (padding < 0)
-    {
-        self.invalid = 255;
-        return;
-    }
-    // Find a character for invalid neither in the alphabet nor equal to the padding.
-    char pad = (char)padding;
-    foreach (i, ok : checked)
-    {
-        if (!ok && (char)i != pad)
-        {
-            self.invalid = (char)i;
-            break;
-        }
-    }
+	bool[256] checked;
+	foreach (i, c : alphabet)
+	{
+		checked[c] = true;
+		self.reverse[c] = (char)i;
+	}
+	if (padding < 0)
+	{
+		self.invalid = 255;
+		return;
+	}
+	// Find a character for invalid neither in the alphabet nor equal to the padding.
+	char pad = (char)padding;
+	foreach (i, ok : checked)
+	{
+		if (!ok && (char)i != pad)
+		{
+			self.invalid = (char)i;
+			break;
+		}
+	}
 }
 
 /**
@@ -155,19 +155,19 @@ fn void! Base64Decoder.init(&self, String alphabet, int padding = '=')
  **/
 fn usz! Base64Decoder.decode_len(&self, usz n)
 {
-    usz dn = n / 4 * 3;
-    usz trailing = n % 4;
-    if (self.padding >= 0)
-    {
-        if (trailing != 0) return Base64Error.INVALID_PADDING?;
-        // source size is multiple of 4
-    }
-    else
-    {
-        if (trailing == 1) return Base64Error.INVALID_PADDING?;
-        dn += trailing * 3 / 4;
-    }
-    return dn;
+	usz dn = n / 4 * 3;
+	usz trailing = n % 4;
+	if (self.padding >= 0)
+	{
+		if (trailing != 0) return Base64Error.INVALID_PADDING?;
+		// source size is multiple of 4
+	}
+	else
+	{
+		if (trailing == 1) return Base64Error.INVALID_PADDING?;
+		dn += trailing * 3 / 4;
+	}
+	return dn;
 }
 
 /**
@@ -179,110 +179,110 @@ fn usz! Base64Decoder.decode_len(&self, usz n)
  **/
 fn usz! Base64Decoder.decode(&self, char[] src, char[] dst)
 {
-    if (src.len == 0) return 0;
-    usz dn = self.decode_len(src.len)!;
-    if (dst.len < dn) return Base64Error.DESTINATION_TOO_SMALL?;
+	if (src.len == 0) return 0;
+	usz dn = self.decode_len(src.len)!;
+	if (dst.len < dn) return Base64Error.DESTINATION_TOO_SMALL?;
 
-    usz trailing = src.len % 4;
-    char[] src4 = src;
-    switch
-    {
-	    case self.padding < 0:
-	        src4 = src[:^trailing];
-	    default:
-	        // If there is padding, keep the last 4 bytes for later.
-	        // NB. src.len >= 4 as decode_len passed
-	        trailing = 4;
-	        char pad = (char)self.padding;
-	        if (src[^1] == pad) src4 = src[:^4];
-    }
-    while (src4.len > 0)
-    {
-        char c0 = self.reverse[src4[0]];
-        char c1 = self.reverse[src4[1]];
-        char c2 = self.reverse[src4[2]];
-        char c3 = self.reverse[src4[3]];
-        switch (self.invalid)
-        {
-            case c0:
-            case c1:
-            case c2:
-            case c3:
-                return Base64Error.INVALID_CHARACTER?;
-        }
-        uint group = (uint)c0 << 18 | (uint)c1 << 12 | (uint)c2 << 6 | (uint)c3;
-        dst[0] = (char)(group >> 16);
-        dst[1] = (char)(group >> 8);
-        dst[2] = (char)group;
-        dst = dst[3..];
-        src4 = src4[4..];
-    }
+	usz trailing = src.len % 4;
+	char[] src4 = src;
+	switch
+	{
+		case self.padding < 0:
+			src4 = src[:^trailing];
+		default:
+			// If there is padding, keep the last 4 bytes for later.
+			// NB. src.len >= 4 as decode_len passed
+			trailing = 4;
+			char pad = (char)self.padding;
+			if (src[^1] == pad) src4 = src[:^4];
+	}
+	while (src4.len > 0)
+	{
+		char c0 = self.reverse[src4[0]];
+		char c1 = self.reverse[src4[1]];
+		char c2 = self.reverse[src4[2]];
+		char c3 = self.reverse[src4[3]];
+		switch (self.invalid)
+		{
+			case c0:
+			case c1:
+			case c2:
+			case c3:
+				return Base64Error.INVALID_CHARACTER?;
+		}
+		uint group = (uint)c0 << 18 | (uint)c1 << 12 | (uint)c2 << 6 | (uint)c3;
+		dst[0] = (char)(group >> 16);
+		dst[1] = (char)(group >> 8);
+		dst[2] = (char)group;
+		dst = dst[3..];
+		src4 = src4[4..];
+	}
 
-    if (trailing == 0) return dn;
+	if (trailing == 0) return dn;
 
-    src = src[^trailing:];
-    char c0 = self.reverse[src[0]];
-    char c1 = self.reverse[src[1]];
-    if (c0 == self.invalid || c1 == self.invalid) return Base64Error.INVALID_PADDING?;
-    if (self.padding < 0)
-    {
-        switch (src.len)
-        {
-            case 2:
-                uint group = (uint)c0 << 18 | (uint)c1 << 12;
-                dst[0] = (char)(group >> 16);
-            case 3:
-                char c2 = self.reverse[src[2]];
-                if (c2 == self.invalid) return Base64Error.INVALID_CHARACTER?;
-                uint group = (uint)c0 << 18 | (uint)c1 << 12 | (uint)c2 << 6;
-                dst[0] = (char)(group >> 16);
-                dst[1] = (char)(group >> 8);
-        }
-    }
-    else
-    {
-        // Valid paddings are:
-        // 2: xx==
-        // 1: xxx=
-        char pad = (char)self.padding;
-        switch (pad)
-        {
-            case src[2]:
-                if (src[3] != pad) return Base64Error.INVALID_PADDING?;
-                uint group = (uint)c0 << 18 | (uint)c1 << 12;
-                dst[0] = (char)(group >> 16);
-                dn -= 2;
-            case src[3]:
-                char c2 = self.reverse[src[2]];
-                if (c2 == self.invalid) return Base64Error.INVALID_CHARACTER?;
-                uint group = (uint)c0 << 18 | (uint)c1 << 12 | (uint)c2 << 6;
-                dst[0] = (char)(group >> 16);
-                dst[1] = (char)(group >> 8);
-                dn -= 1;
-        }
-    }
-    return dn;
+	src = src[^trailing:];
+	char c0 = self.reverse[src[0]];
+	char c1 = self.reverse[src[1]];
+	if (c0 == self.invalid || c1 == self.invalid) return Base64Error.INVALID_PADDING?;
+	if (self.padding < 0)
+	{
+		switch (src.len)
+		{
+			case 2:
+				uint group = (uint)c0 << 18 | (uint)c1 << 12;
+				dst[0] = (char)(group >> 16);
+			case 3:
+				char c2 = self.reverse[src[2]];
+				if (c2 == self.invalid) return Base64Error.INVALID_CHARACTER?;
+				uint group = (uint)c0 << 18 | (uint)c1 << 12 | (uint)c2 << 6;
+				dst[0] = (char)(group >> 16);
+				dst[1] = (char)(group >> 8);
+		}
+	}
+	else
+	{
+		// Valid paddings are:
+		// 2: xx==
+		// 1: xxx=
+		char pad = (char)self.padding;
+		switch (pad)
+		{
+			case src[2]:
+				if (src[3] != pad) return Base64Error.INVALID_PADDING?;
+				uint group = (uint)c0 << 18 | (uint)c1 << 12;
+				dst[0] = (char)(group >> 16);
+				dn -= 2;
+			case src[3]:
+				char c2 = self.reverse[src[2]];
+				if (c2 == self.invalid) return Base64Error.INVALID_CHARACTER?;
+				uint group = (uint)c0 << 18 | (uint)c1 << 12 | (uint)c2 << 6;
+				dst[0] = (char)(group >> 16);
+				dst[1] = (char)(group >> 8);
+				dn -= 1;
+		}
+	}
+	return dn;
 }
 
 // Make sure that all bytes in the alphabet are unique and
 // the padding is not present in the alphabet.
 fn void! check_alphabet(String alphabet, int padding) @local
 {
-    bool[256] checked;
-    if (padding < 0)
-    {
-        foreach (c : alphabet)
-        {
-            if (checked[c]) return Base64Error.DUPLICATE_IN_ALPHABET?;
-            checked[c] = true;
-        }
-        return;
-    }
-    char pad = (char)padding;
-    foreach (c : alphabet)
-    {
-        if (c == pad) return Base64Error.PADDING_IN_ALPHABET?;
-        if (checked[c]) return Base64Error.DUPLICATE_IN_ALPHABET?;
-        checked[c] = true;
-    }
+	bool[256] checked;
+	if (padding < 0)
+	{
+		foreach (c : alphabet)
+		{
+			if (checked[c]) return Base64Error.DUPLICATE_IN_ALPHABET?;
+			checked[c] = true;
+		}
+		return;
+	}
+	char pad = (char)padding;
+	foreach (c : alphabet)
+	{
+		if (c == pad) return Base64Error.PADDING_IN_ALPHABET?;
+		if (checked[c]) return Base64Error.DUPLICATE_IN_ALPHABET?;
+		checked[c] = true;
+	}
 }
\ No newline at end of file
diff --git a/lib/std/encoding/json.c3 b/lib/std/encoding/json.c3
index c67ea97c7..c6439a4dc 100644
--- a/lib/std/encoding/json.c3
+++ b/lib/std/encoding/json.c3
@@ -135,22 +135,22 @@ fn Object*! JsonParser.parse_map(&self)
 	while (token != JsonTokenType.RBRACE)
 	{
 		if (token != JsonTokenType.STRING) return JsonParsingError.UNEXPECTED_CHARACTER?;
-        DString string = self.last_string;
-        if (map.has_key(string.as_str())) return JsonParsingError.DUPLICATE_MEMBERS?;
-        // Copy the key to our temp holder. We do this to work around the issue
-        // if the temp allocator should be used as the default allocator.
-        temp_key.clear();
-        temp_key.append(string);
-        self.parse_expected(COLON)!;
-        Object* element = self.parse_any()!;
+		DString string = self.last_string;
+		if (map.has_key(string.as_str())) return JsonParsingError.DUPLICATE_MEMBERS?;
+		// Copy the key to our temp holder. We do this to work around the issue
+		// if the temp allocator should be used as the default allocator.
+		temp_key.clear();
+		temp_key.append(string);
+		self.parse_expected(COLON)!;
+		Object* element = self.parse_any()!;
 		map.set(temp_key.as_str(), element);
-        token = self.advance()!;
-        if (token == JsonTokenType.COMMA)
-        {
-            token = self.advance()!;
-            continue;
-        }
-        if (token != JsonTokenType.RBRACE) return JsonParsingError.UNEXPECTED_CHARACTER?;
+		token = self.advance()!;
+		if (token == JsonTokenType.COMMA)
+		{
+			token = self.advance()!;
+			continue;
+		}
+		if (token != JsonTokenType.RBRACE) return JsonParsingError.UNEXPECTED_CHARACTER?;
 	}
 	return map;
 }
@@ -168,7 +168,7 @@ fn Object*! JsonParser.parse_array(&self)
 		if (token == JsonTokenType.COMMA)
 		{
 			token = self.advance()!;
-		    continue;
+			continue;
 		}
 		if (token != JsonTokenType.RBRACKET) return JsonParsingError.UNEXPECTED_CHARACTER?;
 	}
diff --git a/lib/std/hash/adler32.c3 b/lib/std/hash/adler32.c3
index 2cbe6d0b3..f6b770cc7 100644
--- a/lib/std/hash/adler32.c3
+++ b/lib/std/hash/adler32.c3
@@ -8,46 +8,46 @@ const uint ADLER_CONST @private = 65521;
 
 struct Adler32
 {
-    uint a;
-    uint b;
+	uint a;
+	uint b;
 }
 
 fn void Adler32.init(&self)
 {
-    *self = { 1, 0 };
+	*self = { 1, 0 };
 }
 
 fn void Adler32.updatec(&self, char c)
 {
-    self.a = (self.a + c) % ADLER_CONST;
-    self.b = (self.b + self.a) % ADLER_CONST;
+	self.a = (self.a + c) % ADLER_CONST;
+	self.b = (self.b + self.a) % ADLER_CONST;
 }
 
 fn void Adler32.update(&self, char[] data)
 {
-    uint a = self.a;
-    uint b = self.b;
-    foreach (char x : data)
-    {
-        a = (a + x) % ADLER_CONST;
-        b = (b + a) % ADLER_CONST;
-    }
-    *self = { a, b };
+	uint a = self.a;
+	uint b = self.b;
+	foreach (char x : data)
+	{
+		a = (a + x) % ADLER_CONST;
+		b = (b + a) % ADLER_CONST;
+	}
+	*self = { a, b };
 }
 
 fn uint Adler32.final(&self)
 {
-    return (self.b << 16) | self.a;
+	return (self.b << 16) | self.a;
 }
 
 fn uint encode(char[] data)
 {
-    uint a = 1;
-    uint b = 0;
-    foreach (char x : data)
-    {
-        a = (a + x) % ADLER_CONST;
-        b = (b + a) % ADLER_CONST;
-    }
-    return (b << 16) | a;
+	uint a = 1;
+	uint b = 0;
+	foreach (char x : data)
+	{
+		a = (a + x) % ADLER_CONST;
+		b = (b + a) % ADLER_CONST;
+	}
+	return (b << 16) | a;
 }
\ No newline at end of file
diff --git a/lib/std/hash/crc32.c3 b/lib/std/hash/crc32.c3
index 9440dc1fb..d34eff23e 100644
--- a/lib/std/hash/crc32.c3
+++ b/lib/std/hash/crc32.c3
@@ -5,41 +5,41 @@ module std::hash::crc32;
 
 struct Crc32
 {
-    uint result;
+	uint result;
 }
 
 fn void Crc32.init(&self, uint seed = 0)
 {
-    self.result = ~seed;
+	self.result = ~seed;
 }
 
 fn void Crc32.updatec(&self, char c)
 {
-    self.result = (self.result >> 8) ^ CRC32_TABLE[(self.result ^ c) & 0xFF];
+	self.result = (self.result >> 8) ^ CRC32_TABLE[(self.result ^ c) & 0xFF];
 }
 
 fn void Crc32.update(&self, char[] data)
 {
-    uint result = self.result;
-    foreach (char x : data)
-    {
-        result = (result >> 8) ^ CRC32_TABLE[(result ^ x) & 0xFF];
-    }
-    self.result = result;
+	uint result = self.result;
+	foreach (char x : data)
+	{
+		result = (result >> 8) ^ CRC32_TABLE[(result ^ x) & 0xFF];
+	}
+	self.result = result;
 }
 
 fn uint Crc32.final(&self)
 {
-    return ~self.result;
+	return ~self.result;
 }
 
 fn uint encode(char[] data)
 {
-    uint result = ~(uint)(0);
-    foreach (char x : data)
-    {
-        result = (result >> 8) ^ CRC32_TABLE[(result ^ x) & 0xFF];
-    }
+	uint result = ~(uint)(0);
+	foreach (char x : data)
+	{
+		result = (result >> 8) ^ CRC32_TABLE[(result ^ x) & 0xFF];
+	}
 	return ~result;
 }
 
diff --git a/lib/std/hash/crc64.c3 b/lib/std/hash/crc64.c3
index e44898218..718fc4b4a 100644
--- a/lib/std/hash/crc64.c3
+++ b/lib/std/hash/crc64.c3
@@ -5,107 +5,107 @@ module std::hash::crc64;
 
 struct Crc64
 {
-    ulong result;
+	ulong result;
 }
 
 fn void Crc64.init(&self, uint seed = 0)
 {
-    self.result = seed;
+	self.result = seed;
 }
 
 fn void Crc64.updatec(&self, char c)
 {
-    self.result = (self.result << 8) ^ CRC64_TABLE[(char)((self.result >> 56) ^ c)];
+	self.result = (self.result << 8) ^ CRC64_TABLE[(char)((self.result >> 56) ^ c)];
 }
 
 fn void Crc64.update(&self, char[] data)
 {
-    ulong result = self.result;
-    foreach (char x : data)
-    {
-        result = (result << 8) ^ CRC64_TABLE[(char)((result >> 56) ^ x)];
-    }
-    self.result = result;
+	ulong result = self.result;
+	foreach (char x : data)
+	{
+		result = (result << 8) ^ CRC64_TABLE[(char)((result >> 56) ^ x)];
+	}
+	self.result = result;
 }
 
 fn ulong Crc64.final(&self)
 {
-    return self.result;
+	return self.result;
 }
 
 fn ulong encode(char[] data)
 {
-    ulong result = (ulong)(0);
-    foreach (char x : data)
-    {
-        result = (result << 8) ^ CRC64_TABLE[(char)((result >> 56) ^ x)];
-    }
+	ulong result = (ulong)(0);
+	foreach (char x : data)
+	{
+		result = (result << 8) ^ CRC64_TABLE[(char)((result >> 56) ^ x)];
+	}
 	return result;
 }
 
 const ulong[256] CRC64_TABLE @private = {
-    0x0000000000000000, 0x42f0e1eba9ea3693, 0x85e1c3d753d46d26, 0xc711223cfa3e5bb5,
-   	0x493366450e42ecdf, 0x0bc387aea7a8da4c, 0xccd2a5925d9681f9, 0x8e224479f47cb76a,
-   	0x9266cc8a1c85d9be, 0xd0962d61b56fef2d, 0x17870f5d4f51b498, 0x5577eeb6e6bb820b,
-   	0xdb55aacf12c73561, 0x99a54b24bb2d03f2, 0x5eb4691841135847, 0x1c4488f3e8f96ed4,
-   	0x663d78ff90e185ef, 0x24cd9914390bb37c, 0xe3dcbb28c335e8c9, 0xa12c5ac36adfde5a,
-   	0x2f0e1eba9ea36930, 0x6dfeff5137495fa3, 0xaaefdd6dcd770416, 0xe81f3c86649d3285,
-   	0xf45bb4758c645c51, 0xb6ab559e258e6ac2, 0x71ba77a2dfb03177, 0x334a9649765a07e4,
-   	0xbd68d2308226b08e, 0xff9833db2bcc861d, 0x388911e7d1f2dda8, 0x7a79f00c7818eb3b,
-   	0xcc7af1ff21c30bde, 0x8e8a101488293d4d, 0x499b3228721766f8, 0x0b6bd3c3dbfd506b,
-   	0x854997ba2f81e701, 0xc7b97651866bd192, 0x00a8546d7c558a27, 0x4258b586d5bfbcb4,
-   	0x5e1c3d753d46d260, 0x1cecdc9e94ace4f3, 0xdbfdfea26e92bf46, 0x990d1f49c77889d5,
-   	0x172f5b3033043ebf, 0x55dfbadb9aee082c, 0x92ce98e760d05399, 0xd03e790cc93a650a,
-   	0xaa478900b1228e31, 0xe8b768eb18c8b8a2, 0x2fa64ad7e2f6e317, 0x6d56ab3c4b1cd584,
-   	0xe374ef45bf6062ee, 0xa1840eae168a547d, 0x66952c92ecb40fc8, 0x2465cd79455e395b,
-   	0x3821458aada7578f, 0x7ad1a461044d611c, 0xbdc0865dfe733aa9, 0xff3067b657990c3a,
-   	0x711223cfa3e5bb50, 0x33e2c2240a0f8dc3, 0xf4f3e018f031d676, 0xb60301f359dbe0e5,
-   	0xda050215ea6c212f, 0x98f5e3fe438617bc, 0x5fe4c1c2b9b84c09, 0x1d14202910527a9a,
-   	0x93366450e42ecdf0, 0xd1c685bb4dc4fb63, 0x16d7a787b7faa0d6, 0x5427466c1e109645,
-   	0x4863ce9ff6e9f891, 0x0a932f745f03ce02, 0xcd820d48a53d95b7, 0x8f72eca30cd7a324,
-   	0x0150a8daf8ab144e, 0x43a04931514122dd, 0x84b16b0dab7f7968, 0xc6418ae602954ffb,
-   	0xbc387aea7a8da4c0, 0xfec89b01d3679253, 0x39d9b93d2959c9e6, 0x7b2958d680b3ff75,
-   	0xf50b1caf74cf481f, 0xb7fbfd44dd257e8c, 0x70eadf78271b2539, 0x321a3e938ef113aa,
-   	0x2e5eb66066087d7e, 0x6cae578bcfe24bed, 0xabbf75b735dc1058, 0xe94f945c9c3626cb,
-   	0x676dd025684a91a1, 0x259d31cec1a0a732, 0xe28c13f23b9efc87, 0xa07cf2199274ca14,
-   	0x167ff3eacbaf2af1, 0x548f120162451c62, 0x939e303d987b47d7, 0xd16ed1d631917144,
-   	0x5f4c95afc5edc62e, 0x1dbc74446c07f0bd, 0xdaad56789639ab08, 0x985db7933fd39d9b,
-   	0x84193f60d72af34f, 0xc6e9de8b7ec0c5dc, 0x01f8fcb784fe9e69, 0x43081d5c2d14a8fa,
-   	0xcd2a5925d9681f90, 0x8fdab8ce70822903, 0x48cb9af28abc72b6, 0x0a3b7b1923564425,
-   	0x70428b155b4eaf1e, 0x32b26afef2a4998d, 0xf5a348c2089ac238, 0xb753a929a170f4ab,
-   	0x3971ed50550c43c1, 0x7b810cbbfce67552, 0xbc902e8706d82ee7, 0xfe60cf6caf321874,
-   	0xe224479f47cb76a0, 0xa0d4a674ee214033, 0x67c58448141f1b86, 0x253565a3bdf52d15,
-   	0xab1721da49899a7f, 0xe9e7c031e063acec, 0x2ef6e20d1a5df759, 0x6c0603e6b3b7c1ca,
-   	0xf6fae5c07d3274cd, 0xb40a042bd4d8425e, 0x731b26172ee619eb, 0x31ebc7fc870c2f78,
-   	0xbfc9838573709812, 0xfd39626eda9aae81, 0x3a28405220a4f534, 0x78d8a1b9894ec3a7,
-   	0x649c294a61b7ad73, 0x266cc8a1c85d9be0, 0xe17dea9d3263c055, 0xa38d0b769b89f6c6,
-   	0x2daf4f0f6ff541ac, 0x6f5faee4c61f773f, 0xa84e8cd83c212c8a, 0xeabe6d3395cb1a19,
-   	0x90c79d3fedd3f122, 0xd2377cd44439c7b1, 0x15265ee8be079c04, 0x57d6bf0317edaa97,
-   	0xd9f4fb7ae3911dfd, 0x9b041a914a7b2b6e, 0x5c1538adb04570db, 0x1ee5d94619af4648,
-   	0x02a151b5f156289c, 0x4051b05e58bc1e0f, 0x87409262a28245ba, 0xc5b073890b687329,
-   	0x4b9237f0ff14c443, 0x0962d61b56fef2d0, 0xce73f427acc0a965, 0x8c8315cc052a9ff6,
-   	0x3a80143f5cf17f13, 0x7870f5d4f51b4980, 0xbf61d7e80f251235, 0xfd913603a6cf24a6,
-   	0x73b3727a52b393cc, 0x31439391fb59a55f, 0xf652b1ad0167feea, 0xb4a25046a88dc879,
-   	0xa8e6d8b54074a6ad, 0xea16395ee99e903e, 0x2d071b6213a0cb8b, 0x6ff7fa89ba4afd18,
-   	0xe1d5bef04e364a72, 0xa3255f1be7dc7ce1, 0x64347d271de22754, 0x26c49cccb40811c7,
-   	0x5cbd6cc0cc10fafc, 0x1e4d8d2b65facc6f, 0xd95caf179fc497da, 0x9bac4efc362ea149,
-   	0x158e0a85c2521623, 0x577eeb6e6bb820b0, 0x906fc95291867b05, 0xd29f28b9386c4d96,
-   	0xcedba04ad0952342, 0x8c2b41a1797f15d1, 0x4b3a639d83414e64, 0x09ca82762aab78f7,
-   	0x87e8c60fded7cf9d, 0xc51827e4773df90e, 0x020905d88d03a2bb, 0x40f9e43324e99428,
-   	0x2cffe7d5975e55e2, 0x6e0f063e3eb46371, 0xa91e2402c48a38c4, 0xebeec5e96d600e57,
-   	0x65cc8190991cb93d, 0x273c607b30f68fae, 0xe02d4247cac8d41b, 0xa2dda3ac6322e288,
-   	0xbe992b5f8bdb8c5c, 0xfc69cab42231bacf, 0x3b78e888d80fe17a, 0x7988096371e5d7e9,
-   	0xf7aa4d1a85996083, 0xb55aacf12c735610, 0x724b8ecdd64d0da5, 0x30bb6f267fa73b36,
-   	0x4ac29f2a07bfd00d, 0x08327ec1ae55e69e, 0xcf235cfd546bbd2b, 0x8dd3bd16fd818bb8,
-   	0x03f1f96f09fd3cd2, 0x41011884a0170a41, 0x86103ab85a2951f4, 0xc4e0db53f3c36767,
-   	0xd8a453a01b3a09b3, 0x9a54b24bb2d03f20, 0x5d45907748ee6495, 0x1fb5719ce1045206,
-   	0x919735e51578e56c, 0xd367d40ebc92d3ff, 0x1476f63246ac884a, 0x568617d9ef46bed9,
-   	0xe085162ab69d5e3c, 0xa275f7c11f7768af, 0x6564d5fde549331a, 0x279434164ca30589,
-   	0xa9b6706fb8dfb2e3, 0xeb46918411358470, 0x2c57b3b8eb0bdfc5, 0x6ea7525342e1e956,
-   	0x72e3daa0aa188782, 0x30133b4b03f2b111, 0xf7021977f9cceaa4, 0xb5f2f89c5026dc37,
-   	0x3bd0bce5a45a6b5d, 0x79205d0e0db05dce, 0xbe317f32f78e067b, 0xfcc19ed95e6430e8,
-   	0x86b86ed5267cdbd3, 0xc4488f3e8f96ed40, 0x0359ad0275a8b6f5, 0x41a94ce9dc428066,
-   	0xcf8b0890283e370c, 0x8d7be97b81d4019f, 0x4a6acb477bea5a2a, 0x089a2aacd2006cb9,
-   	0x14dea25f3af9026d, 0x562e43b4931334fe, 0x913f6188692d6f4b, 0xd3cf8063c0c759d8,
-   	0x5dedc41a34bbeeb2, 0x1f1d25f19d51d821, 0xd80c07cd676f8394, 0x9afce626ce85b507,
+	0x0000000000000000, 0x42f0e1eba9ea3693, 0x85e1c3d753d46d26, 0xc711223cfa3e5bb5,
+	0x493366450e42ecdf, 0x0bc387aea7a8da4c, 0xccd2a5925d9681f9, 0x8e224479f47cb76a,
+	0x9266cc8a1c85d9be, 0xd0962d61b56fef2d, 0x17870f5d4f51b498, 0x5577eeb6e6bb820b,
+	0xdb55aacf12c73561, 0x99a54b24bb2d03f2, 0x5eb4691841135847, 0x1c4488f3e8f96ed4,
+	0x663d78ff90e185ef, 0x24cd9914390bb37c, 0xe3dcbb28c335e8c9, 0xa12c5ac36adfde5a,
+	0x2f0e1eba9ea36930, 0x6dfeff5137495fa3, 0xaaefdd6dcd770416, 0xe81f3c86649d3285,
+	0xf45bb4758c645c51, 0xb6ab559e258e6ac2, 0x71ba77a2dfb03177, 0x334a9649765a07e4,
+	0xbd68d2308226b08e, 0xff9833db2bcc861d, 0x388911e7d1f2dda8, 0x7a79f00c7818eb3b,
+	0xcc7af1ff21c30bde, 0x8e8a101488293d4d, 0x499b3228721766f8, 0x0b6bd3c3dbfd506b,
+	0x854997ba2f81e701, 0xc7b97651866bd192, 0x00a8546d7c558a27, 0x4258b586d5bfbcb4,
+	0x5e1c3d753d46d260, 0x1cecdc9e94ace4f3, 0xdbfdfea26e92bf46, 0x990d1f49c77889d5,
+	0x172f5b3033043ebf, 0x55dfbadb9aee082c, 0x92ce98e760d05399, 0xd03e790cc93a650a,
+	0xaa478900b1228e31, 0xe8b768eb18c8b8a2, 0x2fa64ad7e2f6e317, 0x6d56ab3c4b1cd584,
+	0xe374ef45bf6062ee, 0xa1840eae168a547d, 0x66952c92ecb40fc8, 0x2465cd79455e395b,
+	0x3821458aada7578f, 0x7ad1a461044d611c, 0xbdc0865dfe733aa9, 0xff3067b657990c3a,
+	0x711223cfa3e5bb50, 0x33e2c2240a0f8dc3, 0xf4f3e018f031d676, 0xb60301f359dbe0e5,
+	0xda050215ea6c212f, 0x98f5e3fe438617bc, 0x5fe4c1c2b9b84c09, 0x1d14202910527a9a,
+	0x93366450e42ecdf0, 0xd1c685bb4dc4fb63, 0x16d7a787b7faa0d6, 0x5427466c1e109645,
+	0x4863ce9ff6e9f891, 0x0a932f745f03ce02, 0xcd820d48a53d95b7, 0x8f72eca30cd7a324,
+	0x0150a8daf8ab144e, 0x43a04931514122dd, 0x84b16b0dab7f7968, 0xc6418ae602954ffb,
+	0xbc387aea7a8da4c0, 0xfec89b01d3679253, 0x39d9b93d2959c9e6, 0x7b2958d680b3ff75,
+	0xf50b1caf74cf481f, 0xb7fbfd44dd257e8c, 0x70eadf78271b2539, 0x321a3e938ef113aa,
+	0x2e5eb66066087d7e, 0x6cae578bcfe24bed, 0xabbf75b735dc1058, 0xe94f945c9c3626cb,
+	0x676dd025684a91a1, 0x259d31cec1a0a732, 0xe28c13f23b9efc87, 0xa07cf2199274ca14,
+	0x167ff3eacbaf2af1, 0x548f120162451c62, 0x939e303d987b47d7, 0xd16ed1d631917144,
+	0x5f4c95afc5edc62e, 0x1dbc74446c07f0bd, 0xdaad56789639ab08, 0x985db7933fd39d9b,
+	0x84193f60d72af34f, 0xc6e9de8b7ec0c5dc, 0x01f8fcb784fe9e69, 0x43081d5c2d14a8fa,
+	0xcd2a5925d9681f90, 0x8fdab8ce70822903, 0x48cb9af28abc72b6, 0x0a3b7b1923564425,
+	0x70428b155b4eaf1e, 0x32b26afef2a4998d, 0xf5a348c2089ac238, 0xb753a929a170f4ab,
+	0x3971ed50550c43c1, 0x7b810cbbfce67552, 0xbc902e8706d82ee7, 0xfe60cf6caf321874,
+	0xe224479f47cb76a0, 0xa0d4a674ee214033, 0x67c58448141f1b86, 0x253565a3bdf52d15,
+	0xab1721da49899a7f, 0xe9e7c031e063acec, 0x2ef6e20d1a5df759, 0x6c0603e6b3b7c1ca,
+	0xf6fae5c07d3274cd, 0xb40a042bd4d8425e, 0x731b26172ee619eb, 0x31ebc7fc870c2f78,
+	0xbfc9838573709812, 0xfd39626eda9aae81, 0x3a28405220a4f534, 0x78d8a1b9894ec3a7,
+	0x649c294a61b7ad73, 0x266cc8a1c85d9be0, 0xe17dea9d3263c055, 0xa38d0b769b89f6c6,
+	0x2daf4f0f6ff541ac, 0x6f5faee4c61f773f, 0xa84e8cd83c212c8a, 0xeabe6d3395cb1a19,
+	0x90c79d3fedd3f122, 0xd2377cd44439c7b1, 0x15265ee8be079c04, 0x57d6bf0317edaa97,
+	0xd9f4fb7ae3911dfd, 0x9b041a914a7b2b6e, 0x5c1538adb04570db, 0x1ee5d94619af4648,
+	0x02a151b5f156289c, 0x4051b05e58bc1e0f, 0x87409262a28245ba, 0xc5b073890b687329,
+	0x4b9237f0ff14c443, 0x0962d61b56fef2d0, 0xce73f427acc0a965, 0x8c8315cc052a9ff6,
+	0x3a80143f5cf17f13, 0x7870f5d4f51b4980, 0xbf61d7e80f251235, 0xfd913603a6cf24a6,
+	0x73b3727a52b393cc, 0x31439391fb59a55f, 0xf652b1ad0167feea, 0xb4a25046a88dc879,
+	0xa8e6d8b54074a6ad, 0xea16395ee99e903e, 0x2d071b6213a0cb8b, 0x6ff7fa89ba4afd18,
+	0xe1d5bef04e364a72, 0xa3255f1be7dc7ce1, 0x64347d271de22754, 0x26c49cccb40811c7,
+	0x5cbd6cc0cc10fafc, 0x1e4d8d2b65facc6f, 0xd95caf179fc497da, 0x9bac4efc362ea149,
+	0x158e0a85c2521623, 0x577eeb6e6bb820b0, 0x906fc95291867b05, 0xd29f28b9386c4d96,
+	0xcedba04ad0952342, 0x8c2b41a1797f15d1, 0x4b3a639d83414e64, 0x09ca82762aab78f7,
+	0x87e8c60fded7cf9d, 0xc51827e4773df90e, 0x020905d88d03a2bb, 0x40f9e43324e99428,
+	0x2cffe7d5975e55e2, 0x6e0f063e3eb46371, 0xa91e2402c48a38c4, 0xebeec5e96d600e57,
+	0x65cc8190991cb93d, 0x273c607b30f68fae, 0xe02d4247cac8d41b, 0xa2dda3ac6322e288,
+	0xbe992b5f8bdb8c5c, 0xfc69cab42231bacf, 0x3b78e888d80fe17a, 0x7988096371e5d7e9,
+	0xf7aa4d1a85996083, 0xb55aacf12c735610, 0x724b8ecdd64d0da5, 0x30bb6f267fa73b36,
+	0x4ac29f2a07bfd00d, 0x08327ec1ae55e69e, 0xcf235cfd546bbd2b, 0x8dd3bd16fd818bb8,
+	0x03f1f96f09fd3cd2, 0x41011884a0170a41, 0x86103ab85a2951f4, 0xc4e0db53f3c36767,
+	0xd8a453a01b3a09b3, 0x9a54b24bb2d03f20, 0x5d45907748ee6495, 0x1fb5719ce1045206,
+	0x919735e51578e56c, 0xd367d40ebc92d3ff, 0x1476f63246ac884a, 0x568617d9ef46bed9,
+	0xe085162ab69d5e3c, 0xa275f7c11f7768af, 0x6564d5fde549331a, 0x279434164ca30589,
+	0xa9b6706fb8dfb2e3, 0xeb46918411358470, 0x2c57b3b8eb0bdfc5, 0x6ea7525342e1e956,
+	0x72e3daa0aa188782, 0x30133b4b03f2b111, 0xf7021977f9cceaa4, 0xb5f2f89c5026dc37,
+	0x3bd0bce5a45a6b5d, 0x79205d0e0db05dce, 0xbe317f32f78e067b, 0xfcc19ed95e6430e8,
+	0x86b86ed5267cdbd3, 0xc4488f3e8f96ed40, 0x0359ad0275a8b6f5, 0x41a94ce9dc428066,
+	0xcf8b0890283e370c, 0x8d7be97b81d4019f, 0x4a6acb477bea5a2a, 0x089a2aacd2006cb9,
+	0x14dea25f3af9026d, 0x562e43b4931334fe, 0x913f6188692d6f4b, 0xd3cf8063c0c759d8,
+	0x5dedc41a34bbeeb2, 0x1f1d25f19d51d821, 0xd80c07cd676f8394, 0x9afce626ce85b507,
 };
diff --git a/lib/std/hash/fnv32a.c3 b/lib/std/hash/fnv32a.c3
index 8e853ec4b..c172eb0d8 100644
--- a/lib/std/hash/fnv32a.c3
+++ b/lib/std/hash/fnv32a.c3
@@ -12,17 +12,17 @@ macro void @update(uint* &h, char x) @private => *h = (*h * FNV32A_MUL) ^ x;
 
 fn void Fnv32a.init(&self)
 {
-    *self = FNV32A_START;
+	*self = FNV32A_START;
 }
 
 fn void Fnv32a.update(&self, char[] data)
 {
 	uint h = (uint)*self;
 	foreach (char x : data)
-    {
-        @update(h, x);
-    }
-    *self = (Fnv32a)h;
+	{
+		@update(h, x);
+	}
+	*self = (Fnv32a)h;
 }
 
 macro void Fnv32a.update_char(&self, char c)
@@ -34,8 +34,8 @@ fn uint encode(char[] data)
 {
 	uint h = FNV32A_START;
 	foreach (char x : data)
-    {
+	{
 		@update(h, x);
-    }
-    return h;
+	}
+	return h;
 }
\ No newline at end of file
diff --git a/lib/std/hash/fnv64a.c3 b/lib/std/hash/fnv64a.c3
index c27924688..6ea6a9592 100644
--- a/lib/std/hash/fnv64a.c3
+++ b/lib/std/hash/fnv64a.c3
@@ -12,17 +12,17 @@ macro void @update(ulong* &h, char x) @private => *h = (*h * FNV64A_MUL) ^ x;
 
 fn void Fnv64a.init(&self)
 {
-    *self = FNV64A_START;
+	*self = FNV64A_START;
 }
 
 fn void Fnv64a.update(&self, char[] data)
 {
 	ulong h = (ulong)*self;
 	foreach (char x : data)
-    {
-        @update(h, x);
-    }
-    *self = (Fnv64a)h;
+	{
+		@update(h, x);
+	}
+	*self = (Fnv64a)h;
 }
 
 macro void Fnv64a.update_char(&self, char c)
@@ -34,8 +34,8 @@ fn ulong encode(char[] data)
 {
 	ulong h = FNV64A_START;
 	foreach (char x : data)
-    {
+	{
 		@update(h, x);
-    }
-    return h;
+	}
+	return h;
 }
\ No newline at end of file
diff --git a/lib/std/hash/sha1.c3 b/lib/std/hash/sha1.c3
index 433b2e199..9f51bf690 100644
--- a/lib/std/hash/sha1.c3
+++ b/lib/std/hash/sha1.c3
@@ -16,15 +16,15 @@ struct Sha1
 
 fn void Sha1.init(&self)
 {
-    // SHA1 initialization constants
-    *self = {
-        .state = {
-            0x67452301,
-            0xEFCDAB89,
-            0x98BADCFE,
-            0x10325476,
-            0xC3D2E1F0
-        }
+	// SHA1 initialization constants
+	*self = {
+		.state = {
+			0x67452301,
+			0xEFCDAB89,
+			0x98BADCFE,
+			0x10325476,
+			0xC3D2E1F0
+		}
 	};
 }
 
@@ -99,7 +99,7 @@ macro @blk0(&block, i) @local
 		return block.l[i];
 	$else
 		return block.l[i] = (block.l[i].rotl(24) & 0xFF00FF00)
-            | (block.l[i].rotl(8) & 0x00FF00FF);
+			| (block.l[i].rotl(8) & 0x00FF00FF);
 	$endif
 }
 
diff --git a/lib/std/io/io.c3 b/lib/std/io/io.c3
index 12188d586..7b3499f04 100644
--- a/lib/std/io/io.c3
+++ b/lib/std/io/io.c3
@@ -6,46 +6,46 @@ import libc;
 
 struct File
 {
-    CFile file;
+	CFile file;
 }
 
 enum Seek
 {
-    SET,
-    CURSOR,
-    END
+	SET,
+	CURSOR,
+	END
 }
 
 fault IoError
 {
-    FILE_NOT_FOUND,
-    FILE_NOT_VALID,
-    INVALID_POSITION,
-    OVERFLOW,
-    FILE_IS_PIPE,
-    INCOMPLETE_WRITE,
-    BUSY,
-    NO_PERMISSION,
-    OUT_OF_SPACE,
-    INVALID_PUSHBACK,
-    EOF,
-    UNEXPECTED_EOF,
-    CANNOT_READ_DIR,
-    TOO_MANY_DESCRIPTORS,
-    FILE_IS_DIR,
-    READ_ONLY,
-    FILE_NOT_DIR,
-    SYMLINK_FAILED,
-    ALREADY_EXISTS,
-    NOT_SEEKABLE,
-    NAME_TOO_LONG,
-    WOULD_BLOCK,
-    DIR_NOT_EMPTY,
-    INTERRUPTED,
-    GENERAL_ERROR,
-    UNKNOWN_ERROR,
-    UNSUPPORTED_OPERATION,
-    FILE_CANNOT_DELETE,
+	FILE_NOT_FOUND,
+	FILE_NOT_VALID,
+	INVALID_POSITION,
+	OVERFLOW,
+	FILE_IS_PIPE,
+	INCOMPLETE_WRITE,
+	BUSY,
+	NO_PERMISSION,
+	OUT_OF_SPACE,
+	INVALID_PUSHBACK,
+	EOF,
+	UNEXPECTED_EOF,
+	CANNOT_READ_DIR,
+	TOO_MANY_DESCRIPTORS,
+	FILE_IS_DIR,
+	READ_ONLY,
+	FILE_NOT_DIR,
+	SYMLINK_FAILED,
+	ALREADY_EXISTS,
+	NOT_SEEKABLE,
+	NAME_TOO_LONG,
+	WOULD_BLOCK,
+	DIR_NOT_EMPTY,
+	INTERRUPTED,
+	GENERAL_ERROR,
+	UNKNOWN_ERROR,
+	UNSUPPORTED_OPERATION,
+	FILE_CANNOT_DELETE,
 }
 
 
@@ -142,12 +142,12 @@ fn File stdin()
 
 error FileError
 {
-    ulong errno;
+	ulong errno;
 }
 
 fn FileError errorFromErrno()
 {
-    return FileError { };
+	return FileError { };
 }
 
 
@@ -155,13 +155,13 @@ fn FileError errorFromErrno()
 
 pubic fn void! File.clearerr(File *file) @inline
 {
-    clearerr(file->file);
+	clearerr(file->file);
 }
 
 
 
 fn void File.error(File *file) @inline
 {
-    int err = ferror
+	int err = ferror
 }
 */
diff --git a/lib/std/io/io_file.c3 b/lib/std/io/io_file.c3
index 7ae36cd6c..c6887ed19 100644
--- a/lib/std/io/io_file.c3
+++ b/lib/std/io/io_file.c3
@@ -57,7 +57,7 @@ fn void! File.memopen(File* file, char[] data, String mode)
  */
 fn void! File.putc(self, char c)
 {
-    if (!libc::fputc(c, self.file)) return IoError.EOF?;
+	if (!libc::fputc(c, self.file)) return IoError.EOF?;
 }
 
 /**
@@ -65,25 +65,25 @@ fn void! File.putc(self, char c)
  */
 fn void! File.close(&self) @inline
 {
-    if (self.file && libc::fclose(self.file))
-    {
-        switch (libc::errno())
-        {
-            case errno::ECONNRESET:
-            case errno::EBADF: return IoError.FILE_NOT_VALID?;
-            case errno::EINTR: return IoError.INTERRUPTED?;
-            case errno::EDQUOT:
-            case errno::EFAULT:
-            case errno::EAGAIN:
-            case errno::EFBIG:
-            case errno::ENETDOWN:
-            case errno::ENETUNREACH:
-            case errno::ENOSPC:
-            case errno::EIO: return IoError.INCOMPLETE_WRITE?;
-            default: return IoError.UNKNOWN_ERROR?;
-        }
-    }
-    self.file = null;
+	if (self.file && libc::fclose(self.file))
+	{
+		switch (libc::errno())
+		{
+			case errno::ECONNRESET:
+			case errno::EBADF: return IoError.FILE_NOT_VALID?;
+			case errno::EINTR: return IoError.INTERRUPTED?;
+			case errno::EDQUOT:
+			case errno::EFAULT:
+			case errno::EAGAIN:
+			case errno::EFBIG:
+			case errno::ENETDOWN:
+			case errno::ENETUNREACH:
+			case errno::ENOSPC:
+			case errno::EIO: return IoError.INCOMPLETE_WRITE?;
+			default: return IoError.UNKNOWN_ERROR?;
+		}
+	}
+	self.file = null;
 }
 
 /**
@@ -91,7 +91,7 @@ fn void! File.close(&self) @inline
  */
 fn bool File.eof(self) @inline
 {
-    return libc::feof(self.file) != 0;
+	return libc::feof(self.file) != 0;
 }
 
 /**
@@ -118,7 +118,7 @@ fn usz! File.printn(self, String string = "")
 {
 	usz len = self.print(string)!;
 	if (!libc::putc('\n', self.file)) return IoError.UNKNOWN_ERROR?;
-    return len + 1;
+	return len + 1;
 }
 
 /**
@@ -126,9 +126,9 @@ fn usz! File.printn(self, String string = "")
  */
 fn usz! File.print(self, String string)
 {
-    usz len = string.len;
-    if (len != self.write((char[])string)!) return IoError.UNKNOWN_ERROR?;
-    return len;
+	usz len = string.len;
+	if (len != self.write((char[])string)!) return IoError.UNKNOWN_ERROR?;
+	return len;
 }
 
 /**
diff --git a/lib/std/io/io_formatter_private.c3 b/lib/std/io/io_formatter_private.c3
index 63cf5b407..0d638edcf 100644
--- a/lib/std/io/io_formatter_private.c3
+++ b/lib/std/io/io_formatter_private.c3
@@ -24,9 +24,9 @@ fn uint128! int_from_any(any arg, bool *is_neg) @private
 		return (uint128)(uptr)*(void**)arg.ptr;
 	}
 	if (arg.type.kindof == TypeKind.DISTINCT)
-    {
-    	return int_from_any(any { arg.ptr, arg.type.inner }, is_neg);
-    }
+	{
+		return int_from_any(any { arg.ptr, arg.type.inner }, is_neg);
+	}
 	switch (arg)
 	{
 		case bool:
@@ -44,8 +44,8 @@ fn uint128! int_from_any(any arg, bool *is_neg) @private
 			long val = *arg;
 			return (*is_neg = val < 0) ? (~(uint128)val) + 1 : (uint128)val;
 		case int128:
-            int128 val = *arg;
-            return (*is_neg = val < 0) ? (~(uint128)val) + 1 : (uint128)val;
+			int128 val = *arg;
+			return (*is_neg = val < 0) ? (~(uint128)val) + 1 : (uint128)val;
 		case char:
 			return *arg;
 		case ushort:
@@ -92,7 +92,7 @@ fn FloatType! float_from_any(any arg) @private
 		case long:
 			return *arg;
 		case int128:
-    	    return *arg;
+			return *arg;
 		case char:
 			return *arg;
 		case ushort:
@@ -102,7 +102,7 @@ fn FloatType! float_from_any(any arg) @private
 		case ulong:
 			return *arg;
 		case uint128:
-            return *arg;
+			return *arg;
 		case float:
 			return (FloatType)*arg;
 		case double:
@@ -126,14 +126,14 @@ fn uint simple_atoi(char* buf, usz maxlen, usz* len_ptr) @inline @private
 	uint i = 0;
 	usz len = *len_ptr;
 	while (len < maxlen)
-    {
-        char c = buf[len];
-        if (c < '0' || c > '9') break;
-        i = i * 10 + c - '0';
-        len++;
-    }
-    *len_ptr = len;
-    return i;
+	{
+		char c = buf[len];
+		if (c < '0' || c > '9') break;
+		i = i * 10 + c - '0';
+		len++;
+	}
+	*len_ptr = len;
+	return i;
 }
 
 fn void! Formatter.out_substr(&self, String str) @private
@@ -151,7 +151,7 @@ fn void! Formatter.out_substr(&self, String str) @private
 		// Break if we have precision set and we ran out...
 		if (c & 0xC0 != 0x80 && self.flags.precision && !prec--) break;
 		self.out(c)!;
-        index++;
+		index++;
 	}
 	return self.left_adjust(l);
 }
@@ -192,14 +192,14 @@ fn void! Formatter.floatformat(&self, FloatFormatting formatting, double y) @pri
 	const BUF_SIZE = (math::DOUBLE_MANT_DIG + 28) / 29 + 1
 		+ (math::DOUBLE_MAX_EXP + math::DOUBLE_MANT_DIG + 28 + 8) / 9;
 	uint[BUF_SIZE] big;
-    bool is_neg = false;
-    if (math::signbit(y))
-    {
-        is_neg = true;
-        y = -y;
-    }
-    int pl = is_neg || self.flags.plus ? 1 : 0;
-    // Print inf/nan
+	bool is_neg = false;
+	if (math::signbit(y))
+	{
+		is_neg = true;
+		y = -y;
+	}
+	int pl = is_neg || self.flags.plus ? 1 : 0;
+	// Print inf/nan
 	if (!math::is_finite(y))
 	{
 		// Add padding
@@ -229,20 +229,20 @@ fn void! Formatter.floatformat(&self, FloatFormatting formatting, double y) @pri
 		if (p > 0 && p < math::DOUBLE_MANT_DIG / 4 - 1)
 		{
 			int re = math::DOUBLE_MANT_DIG / 4 - 1 - (int)p;
-    		round *= 1 << (math::DOUBLE_MANT_DIG % 4);
-    		while (re--) round *= 16;
-    		if (is_neg)
-    		{
-    		    y = -y;
+			round *= 1 << (math::DOUBLE_MANT_DIG % 4);
+			while (re--) round *= 16;
+			if (is_neg)
+			{
+				y = -y;
 				y -= round;
-    			y += round;
-    			y = -y;
-    		}
-    		else
-    		{
-    		    y += round;
-    			y -= round;
-    		}
+				y += round;
+				y = -y;
+			}
+			else
+			{
+				y += round;
+				y -= round;
+			}
 		}
 		// Reverse print
 		char* estr = fmt_u(e2 < 0 ? (int128)-e2 : (int128)e2, ebuf);
@@ -476,24 +476,24 @@ fn void! Formatter.floatformat(&self, FloatFormatting formatting, double y) @pri
 	else
 	{
 		if (z <= a) z = a + 1;
-    	for (uint* d = a; d < z && p >= 0; d++)
-    	{
+		for (uint* d = a; d < z && p >= 0; d++)
+		{
 			char* s = fmt_u(*d, buf + 9);
 			if (s == buf + 9) (--s)[0] = '0';
-    		if (d != a)
-    		{
-    		    while (s > buf) (--s)[0] = '0';
-    		}
-    		else
-    		{
-    		    self.out(s++[0])!;
-    		    if (p > 0 || self.flags.hash) self.out('.')!;
-    		}
-    		self.out_chars(s[:math::min(buf + 9 - s, p)])!;
-    		p -= buf + 9 - s;
-    	}
-    	self.pad('0', p + 18, 18)!;
-    	self.out_chars(estr[:ebuf - estr])!;
+			if (d != a)
+			{
+				while (s > buf) (--s)[0] = '0';
+			}
+			else
+			{
+				self.out(s++[0])!;
+				if (p > 0 || self.flags.hash) self.out('.')!;
+			}
+			self.out_chars(s[:math::min(buf + 9 - s, p)])!;
+			p -= buf + 9 - s;
+		}
+		self.pad('0', p + 18, 18)!;
+		self.out_chars(estr[:ebuf - estr])!;
 	}
 
 	if (self.flags.left) self.pad(' ', self.width, pl + l)!;
@@ -598,8 +598,8 @@ fn void! Formatter.out_char(&self, any arg) @private
 	uint l = 1;
 	// pre padding
 	self.right_adjust(l)!;
-    // char output
-    Char32 c = types::any_to_int(arg, uint) ?? 0xFFFD;
+	// char output
+	Char32 c = types::any_to_int(arg, uint) ?? 0xFFFD;
 	switch (true)
 	{
 		case c < 0x7f:
@@ -607,11 +607,11 @@ fn void! Formatter.out_char(&self, any arg) @private
 		case c < 0x7ff:
 			self.out((char)(0xC0 | c >> 6))!;
 			self.out((char)(0x80 | (c & 0x3F)))!;
-        case c < 0xffff:
+		case c < 0xffff:
 			self.out((char)(0xE0 | c >> 12))!;
 			self.out((char)(0x80 | (c >> 6 & 0x3F)))!;
 			self.out((char)(0x80 | (c & 0x3F)))!;
-        default:
+		default:
 			self.out((char)(0xF0 | c >> 18))!;
 			self.out((char)(0x80 | (c >> 12 & 0x3F)))!;
 			self.out((char)(0x80 | (c >> 6 & 0x3F)))!;
@@ -625,16 +625,16 @@ fn void! Formatter.out_reverse(&self, char[] buf) @private
 {
 	usz buffer_start_idx = self.idx;
 	usz len = buf.len;
-    // pad spaces up to given width
-    if (!self.flags.left && !self.flags.zeropad)
-    {
-        for (usz i = len; i < self.width; i++)
-        {
-            self.out(' ')!;
-        }
-    }
-    // reverse string
-    while (len) self.out(buf[--len])!;
+	// pad spaces up to given width
+	if (!self.flags.left && !self.flags.zeropad)
+	{
+		for (usz i = len; i < self.width; i++)
+		{
+			self.out(' ')!;
+		}
+	}
+	// reverse string
+	while (len) self.out(buf[--len])!;
 
 	// append pad spaces up to given width
 	return self.left_adjust(self.idx - buffer_start_idx);
@@ -661,7 +661,7 @@ fn int! printf_parse_format_field(
 	if (c != '*') return 0;
 	printf_advance_format(format_len, index_ptr)!;
 	any val = next_any(args_ptr, args_len, args_index_ptr)!;
-    if (!val.type.kindof.is_int()) return FormattingFault.INVALID_WIDTH_ARG?;
-    uint! intval = types::any_to_int(val, int);
+	if (!val.type.kindof.is_int()) return FormattingFault.INVALID_WIDTH_ARG?;
+	uint! intval = types::any_to_int(val, int);
 	return intval ?? FormattingFault.INVALID_WIDTH_ARG?;
 }
diff --git a/lib/std/io/io_printf.c3 b/lib/std/io/io_printf.c3
index b7e68c800..398f8afd8 100644
--- a/lib/std/io/io_printf.c3
+++ b/lib/std/io/io_printf.c3
@@ -31,14 +31,14 @@ fn usz! printf(String format, args...) @maydiscard
 {
 	Formatter formatter;
 	formatter.init(&out_putchar_fn);
-    return formatter.vprintf(format, args);
+	return formatter.vprintf(format, args);
 }
 
 fn usz! printfn(String format, args...) @maydiscard
 {
 	Formatter formatter;
 	formatter.init(&out_putchar_fn);
-    usz len = formatter.vprintf(format, args)!;
+	usz len = formatter.vprintf(format, args)!;
 	putchar('\n');
 	return len + 1;
 }
@@ -47,23 +47,23 @@ fn char[]! bprintf(char[] buffer, String format, args...) @maydiscard
 {
 	Formatter formatter;
 	BufferData data = { .buffer = buffer };
-    formatter.init(&out_buffer_fn, &data);
-    usz size = formatter.vprintf(format, args)!;
-    return buffer[:data.written];
+	formatter.init(&out_buffer_fn, &data);
+	usz size = formatter.vprintf(format, args)!;
+	return buffer[:data.written];
 }
 
 fn usz! File.printf(self, String format, args...) @maydiscard
 {
 	Formatter formatter;
-    formatter.init(&out_fputchar_fn, &self);
-    return formatter.vprintf(format, args)!;
+	formatter.init(&out_fputchar_fn, &self);
+	return formatter.vprintf(format, args)!;
 }
 
 fn usz! File.printfn(self, String format, args...) @maydiscard
 {
 	Formatter formatter;
-    formatter.init(&out_fputchar_fn, &self);
-    usz len = formatter.vprintf(format, args)!;
+	formatter.init(&out_fputchar_fn, &self);
+	usz len = formatter.vprintf(format, args)!;
 	self.putc('\n')!;
 	self.flush();
 	return len + 1;
@@ -81,9 +81,9 @@ struct Formatter
 	struct
 	{
 		PrintFlags flags;
-    	uint width;
-    	uint prec;
-    	usz idx;
+		uint width;
+		uint prec;
+		usz idx;
 	}
 }
 
@@ -124,8 +124,8 @@ macro bool! Formatter.print_with_function(&self, any arg)
 		arg.to_format(self)!;
 		return true;
 	}
-    if (&arg.to_string)
-    {
+	if (&arg.to_string)
+	{
 		PrintFlags old = self.flags;
 		uint old_width = self.width;
 		uint old_prec = self.prec;
@@ -140,8 +140,8 @@ macro bool! Formatter.print_with_function(&self, any arg)
 			self.out_substr(arg.to_string(mem::temp()))!;
 			return true;
 		};
-    }
-    return false;
+	}
+	return false;
 }
 
 
@@ -152,15 +152,15 @@ fn void! Formatter.out_str(&self, any arg) @private
 		case TYPEID:
 			return self.out_substr("typeid");
 		case VOID:
-        	return self.out_substr("void");
+			return self.out_substr("void");
 		case ANYFAULT:
 		case FAULT:
-        	return self.out_substr((*(anyfault*)arg.ptr).nameof);
+			return self.out_substr((*(anyfault*)arg.ptr).nameof);
 		case ANY:
 			return self.out_str(*(any*)arg);
 		case ENUM:
 			if (self.print_with_function(arg)!) return;
-        	return self.out_substr(arg.type.names[types::any_to_int(arg, usz)!!]);
+			return self.out_substr(arg.type.names[types::any_to_int(arg, usz)!!]);
 		case STRUCT:
 			if (self.print_with_function(arg)!) return;
 			return self.out_substr("<struct>");
@@ -181,7 +181,7 @@ fn void! Formatter.out_str(&self, any arg) @private
 			{
 				return self.out_substr(((DString*)arg).as_str());
 			}
-        	return self.out_str(any { arg.ptr, arg.type.inner });
+			return self.out_str(any { arg.ptr, arg.type.inner });
 		case POINTER:
 			if (self.print_with_function(arg)!) return;
 			return self.ntoa_any(arg, 16);
@@ -231,7 +231,7 @@ fn void! Formatter.out_str(&self, any arg) @private
 				return self.out_substr(*(String*)arg);
 			}
 			usz size = inner.sizeof;
-            // Pretend this is a String
+			// Pretend this is a String
 			String* temp = (void*)arg.ptr;
 			void* ptr = (void*)temp.ptr;
 			usz len = temp.len;
@@ -375,17 +375,17 @@ fn usz! Formatter.vprintf(&self, String format, any[] anys)
 			case 'a':
 				self.atoa(float_from_any(current)!!)!;
 				continue;
-		    case 'F' :
-		        self.flags.uppercase = true;
-		        nextcase;
-		    case 'f':
-		        self.ftoa(float_from_any(current)!!)!;
+			case 'F' :
+				self.flags.uppercase = true;
+				nextcase;
+			case 'f':
+				self.ftoa(float_from_any(current)!!)!;
 				continue;
 			case 'E':
-		        self.flags.uppercase = true;
-		        nextcase;
-            case 'e':
-                self.etoa(float_from_any(current)!!)!;
+				self.flags.uppercase = true;
+				nextcase;
+			case 'e':
+				self.etoa(float_from_any(current)!!)!;
 				continue;
 			case 'G':
 				self.flags.uppercase = true;
diff --git a/lib/std/io/io_stream.c3 b/lib/std/io/io_stream.c3
index 5de4fa07a..c8fa9e777 100644
--- a/lib/std/io/io_stream.c3
+++ b/lib/std/io/io_stream.c3
@@ -106,9 +106,9 @@ fn char! Stream.read_byte(self) @inline
 
 fn usz! Stream.read_all(self, char[] buffer) @inline
 {
-    usz n = self.read(buffer)!;
-    if (n != buffer.len) return IoError.UNEXPECTED_EOF?;
-    return n;
+	usz n = self.read(buffer)!;
+	if (n != buffer.len) return IoError.UNEXPECTED_EOF?;
+	return n;
 }
 
 fn String! Stream.treadline(self) => self.readline(mem::temp()) @inline;
@@ -118,26 +118,26 @@ fn String! Stream.readline(self, Allocator* using = mem::heap())
 	ReadByteStreamFn func;
 	if (func = self.fns.read_byte_fn, !func) return IoError.UNSUPPORTED_OPERATION?;
 	bool read = false;
-    char val = func(self)!;
-    if (val == '\n') return "";
-    @pool(using)
-    {
-        DString str = dstring::tnew_with_capacity(256);
-    	if (val != '\r') str.append(val);
-    	while (1)
-        {
-            char! c = func(self);
-            if (catch err = c)
-            {
-                if (err == IoError.EOF) break;
-                return err?;
-            }
-            if (c == '\r') continue;
-            if (c == '\n') break;
-            str.append_char(c);
-        }
-        return str.copy_str(using);
-    };
+	char val = func(self)!;
+	if (val == '\n') return "";
+	@pool(using)
+	{
+		DString str = dstring::tnew_with_capacity(256);
+		if (val != '\r') str.append(val);
+		while (1)
+		{
+			char! c = func(self);
+			if (catch err = c)
+			{
+				if (err == IoError.EOF) break;
+				return err?;
+			}
+			if (c == '\r') continue;
+			if (c == '\n') break;
+			str.append_char(c);
+		}
+		return str.copy_str(using);
+	};
 }
 
 fn usz! Stream.write(self, char[] bytes) @inline
diff --git a/lib/std/io/os/file_libc.c3 b/lib/std/io/os/file_libc.c3
index 263744ac2..b5cd36273 100644
--- a/lib/std/io/os/file_libc.c3
+++ b/lib/std/io/os/file_libc.c3
@@ -84,27 +84,27 @@ macro anyfault file_open_errno() @local
 {
 	switch (libc::errno())
 	{
-	    case errno::EACCES: return IoError.NO_PERMISSION;
-	    case errno::EDQUOT: return IoError.OUT_OF_SPACE;
-	    case errno::EBADF: return IoError.FILE_NOT_VALID;
-	    case errno::EEXIST: return IoError.ALREADY_EXISTS;
-	    case errno::EINTR: return IoError.INTERRUPTED;
-	    case errno::EFAULT: return IoError.GENERAL_ERROR;
-	    case errno::EISDIR: return IoError.FILE_IS_DIR;
-	    case errno::ELOOP: return IoError.SYMLINK_FAILED;
-	    case errno::EMFILE: return IoError.TOO_MANY_DESCRIPTORS;
-	    case errno::ENAMETOOLONG: return IoError.NAME_TOO_LONG;
-	    case errno::ENFILE: return IoError.OUT_OF_SPACE;
-	    case errno::ENOTDIR: return IoError.FILE_NOT_DIR;
+		case errno::EACCES: return IoError.NO_PERMISSION;
+		case errno::EDQUOT: return IoError.OUT_OF_SPACE;
+		case errno::EBADF: return IoError.FILE_NOT_VALID;
+		case errno::EEXIST: return IoError.ALREADY_EXISTS;
+		case errno::EINTR: return IoError.INTERRUPTED;
+		case errno::EFAULT: return IoError.GENERAL_ERROR;
+		case errno::EISDIR: return IoError.FILE_IS_DIR;
+		case errno::ELOOP: return IoError.SYMLINK_FAILED;
+		case errno::EMFILE: return IoError.TOO_MANY_DESCRIPTORS;
+		case errno::ENAMETOOLONG: return IoError.NAME_TOO_LONG;
+		case errno::ENFILE: return IoError.OUT_OF_SPACE;
+		case errno::ENOTDIR: return IoError.FILE_NOT_DIR;
 		case errno::ENOENT: return IoError.FILE_NOT_FOUND;
-	    case errno::ENOSPC: return IoError.OUT_OF_SPACE;
+		case errno::ENOSPC: return IoError.OUT_OF_SPACE;
 		case errno::ENXIO: return IoError.FILE_NOT_FOUND;
 		case errno::EOVERFLOW: return IoError.OVERFLOW;
 		case errno::EROFS: return IoError.READ_ONLY;
 		case errno::EOPNOTSUPP: return IoError.UNSUPPORTED_OPERATION;
-	    case errno::EIO: return IoError.INCOMPLETE_WRITE;
-	    case errno::EWOULDBLOCK: return IoError.WOULD_BLOCK;
-	    default: return IoError.UNKNOWN_ERROR;
+		case errno::EIO: return IoError.INCOMPLETE_WRITE;
+		case errno::EWOULDBLOCK: return IoError.WOULD_BLOCK;
+		default: return IoError.UNKNOWN_ERROR;
 	}
 }
 
@@ -115,15 +115,15 @@ macro anyfault file_seek_errno() @local
 		case errno::ESPIPE: return IoError.FILE_IS_PIPE;
 		case errno::EPIPE: return IoError.FILE_IS_PIPE;
 		case errno::EOVERFLOW: return IoError.OVERFLOW;
-	    case errno::ENXIO: return IoError.FILE_NOT_FOUND;
-	    case errno::ENOSPC: return IoError.OUT_OF_SPACE;
-        case errno::EIO: return IoError.INCOMPLETE_WRITE;
+		case errno::ENXIO: return IoError.FILE_NOT_FOUND;
+		case errno::ENOSPC: return IoError.OUT_OF_SPACE;
+		case errno::EIO: return IoError.INCOMPLETE_WRITE;
 		case errno::EINVAL: return IoError.INVALID_POSITION;
-	    case errno::EINTR: return IoError.INTERRUPTED;
-	    case errno::EFBIG: return IoError.OUT_OF_SPACE;
-	    case errno::EBADF: return IoError.FILE_NOT_VALID;
-	    case errno::EAGAIN: return IoError.WOULD_BLOCK;
-	    default: return IoError.UNKNOWN_ERROR;
+		case errno::EINTR: return IoError.INTERRUPTED;
+		case errno::EFBIG: return IoError.OUT_OF_SPACE;
+		case errno::EBADF: return IoError.FILE_NOT_VALID;
+		case errno::EAGAIN: return IoError.WOULD_BLOCK;
+		default: return IoError.UNKNOWN_ERROR;
 	}
 }
 
diff --git a/lib/std/io/os/fileinfo.c3 b/lib/std/io/os/fileinfo.c3
index 21502e39a..e034e4c5c 100644
--- a/lib/std/io/os/fileinfo.c3
+++ b/lib/std/io/os/fileinfo.c3
@@ -75,18 +75,18 @@ fn bool native_file_or_dir_exists(String path)
 			Stat stat;
 			return @ok(native_stat(&stat, path));
 		$case env::WIN32:
-    	    @pool()
-    	    {
-    		    return (bool)win32::pathFileExistsW(path.to_temp_utf16()) ?? false;
-    	    };
-    	$case env::POSIX:
-    	    @pool()
-            {
-                return posix::access(path.zstr_tcopy(), 0 /* F_OK */) != -1;
-            };
-        $default:
+			@pool()
+			{
+				return (bool)win32::pathFileExistsW(path.to_temp_utf16()) ?? false;
+			};
+		$case env::POSIX:
+			@pool()
+			{
+				return posix::access(path.zstr_tcopy(), 0 /* F_OK */) != -1;
+			};
+		$default:
 			unreachable("Not supported");
-    $endswitch
+	$endswitch
 }
 
 fn bool native_is_file(String path)
diff --git a/lib/std/io/os/getcwd.c3 b/lib/std/io/os/getcwd.c3
index 961ab4f46..6f78c9018 100644
--- a/lib/std/io/os/getcwd.c3
+++ b/lib/std/io/os/getcwd.c3
@@ -12,7 +12,7 @@ macro String! getcwd(Allocator* using = mem::heap())
 			defer if (free) libc::free(res);
 			if (!res)
 			{
-			    if (libc::errno() != errno::ERANGE) return IoError.GENERAL_ERROR?;
+				if (libc::errno() != errno::ERANGE) return IoError.GENERAL_ERROR?;
 				res = win32::_wgetcwd(null, 0);
 				free = true;
 			}
@@ -35,7 +35,7 @@ macro String! getcwd(Allocator* using = mem::heap())
 			return res.copy(using);
 
 		$default:
-		    return IoError.UNSUPPORTED_OPERATION?;
+			return IoError.UNSUPPORTED_OPERATION?;
 	$endswitch
 }
 
diff --git a/lib/std/io/os/ls.c3 b/lib/std/io/os/ls.c3
index b2c0811e8..8b38f0d56 100644
--- a/lib/std/io/os/ls.c3
+++ b/lib/std/io/os/ls.c3
@@ -27,23 +27,23 @@ fn PathList! native_ls(Path dir, bool no_dirs, bool no_symlinks, String mask, Al
 	PathList list;
 	list.init(.using = using);
 
-    @pool(using)
-    {
-	    WString result = dir.as_str().tconcat(`\*`).to_temp_wstring()!!;
-	    Win32_WIN32_FIND_DATAW find_data;
-        Win32_HANDLE find = win32::findFirstFileW(result, &find_data);
-        if (find == win32::INVALID_HANDLE_VALUE) return IoError.CANNOT_READ_DIR?;
-        defer win32::findClose(find);
-        do
-        {
-            if (no_dirs && (find_data.dwFileAttributes & win32::FILE_ATTRIBUTE_DIRECTORY)) continue;
-            @pool(using)
-            {
+	@pool(using)
+	{
+		WString result = dir.as_str().tconcat(`\*`).to_temp_wstring()!!;
+		Win32_WIN32_FIND_DATAW find_data;
+		Win32_HANDLE find = win32::findFirstFileW(result, &find_data);
+		if (find == win32::INVALID_HANDLE_VALUE) return IoError.CANNOT_READ_DIR?;
+		defer win32::findClose(find);
+		do
+		{
+			if (no_dirs && (find_data.dwFileAttributes & win32::FILE_ATTRIBUTE_DIRECTORY)) continue;
+			@pool(using)
+			{
 				String filename = string::temp_from_wstring((WString)&find_data.cFileName)!;
-                if (filename == ".." || filename == ".") continue;
-	            list.append(path::new(filename, using));
-            };
-        } while (win32::findNextFileW(find, &find_data));
-        return list;
-    };
+				if (filename == ".." || filename == ".") continue;
+				list.append(path::new(filename, using));
+			};
+		} while (win32::findNextFileW(find, &find_data));
+		return list;
+	};
 }
diff --git a/lib/std/io/os/mkdir.c3 b/lib/std/io/os/mkdir.c3
index 7e4f8928e..3ac638af5 100644
--- a/lib/std/io/os/mkdir.c3
+++ b/lib/std/io/os/mkdir.c3
@@ -27,15 +27,15 @@ macro bool! native_mkdir(Path path, MkdirPermissions permissions)
 			}
 		$case env::WIN32:
 			@pool()
-	        {
-	            // TODO security attributes
+			{
+				// TODO security attributes
 				if (win32::createDirectoryW(path.as_str().to_temp_utf16()!!, null)) return true;
 				switch (win32::getLastError())
 				{
 					case win32::ERROR_ACCESS_DENIED:
 						return IoError.NO_PERMISSION?;
 					case win32::ERROR_DISK_FULL:
-				        return IoError.OUT_OF_SPACE?;
+						return IoError.OUT_OF_SPACE?;
 					case win32::ERROR_ALREADY_EXISTS:
 						return false;
 					case win32::ERROR_PATH_NOT_FOUND:
@@ -43,7 +43,7 @@ macro bool! native_mkdir(Path path, MkdirPermissions permissions)
 					default:
 						return IoError.GENERAL_ERROR?;
 				}
-	        };
+			};
 		$default:
 			return IoError.UNSUPPORTED_OPERATION?;
 	$endswitch
diff --git a/lib/std/io/os/rmdir.c3 b/lib/std/io/os/rmdir.c3
index fc3c81e0d..ed7648afa 100644
--- a/lib/std/io/os/rmdir.c3
+++ b/lib/std/io/os/rmdir.c3
@@ -25,14 +25,14 @@ macro bool! native_rmdir(Path path)
 			}
 		$case env::WIN32:
 			@pool()
-		    {
+			{
 				if (win32::removeDirectoryW(path.as_str().to_temp_utf16()!!)) return true;
 				switch (win32::getLastError())
 				{
 					case win32::ERROR_ACCESS_DENIED:
 						return IoError.NO_PERMISSION?;
 					case win32::ERROR_CURRENT_DIRECTORY:
-				        return IoError.BUSY?;
+						return IoError.BUSY?;
 					case win32::ERROR_DIR_NOT_EMPTY:
 						return IoError.DIR_NOT_EMPTY?;
 					case win32::ERROR_DIRECTORY:
@@ -41,7 +41,7 @@ macro bool! native_rmdir(Path path)
 					default:
 						return IoError.GENERAL_ERROR?;
 				}
-		    };
+			};
 		$default:
 			return IoError.UNSUPPORTED_OPERATION?;
 	$endswitch
diff --git a/lib/std/io/os/rmtree.c3 b/lib/std/io/os/rmtree.c3
index 0f224b62e..8d62fa4f4 100644
--- a/lib/std/io/os/rmtree.c3
+++ b/lib/std/io/os/rmtree.c3
@@ -15,18 +15,18 @@ fn void! native_rmtree(Path dir)
 		@pool()
 		{
 			String name = ((ZString)&entry.name).as_str();
-            if (!name || name == "." || name == "..") continue;
-            Path new_path = dir.tappend(name)!;
-            if (entry.d_type == posix::DT_DIR)
-            {
-            	native_rmtree(new_path)!;
-            	continue;
-            }
-            if (libc::remove(new_path.as_zstr()))
-            {
-            	// TODO improve
-            	return IoError.GENERAL_ERROR?;
-            }
+			if (!name || name == "." || name == "..") continue;
+			Path new_path = dir.tappend(name)!;
+			if (entry.d_type == posix::DT_DIR)
+			{
+				native_rmtree(new_path)!;
+				continue;
+			}
+			if (libc::remove(new_path.as_zstr()))
+			{
+				// TODO improve
+				return IoError.GENERAL_ERROR?;
+			}
 		};
 	}
 	os::native_rmdir(dir)!;
@@ -36,12 +36,12 @@ module std::io::os @if(env::WIN32);
 
 fn void! native_rmtree(Path path)
 {
-    Win32_WIN32_FIND_DATAW find_data;
+	Win32_WIN32_FIND_DATAW find_data;
 	String s = path.as_str().tconcat("\\*");
 	Win32_HANDLE find = win32::findFirstFileW(s.to_utf16(mem::temp()), &find_data)!;
 
 	if (find == win32::INVALID_HANDLE_VALUE) return IoError.CANNOT_READ_DIR?;
-    defer win32::findClose(find);
+	defer win32::findClose(find);
 	do
 	{
 		@pool()
@@ -59,5 +59,5 @@ fn void! native_rmtree(Path path)
 			}
 		};
 	} while (win32::findNextFileW(find, &find_data) != 0);
-    os::native_rmdir(path)!;
+	os::native_rmdir(path)!;
 }
diff --git a/lib/std/io/os/temp_directory.c3 b/lib/std/io/os/temp_directory.c3
index 226fb10cf..07e15c49f 100644
--- a/lib/std/io/os/temp_directory.c3
+++ b/lib/std/io/os/temp_directory.c3
@@ -14,7 +14,7 @@ fn Path! native_temp_directory(Allocator* using = mem::heap()) @if(env::WIN32)
 {
 	@pool(using)
 	{
-	    Win32_DWORD len = win32::getTempPathW(0, null);
+		Win32_DWORD len = win32::getTempPathW(0, null);
 		if (!len) return IoError.GENERAL_ERROR?;
 		Char16[] buff = tmalloc(Char16, len + 1);
 		if (!win32::getTempPathW(len, buff)) return IoError.GENERAL_ERROR?;
diff --git a/lib/std/io/path.c3 b/lib/std/io/path.c3
index cd43765f9..1b8a00fab 100644
--- a/lib/std/io/path.c3
+++ b/lib/std/io/path.c3
@@ -168,9 +168,9 @@ fn usz Path.start_of_base_name(self) @local
 
 fn bool! Path.is_absolute(self)
 {
-    String path_str = self.as_str();
-    if (!path_str.len) return false;
-    usz path_start = volume_name_len(path_str, self.env)!;
+	String path_str = self.as_str();
+	if (!path_str.len) return false;
+	usz path_start = volume_name_len(path_str, self.env)!;
 	return path_start < path_str.len && is_separator(path_str[path_start], self.env);
 }
 
@@ -180,16 +180,16 @@ fn Path! Path.absolute(self, Allocator* using = mem::heap())
 	if (!path_str.len) path_str = ".";
 	if (path_str == ".")
 	{
-	    String cwd = os::getcwd(mem::temp())!;
-	    return new(cwd, using, self.env);
+		String cwd = os::getcwd(mem::temp())!;
+		return new(cwd, using, self.env);
 	}
 	switch (self.env)
 	{
-	    case WIN32:
-            usz path_start = volume_name_len(path_str, self.env)!;
-            if (path_start > 0) return self;
-	    case POSIX:
-	        if (path_str[0] == PREFERRED_SEPARATOR_POSIX) return self;
+		case WIN32:
+			usz path_start = volume_name_len(path_str, self.env)!;
+			if (path_start > 0) return self;
+		case POSIX:
+			if (path_str[0] == PREFERRED_SEPARATOR_POSIX) return self;
 	}
 	String cwd = os::getcwd(mem::temp())!;
 	return Path{ cwd, self.env }.append(path_str, using)!;
@@ -235,28 +235,28 @@ fn usz! volume_name_len(String path, PathEnv path_env) @local
 	usz len = path.len;
 	if (len < 2 || path_env != PathEnv.WIN32) return 0;
 	switch (path[0])
-    {
-    	case '\\':
-    	    // "\\" paths.. must be longer than 2
-    	    if (len == 2) return 0;
+	{
+		case '\\':
+			// "\\" paths.. must be longer than 2
+			if (len == 2) return 0;
 			int count = 1;
 			while (count < len && path[count] == '\\') count++;
 			// Not 2 => folded paths
 			if (count != 2) return 0;
 			// Check that we have a name followed by '/'
 			for (usz i = 2; i < len; i++)
-    		{
-    		    char c = path[i];
-    			if (is_win32_separator(c)) return i;
-    			if (is_reserved_win32_path_char(c)) return PathResult.INVALID_PATH?;
-    		}
-    		return PathResult.INVALID_PATH?;
-    	case 'A'..'Z':
-    	case 'a'..'z':
-    	    return path[1] == ':' ? 2 : 0;
-    	default:
-    	    return 0;
-    }
+			{
+				char c = path[i];
+				if (is_win32_separator(c)) return i;
+				if (is_reserved_win32_path_char(c)) return PathResult.INVALID_PATH?;
+			}
+			return PathResult.INVALID_PATH?;
+		case 'A'..'Z':
+		case 'a'..'z':
+			return path[1] == ':' ? 2 : 0;
+		default:
+			return 0;
+	}
 }
 
 fn Path! Path.parent(self)
@@ -275,7 +275,7 @@ fn Path! Path.parent(self)
 fn String! normalize(String path_str, PathEnv path_env = DEFAULT_PATH_ENV)
 {
 	if (!path_str.len) return "";
-    usz path_start = volume_name_len(path_str, path_env)!;
+	usz path_start = volume_name_len(path_str, path_env)!;
 	usz path_len = path_str.len;
 	if (path_start == path_len) return path_str;
 	char path_separator = path_env == PathEnv.WIN32 ? PREFERRED_SEPARATOR_WIN32 : PREFERRED_SEPARATOR_POSIX;
@@ -367,7 +367,7 @@ fn String! normalize(String path_str, PathEnv path_env = DEFAULT_PATH_ENV)
 					}
 					// Reading, we go from /../abc to /../abc
 					//                      ^            ^
- 					i += 2;
+					i += 2;
 					continue;
 				default:
 					break;
@@ -411,18 +411,18 @@ def PathWalker = fn bool(Path, bool is_dir, void*);
 
 fn bool! Path.walk(self, PathWalker w, void* data, Allocator* using = mem::heap())
 {
-    Path abs = self.absolute(using)!;
-    defer abs.free();
-    PathList files = ls(abs, .using = using)!;
-    foreach (f : files)
-    {
-        if (f.as_str() == "." || f.as_str() == "..") continue;
-        f = abs.append(f.as_str(), using)!;
-        bool is_directory = is_dir(f);
-        if (w(f, is_directory, data)) return true;
-        if (is_directory && f.walk(w, data, using)!) return true;
-    }
-    return false;
+	Path abs = self.absolute(using)!;
+	defer abs.free();
+	PathList files = ls(abs, .using = using)!;
+	foreach (f : files)
+	{
+		if (f.as_str() == "." || f.as_str() == "..") continue;
+		f = abs.append(f.as_str(), using)!;
+		bool is_directory = is_dir(f);
+		if (w(f, is_directory, data)) return true;
+		if (is_directory && f.walk(w, data, using)!) return true;
+	}
+	return false;
 }
 
 fn String Path.as_str(self) @inline
diff --git a/lib/std/io/stream/buffer.c3 b/lib/std/io/stream/buffer.c3
index 23f606fec..8fd674025 100644
--- a/lib/std/io/stream/buffer.c3
+++ b/lib/std/io/stream/buffer.c3
@@ -2,10 +2,10 @@ module std::io;
 
 struct ReadBuffer
 {
-    Stream stream;
-    char[] bytes;
-    usz read_idx;
-    usz write_idx;
+	Stream stream;
+	char[] bytes;
+	usz read_idx;
+	usz write_idx;
 }
 
 /**
@@ -16,61 +16,61 @@ struct ReadBuffer
  **/
 fn void ReadBuffer.init(&self, Stream stream, char[] bytes)
 {
-    *self = { .stream = stream, .bytes = bytes };
+	*self = { .stream = stream, .bytes = bytes };
 }
 
 fn Stream ReadBuffer.as_stream(&self)
 {
-    return { .fns = &readbuffer_interface, .data = self };
+	return { .fns = &readbuffer_interface, .data = self };
 }
 
 StreamInterface readbuffer_interface = {
-    .read_fn = fn(s, char[] bytes) => ((ReadBuffer*)s.data).read(bytes),
-    .read_byte_fn = fn(s) => ((ReadBuffer*)s.data).read_byte(),
+	.read_fn = fn(s, char[] bytes) => ((ReadBuffer*)s.data).read(bytes),
+	.read_byte_fn = fn(s) => ((ReadBuffer*)s.data).read_byte(),
 };
 
 fn String ReadBuffer.as_str(&self)
 {
-    return (String)self.bytes[self.read_idx:self.write_idx - self.read_idx];
+	return (String)self.bytes[self.read_idx:self.write_idx - self.read_idx];
 }
 
 fn usz! ReadBuffer.read(&self, char[] bytes)
 {
-    if (self.read_idx == self.write_idx)
-    {
-        if (self.read_idx == 0 && bytes.len >= self.bytes.len)
-        {
-            // Read directly into the input buffer.
-            return self.stream.read(bytes)!;
-        }
-        self.refill()!;
-    }
-    usz n = min(self.write_idx - self.read_idx, bytes.len);
-    bytes[:n] = self.bytes[self.read_idx:n];
-    self.read_idx += n;
-    return n;
+	if (self.read_idx == self.write_idx)
+	{
+		if (self.read_idx == 0 && bytes.len >= self.bytes.len)
+		{
+			// Read directly into the input buffer.
+			return self.stream.read(bytes)!;
+		}
+		self.refill()!;
+	}
+	usz n = min(self.write_idx - self.read_idx, bytes.len);
+	bytes[:n] = self.bytes[self.read_idx:n];
+	self.read_idx += n;
+	return n;
 }
 
 fn char! ReadBuffer.read_byte(&self)
 {
-    if (self.read_idx == self.write_idx) self.refill()!;
-    if (self.read_idx == self.write_idx) return IoError.EOF?;
-    char c = self.bytes[self.read_idx];
-    self.read_idx++;
-    return c;
+	if (self.read_idx == self.write_idx) self.refill()!;
+	if (self.read_idx == self.write_idx) return IoError.EOF?;
+	char c = self.bytes[self.read_idx];
+	self.read_idx++;
+	return c;
 }
 
 fn void! ReadBuffer.refill(&self) @local
 {
-    self.read_idx = 0;
-    self.write_idx = self.stream.read(self.bytes)!;
+	self.read_idx = 0;
+	self.write_idx = self.stream.read(self.bytes)!;
 }
 
 struct WriteBuffer
 {
-    Stream stream;
-    char[] bytes;
-    usz index;
+	Stream stream;
+	char[] bytes;
+	usz index;
 }
 
 /**
@@ -81,63 +81,63 @@ struct WriteBuffer
  **/
 fn void WriteBuffer.init(&self, Stream stream, char[] bytes)
 {
-    *self = { .stream = stream, .bytes = bytes };
+	*self = { .stream = stream, .bytes = bytes };
 }
 
 fn Stream WriteBuffer.as_stream(&self)
 {
-    return { .fns = &writebuffer_interface, .data = self };
+	return { .fns = &writebuffer_interface, .data = self };
 }
 
 StreamInterface writebuffer_interface = {
-    .flush_fn = fn(s) => ((WriteBuffer*)s.data).flush(),
-    .write_fn = fn(s, char[] bytes) => ((WriteBuffer*)s.data).write(bytes),
-    .write_byte_fn = fn(s, char c) => ((WriteBuffer*)s.data).write_byte(c),
+	.flush_fn = fn(s) => ((WriteBuffer*)s.data).flush(),
+	.write_fn = fn(s, char[] bytes) => ((WriteBuffer*)s.data).write(bytes),
+	.write_byte_fn = fn(s, char c) => ((WriteBuffer*)s.data).write_byte(c),
 };
 
 fn String WriteBuffer.as_str(&self)
 {
-    return (String)self.bytes[:self.index];
+	return (String)self.bytes[:self.index];
 }
 
 fn void! WriteBuffer.flush(&self)
 {
-    self.write_pending()!;
-    if (self.stream.supports_flush()) self.stream.flush()!;
+	self.write_pending()!;
+	if (self.stream.supports_flush()) self.stream.flush()!;
 }
 
 fn usz! WriteBuffer.write(&self, char[] bytes)
 {
-    usz n = self.bytes.len - self.index;
-    if (bytes.len < n)
-    {
-        // Enough room in the buffer.
-        self.bytes[self.index:bytes.len] = bytes[..];
-        self.index += bytes.len;
-        return bytes.len;
-    }
-    self.write_pending()!;
-    if (bytes.len >= self.bytes.len)
-    {
-        // Write directly to the stream.
-        return self.stream.write(bytes);
-    }
-    // Buffer the data.
-    self.bytes[:bytes.len] = bytes[..];
-    self.index = bytes.len;
-    return bytes.len;
+	usz n = self.bytes.len - self.index;
+	if (bytes.len < n)
+	{
+		// Enough room in the buffer.
+		self.bytes[self.index:bytes.len] = bytes[..];
+		self.index += bytes.len;
+		return bytes.len;
+	}
+	self.write_pending()!;
+	if (bytes.len >= self.bytes.len)
+	{
+		// Write directly to the stream.
+		return self.stream.write(bytes);
+	}
+	// Buffer the data.
+	self.bytes[:bytes.len] = bytes[..];
+	self.index = bytes.len;
+	return bytes.len;
 }
 
 fn void! WriteBuffer.write_byte(&self, char c)
 {
-    usz n = self.bytes.len - self.index;
-    if (n == 0) self.write_pending()!;
-    self.bytes[0] = c;
-    self.index = 1;
+	usz n = self.bytes.len - self.index;
+	if (n == 0) self.write_pending()!;
+	self.bytes[0] = c;
+	self.index = 1;
 }
 
 fn void! WriteBuffer.write_pending(&self) @local
 {
-    self.index -= self.stream.write(self.bytes[:self.index])!;
-    if (self.index != 0) return IoError.INCOMPLETE_WRITE?;
+	self.index -= self.stream.write(self.bytes[:self.index])!;
+	if (self.index != 0) return IoError.INCOMPLETE_WRITE?;
 }
\ No newline at end of file
diff --git a/lib/std/io/stream/limitreader.c3 b/lib/std/io/stream/limitreader.c3
index d4209317e..1f732662d 100644
--- a/lib/std/io/stream/limitreader.c3
+++ b/lib/std/io/stream/limitreader.c3
@@ -2,35 +2,35 @@ module std::io::stream;
 
 struct LimitReader
 {
-    Stream reader;
-    usz limit;
+	Stream reader;
+	usz limit;
 }
 
 fn void LimitReader.init(&self, Stream reader, usz limit)
 {
-    *self = { .reader = reader, .limit = limit };
+	*self = { .reader = reader, .limit = limit };
 }
 
 fn usz! LimitReader.read(&self, char[] bytes)
 {
-    if (self.limit == 0) return IoError.EOF?;
-    usz m = min(bytes.len, self.limit);
-    usz n = self.reader.read(bytes[:m])!;
-    self.limit -= n;
-    return n;
+	if (self.limit == 0) return IoError.EOF?;
+	usz m = min(bytes.len, self.limit);
+	usz n = self.reader.read(bytes[:m])!;
+	self.limit -= n;
+	return n;
 }
 
 fn Stream LimitReader.as_stream(&self)
 {
-    return { .fns = &limitreader_interface, .data = self };
+	return { .fns = &limitreader_interface, .data = self };
 }
 
 fn usz LimitReader.available(&self)
 {
-    return self.limit;
+	return self.limit;
 }
 
 StreamInterface limitreader_interface = {
-    .read_fn = fn(s, char[] bytes) => ((LimitReader*)s.data).read(bytes),
-    .available_fn = fn(s) => ((LimitReader*)s.data).available(),
+	.read_fn = fn(s, char[] bytes) => ((LimitReader*)s.data).read(bytes),
+	.available_fn = fn(s) => ((LimitReader*)s.data).available(),
 };
\ No newline at end of file
diff --git a/lib/std/libc/libc.c3 b/lib/std/libc/libc.c3
index 056e26ea4..c0e405de0 100644
--- a/lib/std/libc/libc.c3
+++ b/lib/std/libc/libc.c3
@@ -11,14 +11,14 @@ const int RAND_MAX = 0x7fffffff;
 
 struct DivResult
 {
-    CInt quot;
-    CInt rem;
+	CInt quot;
+	CInt rem;
 }
 
 struct LongDivResult
 {
-    CLong quot;
-    CLong rem;
+	CLong quot;
+	CLong rem;
 }
 
 fn Errno errno()
@@ -394,8 +394,8 @@ struct Tm
 	CInt	tm_yday;	// days since January 1 [0-365]
 	CInt	tm_isdst;	// Daylight Savings Time flag
 	TimeOffset tm_gmtoff @if(!env::WIN32);	/* offset from UTC in seconds */
-    char *tm_zone @if(!env::WIN32);	/* timezone abbreviation */
-    CInt tm_nsec @if(env::WASI);
+	char *tm_zone @if(!env::WIN32);	/* timezone abbreviation */
+	CInt tm_nsec @if(env::WASI);
 }
 
 struct TimeSpec
diff --git a/lib/std/libc/os/darwin.c3 b/lib/std/libc/os/darwin.c3
index 0a8df7f8f..938c8014a 100644
--- a/lib/std/libc/os/darwin.c3
+++ b/lib/std/libc/os/darwin.c3
@@ -18,16 +18,16 @@ struct Stat
 	Dev_t st_rdev;
 
 	Timespec st_atimespec; // time of last access
-    Timespec st_mtimespec; // time of last data modification
-    Timespec st_ctimespec; // time of last status change
-    Timespec st_birthtimespec; // time of file creation(birth)
-    Off_t st_size; // file size, in bytes
-    Blkcnt_t st_blocks; // blocks allocated for file
-    Blksize_t st_blocksize; // optimal blocksize for I/O
-    uint st_flags; // user defined flags for file
-    uint st_gen; // file generation number
-    int st_lspare; // RESERVED
-    long[2] st_qspare; // RESERVED
+	Timespec st_mtimespec; // time of last data modification
+	Timespec st_ctimespec; // time of last status change
+	Timespec st_birthtimespec; // time of file creation(birth)
+	Off_t st_size; // file size, in bytes
+	Blkcnt_t st_blocks; // blocks allocated for file
+	Blksize_t st_blocksize; // optimal blocksize for I/O
+	uint st_flags; // user defined flags for file
+	uint st_gen; // file generation number
+	int st_lspare; // RESERVED
+	long[2] st_qspare; // RESERVED
 }
 
 extern fn int stat(ZString str, Stat* stat) @extern("stat64");
diff --git a/lib/std/libc/os/linux.c3 b/lib/std/libc/os/linux.c3
index 0d428002b..617e0cf59 100644
--- a/lib/std/libc/os/linux.c3
+++ b/lib/std/libc/os/linux.c3
@@ -14,46 +14,46 @@ def Blkcnt64_t = long;
 struct Stat @if(env::X86_64)
 {
 	Dev_t st_dev;
-    Ino_t st_ino;
-    Nlink_t st_nlink;
-    Mode_t st_mode;
-    Uid_t st_uid;
-    Gid_t st_gid;
-    CInt __pad0;
-    Dev_t st_rdev;
-    Off_t st_size;
-    Blksize_t st_blksize;
-    Blkcnt_t st_blocks;
-    Time_t st_atime;
-    long st_atime_nsec;
-    Time_t st_mtime;
-    long st_mtime_nsec;
-    Time_t st_ctime;
-    long st_ctime_nsec;
-    long[3] __unused;
+	Ino_t st_ino;
+	Nlink_t st_nlink;
+	Mode_t st_mode;
+	Uid_t st_uid;
+	Gid_t st_gid;
+	CInt __pad0;
+	Dev_t st_rdev;
+	Off_t st_size;
+	Blksize_t st_blksize;
+	Blkcnt_t st_blocks;
+	Time_t st_atime;
+	long st_atime_nsec;
+	Time_t st_mtime;
+	long st_mtime_nsec;
+	Time_t st_ctime;
+	long st_ctime_nsec;
+	long[3] __unused;
 }
 
 struct Stat @if(!env::X86_64)
 {
 	Dev_t st_dev;
-    Ino_t st_ino;
-    Mode_t st_mode;
-    Nlink_t st_nlink;
-    Uid_t st_uid;
-    Gid_t st_gid;
-    Dev_t st_rdev;
-    CInt __pad1;
-    Off_t st_size;
-    Blksize_t st_blksize;
-    CInt __pad2;
-    Blkcnt_t st_blocks;
-    Time_t st_atime;
-    long st_atime_nsec;
-    Time_t st_mtime;
-    long st_mtime_nsec;
-    Time_t st_ctime;
-    long st_ctime_nsec;
-    CInt[2] __unused;
+	Ino_t st_ino;
+	Mode_t st_mode;
+	Nlink_t st_nlink;
+	Uid_t st_uid;
+	Gid_t st_gid;
+	Dev_t st_rdev;
+	CInt __pad1;
+	Off_t st_size;
+	Blksize_t st_blksize;
+	CInt __pad2;
+	Blkcnt_t st_blocks;
+	Time_t st_atime;
+	long st_atime_nsec;
+	Time_t st_mtime;
+	long st_mtime_nsec;
+	Time_t st_ctime;
+	long st_ctime_nsec;
+	CInt[2] __unused;
 }
 
 extern fn CInt stat(ZString path, Stat* stat);
diff --git a/lib/std/math/math.c3 b/lib/std/math/math.c3
index 2afa0650c..e65f7d3b5 100644
--- a/lib/std/math/math.c3
+++ b/lib/std/math/math.c3
@@ -82,7 +82,7 @@ enum RoundingMode : int
 
 fault MatrixError
 {
-    MATRIX_INVERSE_DOESNT_EXIST,
+	MATRIX_INVERSE_DOESNT_EXIST,
 }
 
 def Complexf = Complex(<float>);
@@ -359,13 +359,13 @@ macro min(x, y, ...)
 {
 	$if $vacount == 0:
 		return $$min(x, y);
-    $else
-    	var m = $$min(x, y);
-    	$for (var $i = 0; $i < $vacount; $i++)
-    		m = $$min(m, $vaarg($i));
-    	$endfor
-    	return m;
-    $endif
+	$else
+		var m = $$min(x, y);
+		$for (var $i = 0; $i < $vacount; $i++)
+			m = $$min(m, $vaarg($i));
+		$endfor
+		return m;
+	$endif
 }
 
 /**
@@ -385,11 +385,11 @@ macro nearbyint(x) => $$nearbyint(x);
  **/
 macro pow(x, exp)
 {
-    $if types::is_floatlike($typeof(exp)):
+	$if types::is_floatlike($typeof(exp)):
 		return $$pow(x, ($typeof(x))exp);
-    $else
+	$else
 		return $$pow_int(x, exp);
-    $endif
+	$endif
 }
 
 /**
@@ -906,7 +906,7 @@ macro equals_vec(v1, v2) @private
 	var abs_diff = math::abs(v1 - v2);
 	var abs_v1 = math::abs(v1);
 	var abs_v2 = math::abs(v2);
-    $typeof(abs_v2) eps = 1;
+	$typeof(abs_v2) eps = 1;
 	return abs_diff.comp_le(FLOAT_EPSILON * math::max(abs_v1, abs_v2, eps)).and();
 }
 
diff --git a/lib/std/math/math.complex.c3 b/lib/std/math/math.complex.c3
index 3d774f114..28871d755 100644
--- a/lib/std/math/math.complex.c3
+++ b/lib/std/math/math.complex.c3
@@ -3,9 +3,9 @@ module std::math::complex(<Real>);
 union Complex
 {
 	struct
-    {
-    	Real r, c;
-    }
+	{
+		Real r, c;
+	}
 	Real[<2>] v;
 }
 
diff --git a/lib/std/math/math.matrix.c3 b/lib/std/math/math.matrix.c3
index 170f48aee..011f7d7b8 100644
--- a/lib/std/math/math.matrix.c3
+++ b/lib/std/math/math.matrix.c3
@@ -386,29 +386,29 @@ fn Matrix4x4 Matrix4x4.scale(&self, Real[<3>] v)
 
 fn Matrix4x4 ortho(Real left, Real right, Real top, Real bottom, Real near, Real far)
 {
-    Real width = right - left;
-    Real height = top - bottom;
-    Real depth = far - near;
-    return {
-        2 / width, 0, 0, 0,
-        0, 2 / height, 0, 0,
-        0, 0, -2 / depth, 0,
-        -(right + left) / width, -(top + bottom) / height, -(far + near) / depth, 1
-    };
+	Real width = right - left;
+	Real height = top - bottom;
+	Real depth = far - near;
+	return {
+		2 / width, 0, 0, 0,
+		0, 2 / height, 0, 0,
+		0, 0, -2 / depth, 0,
+		-(right + left) / width, -(top + bottom) / height, -(far + near) / depth, 1
+	};
 }
 
 // fov in radians
 fn Matrix4x4 perspective(Real fov, Real aspect_ratio, Real near, Real far)
 {
- 	Real f = (Real)math::tan(math::PI * 0.5 - 0.5 * fov);
+	Real f = (Real)math::tan(math::PI * 0.5 - 0.5 * fov);
 	Real rangeInv = (Real)1.0 / (near - far);
 	
-    return {
-        f / aspect_ratio, 0, 0, 0,
-        0, f, 0, 0,
-        0, 0, (near + far) * rangeInv, -1,
-        0, 0, near * far * rangeInv * 2, 0,
-    };
+	return {
+		f / aspect_ratio, 0, 0, 0,
+		0, f, 0, 0,
+		0, 0, (near + far) * rangeInv, -1,
+		0, 0, near * far * rangeInv * 2, 0,
+	};
 }
 
 const Matrix2x2 IDENTITY2 = { .m = { [0] = 1, [3] = 1 } };
diff --git a/lib/std/math/math.random.c3 b/lib/std/math/math.random.c3
index e610bbc6e..85c09e5fa 100644
--- a/lib/std/math/math.random.c3
+++ b/lib/std/math/math.random.c3
@@ -100,20 +100,20 @@ fn void Random.set_seeds(&random, char[] seed)
  **/
 fn bool Random.next_bool(&random)
 {
-    return random.next(1) != 0;
+	return random.next(1) != 0;
 }
 
 fn float Random.next_float(&r)
 {
-    return r.next(24) / (float)(1 << 24);
+	return r.next(24) / (float)(1 << 24);
 }
 
 fn double Random.next_double(&r)
 {
-    return (((long)(r.next(26)) << 27) + r.next(27)) * 0x1.0p-53;
+	return (((long)(r.next(26)) << 27) + r.next(27)) * 0x1.0p-53;
 }
 
 fn uint Random.next_int(&r)
 {
-    return r.next(32) @inline;
+	return r.next(32) @inline;
 }
diff --git a/lib/std/math/math_easings.c3 b/lib/std/math/math_easings.c3
index 5a1aade5b..c91ddbef0 100644
--- a/lib/std/math/math_easings.c3
+++ b/lib/std/math/math_easings.c3
@@ -65,7 +65,7 @@ fn float cubic_inout(float t, float b, float c, float d) @inline
 	t /= d / 2;
 	return t < 1
 		? (c / 2) * cube(t) + b
-        : c / 2 * (cube(t - 2) + 2) + b;
+		: c / 2 * (cube(t - 2) + 2) + b;
 }
 
 // Quadratic Easing functions
@@ -79,9 +79,9 @@ fn float quad_out(float t, float b, float c, float d) @inline
 fn float quad_inout(float t, float b, float c, float d) @inline
 {
 	t /= d / 2;
-    return t < 1
-        ? (c / 2) * sq(t) + b
-        : (-c / 2) * ((t - 1) * (t - 3) - 1) + b;
+	return t < 1
+		? (c / 2) * sq(t) + b
+		: (-c / 2) * ((t - 1) * (t - 3) - 1) + b;
 }
 
 // Exponential Easing functions
@@ -92,37 +92,37 @@ fn float expo_out(float t, float b, float c, float d) @inline
 }
 fn float expo_inout(float t, float b, float c, float d) @inline                                                                        // Ease: Exponential In Out
 {
-    if (t == 0) return b;
-    if (t == d) return b + c;
-    t /= d / 2;
-    return t < 1
-        ? (c / 2) * math::pow(2.0f, 10 * (t - 1)) + b
-        : (c / 2) * (-math::pow(2.0f, -10 * (t - 1)) + 2) + b;
+	if (t == 0) return b;
+	if (t == d) return b + c;
+	t /= d / 2;
+	return t < 1
+		? (c / 2) * math::pow(2.0f, 10 * (t - 1)) + b
+		: (c / 2) * (-math::pow(2.0f, -10 * (t - 1)) + 2) + b;
 }
 
 // Back Easing functions
 fn float back_in(float t, float b, float c, float d, float s = 1.70158f) @inline
 {
-    t /= d;
-    return c * sq(t) * ((s + 1) * t - s) + b;
+	t /= d;
+	return c * sq(t) * ((s + 1) * t - s) + b;
 }
 
 fn float back_out(float t, float b, float c, float d, float s = 1.70158f) @inline
 {
-    t = t / d - 1;
-    return c * (sq(t) * ((s + 1) * t + s) + 1) + b;
+	t = t / d - 1;
+	return c * (sq(t) * ((s + 1) * t + s) + 1) + b;
 }
 
 fn float back_inout(float t, float b, float c, float d, float s = 1.70158f) @inline
 {
-    s *= 1.525f;
-    t /= d / 2;
-    if (t < 1)
-    {
-        return (c / 2) * sq(t) * ((s + 1) * t - s) + b;
-    }
-    t -= 2.0f;
-    return (c / 2) * (sq(t) * ((s + 1) * t + s) + 2) + b;
+	s *= 1.525f;
+	t /= d / 2;
+	if (t < 1)
+	{
+		return (c / 2) * sq(t) * ((s + 1) * t - s) + b;
+	}
+	t -= 2.0f;
+	return (c / 2) * (sq(t) * ((s + 1) * t + s) + 2) + b;
 }
 
 // Bounce Easing functions
@@ -132,16 +132,16 @@ fn float bounce_out(float t, float b, float c, float d) @inline
 	switch
 	{
 		case t < 1 / 2.75f:
-	        return c * 7.5625f * sq(t) + b;
+			return c * 7.5625f * sq(t) + b;
 		case t < 2 / 2.75f:
-	        t -= 1.5f / 2.75f;
-            return c * (7.5625f * sq(t) + 0.75f) + b;
+			t -= 1.5f / 2.75f;
+			return c * (7.5625f * sq(t) + 0.75f) + b;
 		case t < 2.5f / 2.75f:
-            t -= 2.25f / 2.75f;
-            return c * (7.5625f * sq(t) + 0.9375f) + b;
+			t -= 2.25f / 2.75f;
+			return c * (7.5625f * sq(t) + 0.9375f) + b;
 		default:
-	        t -= 2.625f / 2.75f;
-            return c * (7.5625f * sq(t) + 0.984375f) + b;
+			t -= 2.625f / 2.75f;
+			return c * (7.5625f * sq(t) + 0.984375f) + b;
 	}
 }
 
@@ -156,44 +156,44 @@ fn float bounce_inout(float t, float b, float c, float d) @inline
 // Elastic Easing functions
 fn float elastic_in(float t, float b, float c, float d) @inline
 {
-    if (t == 0) return b;
-    t /= d;
-    if (t == 1) return b + c;
+	if (t == 0) return b;
+	t /= d;
+	if (t == 1) return b + c;
 
-    float p = d * 0.3f;
-    float a = c;
-    float s = p / 4;
-    t -= 1;
-    return -a * math::pow(2.0f, 10 * t) * math::sin((t * d - s) * (2 * (float)math::PI) / p) + b;
+	float p = d * 0.3f;
+	float a = c;
+	float s = p / 4;
+	t -= 1;
+	return -a * math::pow(2.0f, 10 * t) * math::sin((t * d - s) * (2 * (float)math::PI) / p) + b;
 }
 
 fn float elastic_out(float t, float b, float c, float d) @inline
 {
-    if (t == 0) return b;
-    t /= d;
-    if (t == 1) return b + c;
+	if (t == 0) return b;
+	t /= d;
+	if (t == 1) return b + c;
 
-    float p = d * 0.3f;
-    float a = c;
-    float s = p / 4;
+	float p = d * 0.3f;
+	float a = c;
+	float s = p / 4;
 
-    return a * math::pow(2.0f, -10 * t) * math::sin((t * d - s) * (2 * (float)math::PI) / p) + c + b;
+	return a * math::pow(2.0f, -10 * t) * math::sin((t * d - s) * (2 * (float)math::PI) / p) + c + b;
 }
 
 fn float elastic_inout(float t, float b, float c, float d) @inline
 {
-    if (t == 0) return b;
-    t /= d / 2;
-    if (t == 2) return b + c;
+	if (t == 0) return b;
+	t /= d / 2;
+	if (t == 2) return b + c;
 
-    float p = d * (0.3f * 1.5f);
-    float a = c;
-    float s = p / 4;
+	float p = d * (0.3f * 1.5f);
+	float a = c;
+	float s = p / 4;
 
-    t -= 1;
-    return t < 0
-        ? -0.5f * a * math::pow(2.0f, 10 * t) * math::sin((t * d - s) * (2 * (float)math::PI)/p) + b
-        :  a * math::pow(2.0f, -10 * t) * math::sin((t * d - s) * (2 * (float)math::PI) / p) * 0.5f + c + b;
+	t -= 1;
+	return t < 0
+		? -0.5f * a * math::pow(2.0f, 10 * t) * math::sin((t * d - s) * (2 * (float)math::PI)/p) + b
+		:  a * math::pow(2.0f, -10 * t) * math::sin((t * d - s) * (2 * (float)math::PI) / p) * 0.5f + c + b;
 }
 
 macro sq(x) @private => x * x;
diff --git a/lib/std/math/math_i128.c3 b/lib/std/math/math_i128.c3
index 4e8f56325..7dc539617 100644
--- a/lib/std/math/math_i128.c3
+++ b/lib/std/math/math_i128.c3
@@ -13,51 +13,51 @@ fn int128 __divti3(int128 a, int128 b) @extern("__divti3") @weak @nostrip
 fn uint128 __umodti3(uint128 n, uint128 d) @extern("__umodti3") @weak @nostrip
 {
 	// Ignore d = 0
-    uint128 sr = (d ? $$clz(d) : 128) - (n ? $$clz(n) : 128);
-    // If n < d then sr is wrapping.
-    // which means we can just return n.
-    if (sr > 127) return n;
-    // If d == 1 and n = MAX
-    if (sr == 127) return 0;
-    sr++;
-    uint128 r = n >> sr;
-    // Follow known algorithm:
-    n <<= 128 - sr;
-    for (uint128 carry = 0; sr > 0; sr--)
-    {
-        r = (r << 1) | (n >> 127);
-        n = (n << 1) | carry;
-        int128 sign = (int128)(d - r - 1) >> 127;
-        carry = sign & 1;
-        r -= d & sign;
-    }
-    return r;
+	uint128 sr = (d ? $$clz(d) : 128) - (n ? $$clz(n) : 128);
+	// If n < d then sr is wrapping.
+	// which means we can just return n.
+	if (sr > 127) return n;
+	// If d == 1 and n = MAX
+	if (sr == 127) return 0;
+	sr++;
+	uint128 r = n >> sr;
+	// Follow known algorithm:
+	n <<= 128 - sr;
+	for (uint128 carry = 0; sr > 0; sr--)
+	{
+		r = (r << 1) | (n >> 127);
+		n = (n << 1) | carry;
+		int128 sign = (int128)(d - r - 1) >> 127;
+		carry = sign & 1;
+		r -= d & sign;
+	}
+	return r;
 }
 
 fn uint128 __udivti3(uint128 n, uint128 d) @extern("__udivti3") @weak @nostrip
 {
 	// Ignore d = 0
-    uint128 sr = (d ? $$clz(d) : 128) - (n ? $$clz(n) : 128);
-    // If n < d then sr is wrapping.
-    // which means we can just return 0.
-    if (sr > 127) return 0;
-    // If d == 1 and n = MAX
-    if (sr == 127) return n;
-    sr++;
-    uint128 r = n >> sr;
-    // Follow known algorithm:
-    n <<= 128 - sr;
-    uint128 carry = 0;
-    for (; sr > 0; sr--)
-    {
-        r = (r << 1) | (n >> 127);
-        n = (n << 1) | carry;
-        int128 sign = (int128)(d - r - 1) >> 127;
-        carry = sign & 1;
-        r -= d & sign;
-    }
+	uint128 sr = (d ? $$clz(d) : 128) - (n ? $$clz(n) : 128);
+	// If n < d then sr is wrapping.
+	// which means we can just return 0.
+	if (sr > 127) return 0;
+	// If d == 1 and n = MAX
+	if (sr == 127) return n;
+	sr++;
+	uint128 r = n >> sr;
+	// Follow known algorithm:
+	n <<= 128 - sr;
+	uint128 carry = 0;
+	for (; sr > 0; sr--)
+	{
+		r = (r << 1) | (n >> 127);
+		n = (n << 1) | carry;
+		int128 sign = (int128)(d - r - 1) >> 127;
+		carry = sign & 1;
+		r -= d & sign;
+	}
 	n = (n << 1) | carry;
-    return n;
+	return n;
 }
 
 fn int128 __modti3(int128 a, int128 b) @extern("__modti3") @weak @nostrip
@@ -85,56 +85,56 @@ union Int128bits @private
 
 fn uint128 __lshrti3(uint128 a, uint b) @extern("__lshrti3") @weak @nostrip
 {
-    Int128bits result;
-    result.all = a;
-    if (b >= 64)
-    {
-        result.ulow = result.uhigh >> (b - 64);
-        result.uhigh = 0;
-    }
-    else
-    {
-        if (b == 0) return a;
-        result.ulow = (result.uhigh << (64 - b)) | (result.ulow >> b);
-        result.uhigh  = result.uhigh >> b;
-    }
-    return result.all;
+	Int128bits result;
+	result.all = a;
+	if (b >= 64)
+	{
+		result.ulow = result.uhigh >> (b - 64);
+		result.uhigh = 0;
+	}
+	else
+	{
+		if (b == 0) return a;
+		result.ulow = (result.uhigh << (64 - b)) | (result.ulow >> b);
+		result.uhigh  = result.uhigh >> b;
+	}
+	return result.all;
 }
 
 fn int128 __ashrti3(int128 a, uint b) @extern("__ashrti3") @weak @nostrip
 {
-    Int128bits result;
-    result.all = a;
-    if (b >= 64)
-    {
-        result.ilow = result.ihigh >> (b - 64);
-        result.ihigh = result.ihigh >> 63;
-    }
-    else
-    {
-        if (b == 0) return a;
-        result.ilow = result.ihigh << (64 - b) | (result.ilow >> b);
-        result.ihigh  = result.ihigh >> b;
-    }
-    return result.all;
+	Int128bits result;
+	result.all = a;
+	if (b >= 64)
+	{
+		result.ilow = result.ihigh >> (b - 64);
+		result.ihigh = result.ihigh >> 63;
+	}
+	else
+	{
+		if (b == 0) return a;
+		result.ilow = result.ihigh << (64 - b) | (result.ilow >> b);
+		result.ihigh  = result.ihigh >> b;
+	}
+	return result.all;
 }
 
 fn int128 __ashlti3(int128 a, uint b) @extern("__ashlti3") @weak @nostrip
 {
-    Int128bits result;
-    result.all = a;
-    if (b >= 64)
-    {
-        result.ulow = 0;
-        result.uhigh = result.ulow << (b - 64);
-    }
-    else
-    {
-        if (b == 0) return a;
-        result.uhigh = (result.uhigh << b) | (result.ulow >> (64 - b));
-        result.ulow  = result.ulow << b;
-    }
-    return result.all;
+	Int128bits result;
+	result.all = a;
+	if (b >= 64)
+	{
+		result.ulow = 0;
+		result.uhigh = result.ulow << (b - 64);
+	}
+	else
+	{
+		if (b == 0) return a;
+		result.uhigh = (result.uhigh << b) | (result.ulow >> (64 - b));
+		result.ulow  = result.ulow << b;
+	}
+	return result.all;
 }
 
 // Returns: a * b
@@ -143,7 +143,7 @@ fn int128 __mulddi3(ulong a, ulong b) @private
 {
 	Int128bits r;
 	const ulong LOWER_MASK = 0xffff_ffff;
-    r.ulow = (a & LOWER_MASK) * (b & LOWER_MASK);
+	r.ulow = (a & LOWER_MASK) * (b & LOWER_MASK);
 	ulong t = r.ulow >> 32;
 	r.ulow &= LOWER_MASK;
 	t += (a >> 32) * (b & LOWER_MASK);
@@ -204,36 +204,36 @@ macro float_from_i128($Type, a) @private
 	$endswitch
 	if (a == 0) return ($Type)0;
 	// Grab and remove sign.
-    int128 sign = a >> 127;
-    a = (a ^ sign) - sign;
+	int128 sign = a >> 127;
+	a = (a ^ sign) - sign;
 	int sd = 128 - (int)$$clz(a); // digits
 	int e = sd - 1; // exponent
 	if (sd > MANT_DIG)
 	{
-	    switch (sd)
-	    {
-            case MANT_DIG + 1:
-                a <<= 1;
-            case MANT_DIG + 2:
-                break;
-            default:
-                a = (a >> (sd - (MANT_DIG + 2)))
-                    | (uint128)((a & ((uint128)(-1) >> ((128 + MANT_DIG + 2) - sd))) != 0);
-        }
+		switch (sd)
+		{
+			case MANT_DIG + 1:
+				a <<= 1;
+			case MANT_DIG + 2:
+				break;
+			default:
+				a = (a >> (sd - (MANT_DIG + 2)))
+					| (uint128)((a & ((uint128)(-1) >> ((128 + MANT_DIG + 2) - sd))) != 0);
+		}
 		a |= (uint128)((a & 4) != 0);
-        a++;
-        a >>= 2;
-        if (a & (1i128 << MANT_DIG))
-        {
-            a >>= 1;
-            e++;
-        }
-    }
-    else
-    {
-        a <<= (MANT_DIG - sd);
-    }
-    return bitcast((($Rep)sign & SIGN_BIT) | ((($Rep)e + ($Rep)EXP_BIAS) << SIGNIFICANT_BITS) | (($Rep)a & ($Rep)MANTISSA_MASK), $Type);
+		a++;
+		a >>= 2;
+		if (a & (1i128 << MANT_DIG))
+		{
+			a >>= 1;
+			e++;
+		}
+	}
+	else
+	{
+		a <<= (MANT_DIG - sd);
+	}
+	return bitcast((($Rep)sign & SIGN_BIT) | ((($Rep)e + ($Rep)EXP_BIAS) << SIGNIFICANT_BITS) | (($Rep)a & ($Rep)MANTISSA_MASK), $Type);
 }
 
 macro float_from_u128($Type, a) @private
@@ -264,30 +264,30 @@ macro float_from_u128($Type, a) @private
 	int e = sd - 1; // exponent
 	if (sd > MANT_DIG)
 	{
-	    switch (sd)
-	    {
-            case MANT_DIG + 1:
-                a <<= 1;
-            case MANT_DIG + 2:
-                break;
-            default:
-                a = (a >> (sd - (MANT_DIG + 2)))
-                    | (uint128)((a & ((uint128)(-1) >> ((128 + MANT_DIG + 2) - sd))) != 0);
-        }
+		switch (sd)
+		{
+			case MANT_DIG + 1:
+				a <<= 1;
+			case MANT_DIG + 2:
+				break;
+			default:
+				a = (a >> (sd - (MANT_DIG + 2)))
+					| (uint128)((a & ((uint128)(-1) >> ((128 + MANT_DIG + 2) - sd))) != 0);
+		}
 		a |= (uint128)((a & 4) != 0);
-        a++;
-        a >>= 2;
-        if (a & (1i128 << MANT_DIG))
-        {
-            a >>= 1;
-            e++;
-        }
-    }
-    else
-    {
-        a <<= (MANT_DIG - sd);
-    }
-    return bitcast(((($Rep)e + ($Rep)EXP_BIAS) << SIGNIFICANT_BITS) | (($Rep)a & ($Rep)MANTISSA_MASK), $Type);
+		a++;
+		a >>= 2;
+		if (a & (1i128 << MANT_DIG))
+		{
+			a >>= 1;
+			e++;
+		}
+	}
+	else
+	{
+		a <<= (MANT_DIG - sd);
+	}
+	return bitcast(((($Rep)e + ($Rep)EXP_BIAS) << SIGNIFICANT_BITS) | (($Rep)a & ($Rep)MANTISSA_MASK), $Type);
 }
 
 
@@ -332,7 +332,7 @@ macro fixuint(a) @private
 	if (sign == -1 || exponent < 0) return 0u128;
 	if ((uint)exponent >= uint128.sizeof * 8) return ~0u128;
 	if (exponent < SIGNIFICANT_BITS) return (uint128)significand >> (SIGNIFICANT_BITS - exponent);
-    return (uint128)significand << (exponent - SIGNIFICANT_BITS);
+	return (uint128)significand << (exponent - SIGNIFICANT_BITS);
 }
 
 macro fixint(a) @private
@@ -377,5 +377,5 @@ macro fixint(a) @private
 	if ((uint)exponent >= uint128.sizeof * 8) return sign == 1 ? int128.max : int128.min;
 
 	if (exponent < SIGNIFICANT_BITS) return sign * ((int128)significand >> (SIGNIFICANT_BITS - exponent));
-    return sign * ((int128)significand << (exponent - SIGNIFICANT_BITS));
+	return sign * ((int128)significand << (exponent - SIGNIFICANT_BITS));
 }
diff --git a/lib/std/math/math_quaternion.c3 b/lib/std/math/math_quaternion.c3
index 2e3d0735c..68257294d 100644
--- a/lib/std/math/math_quaternion.c3
+++ b/lib/std/math/math_quaternion.c3
@@ -3,9 +3,9 @@ import std::math::vector;
 union Quaternion
 {
 	struct
-    {
-    	Real i, j, k, l;
-    }
+	{
+		Real i, j, k, l;
+	}
 	Real[<4>] v;
 }
 
@@ -26,22 +26,22 @@ fn Quaternion Quaternion.invert(q)
 {
 	Real length_sq = q.v.dot(q.v);
 	if (length_sq <= 0) return q;
-    Real inv_length = 1 / length_sq;
+	Real inv_length = 1 / length_sq;
 	return { q.v[0] * -inv_length, q.v[1] * -inv_length, q.v[2] * -inv_length, q.v[3] * inv_length };
 }
 
 fn Quaternion Quaternion.slerp(q1, Quaternion q2, Real amount)
 {
-    Quaternion result = {};
+	Quaternion result = {};
 
 	Real[<4>] q2v = q2.v;
-    Real cos_half_theta = q1.v.dot(q2v);
+	Real cos_half_theta = q1.v.dot(q2v);
 
-    if (cos_half_theta < 0)
-    {
-        q2v = -q2v;
-        cos_half_theta = -cos_half_theta;
-    }
+	if (cos_half_theta < 0)
+	{
+		q2v = -q2v;
+		cos_half_theta = -cos_half_theta;
+	}
 
 	if (cos_half_theta >= 1) return q1;
 
@@ -54,45 +54,45 @@ fn Quaternion Quaternion.slerp(q1, Quaternion q2, Real amount)
 	{
 		return { .v = (q1v + q2v) * 0.5f };
 	}
-    Real ratio_a = math::sin((1 - amount) * half_theta) / sin_half_theta;
-    Real ratio_b = math::sin(amount * half_theta) / sin_half_theta;
+	Real ratio_a = math::sin((1 - amount) * half_theta) / sin_half_theta;
+	Real ratio_b = math::sin(amount * half_theta) / sin_half_theta;
 	return { .v = q1v * ratio_a + q2v * ratio_b };
 }
 
 fn Quaternion Quaternion.mul(a, Quaternion b)
 {
 	return { a.i * b.l + a.l * b.i + a.j * b.k - a.k * b.j,
-	         a.j * b.l + a.l * b.j + a.k * b.i - a.i * b.k,
-	         a.k * b.l + a.l * b.k + a.i * b.j - a.j * b.i,
-	         a.l * b.l - a.i * b.i - a.j * a.j - a.k * a.k };
+			 a.j * b.l + a.l * b.j + a.k * b.i - a.i * b.k,
+			 a.k * b.l + a.l * b.k + a.i * b.j - a.j * b.i,
+			 a.l * b.l - a.i * b.i - a.j * a.j - a.k * a.k };
 }
 
 macro into_matrix(Quaternion* q, $Type) @private
 {
-    $Type result = { .m = { [0] = 1, [5] = 1, [10] = 1, [15] = 1 } };
-    Quaternion norm = q.normalize();
+	$Type result = { .m = { [0] = 1, [5] = 1, [10] = 1, [15] = 1 } };
+	Quaternion norm = q.normalize();
 
-    var ii = norm.i*norm.i;
-    var jj = norm.j*norm.j;
-    var kk = norm.k*norm.k;
-    var ik = norm.i*norm.k;
-    var ij = norm.i*q.j;
-    var jk = norm.j*norm.k;
-    var li = norm.l*norm.i;
-    var lj = norm.l*norm.j;
-    var lk = norm.l*norm.k;
+	var ii = norm.i*norm.i;
+	var jj = norm.j*norm.j;
+	var kk = norm.k*norm.k;
+	var ik = norm.i*norm.k;
+	var ij = norm.i*q.j;
+	var jk = norm.j*norm.k;
+	var li = norm.l*norm.i;
+	var lj = norm.l*norm.j;
+	var lk = norm.l*norm.k;
 
 	result.m00 = 1 - 2*(jj + kk);
-    result.m01 = 2*(ik + lk);
-    result.m02 = 2*(ij - lj);
+	result.m01 = 2*(ik + lk);
+	result.m02 = 2*(ij - lj);
 
-    result.m10 = 2*(ij - lk);
-    result.m11 = 1 - 2*(ii + kk);
-    result.m12 = 2*(jk + li);
+	result.m10 = 2*(ij - lk);
+	result.m11 = 1 - 2*(ii + kk);
+	result.m12 = 2*(jk + li);
 
-    result.m20 = 2*(ik + lj);
-    result.m21 = 2*(jk - li);
-    result.m22 = 1 - 2*(ii + jj);
+	result.m20 = 2*(ik + lj);
+	result.m21 = 2*(jk - li);
+	result.m22 = 1 - 2*(ii + jj);
 
-    return result;
+	return result;
 }
\ No newline at end of file
diff --git a/lib/std/math/math_vector.c3 b/lib/std/math/math_vector.c3
index cac87c541..b9dfef8d7 100644
--- a/lib/std/math/math_vector.c3
+++ b/lib/std/math/math_vector.c3
@@ -81,11 +81,11 @@ fn Vec3 Vec3.unproject(self, Matrix4 projection, Matrix4 view) => unproject3(sel
 macro towards(v, target, max_distance) @private
 {
 	var delta = target - v;
-    var square = delta.length_sq();
+	var square = delta.length_sq();
 
-    if (square == 0 || (max_distance >= 0 && (square <= max_distance * max_distance))) return target;
+	if (square == 0 || (max_distance >= 0 && (square <= max_distance * max_distance))) return target;
 
-    var dist = math::sqrt(square);
+	var dist = math::sqrt(square);
 
 	return v + delta * max_distance / dist;
 }
@@ -93,13 +93,13 @@ macro towards(v, target, max_distance) @private
 macro clamp_magnitude(v, min, max) @private
 {
 	var length = v.dot(v);
-    if (length > 0)
-    {
-        length = math::sqrt(length);
+	if (length > 0)
+	{
+		length = math::sqrt(length);
 
-        if (length < min) return v * (min / length);
-        if (length > max) return v * (max / length);
-    }
+		if (length < min) return v * (min / length);
+		if (length > max) return v * (max / length);
+	}
 	return v;
 }
 
@@ -112,19 +112,19 @@ macro rotate(v, angle) @private
 
 macro perpendicular3(v) @private
 {
-    var min = math::abs(v[0]);
-    $typeof(v) cardinal_axis = { 1, 0, 0 };
+	var min = math::abs(v[0]);
+	$typeof(v) cardinal_axis = { 1, 0, 0 };
 
-    if (var vy = math::abs(v[1]), vy < min)
-    {
-        min = vy;
-        cardinal_axis = { 0, 1, 0 };
-    }
+	if (var vy = math::abs(v[1]), vy < min)
+	{
+		min = vy;
+		cardinal_axis = { 0, 1, 0 };
+	}
 
-    if (var vz = math::abs(v[2]), vz < min)
-    {
-        cardinal_axis = { 0, 0, 1 };
-    }
+	if (var vz = math::abs(v[2]), vz < min)
+	{
+		cardinal_axis = { 0, 0, 1 };
+	}
 
 	return cross3(v, cardinal_axis);
 }
@@ -145,19 +145,19 @@ macro transform2(v, mat) @private
 
 macro transform3(v, mat) @private
 {
-    return $typeof(v) {
-        mat.m00 * v[0] + mat.m10 * v[1] + mat.m20 * v[2] + mat.m30,
-        mat.m01 * v[0] + mat.m11 * v[1] + mat.m21 * v[2] + mat.m31,
-        mat.m02 * v[0] + mat.m12 * v[1] + mat.m22 * v[2] + mat.m32
-    };
+	return $typeof(v) {
+		mat.m00 * v[0] + mat.m10 * v[1] + mat.m20 * v[2] + mat.m30,
+		mat.m01 * v[0] + mat.m11 * v[1] + mat.m21 * v[2] + mat.m31,
+		mat.m02 * v[0] + mat.m12 * v[1] + mat.m22 * v[2] + mat.m32
+	};
 }
 
 
 macro angle3(v1, v2) @private
 {
 	var len = v1.cross(v2).length();
-    var dot = v1.dot(v2);
-    return math::atan2(len, dot);
+	var dot = v1.dot(v2);
+	return math::atan2(len, dot);
 }
 
 macro void ortho_normalize3(v1, v2) @private
@@ -184,10 +184,10 @@ macro rotate_by_quat3(v, q) @private
 
 macro rotate_axis_angle(v, axis, angle) @private
 {
-    axis = axis.normalize();
+	axis = axis.normalize();
 
-    angle /= 2;
-    var w = axis * math::sin(angle);
+	angle /= 2;
+	var w = axis * math::sin(angle);
 	var wv = w.cross(v);
 	var wwv = w.cross(wv);
 	wv *= math::cos(angle) * 2;
@@ -198,7 +198,7 @@ macro rotate_axis_angle(v, axis, angle) @private
 
 macro matrix_look_at($Type, eye, target, up) @private
 {
-    var vz = (eye - target).normalize();
+	var vz = (eye - target).normalize();
 	var vx = up.cross(vz).normalize();
 	var vy = vz.cross(vx);
 
@@ -216,22 +216,22 @@ return v;
 /*
 	var view_proj = m1.mul(m2);
 	var invert = view_proj.invert();
-    // Create quaternion from source point
+	// Create quaternion from source point
 	$if $typeof(v[0]).typeid == float.typeid:
-	    Quaternionf quat = { v.x, v.y, v.z, 1 };
+		Quaternionf quat = { v.x, v.y, v.z, 1 };
 	$else
-	    Quaternion quat = { v.x, v.y, v.z, 1 };
+		Quaternion quat = { v.x, v.y, v.z, 1 };
 	$endif
 
-    // Multiply quat point by unproject matrix
-    var qtransformed = quat.transform(invert);
+	// Multiply quat point by unproject matrix
+	var qtransformed = quat.transform(invert);
 
-    // Normalized world points in vectors
-    return {
-        qtransformed.i / qtransformed.l,
-        qtransformed.j / qtransformed.l,
-        qtransformed.k  / qtransformed.l
-    };*/
+	// Normalized world points in vectors
+	return {
+		qtransformed.i / qtransformed.l,
+		qtransformed.j / qtransformed.l,
+		qtransformed.k  / qtransformed.l
+	};*/
 }
 
 macro barycenter3(p, a, b, c) @private
@@ -252,8 +252,8 @@ macro barycenter3(p, a, b, c) @private
 
 macro refract3(v, n, r) @private
 {
-    var dot = v.dot(n);
-    var d = 1 - r * r * (1 - dot * dot);
+	var dot = v.dot(n);
+	var d = 1 - r * r * (1 - dot * dot);
 
-    return d < 0 ? v : r * v - (r * dot + math::sqrt(d)) * n;
+	return d < 0 ? v : r * v - (r * dot + math::sqrt(d)) * n;
 }
\ No newline at end of file
diff --git a/lib/std/math/random/math.lcg.c3 b/lib/std/math/random/math.lcg.c3
index bab5a5d34..f8ee59449 100644
--- a/lib/std/math/random/math.lcg.c3
+++ b/lib/std/math/random/math.lcg.c3
@@ -18,15 +18,15 @@ def Lcg128_64 = distinct uint128;
 
 fn void Lcg128_64.seed(&lcg, char[16] seed)
 {
-    *lcg = bitcast(seed, Lcg128_64);
+	*lcg = bitcast(seed, Lcg128_64);
 }
 
 fn ulong Lcg128_64.next(&lcg)
 {
-    uint128* s = (uint128*)lcg;
-    ulong result = (ulong)(*s >> 64);
-    *s = *s * MUL_LCG128 + ODD_PHI128;
-    return result;
+	uint128* s = (uint128*)lcg;
+	ulong result = (ulong)(*s >> 64);
+	*s = *s * MUL_LCG128 + ODD_PHI128;
+	return result;
 }
 
 
@@ -36,15 +36,15 @@ def Lcg64_32 = distinct ulong;
 
 fn void Lcg64_32.seed(&lcg, char[8] seed)
 {
-    *lcg = bitcast(seed, Lcg64_32);
+	*lcg = bitcast(seed, Lcg64_32);
 }
 
 fn uint Lcg64_32.next(&lcg)
 {
-    ulong* s = (ulong*)lcg;
-    uint result = (uint)(*s >> 32);
-    *s = *s * MUL_LCG64 + ODD_PHI64;
-    return result;
+	ulong* s = (ulong*)lcg;
+	uint result = (uint)(*s >> 32);
+	*s = *s * MUL_LCG64 + ODD_PHI64;
+	return result;
 }
 
 
@@ -54,15 +54,15 @@ def Lcg32_16 = distinct uint;
 
 fn void Lcg32_16.seed(&lcg, char[4] seed)
 {
-    *lcg = bitcast(seed, Lcg32_16);
+	*lcg = bitcast(seed, Lcg32_16);
 }
 
 fn ushort Lcg32_16.next(&lcg)
 {
-    uint* s = (uint*)lcg;
-    ushort result = (ushort)(*s >> 16);
-    *s = *s * MUL_LCG32 + ODD_PHI32;
-    return result;
+	uint* s = (uint*)lcg;
+	ushort result = (ushort)(*s >> 16);
+	*s = *s * MUL_LCG32 + ODD_PHI32;
+	return result;
 }
 
 
@@ -72,13 +72,13 @@ def Lcg16_8 = distinct ushort;
 
 fn void Lcg16_8.seed(&lcg, char[2] seed)
 {
-    *lcg = bitcast(seed, Lcg16_8);
+	*lcg = bitcast(seed, Lcg16_8);
 }
 
 fn char Lcg16_8.next(&lcg)
 {
-    ushort* s = (ushort*)lcg;
-    char result = (char)(*s >> 8);
-    *s = *s * MUL_LCG16 + ODD_PHI16;
-    return result;
+	ushort* s = (ushort*)lcg;
+	char result = (char)(*s >> 8);
+	*s = *s * MUL_LCG16 + ODD_PHI16;
+	return result;
 }
diff --git a/lib/std/math/random/math.mcg.c3 b/lib/std/math/random/math.mcg.c3
index 82fc271c4..26f786247 100644
--- a/lib/std/math/random/math.mcg.c3
+++ b/lib/std/math/random/math.mcg.c3
@@ -11,15 +11,15 @@ def Mcg128_64 = distinct uint128;
 
 fn void Mcg128_64.seed(&mcg, char[16] seed)
 {
-    *mcg = bitcast(seed, Mcg128_64) | 1;
+	*mcg = bitcast(seed, Mcg128_64) | 1;
 }
 
 fn ulong Mcg128_64.next(&mcg)
 {
-    uint128* s = (uint128*)mcg;
-    ulong result = (ulong)(*s >> 64);
-    *s *= MUL_MCG128;
-    return result;
+	uint128* s = (uint128*)mcg;
+	ulong result = (ulong)(*s >> 64);
+	*s *= MUL_MCG128;
+	return result;
 }
 
 
@@ -29,15 +29,15 @@ def Mcg64_32 = distinct ulong;
 
 fn void Mcg64_32.seed(&mcg, char[8] seed)
 {
-    *mcg = bitcast(seed, Mcg64_32) | 1;
+	*mcg = bitcast(seed, Mcg64_32) | 1;
 }
 
 fn uint Mcg64_32.next(&mcg)
 {
-    ulong* s = (ulong*)mcg;
-    uint result = (uint)(*s >> 32);
-    *s *= MUL_MCG64;
-    return result;
+	ulong* s = (ulong*)mcg;
+	uint result = (uint)(*s >> 32);
+	*s *= MUL_MCG64;
+	return result;
 }
 
 
@@ -47,15 +47,15 @@ def Mcg32_16 = distinct uint;
 
 fn void Mcg32_16.seed(&mcg, char[4] seed)
 {
-    *mcg = bitcast(seed, Mcg32_16) | 1;
+	*mcg = bitcast(seed, Mcg32_16) | 1;
 }
 
 fn ushort Mcg32_16.next(&mcg)
 {
-    uint* s = (uint*)mcg;
-    ushort result = (ushort)(*s >> 16);
-    *s *= MUL_MCG32;
-    return result;
+	uint* s = (uint*)mcg;
+	ushort result = (ushort)(*s >> 16);
+	*s *= MUL_MCG32;
+	return result;
 }
 
 
@@ -65,13 +65,13 @@ def Mcg16_8 = distinct ushort;
 
 fn void Mcg16_8.seed(&mcg, char[2] seed)
 {
-    *mcg = bitcast(seed, Mcg16_8) | 1;
+	*mcg = bitcast(seed, Mcg16_8) | 1;
 }
 
 fn char Mcg16_8.next(&mcg)
 {
-    ushort* s = (ushort*)mcg;
-    char result = (char)(*s >> 8);
-    *s *= MUL_MCG16;
-    return result;
+	ushort* s = (ushort*)mcg;
+	char result = (char)(*s >> 8);
+	*s *= MUL_MCG16;
+	return result;
 }
diff --git a/lib/std/math/random/math.msws.c3 b/lib/std/math/random/math.msws.c3
index 7eff36890..b1bf35201 100644
--- a/lib/std/math/random/math.msws.c3
+++ b/lib/std/math/random/math.msws.c3
@@ -11,138 +11,138 @@ const ODD_PHI8 @local = 0x9f;
 // -------------------------------- Msws128 --------------------------------
 
 struct Msws128 {
-    uint128 state0, state1;
-    uint128 weyl0, weyl1;
+	uint128 state0, state1;
+	uint128 weyl0, weyl1;
 }
 
 fn void Msws128.seed(&msws, char[16 * 4] seed)
 {
-    *msws = bitcast(seed, Msws128);
+	*msws = bitcast(seed, Msws128);
 }
 
 fn uint128 Msws128.next(&msws)
 {
-    uint128 s0 = msws.state0;
-    msws.state0 = msws.state0 * msws.state0 + msws.weyl0;
-    msws.state0 = msws.state0.rotr(64);
-    msws.weyl0 += ODD_PHI128;
+	uint128 s0 = msws.state0;
+	msws.state0 = msws.state0 * msws.state0 + msws.weyl0;
+	msws.state0 = msws.state0.rotr(64);
+	msws.weyl0 += ODD_PHI128;
 
-    msws.state1 = msws.state1 * msws.state1 + msws.weyl1;
-    uint128 s1 = msws.state1;
-    msws.state1 = msws.state1.rotr(64);
-    msws.weyl1 -= ODD_PHI128;
+	msws.state1 = msws.state1 * msws.state1 + msws.weyl1;
+	uint128 s1 = msws.state1;
+	msws.state1 = msws.state1.rotr(64);
+	msws.weyl1 -= ODD_PHI128;
 
-    return s0 + s1;
+	return s0 + s1;
 }
 
 
 // -------------------------------- Msws64 --------------------------------
 
 struct Msws64 {
-    ulong state0, state1;
-    ulong weyl0, weyl1;
+	ulong state0, state1;
+	ulong weyl0, weyl1;
 }
 
 fn void Msws64.seed(&msws, char[8 * 4] seed)
 {
-    *msws = bitcast(seed, Msws64);
+	*msws = bitcast(seed, Msws64);
 }
 
 fn ulong Msws64.next(&msws)
 {
-    ulong s0 = msws.state0;
-    msws.state0 = msws.state0 * msws.state0 + msws.weyl0;
-    msws.state0 = msws.state0.rotr(32);
-    msws.weyl0 += ODD_PHI64;
+	ulong s0 = msws.state0;
+	msws.state0 = msws.state0 * msws.state0 + msws.weyl0;
+	msws.state0 = msws.state0.rotr(32);
+	msws.weyl0 += ODD_PHI64;
 
-    msws.state1 = msws.state1 * msws.state1 + msws.weyl1;
-    ulong s1 = msws.state1;
-    msws.state1 = msws.state1.rotr(32);
-    msws.weyl1 -= ODD_PHI64;
+	msws.state1 = msws.state1 * msws.state1 + msws.weyl1;
+	ulong s1 = msws.state1;
+	msws.state1 = msws.state1.rotr(32);
+	msws.weyl1 -= ODD_PHI64;
 
-    return s0 + s1;
+	return s0 + s1;
 }
 
 
 // -------------------------------- Msws32 --------------------------------
 
 struct Msws32 {
-    uint state0, state1;
-    uint weyl0, weyl1;
+	uint state0, state1;
+	uint weyl0, weyl1;
 }
 
 fn void Msws32.seed(&msws, char[4 * 4] seed)
 {
-    *msws = bitcast(seed, Msws32);
+	*msws = bitcast(seed, Msws32);
 }
 
 fn uint Msws32.next(&msws)
 {
-    uint s0 = msws.state0;
-    msws.state0 = msws.state0 * msws.state0 + msws.weyl0;
-    msws.state0 = msws.state0.rotr(16);
-    msws.weyl0 += ODD_PHI32;
+	uint s0 = msws.state0;
+	msws.state0 = msws.state0 * msws.state0 + msws.weyl0;
+	msws.state0 = msws.state0.rotr(16);
+	msws.weyl0 += ODD_PHI32;
 
-    msws.state1 = msws.state1 * msws.state1 + msws.weyl1;
-    uint s1 = msws.state1;
-    msws.state1 = msws.state1.rotr(16);
-    msws.weyl1 -= ODD_PHI32;
+	msws.state1 = msws.state1 * msws.state1 + msws.weyl1;
+	uint s1 = msws.state1;
+	msws.state1 = msws.state1.rotr(16);
+	msws.weyl1 -= ODD_PHI32;
 
-    return s0 + s1;
+	return s0 + s1;
 }
 
 
 // -------------------------------- Msws16 --------------------------------
 
 struct Msws16 {
-    ushort state0, state1;
-    ushort weyl0, weyl1;
+	ushort state0, state1;
+	ushort weyl0, weyl1;
 }
 
 fn void Msws16.seed(&msws, char[2 * 4] seed)
 {
-    *msws = bitcast(seed, Msws16);
+	*msws = bitcast(seed, Msws16);
 }
 
 fn ushort Msws16.next(&msws)
 {
-    ushort s0 = msws.state0;
-    msws.state0 = msws.state0 * msws.state0 + msws.weyl0;
-    msws.state0 = msws.state0.rotr(8);
-    msws.weyl0 += ODD_PHI16;
+	ushort s0 = msws.state0;
+	msws.state0 = msws.state0 * msws.state0 + msws.weyl0;
+	msws.state0 = msws.state0.rotr(8);
+	msws.weyl0 += ODD_PHI16;
 
-    msws.state1 = msws.state1 * msws.state1 + msws.weyl1;
-    ushort s1 = msws.state1;
-    msws.state1 = msws.state1.rotr(8);
-    msws.weyl1 -= ODD_PHI16;
+	msws.state1 = msws.state1 * msws.state1 + msws.weyl1;
+	ushort s1 = msws.state1;
+	msws.state1 = msws.state1.rotr(8);
+	msws.weyl1 -= ODD_PHI16;
 
-    return s0 + s1;
+	return s0 + s1;
 }
 
 
 // -------------------------------- Msws8 --------------------------------
 
 struct Msws8 {
-    char state0, state1;
-    char weyl0, weyl1;
+	char state0, state1;
+	char weyl0, weyl1;
 }
 
 fn void Msws8.seed(&msws, char[1 * 4] seed)
 {
-    *msws = bitcast(seed, Msws8);
+	*msws = bitcast(seed, Msws8);
 }
 
 fn char Msws8.next(&msws)
 {
-    char s0 = msws.state0;
-    msws.state0 = msws.state0 * msws.state0 + msws.weyl0;
-    msws.state0 = msws.state0.rotr(4);
-    msws.weyl0 += ODD_PHI8;
+	char s0 = msws.state0;
+	msws.state0 = msws.state0 * msws.state0 + msws.weyl0;
+	msws.state0 = msws.state0.rotr(4);
+	msws.weyl0 += ODD_PHI8;
 
-    msws.state1 = msws.state1 * msws.state1 + msws.weyl1;
-    char s1 = msws.state1;
-    msws.state1 = msws.state1.rotr(4);
-    msws.weyl1 -= ODD_PHI8;
+	msws.state1 = msws.state1 * msws.state1 + msws.weyl1;
+	char s1 = msws.state1;
+	msws.state1 = msws.state1.rotr(4);
+	msws.weyl1 -= ODD_PHI8;
 
-    return s0 + s1;
+	return s0 + s1;
 }
diff --git a/lib/std/math/random/math.pcg.c3 b/lib/std/math/random/math.pcg.c3
index dabc37a9e..5d4de759f 100644
--- a/lib/std/math/random/math.pcg.c3
+++ b/lib/std/math/random/math.pcg.c3
@@ -18,17 +18,17 @@ def Pcg128_64 = distinct uint128;
 
 fn void Pcg128_64.seed(&pcg, char[16] seed)
 {
-    *pcg = bitcast(seed, Pcg128_64);
+	*pcg = bitcast(seed, Pcg128_64);
 }
 
 fn ulong Pcg128_64.next(&pcg)
 {
-    const ROT_SHIFT = 64 - 6;
-    uint128* s = (uint128*)pcg;
-    uint128 xor = *s ^ *s >> ((128 - ROT_SHIFT) / 2);
-    char rot = (char)(*s >> (128 - 6));
-    *s = *s * MUL_LCG128 + ODD_PHI128;
-    return ((ulong)(xor >> ROT_SHIFT)).rotr(rot);
+	const ROT_SHIFT = 64 - 6;
+	uint128* s = (uint128*)pcg;
+	uint128 xor = *s ^ *s >> ((128 - ROT_SHIFT) / 2);
+	char rot = (char)(*s >> (128 - 6));
+	*s = *s * MUL_LCG128 + ODD_PHI128;
+	return ((ulong)(xor >> ROT_SHIFT)).rotr(rot);
 }
 
 
@@ -38,17 +38,17 @@ def Pcg64_32 = distinct ulong;
 
 fn void Pcg64_32.seed(&pcg, char[8] seed)
 {
-    *pcg = bitcast(seed, Pcg64_32);
+	*pcg = bitcast(seed, Pcg64_32);
 }
 
 fn uint Pcg64_32.next(&pcg)
 {
-    const ROT_SHIFT = 32 - 5;
-    ulong* s = (ulong*)pcg;
-    ulong xor = *s ^ *s >> ((64 - ROT_SHIFT) / 2);
-    char rot = (char)(*s >> (64 - 5));
-    *s = *s * MUL_LCG64 + ODD_PHI64;
-    return ((uint)(xor >> ROT_SHIFT)).rotr(rot);
+	const ROT_SHIFT = 32 - 5;
+	ulong* s = (ulong*)pcg;
+	ulong xor = *s ^ *s >> ((64 - ROT_SHIFT) / 2);
+	char rot = (char)(*s >> (64 - 5));
+	*s = *s * MUL_LCG64 + ODD_PHI64;
+	return ((uint)(xor >> ROT_SHIFT)).rotr(rot);
 }
 
 
@@ -58,17 +58,17 @@ def Pcg32_16 = distinct uint;
 
 fn void Pcg32_16.seed(&pcg, char[4] seed)
 {
-    *pcg = bitcast(seed, Pcg32_16);
+	*pcg = bitcast(seed, Pcg32_16);
 }
 
 fn ushort Pcg32_16.next(&pcg)
 {
-    const ROT_SHIFT = 16 - 4;
-    uint* s = (uint*)pcg;
-    uint xor = *s ^ *s >> ((32 - ROT_SHIFT) / 2);
-    char rot = (char)(*s >> (32 - 4));
-    *s = *s * MUL_LCG32 + ODD_PHI32;
-    return ((ushort)(xor >> ROT_SHIFT)).rotr(rot);
+	const ROT_SHIFT = 16 - 4;
+	uint* s = (uint*)pcg;
+	uint xor = *s ^ *s >> ((32 - ROT_SHIFT) / 2);
+	char rot = (char)(*s >> (32 - 4));
+	*s = *s * MUL_LCG32 + ODD_PHI32;
+	return ((ushort)(xor >> ROT_SHIFT)).rotr(rot);
 }
 
 
@@ -78,15 +78,15 @@ def Pcg16_8 = distinct ushort;
 
 fn void Pcg16_8.seed(&pcg, char[2] seed)
 {
-    *pcg = bitcast(seed, Pcg16_8);
+	*pcg = bitcast(seed, Pcg16_8);
 }
 
 fn char Pcg16_8.next(&pcg)
 {
-    const ROT_SHIFT = 8 - 3;
-    ushort* s = (ushort*)pcg;
-    ushort xor = *s ^ *s >> ((16 - ROT_SHIFT) / 2);
-    char rot = (char)(*s >> (16 - 3));
-    *s = *s * MUL_LCG16 + ODD_PHI16;
-    return ((char)(xor >> ROT_SHIFT)).rotr(rot);
+	const ROT_SHIFT = 8 - 3;
+	ushort* s = (ushort*)pcg;
+	ushort xor = *s ^ *s >> ((16 - ROT_SHIFT) / 2);
+	char rot = (char)(*s >> (16 - 3));
+	*s = *s * MUL_LCG16 + ODD_PHI16;
+	return ((char)(xor >> ROT_SHIFT)).rotr(rot);
 }
diff --git a/lib/std/math/random/math.seeder.c3 b/lib/std/math/random/math.seeder.c3
index 5d326bed8..e72ecfba3 100644
--- a/lib/std/math/random/math.seeder.c3
+++ b/lib/std/math/random/math.seeder.c3
@@ -7,47 +7,47 @@ const MUL_LCG64 @local = 0xd1342543de82ef95;
 // TODO: Make endian independent
 fn char[] seeder(usz outChars, char[] input)
 {
-    $if env::BIG_ENDIAN:
-        $echo("Please note that the seeding function behaves differently on BE architectures.");
-    $endif
+	$if env::BIG_ENDIAN:
+		$echo("Please note that the seeding function behaves differently on BE architectures.");
+	$endif
 
-    // Init words
-    ulong[] words = malloc(ulong, (outChars + 7) / 8);
-    words[..] = ODD_PHI64;
+	// Init words
+	ulong[] words = malloc(ulong, (outChars + 7) / 8);
+	words[..] = ODD_PHI64;
 
-    // Add word at a time
-    for (usz i = 0; i <= input.len / 8; i++)
-    {
-        usz j = i % words.len;
-        words[j] -= bitcast(*(char[8]*)&input[i * 8], ulong) * MUL_LCG64;
-        words[j] ^= words[j] >> 25;
-    }
+	// Add word at a time
+	for (usz i = 0; i <= input.len / 8; i++)
+	{
+		usz j = i % words.len;
+		words[j] -= bitcast(*(char[8]*)&input[i * 8], ulong) * MUL_LCG64;
+		words[j] ^= words[j] >> 25;
+	}
 
-    // Add rest of the bytes
-    usz remaining = input.len - input.len / 8 * 8;
-    if (remaining)
-    {
-        ulong rest = MUL_MCG64;
-        mem::copy(&rest, &input[^remaining], remaining);
-        words[^1] -= rest * MUL_LCG64;
-        words[^1] ^= words[^1] >> 25;
-    }
+	// Add rest of the bytes
+	usz remaining = input.len - input.len / 8 * 8;
+	if (remaining)
+	{
+		ulong rest = MUL_MCG64;
+		mem::copy(&rest, &input[^remaining], remaining);
+		words[^1] -= rest * MUL_LCG64;
+		words[^1] ^= words[^1] >> 25;
+	}
 
-    // Mix between words
-    for (isz i = words.len * 2 - 1; i >= 0; i--)
-    {
-        isz j = i % words.len;
-        words[j] -= words[(i + 1) % words.len] * MUL_LCG64;
-        words[j] ^= words[j] >> 25;
-    }
+	// Mix between words
+	for (isz i = words.len * 2 - 1; i >= 0; i--)
+	{
+		isz j = i % words.len;
+		words[j] -= words[(i + 1) % words.len] * MUL_LCG64;
+		words[j] ^= words[j] >> 25;
+	}
 
-    // Mix within words
-    for (usz i = 0; i < 2; i++)
-    {
-        usz j = i % words.len;
-        words[j] *= MUL_MCG64;
-        words[j] ^= words[j] >> 25;
-    }
+	// Mix within words
+	for (usz i = 0; i < 2; i++)
+	{
+		usz j = i % words.len;
+		words[j] *= MUL_MCG64;
+		words[j] ^= words[j] >> 25;
+	}
 
-    return ((char*)words.ptr)[:words.len * 8];
+	return ((char*)words.ptr)[:words.len * 8];
 }
diff --git a/lib/std/math/random/math.sfc.c3 b/lib/std/math/random/math.sfc.c3
index f85333b38..8fef6c4b5 100644
--- a/lib/std/math/random/math.sfc.c3
+++ b/lib/std/math/random/math.sfc.c3
@@ -14,18 +14,18 @@ def Sfc128 = distinct uint128[4];
 
 fn void Sfc128.seed(&sfc, char[16 * 4] seed)
 {
-    *sfc = bitcast(seed, Sfc128);
+	*sfc = bitcast(seed, Sfc128);
 }
 
 fn uint128 Sfc128.next(&sfc) // TODO: Find good constant
 {
-    uint128* s = (uint128[4]*)sfc;
-    uint128 result = s[0] + s[1] + s[3];
-    s[0] = s[1] ^ s[1] >> 11;
-    s[1] = s[2] + s[2] << 3;
-    s[2] = s[2].rotr(40) + result;
-    s[3] += ODD_PHI128;
-    return result;
+	uint128* s = (uint128[4]*)sfc;
+	uint128 result = s[0] + s[1] + s[3];
+	s[0] = s[1] ^ s[1] >> 11;
+	s[1] = s[2] + s[2] << 3;
+	s[2] = s[2].rotr(40) + result;
+	s[3] += ODD_PHI128;
+	return result;
 }
 
 
@@ -35,18 +35,18 @@ def Sfc64 = distinct ulong[4];
 
 fn void Sfc64.seed(&sfc, char[8 * 4] seed)
 {
-    *sfc = bitcast(seed, Sfc64);
+	*sfc = bitcast(seed, Sfc64);
 }
 
 fn ulong Sfc64.next(&sfc)
 {
-    ulong* s = (ulong[4]*)sfc;
-    ulong result = s[0] + s[1] + s[3];
-    s[0] = s[1] ^ s[1] >> 11;
-    s[1] = s[2] + s[2] << 3;
-    s[2] = s[2].rotr(40) + result;
-    s[3] += ODD_PHI64;
-    return result;
+	ulong* s = (ulong[4]*)sfc;
+	ulong result = s[0] + s[1] + s[3];
+	s[0] = s[1] ^ s[1] >> 11;
+	s[1] = s[2] + s[2] << 3;
+	s[2] = s[2].rotr(40) + result;
+	s[3] += ODD_PHI64;
+	return result;
 }
 
 
@@ -56,18 +56,18 @@ def Sfc32 = distinct uint[4];
 
 fn void Sfc32.seed(&sfc, char[4 * 4] seed)
 {
-    *sfc = bitcast(seed, Sfc32);
+	*sfc = bitcast(seed, Sfc32);
 }
 
 fn uint Sfc32.next(&sfc)
 {
-    uint* s = (uint[4]*)sfc;
-    uint result = s[0] + s[1] + s[3];
-    s[0] = s[1] ^ s[1] >> 9;
-    s[1] = s[2] + s[2] << 3;
-    s[2] = s[2].rotr(11) + result;
-    s[3] += ODD_PHI32;
-    return result;
+	uint* s = (uint[4]*)sfc;
+	uint result = s[0] + s[1] + s[3];
+	s[0] = s[1] ^ s[1] >> 9;
+	s[1] = s[2] + s[2] << 3;
+	s[2] = s[2].rotr(11) + result;
+	s[3] += ODD_PHI32;
+	return result;
 }
 
 
@@ -77,18 +77,18 @@ def Sfc16 = distinct ushort[4];
 
 fn void Sfc16.seed(&sfc, char[2 * 4] seed)
 {
-    *sfc = bitcast(seed, Sfc16);
+	*sfc = bitcast(seed, Sfc16);
 }
 
 fn ushort Sfc16.next(&sfc)
 {
-    ushort* s = (ushort[4]*)sfc;
-    ushort result = s[0] + s[1] + s[3];
-    s[0] = s[1] ^ s[1] >> 2;
-    s[1] = s[2] + s[2] << 3;
-    s[2] = s[2].rotr(12) + result;
-    s[3] += ODD_PHI16;
-    return result;
+	ushort* s = (ushort[4]*)sfc;
+	ushort result = s[0] + s[1] + s[3];
+	s[0] = s[1] ^ s[1] >> 2;
+	s[1] = s[2] + s[2] << 3;
+	s[2] = s[2].rotr(12) + result;
+	s[3] += ODD_PHI16;
+	return result;
 }
 
 
@@ -98,16 +98,16 @@ def Sfc8 = distinct char[4];
 
 fn void Sfc8.seed(&sfc, char[1 * 4] seed)
 {
-    *sfc = bitcast(seed, Sfc8);
+	*sfc = bitcast(seed, Sfc8);
 }
 
 fn char Sfc8.next(&sfc) // TODO: Find better constants
 {
-    char* s = (char[4]*)sfc;
-    char result = s[0] + s[1] + s[3];
-    s[0] = s[1] ^ s[1] >> 1;
-    s[1] = s[2] + s[2] << 2;
-    s[2] = s[2].rotr(3) + result;
-    s[3] += ODD_PHI8;
-    return result;
+	char* s = (char[4]*)sfc;
+	char result = s[0] + s[1] + s[3];
+	s[0] = s[1] ^ s[1] >> 1;
+	s[1] = s[2] + s[2] << 2;
+	s[2] = s[2].rotr(3) + result;
+	s[3] += ODD_PHI8;
+	return result;
 }
diff --git a/lib/std/math/random/math.simple_random.c3 b/lib/std/math/random/math.simple_random.c3
index 9c351dbd3..1c7e57e45 100644
--- a/lib/std/math/random/math.simple_random.c3
+++ b/lib/std/math/random/math.simple_random.c3
@@ -18,14 +18,14 @@ fn Random SimpleRandom.as_random(&random)
 
 fn uint SimpleRandom.next(&r, int bits)
 {
-    ulong nextseed = ((ulong)*r * SIMPLE_RANDOM_MULTIPLIER + SIMPLE_RANDOM_ADDEND) & SIMPLE_RANDOM_MASK;
-    *r = (SimpleRandom)nextseed;
-    return (uint)(nextseed >> (48 - bits));
+	ulong nextseed = ((ulong)*r * SIMPLE_RANDOM_MULTIPLIER + SIMPLE_RANDOM_ADDEND) & SIMPLE_RANDOM_MASK;
+	*r = (SimpleRandom)nextseed;
+	return (uint)(nextseed >> (48 - bits));
 }
 
 fn void SimpleRandom.set_seed(&r, ulong seed)
 {
-    *r = (SimpleRandom)((seed ^ SIMPLE_RANDOM_MULTIPLIER) & SIMPLE_RANDOM_MASK);
+	*r = (SimpleRandom)((seed ^ SIMPLE_RANDOM_MULTIPLIER) & SIMPLE_RANDOM_MASK);
 }
 fn void SimpleRandom.set_seeds(&r, char[] seed)
 {
diff --git a/lib/std/net/inetaddr.c3 b/lib/std/net/inetaddr.c3
index 2a20d597d..4ce9cfc1f 100644
--- a/lib/std/net/inetaddr.c3
+++ b/lib/std/net/inetaddr.c3
@@ -77,81 +77,81 @@ fn InetAddress! ipv6_from_str(String s)
 	bool last_was_colon, found_zero;
 	int current = -1;
 	InetAddress addr = { .is_ipv6 = true };
-    foreach (i, c : s)
-    {
+	foreach (i, c : s)
+	{
 		if (c == ':')
-        {
-            if (!last_was_colon)
-            {
-                if (current == -1)
-                {
-		            last_was_colon = true;
-                    continue;
-                }
-                if (current < 0 || current > 65535) return NetError.INVALID_IP_STRING?;
-                addr.ipv6arr[index++].val = (ushort)current;
-                current = -1;
-	            last_was_colon = true;
-                continue;
-            }
-            assert(current == -1);
-            // Check that this is the first ::
-            if (found_zero) return NetError.INVALID_IP_STRING?;
-            // Also check that the zeroed section is at least 2
-            if (zero_segment_len < 2) return NetError.INVALID_IP_STRING?;
-            // Skip (will be zero by default
-            index += zero_segment_len;
-            found_zero = true;
-            last_was_colon = false;
-            continue;
-        }
-        last_was_colon = false;
-        if (index > 7 || !c.is_xdigit()) return NetError.INVALID_IP_STRING?;
-        if (current < 0) current = 0;
-        current = current * 16 + (c <= '9' ? c - '0' : (c | 32) - 'a' + 10);
-    }
-    // Ends with ::
-    if (index == 8 && current == -1) return addr;
+		{
+			if (!last_was_colon)
+			{
+				if (current == -1)
+				{
+					last_was_colon = true;
+					continue;
+				}
+				if (current < 0 || current > 65535) return NetError.INVALID_IP_STRING?;
+				addr.ipv6arr[index++].val = (ushort)current;
+				current = -1;
+				last_was_colon = true;
+				continue;
+			}
+			assert(current == -1);
+			// Check that this is the first ::
+			if (found_zero) return NetError.INVALID_IP_STRING?;
+			// Also check that the zeroed section is at least 2
+			if (zero_segment_len < 2) return NetError.INVALID_IP_STRING?;
+			// Skip (will be zero by default
+			index += zero_segment_len;
+			found_zero = true;
+			last_was_colon = false;
+			continue;
+		}
+		last_was_colon = false;
+		if (index > 7 || !c.is_xdigit()) return NetError.INVALID_IP_STRING?;
+		if (current < 0) current = 0;
+		current = current * 16 + (c <= '9' ? c - '0' : (c | 32) - 'a' + 10);
+	}
+	// Ends with ::
+	if (index == 8 && current == -1) return addr;
 
-    // Ends with number
-    if (index != 7 || current < 0 || current > 65535) return NetError.INVALID_IP_STRING?;
-    addr.ipv6arr[7].val = (ushort)current;
-    return addr;
+	// Ends with number
+	if (index != 7 || current < 0 || current > 65535) return NetError.INVALID_IP_STRING?;
+	addr.ipv6arr[7].val = (ushort)current;
+	return addr;
 }
 
 fn InetAddress! ipv4_from_str(String s)
 {
 	InetAddress addr;
 	int element;
-    int current = -1;
-    foreach (c : s)
-    {
+	int current = -1;
+	foreach (c : s)
+	{
 		if (c == '.')
-        {
-            if (current < 0) return NetError.INVALID_IP_STRING?;
-            if (current > 255) return NetError.INVALID_IP_STRING?;
-            switch (element)
-            {
-                case 0: addr.ipv4.a = (char)current;
-                case 1: addr.ipv4.b = (char)current;
-                case 2: addr.ipv4.c = (char)current;
-                default: return NetError.INVALID_IP_STRING?;
-            }
-            current = -1;
-            element++;
-            continue;
-        }
-        if (element > 3 || c < '0' || c > '9') return NetError.INVALID_IP_STRING?;
-        if (current < 0)
-        {
-            current = c - '0';
-            continue;
-        }
-        current = current * 10 + c - '0';
-    }
-    if (element != 3 || current < 0 || current > 255) return NetError.INVALID_IP_STRING?;
-    addr.ipv4.d = (char)current;
-    return addr;
+		{
+			if (current < 0) return NetError.INVALID_IP_STRING?;
+			if (current > 255) return NetError.INVALID_IP_STRING?;
+			switch (element)
+			{
+				case 0: addr.ipv4.a = (char)current;
+				case 1: addr.ipv4.b = (char)current;
+				case 2: addr.ipv4.c = (char)current;
+				default: return NetError.INVALID_IP_STRING?;
+			}
+			current = -1;
+			element++;
+			continue;
+		}
+		if (element > 3 || c < '0' || c > '9') return NetError.INVALID_IP_STRING?;
+		if (current < 0)
+		{
+			current = c - '0';
+			continue;
+		}
+		current = current * 10 + c - '0';
+	}
+	if (element != 3 || current < 0 || current > 255) return NetError.INVALID_IP_STRING?;
+	addr.ipv4.d = (char)current;
+	return addr;
 }
 
 fn bool InetAddress.is_loopback(InetAddress* addr)
@@ -195,7 +195,7 @@ fn bool InetAddress.is_site_local(InetAddress* addr)
 		case addr.ipv4.a == 192 && addr.ipv4.b == 168:
 			return true;
 		default:
-		    return false;
+			return false;
 	}
 }
 
diff --git a/lib/std/net/os/common.c3 b/lib/std/net/os/common.c3
index 49b2f3026..58071c1b2 100644
--- a/lib/std/net/os/common.c3
+++ b/lib/std/net/os/common.c3
@@ -16,11 +16,11 @@ struct AddrInfo
 	struct @if(env::WIN32 || env::DARWIN)
 	{
 		ZString ai_canonname;
-        SockAddrPtr ai_addr;
+		SockAddrPtr ai_addr;
 	}
 	struct @if(env::LINUX)
 	{
-        SockAddrPtr ai_addr;
+		SockAddrPtr ai_addr;
 		ZString ai_canonname;
 	}
 	AddrInfo* ai_next;
diff --git a/lib/std/net/os/posix.c3 b/lib/std/net/os/posix.c3
index 15453b753..d9e87427c 100644
--- a/lib/std/net/os/posix.c3
+++ b/lib/std/net/os/posix.c3
@@ -25,7 +25,7 @@ macro void! NativeSocket.close(self)
 macro void! NativeSocket.set_non_blocking(self)
 {
 	int flags = fcntl(self, F_GETFL, 0);
-    if (fcntl(self, F_SETFL, flags | O_NONBLOCK) == -1)
+	if (fcntl(self, F_SETFL, flags | O_NONBLOCK) == -1)
 	{
 		if (libc::errno() == errno::EBADF) return NetError.INVALID_SOCKET?;
 		return NetError.GENERAL_ERROR?;
diff --git a/lib/std/net/os/win32.c3 b/lib/std/net/os/win32.c3
index 415692046..c40254d3d 100644
--- a/lib/std/net/os/win32.c3
+++ b/lib/std/net/os/win32.c3
@@ -19,11 +19,11 @@ extern fn NativeSocket accept(NativeSocket, SockAddrPtr address, Socklen_t* addr
 
 macro NativeSocket.close(self)
 {
-    if (int err = closesocket(self))
-    {
-        if (err == WSAENOTSOCK) return NetError.INVALID_SOCKET?;
+	if (int err = closesocket(self))
+	{
+		if (err == WSAENOTSOCK) return NetError.INVALID_SOCKET?;
 		return NetError.GENERAL_ERROR?;
-    }
+	}
 }
 
 const int WSAENOTSOCK = 10038;
diff --git a/lib/std/os/subprocess.c3 b/lib/std/os/subprocess.c3
index b86f6cd01..3f00ed116 100644
--- a/lib/std/os/subprocess.c3
+++ b/lib/std/os/subprocess.c3
@@ -20,7 +20,7 @@ fault SubProcessResult
 struct SubProcess
 {
 	CFile stdin_file;
-    CFile stdout_file;
+	CFile stdout_file;
 	CFile stderr_file;
 
 	Win32_HANDLE hProcess @if(env::WIN32);
@@ -45,8 +45,8 @@ bitstruct SubProcessOptions : int
 	// Spawn child process without window if supported
 	bool no_window;
 	// Search for program names in the PATH variable. Always enabled on Windows.
-    // Note: this will **not** search for paths in any provided custom environment
-    // and instead uses the PATH of the spawning process.
+	// Note: this will **not** search for paths in any provided custom environment
+	// and instead uses the PATH of the spawning process.
 	bool search_user_path;
 }
 
@@ -122,14 +122,14 @@ fn WString convert_command_line_win32(String[] command_line) @inline @if(env::WI
 fn SubProcess! create(String[] command_line, SubProcessOptions options = {}, String[] environment = {}) @if(env::WIN32)
 {
 	void* rd, wr;
-    Win32_DWORD flags = win32::CREATE_UNICODE_ENVIRONMENT;
-    Win32_PROCESS_INFORMATION process_info;
-    Win32_SECURITY_ATTRIBUTES sa_attr = { Win32_SECURITY_ATTRIBUTES.sizeof, null, 1 };
-    Win32_STARTUPINFOW start_info = {
-        .cb = Win32_STARTUPINFOW.sizeof,
-        .dwFlags = win32::STARTF_USESTDHANDLES
-    };
-    if (options.no_window) flags |= win32::CREATE_NO_WINDOW;
+	Win32_DWORD flags = win32::CREATE_UNICODE_ENVIRONMENT;
+	Win32_PROCESS_INFORMATION process_info;
+	Win32_SECURITY_ATTRIBUTES sa_attr = { Win32_SECURITY_ATTRIBUTES.sizeof, null, 1 };
+	Win32_STARTUPINFOW start_info = {
+		.cb = Win32_STARTUPINFOW.sizeof,
+		.dwFlags = win32::STARTF_USESTDHANDLES
+	};
+	if (options.no_window) flags |= win32::CREATE_NO_WINDOW;
 	if (!win32::createPipe(&rd, &wr, &sa_attr, 0)) return SubProcessResult.FAILED_TO_CREATE_PIPE?;
 	// TODO defer catch
 	if (!win32::setHandleInformation(wr, win32::HANDLE_FLAG_INHERIT, 0)) return SubProcessResult.FAILED_TO_CREATE_PIPE?;
@@ -137,16 +137,16 @@ fn SubProcess! create(String[] command_line, SubProcessOptions options = {}, Str
 	CFile stdin;
 	CFile stdout;
 	CFile stderr;
-    @pool()
-    {
-        WString used_environment = null;
-        if (!options.inherit_environment)
-        {
-	        DString env;
-            env.tinit();
-            if (!environment.len)
-            {
-                env.append("\0");
+	@pool()
+	{
+		WString used_environment = null;
+		if (!options.inherit_environment)
+		{
+			DString env;
+			env.tinit();
+			if (!environment.len)
+			{
+				env.append("\0");
 			}
 			foreach (String s : environment)
 			{
@@ -157,63 +157,63 @@ fn SubProcess! create(String[] command_line, SubProcessOptions options = {}, Str
 			used_environment = env.as_str().to_temp_wstring()!;
 		}
 		int fd = win32::_open_osfhandle((iptr)wr, 0);
-    	if (fd != -1)
-    	{
-    		stdin = win32::_fdopen(fd, "wb");
-    		if (!stdin) return SubProcessResult.FAILED_TO_OPEN_STDIN?;
-    	}
-    	start_info.hStdInput = rd;
-    	if (options.read_async)
-    	{
-    		create_named_pipe_helper(&rd, &wr)!;
-    	}
-    	else
-    	{
-    		if (!win32::createPipe(&rd, &wr, &sa_attr, 0)) return SubProcessResult.FAILED_TO_CREATE_PIPE?;
-    	}
-    	if (!win32::setHandleInformation(rd, win32::HANDLE_FLAG_INHERIT, 0)) return SubProcessResult.FAILED_TO_CREATE_PIPE?;
-    	fd = win32::_open_osfhandle((iptr)rd, 0);
-    	if (fd != -1)
-    	{
-    		stdout = win32::_fdopen(fd, "rb");
-    		if (!stdout) return SubProcessResult.FAILED_TO_OPEN_STDOUT?;
-    	}
+		if (fd != -1)
+		{
+			stdin = win32::_fdopen(fd, "wb");
+			if (!stdin) return SubProcessResult.FAILED_TO_OPEN_STDIN?;
+		}
+		start_info.hStdInput = rd;
+		if (options.read_async)
+		{
+			create_named_pipe_helper(&rd, &wr)!;
+		}
+		else
+		{
+			if (!win32::createPipe(&rd, &wr, &sa_attr, 0)) return SubProcessResult.FAILED_TO_CREATE_PIPE?;
+		}
+		if (!win32::setHandleInformation(rd, win32::HANDLE_FLAG_INHERIT, 0)) return SubProcessResult.FAILED_TO_CREATE_PIPE?;
+		fd = win32::_open_osfhandle((iptr)rd, 0);
+		if (fd != -1)
+		{
+			stdout = win32::_fdopen(fd, "rb");
+			if (!stdout) return SubProcessResult.FAILED_TO_OPEN_STDOUT?;
+		}
 
-        start_info.hStdOutput = wr;
+		start_info.hStdOutput = wr;
 
-    	{|
-    		if (options.combined_stdout_stderr)
-    		{
-    			stderr = stdout;
-    			start_info.hStdError = start_info.hStdOutput;
-    			return;
-    		}
-    		if (options.read_async)
-    		{
-    			create_named_pipe_helper(&rd, &wr)!;
-    		}
-    		else
-    		{
-    			if (!win32::createPipe(&rd, &wr, &sa_attr, 0)) return SubProcessResult.FAILED_TO_CREATE_PIPE?;
-    		}
-    		if (!win32::setHandleInformation(rd, win32::HANDLE_FLAG_INHERIT, 0)) return SubProcessResult.FAILED_TO_CREATE_PIPE?;
+		{|
+			if (options.combined_stdout_stderr)
+			{
+				stderr = stdout;
+				start_info.hStdError = start_info.hStdOutput;
+				return;
+			}
+			if (options.read_async)
+			{
+				create_named_pipe_helper(&rd, &wr)!;
+			}
+			else
+			{
+				if (!win32::createPipe(&rd, &wr, &sa_attr, 0)) return SubProcessResult.FAILED_TO_CREATE_PIPE?;
+			}
+			if (!win32::setHandleInformation(rd, win32::HANDLE_FLAG_INHERIT, 0)) return SubProcessResult.FAILED_TO_CREATE_PIPE?;
 
-            fd = win32::_open_osfhandle((iptr)rd, 0);
-    		if (fd != -1)
-    		{
-    			stderr = win32::_fdopen(fd, "rb");
-    			if (!stderr) return SubProcessResult.FAILED_TO_OPEN_STDERR?;
-    		}
-    		start_info.hStdError = wr;
+			fd = win32::_open_osfhandle((iptr)rd, 0);
+			if (fd != -1)
+			{
+				stderr = win32::_fdopen(fd, "rb");
+				if (!stderr) return SubProcessResult.FAILED_TO_OPEN_STDERR?;
+			}
+			start_info.hStdError = wr;
 
-    	|};
-    	void *event_output;
-    	void *event_error;
-    	if (options.read_async)
-    	{
-    		event_output = win32::createEventA(&sa_attr, 1, 1, null);
-    		event_error = win32::createEventA(&sa_attr, 1, 1, null);
-        }
+		|};
+		void *event_output;
+		void *event_error;
+		if (options.read_async)
+		{
+			event_output = win32::createEventA(&sa_attr, 1, 1, null);
+			event_error = win32::createEventA(&sa_attr, 1, 1, null);
+		}
 		if (!win32::createProcessW(
 			null,
 			convert_command_line_win32(command_line),
@@ -225,7 +225,7 @@ fn SubProcess! create(String[] command_line, SubProcessOptions options = {}, Str
 			null,                   // use parent dir
 			&start_info,            // startup info ptr
 			&process_info)) return SubProcessResult.FAILED_TO_START_PROCESS?;
-    };
+	};
 	// We don't need the handle of the primary thread in the called process.
 	win32::closeHandle(process_info.hThread);
 	if (start_info.hStdOutput)
@@ -241,7 +241,7 @@ fn SubProcess! create(String[] command_line, SubProcessOptions options = {}, Str
 		.stdout_file = stdout,
 		.stderr_file = stderr,
 		.is_alive = true,
-    };
+	};
 }
 
 /**
@@ -278,14 +278,14 @@ fn ZString* tcopy_env(String[] environment) @local @inline @if(env::POSIX)
 fn SubProcess! create(String[] command_line, SubProcessOptions options = {}, String[] environment = {}) @if(env::POSIX)
 {
 	CInt[2] stdinfd;
-    CInt[2] stdoutfd;
-    CInt[2] stderrfd;
+	CInt[2] stdoutfd;
+	CInt[2] stderrfd;
 
 	if (posix::pipe(&stdinfd)) return SubProcessResult.FAILED_TO_OPEN_STDIN?;
 	if (posix::pipe(&stdoutfd)) return SubProcessResult.FAILED_TO_OPEN_STDOUT?;
 	if (!options.combined_stdout_stderr && posix::pipe(&stderrfd)) return SubProcessResult.FAILED_TO_OPEN_STDERR?;
 
-    Posix_spawn_file_actions_t actions;
+	Posix_spawn_file_actions_t actions;
 	if (posix::spawn_file_actions_init(&actions)) return SubProcessResult.FAILED_TO_INITIALIZE_ACTIONS?;
 	defer posix::spawn_file_actions_destroy(&actions);
 	if (posix::spawn_file_actions_addclose(&actions, stdinfd[1])) return SubProcessResult.FAILED_TO_OPEN_STDIN?;
@@ -301,7 +301,7 @@ fn SubProcess! create(String[] command_line, SubProcessOptions options = {}, Str
 		if (posix::spawn_file_actions_addclose(&actions, stderrfd[0])) return SubProcessResult.FAILED_TO_OPEN_STDERR?;
 		if (posix::spawn_file_actions_adddup2(&actions, stderrfd[1], libc::STDERR_FD)) return SubProcessResult.FAILED_TO_OPEN_STDERR?;
 	}
-    Pid_t child;
+	Pid_t child;
 	@pool()
 	{
 		ZString* command_line_copy = tcopy_command_line(command_line);
@@ -322,7 +322,7 @@ fn SubProcess! create(String[] command_line, SubProcessOptions options = {}, Str
 	CFile stderr = {|
 		if (options.combined_stdout_stderr) return stdout;
 		libc::close(stderrfd[1]);
-    	return libc::fdopen(stderrfd[0], "rb");
+		return libc::fdopen(stderrfd[0], "rb");
 	|};
 	return {
 		.stdin_file = stdin,
@@ -343,8 +343,8 @@ fn CInt! SubProcess.join(&self) @if(env::POSIX)
 	CInt status;
 	if (self.child && self.child != posix::waitpid(self.child, &status, 0)) return SubProcessResult.PROCESS_JOIN_FAILED?;
 
-    self.child = 0;
-    self.is_alive = false;
+	self.child = 0;
+	self.is_alive = false;
 
 	return self.return_status = posix::wIFEXITED(status) ? posix::wEXITSTATUS(status) : libc::EXIT_FAILURE;
 }
@@ -369,8 +369,8 @@ fn CInt! SubProcess.join(&self) @if(env::WIN32)
 	win32::waitForSingleObject(self.hProcess, win32::INFINITE);
 	Win32_DWORD return_code @noinit;
 	if (!win32::getExitCodeProcess(self.hProcess, &return_code)) return SubProcessResult.PROCESS_JOIN_FAILED?;
-    self.is_alive = false;
-    return return_code;
+	self.is_alive = false;
+	return return_code;
 }
 
 fn bool SubProcess.destroy(&self)
@@ -408,11 +408,11 @@ fn usz! read_from_file_win32(CFile file, Win32_HANDLE event_handle, char* buffer
 {
 	CInt fd = libc::fileno(file);
 	Win32_DWORD bytes_read = 0;
-    Win32_OVERLAPPED overlapped = { .hEvent = event_handle };
-    Win32_HANDLE handle = (Win32_HANDLE)win32::_get_osfhandle(fd);
+	Win32_OVERLAPPED overlapped = { .hEvent = event_handle };
+	Win32_HANDLE handle = (Win32_HANDLE)win32::_get_osfhandle(fd);
 	if (!win32::readFile(handle, buffer, (Win32_DWORD)size, &bytes_read, &overlapped))
 	{
-        // Means we've got an async read!
+		// Means we've got an async read!
 		if (win32::getLastError() == win32::ERROR_IO_PENDING)
 		{
 			if (!win32::getOverlappedResult(handle, &overlapped, &bytes_read, 1))
@@ -425,16 +425,16 @@ fn usz! read_from_file_win32(CFile file, Win32_HANDLE event_handle, char* buffer
 					default:
 						return SubProcessResult.READ_FAILED?;
 				}
-            }
-        }
-    }
-    return bytes_read;
+			}
+		}
+	}
+	return bytes_read;
 }
 fn usz! read_from_file_posix(CFile file, char* buffer, usz size) @if(env::POSIX) @local
 {
 	isz bytes_read = libc::read(libc::fileno(file), buffer, size);
-    if (bytes_read < 0) return SubProcessResult.READ_FAILED?;
-    return bytes_read;
+	if (bytes_read < 0) return SubProcessResult.READ_FAILED?;
+	return bytes_read;
 }
 
 fn usz! SubProcess.read_stdout(&self, char* buffer, usz size)
diff --git a/lib/std/os/win32/process.c3 b/lib/std/os/win32/process.c3
index 8be5561bb..24cc2e7b6 100644
--- a/lib/std/os/win32/process.c3
+++ b/lib/std/os/win32/process.c3
@@ -35,12 +35,12 @@ struct NativeMutex
 {
 	union
 	{
-        Win32_CRITICAL_SECTION critical_section;
-        Win32_HANDLE handle;
-    }
-    bool already_locked;
-    bool recursive;
-    bool timed;
+		Win32_CRITICAL_SECTION critical_section;
+		Win32_HANDLE handle;
+	}
+	bool already_locked;
+	bool recursive;
+	bool timed;
 }
 
 struct NativeOnceFlag
diff --git a/lib/std/os/win32/types.c3 b/lib/std/os/win32/types.c3
index 7b980c792..bd4eb0018 100644
--- a/lib/std/os/win32/types.c3
+++ b/lib/std/os/win32/types.c3
@@ -192,7 +192,7 @@ def Win32_CRITICAL_SECTION = distinct ulong[5];
 struct Win32_SECURITY_ATTRIBUTES
 {
 	Win32_DWORD  nLength;
-    Win32_LPVOID lpSecurityDescriptor;
+	Win32_LPVOID lpSecurityDescriptor;
 	Win32_BOOL   bInheritHandle;
 }
 
@@ -226,15 +226,15 @@ struct Win32_STARTUPINFOW
 struct Win32_OVERLAPPED
 {
 	Win32_ULONG_PTR internal;
-    Win32_ULONG_PTR internalHigh;
-    union {
-        struct {
-            Win32_DWORD offset;
-            Win32_DWORD offsetHigh;
-        }
-        Win32_PVOID pointer;
-    }
-    Win32_HANDLE hEvent;
+	Win32_ULONG_PTR internalHigh;
+	union {
+		struct {
+			Win32_DWORD offset;
+			Win32_DWORD offsetHigh;
+		}
+		Win32_PVOID pointer;
+	}
+	Win32_HANDLE hEvent;
 }
 
 def Win32_LPOVERLAPPED = Win32_OVERLAPPED*;
@@ -243,7 +243,7 @@ def Win32_LPSTARTUPINFOW = Win32_STARTUPINFOW*;
 struct Win32_STARTUPINFOEXW
 {
 	inline Win32_STARTUPINFOW win32_StartupInfo;
-    Win32_LPPROC_THREAD_ATTRIBUTE_LIST lpAttributeList;
+	Win32_LPPROC_THREAD_ATTRIBUTE_LIST lpAttributeList;
 }
 
 def Win32_LPPROC_THREAD_ATTRIBUTE_LIST = void*;
diff --git a/lib/std/sort/binarysearch.c3 b/lib/std/sort/binarysearch.c3
index c3e2da9a5..72fb1cfdc 100644
--- a/lib/std/sort/binarysearch.c3
+++ b/lib/std/sort/binarysearch.c3
@@ -8,32 +8,32 @@ module std::sort;
  **/
 macro usz binarysearch(list, x, cmp = null) @builtin
 {
-    usz i;
-    usz len = @len_from_list(list);
-    for (usz j = len; i < j;)
-    {
-        usz half = i + (j - i) / 2;
-        $if $checks(!cmp):
-            switch
-            {
-                case greater(list[half], x): j = half;
-                case less(list[half], x): i = half + 1;
-                default: return half;
-            }
-        $else
-            $switch
-                $case $checks(cmp(list[0], list[0])):
-                    int res = cmp(list[half], x);
-                $case $checks(cmp(&list[0], &list[0])):
-                    int res = cmp(&list[half], &x);
-            $endswitch
-            switch
-            {
-                case res > 0: j = half;
-                case res < 0: i = half + 1;
-                default: return half;
-            }
-        $endif
-    }
-    return i;
+	usz i;
+	usz len = @len_from_list(list);
+	for (usz j = len; i < j;)
+	{
+		usz half = i + (j - i) / 2;
+		$if $checks(!cmp):
+			switch
+			{
+				case greater(list[half], x): j = half;
+				case less(list[half], x): i = half + 1;
+				default: return half;
+			}
+		$else
+			$switch
+				$case $checks(cmp(list[0], list[0])):
+					int res = cmp(list[half], x);
+				$case $checks(cmp(&list[0], &list[0])):
+					int res = cmp(&list[half], &x);
+			$endswitch
+			switch
+			{
+				case res > 0: j = half;
+				case res < 0: i = half + 1;
+				default: return half;
+			}
+		$endif
+	}
+	return i;
 }
\ No newline at end of file
diff --git a/lib/std/sort/quicksort.c3 b/lib/std/sort/quicksort.c3
index b5cec1c65..d75d3ccec 100644
--- a/lib/std/sort/quicksort.c3
+++ b/lib/std/sort/quicksort.c3
@@ -8,10 +8,10 @@ import std::sort::qs;
  **/
 macro quicksort(list, cmp = null) @builtin
 {
-    var $Type = $typeof(list);
-    var $CmpType = $typeof(cmp);
-    usz len = sort::@len_from_list(list);
-    qs::qsort(<$Type, $CmpType>)(list, 0, (isz)len - 1, cmp);
+	var $Type = $typeof(list);
+	var $CmpType = $typeof(cmp);
+	usz len = sort::@len_from_list(list);
+	qs::qsort(<$Type, $CmpType>)(list, 0, (isz)len - 1, cmp);
 }
 
 module std::sort::qs(<Type, Comparer>);
@@ -20,49 +20,49 @@ def ElementType = $typeof(Type{}[0]);
 
 fn void qsort(Type list, isz low, isz high, Comparer cmp)
 {
-    if (low >= 0 && high >= 0 && low < high)
-    {
-        isz p = partition(list, low, high, cmp);
-        qsort(list, low, p, cmp);
-        qsort(list, p + 1, high, cmp);
-    }
+	if (low >= 0 && high >= 0 && low < high)
+	{
+		isz p = partition(list, low, high, cmp);
+		qsort(list, low, p, cmp);
+		qsort(list, p + 1, high, cmp);
+	}
 }
 
 fn isz partition(Type list, isz low, isz high, Comparer cmp) @inline @local
 {
-    ElementType pivot = list[low + (high - low) / 2];
-    isz i = low - 1;
-    isz j = high + 1;
-    bool ok;
-    while (true)
-    {
-        do {
-            i++;
-            $switch
-                $case $checks(cmp(list[0], list[0])):
-                    ok = cmp(list[i], pivot) < 0;
-                $case $checks(cmp(&list[0], &list[0])):
-                    ok = cmp(&list[i], &pivot) < 0;
-                $default:
-                    ok = less(list[i], pivot);
-            $endswitch
-        } while (ok);
-        do {
-            j--;
-            $switch
-                $case $checks(cmp(list[0], list[0])):
-                    ok = cmp(list[j], pivot) > 0;
-                $case $checks(cmp(&list[0], &list[0])):
-                    ok = cmp(&list[j], &pivot) > 0;
-                $default:
-                    ok = greater(list[j], pivot);
-            $endswitch
-        } while (ok);
-        if (i >= j) return j;
-        $if $checks(list.swap(0, 0)):
-            list.swap(i, j);
-        $else
-            @swap(list[i], list[j]);
-        $endif
-    }
+	ElementType pivot = list[low + (high - low) / 2];
+	isz i = low - 1;
+	isz j = high + 1;
+	bool ok;
+	while (true)
+	{
+		do {
+			i++;
+			$switch
+				$case $checks(cmp(list[0], list[0])):
+					ok = cmp(list[i], pivot) < 0;
+				$case $checks(cmp(&list[0], &list[0])):
+					ok = cmp(&list[i], &pivot) < 0;
+				$default:
+					ok = less(list[i], pivot);
+			$endswitch
+		} while (ok);
+		do {
+			j--;
+			$switch
+				$case $checks(cmp(list[0], list[0])):
+					ok = cmp(list[j], pivot) > 0;
+				$case $checks(cmp(&list[0], &list[0])):
+					ok = cmp(&list[j], &pivot) > 0;
+				$default:
+					ok = greater(list[j], pivot);
+			$endswitch
+		} while (ok);
+		if (i >= j) return j;
+		$if $checks(list.swap(0, 0)):
+			list.swap(i, j);
+		$else
+			@swap(list[i], list[j]);
+		$endif
+	}
 }
\ No newline at end of file
diff --git a/lib/std/threads/os/thread_posix.c3 b/lib/std/threads/os/thread_posix.c3
index c11348d04..be1249144 100644
--- a/lib/std/threads/os/thread_posix.c3
+++ b/lib/std/threads/os/thread_posix.c3
@@ -11,11 +11,11 @@ fn void! NativeMutex.init(&mtx, MutexType type)
 	Pthread_mutexattr_t attr;
 	if (pthread_mutexattr_init(&attr)) return ThreadFault.INIT_FAILED?;
 	defer pthread_mutexattr_destroy(&attr);
-    if (type & thread::MUTEX_RECURSIVE)
-    {
-        if (pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE)) return ThreadFault.INIT_FAILED?;
-    }
-    if (pthread_mutex_init(mtx, &attr)) return ThreadFault.INIT_FAILED?;
+	if (type & thread::MUTEX_RECURSIVE)
+	{
+		if (pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE)) return ThreadFault.INIT_FAILED?;
+	}
+	if (pthread_mutex_init(mtx, &attr)) return ThreadFault.INIT_FAILED?;
 }
 
 fn void! NativeMutex.destroy(&mtx)
@@ -30,25 +30,25 @@ fn void! NativeMutex.lock(&mtx)
 
 fn void! NativeMutex.lock_timeoutout(&mtx, ulong ms)
 {
-    /* Try to acquire the lock and, if we fail, sleep for 5ms. */
-    Errno result;
-    while ((result = pthread_mutex_trylock(mtx)) == errno::EBUSY)
-    {
-        if (!ms) break;
-        ulong sleep = min(5, ms);
-        if (!libc::nanosleep(&& TimeSpec { .s = 0, .ns = (CLong)sleep * 1000_000 }, null)) return ThreadFault.LOCK_FAILED?;
-        ms -= sleep;
-    }
-    switch (result)
-    {
-        case errno::OK:
-            return;
-        case errno::EBUSY:
-        case errno::ETIMEDOUT:
-            return ThreadFault.LOCK_TIMEOUT?;
-        default:
-            return ThreadFault.LOCK_FAILED?;
-    }
+	/* Try to acquire the lock and, if we fail, sleep for 5ms. */
+	Errno result;
+	while ((result = pthread_mutex_trylock(mtx)) == errno::EBUSY)
+	{
+		if (!ms) break;
+		ulong sleep = min(5, ms);
+		if (!libc::nanosleep(&& TimeSpec { .s = 0, .ns = (CLong)sleep * 1000_000 }, null)) return ThreadFault.LOCK_FAILED?;
+		ms -= sleep;
+	}
+	switch (result)
+	{
+		case errno::OK:
+			return;
+		case errno::EBUSY:
+		case errno::ETIMEDOUT:
+			return ThreadFault.LOCK_TIMEOUT?;
+		default:
+			return ThreadFault.LOCK_FAILED?;
+	}
 }
 
 fn bool NativeMutex.try_lock(&mtx)
@@ -83,7 +83,7 @@ fn void! NativeConditionVariable.broadcast(&cond)
 
 fn void! NativeConditionVariable.wait(&cond, NativeMutex* mtx)
 {
-    if (pthread_cond_wait(cond, mtx)) return ThreadFault.WAIT_FAILED?;
+	if (pthread_cond_wait(cond, mtx)) return ThreadFault.WAIT_FAILED?;
 }
 
 fn void! NativeConditionVariable.wait_timeout(&cond, NativeMutex* mtx, ulong ms)
@@ -115,11 +115,11 @@ fn void! NativeThread.create(&thread, ThreadFn thread_fn, void* arg)
 	PosixThreadData *thread_data = malloc(PosixThreadData);
 	*thread_data = { .thread_fn = thread_fn, .arg = arg };
 	if (pthread_create(thread, null, &callback, thread_data) != 0)
-    {
-        *thread = null;
-        free(thread_data);
-        return ThreadFault.INIT_FAILED?;
-    }
+	{
+		*thread = null;
+		free(thread_data);
+		return ThreadFault.INIT_FAILED?;
+	}
 }
 
 fn void! NativeThread.detach(thread)
diff --git a/lib/std/threads/os/thread_win32.c3 b/lib/std/threads/os/thread_win32.c3
index e256dd986..7aec431eb 100644
--- a/lib/std/threads/os/thread_win32.c3
+++ b/lib/std/threads/os/thread_win32.c3
@@ -4,14 +4,14 @@ import std::os::win32;
 fn void! NativeMutex.init(&mtx, MutexType type)
 {
 	mtx.already_locked = false;
-    mtx.recursive = (bool)(type & thread::MUTEX_RECURSIVE);
-    mtx.timed = (bool)(type & thread::MUTEX_TIMED);
-    if (!mtx.timed)
-    {
-        win32::initializeCriticalSection(&(mtx.critical_section));
-        return;
-    }
-    if (!(mtx.handle = win32::createMutex(null, false, null))) return ThreadFault.INIT_FAILED?;
+	mtx.recursive = (bool)(type & thread::MUTEX_RECURSIVE);
+	mtx.timed = (bool)(type & thread::MUTEX_TIMED);
+	if (!mtx.timed)
+	{
+		win32::initializeCriticalSection(&(mtx.critical_section));
+		return;
+	}
+	if (!(mtx.handle = win32::createMutex(null, false, null))) return ThreadFault.INIT_FAILED?;
 }
 
 fn void! NativeMutex.destroy(&mtx)
@@ -21,27 +21,27 @@ fn void! NativeMutex.destroy(&mtx)
 		win32::deleteCriticalSection(&mtx.critical_section);
 		return;
 	}
-    if (!win32::closeHandle(mtx.handle)) return ThreadFault.DESTROY_FAILED?;
+	if (!win32::closeHandle(mtx.handle)) return ThreadFault.DESTROY_FAILED?;
 }
 
 fn void! NativeMutex.lock(&mtx)
 {
 	if (!mtx.timed)
-    {
-        win32::enterCriticalSection(&mtx.critical_section);
-    }
-    else
-    {
-        switch (win32::waitForSingleObject(mtx.handle, win32::INFINITE))
-        {
-            case win32::WAIT_OBJECT_0:
-                break;
+	{
+		win32::enterCriticalSection(&mtx.critical_section);
+	}
+	else
+	{
+		switch (win32::waitForSingleObject(mtx.handle, win32::INFINITE))
+		{
+			case win32::WAIT_OBJECT_0:
+				break;
 			case win32::WAIT_ABANDONED:
 			default:
 				return ThreadFault.LOCK_FAILED?;
 
-        }
-    }
+		}
+	}
 	if (!mtx.recursive)
 	{
 		while (mtx.already_locked) win32::sleep(1);
@@ -97,10 +97,10 @@ fn void! NativeMutex.unlock(&mtx)
 	mtx.already_locked = false;
 	if (!mtx.timed)
 	{
-	    win32::leaveCriticalSection(&mtx.critical_section);
-	    return;
+		win32::leaveCriticalSection(&mtx.critical_section);
+		return;
 	}
-    if (!win32::releaseMutex(mtx.handle)) return ThreadFault.UNLOCK_FAILED?;
+	if (!win32::releaseMutex(mtx.handle)) return ThreadFault.UNLOCK_FAILED?;
 }
 
 const int CONDITION_EVENT_ONE = 0;
@@ -151,23 +151,23 @@ fn void! NativeConditionVariable.broadcast(&cond)
 fn void! timedwait(NativeConditionVariable* cond, NativeMutex* mtx, uint timeout) @private
 {
 	win32::enterCriticalSection(&cond.waiters_count_lock);
-    cond.waiters_count++;
+	cond.waiters_count++;
 	win32::leaveCriticalSection(&cond.waiters_count_lock);
 
 	mtx.unlock()!;
 
-    uint result = win32::waitForMultipleObjects(2, &cond.events, false, timeout);
-    switch (result)
-    {
-        case win32::WAIT_TIMEOUT:
-            mtx.lock()!;
-            return ThreadFault.WAIT_TIMEOUT?;
-        case win32::WAIT_FAILED:
-            mtx.lock()!;
-            return ThreadFault.WAIT_FAILED?;
-        default:
-            break;
-    }
+	uint result = win32::waitForMultipleObjects(2, &cond.events, false, timeout);
+	switch (result)
+	{
+		case win32::WAIT_TIMEOUT:
+			mtx.lock()!;
+			return ThreadFault.WAIT_TIMEOUT?;
+		case win32::WAIT_FAILED:
+			mtx.lock()!;
+			return ThreadFault.WAIT_FAILED?;
+		default:
+			break;
+	}
 
 	win32::enterCriticalSection(&cond.waiters_count_lock);
 	cond.waiters_count--;
@@ -220,30 +220,30 @@ fn void native_thread_yield()
 
 fn void NativeOnceFlag.call_once(&flag, OnceFn func)
 {
-    while (@volatile_load(flag.status) < 3)
-    {
-        switch (@volatile_load(flag.status))
-        {
-            case 0:
-                if (mem::compare_exchange_volatile(&flag.status, 1, 0, AtomicOrdering.SEQ_CONSISTENT, AtomicOrdering.SEQ_CONSISTENT) == 0)
-                {
-                    win32::initializeCriticalSection(&flag.lock);
-                    win32::enterCriticalSection(&flag.lock);
-                    @volatile_store(flag.status, 2);
-                    func();
-                    @volatile_store(flag.status, 3);
-                    win32::leaveCriticalSection(&flag.lock);
-                    return;
-                }
-                break;
-            case 1:
-                break;
-            case 2:
-                win32::enterCriticalSection(&flag.lock);
-                win32::leaveCriticalSection(&flag.lock);
-                break;
-        }
-    }
+	while (@volatile_load(flag.status) < 3)
+	{
+		switch (@volatile_load(flag.status))
+		{
+			case 0:
+				if (mem::compare_exchange_volatile(&flag.status, 1, 0, AtomicOrdering.SEQ_CONSISTENT, AtomicOrdering.SEQ_CONSISTENT) == 0)
+				{
+					win32::initializeCriticalSection(&flag.lock);
+					win32::enterCriticalSection(&flag.lock);
+					@volatile_store(flag.status, 2);
+					func();
+					@volatile_store(flag.status, 3);
+					win32::leaveCriticalSection(&flag.lock);
+					return;
+				}
+				break;
+			case 1:
+				break;
+			case 2:
+				win32::enterCriticalSection(&flag.lock);
+				win32::leaveCriticalSection(&flag.lock);
+				break;
+		}
+	}
 }
 
 fn void! NativeThread.join(thread, int *res)
diff --git a/lib/std/threads/thread.c3 b/lib/std/threads/thread.c3
index ec38dabf7..6b5f8b7dd 100644
--- a/lib/std/threads/thread.c3
+++ b/lib/std/threads/thread.c3
@@ -53,11 +53,11 @@ macro void! ConditionVariable.signal(&cond) => NativeConditionVariable.signal((N
 macro void! ConditionVariable.broadcast(&cond) => NativeConditionVariable.broadcast((NativeConditionVariable*)cond);
 macro void! ConditionVariable.wait(&cond, Mutex* mutex)
 {
-    return NativeConditionVariable.wait((NativeConditionVariable*)cond, (NativeMutex*)mutex);
+	return NativeConditionVariable.wait((NativeConditionVariable*)cond, (NativeMutex*)mutex);
 }
 macro void! ConditionVariable.wait_timeout(&cond, Mutex* mutex, ulong timeout)
 {
-    return NativeConditionVariable.wait_timeout((NativeConditionVariable*)cond, (NativeMutex*)mutex, timeout);
+	return NativeConditionVariable.wait_timeout((NativeConditionVariable*)cond, (NativeMutex*)mutex, timeout);
 }
 
 
diff --git a/releasenotes.md b/releasenotes.md
index 7f1272a8a..4d679d9df 100644
--- a/releasenotes.md
+++ b/releasenotes.md
@@ -102,6 +102,7 @@
 - `assert` may now take varargs for formatting.
  
 ### Stdlib changes
+- Socket handling.
 - `csv` package.
 - Updated posix/win32 stdlib namespacing
 - `process` stdlib