diff --git a/.clang-format b/.clang-format
new file mode 100644
index 00000000..ae03cfa5
--- /dev/null
+++ b/.clang-format
@@ -0,0 +1,2 @@
+IndentWidth: 4
+AccessModifierOffset: -4
\ No newline at end of file
diff --git a/docs/docs/standard-lib/buffer.md b/docs/docs/standard-lib/buffer.md
new file mode 100644
index 00000000..4148eb7d
--- /dev/null
+++ b/docs/docs/standard-lib/buffer.md
@@ -0,0 +1,480 @@
+---
+layout: default
+title: Buffer
+nav_order: 4
+parent: Standard Library
+---
+
+# Buffer
+{: .no_toc }
+
+## Table of contents
+{: .no_toc .text-delta }
+
+1. TOC
+{:toc}
+
+---
+
+## Buffer
+To make use of the Buffer module an import is required.
+
+```js
+import Buffer;
+```
+
+The maximum byte size for a buffer is `2147483647 - 1`
+
+### Buffer.new() -> Result\<Buffer>
+
+Returns a Result with a new buffer with the given size in bytes.
+
+```cs
+const buffer = Buffer.new(1024).unwrap();
+print(buffer);
+// <Buffer>
+```
+
+### Buffer.fromString(String) -> Result\<Buffer>
+
+Returns a Result with a new buffer created from the given string.
+
+```cs
+const buffer = Buffer.fromString("Dictu!").unwrap();
+print(buffer);
+// <Buffer>
+```
+
+### Buffer.resize(Number) -> Result\<Number>
+
+Resizes the buffer to the given size. The argument needs to be greater than 0 or the function will return an error.
+
+```cs
+const buffer = Buffer.new(8).unwrap();
+print(buffer.resize(16).unwrap());
+// 16
+```
+
+### Buffer.get(Number) -> Result\<Number>
+
+Returns the value of byte at the given index.
+```cs
+const buffer = Buffer.new("Dictu!").unwrap();
+print(buffer.get(0).unwrap());
+
+// 68 (ASCII value of 'D')
+```
+
+### Buffer.set(Number, Number) -> Result\<Number>
+
+Sets the given index of the buffer to the second argument.
+Returns a Number result with the new value.
+```cs
+const buffer = Buffer.fromString("dictu!").unwrap();
+buffer.set(0, 68).unwrap();
+print(buffer.string()); // "Dictu!"
+```
+
+### Buffer.subarray(Number: start -> Optional, Number: end -> Optional) -> Result\<Buffer>
+
+Returns a new Buffer with the optional given start and end parameters.
+* `start`: The start index within the buffer, default `0`
+* `end`: The end index within the buffer(non inclusive), default: `buffer.len()`
+```cs
+const buffer = Buffer.fromString("Dictu!").unwrap();
+const sub = buffer.subarray(0, buffer.len()-1).unwrap();
+print(sub.string()); // "Dictu"
+```
+
+### Buffer.string() -> String
+
+Returns a string representation of the buffer.
+```cs
+const buffer = Buffer.fromString("Dictu!").unwrap();
+const str = buffer.string();
+print(str); // "Dictu!"
+```
+
+### Buffer.len() -> Number
+
+Returns the byte length of the buffer.
+```cs
+const buffer = Buffer.new(9).unwrap();
+const len = buffer.len();
+print(len); // 9
+```
+
+### Buffer.values() -> List
+
+Returns a list with the integer values of the buffer.
+```cs
+const buffer = Buffer.fromString("Dictu!").unwrap();
+const v = buffer.values();
+print(v); // [68, 105, 99, 116, 117, 33]
+```
+
+
+### Buffer.writeString(Number, String) -> Result\<Nil>
+
+Sets a string into buffer given the starting index. If the string doesn't fit in the buffer an error is returned.
+```cs
+const buffer = Buffer.new(6).unwrap();
+buffer.writeString(0, "Dictu!");
+```
+
+### Buffer.readString(Number: start -> Optional, Number: end -> Optional) -> Result\<String>
+
+Returns a String with the optional given start and end parameters, this works very similar to subarray.
+* `start`: The start index within the buffer, default `0`
+* `end`: The end index within the buffer(non inclusive), default: `buffer.len()`
+```cs
+const buffer = Buffer.new(6).unwrap();
+buffer.writeString(0, "Dictu!");
+const sub = buffer.string(0, buffer.len()-1).unwrap();
+print(sub) // "Dictu"
+```
+
+### Buffer.readUInt64LE(Number) -> Result\<Number>
+
+Returns the u64(unsigned 8 byte integer in little endian) value given the starting index.
+If the given index + byte length does exceed the buffer bounds an error is returned.
+**Note**: The maximum value supported is: `9007199254740992`, if a read of a larger value is attempted a error is returned.
+
+```cs
+const buffer = Buffer.new(8).unwrap();
+buffer.writeUInt64LE(0, 12000);
+print(buffer.readUInt64LE(0).unwrap()) // 12000
+```
+
+### Buffer.readUInt32LE(Number) -> Result\<Number>
+
+Returns the u32(unsigned 4 byte integer in little endian) value given the starting index.
+If the given index + byte length does exceed the buffer bounds an error is returned.
+
+```cs
+const buffer = Buffer.new(4).unwrap();
+buffer.writeUInt32LE(0, 1337);
+print(buffer.readUInt32LE(0).unwrap()) // 1337
+```
+
+### Buffer.readUInt16LE(Number) -> Result\<Number>
+
+Returns the u16(unsigned 2 byte integer in little endian) value given the starting index.
+If the given index + byte length does exceed the buffer bounds an error is returned.
+
+```cs
+const buffer = Buffer.new(2).unwrap();
+buffer.writeUInt16LE(0, 1337);
+print(buffer.readUInt16LE(0).unwrap()) // 1337
+```
+
+### Buffer.readInt64LE(Number) -> Result\<Number>
+
+Returns the i64(signed 8 byte integer in little endian) value given the starting index.
+If the given index + byte length does exceed the buffer bounds an error is returned.
+
+```cs
+const buffer = Buffer.new(8).unwrap();
+buffer.writeInt64LE(0, -12000);
+print(buffer.readInt64LE(0).unwrap()) // -12000
+```
+
+### Buffer.readInt32LE(Number) -> Result\<Number>
+
+Returns the i32(signed 4 byte integer in little endian) value given the starting index.
+If the given index + byte length does exceed the buffer bounds an error is returned.
+
+```cs
+const buffer = Buffer.new(4).unwrap();
+buffer.writeInt32LE(0, -1337);
+print(buffer.readInt32LE(0).unwrap()) // -1337
+```
+
+### Buffer.readInt16LE(Number) -> Result\<Number>
+
+Returns the i16(signed 2 byte integer in little endian) value given the starting index.
+If the given index + byte length does exceed the buffer bounds an error is returned.
+
+```cs
+const buffer = Buffer.new(2).unwrap();
+buffer.writeInt16LE(0, -1337);
+print(buffer.readInt16LE(0).unwrap()) // -1337
+```
+
+### Buffer.readInt8(Number) -> Result\<Number>
+
+Returns the i8(signed 1 byte integer) value given the starting index.
+If the given index + byte length does exceed the buffer bounds an error is returned.
+**Note**: For the unsigned equivalent use get().
+
+```cs
+const buffer = Buffer.new(1).unwrap();
+buffer.writeUInt8(0, -12);
+print(buffer.readInt8(0).unwrap()) // -12
+```
+
+### Buffer.writeUInt64LE(Number, Number) -> Result\<Number>
+
+Writes a u64(unsigned 8 byte integer in little endian) at the index(the first argument).
+Returns a result with the set value or an error incase the byte size from the start index would exceed the buffer bounds.
+```cs
+const buffer = Buffer.new(8).unwrap();
+buffer.writeUInt64LE(0, 12000);
+```
+
+### Buffer.writeUInt32LE(Number, Number) -> Result\<Number>
+
+Writes a u32(unsigned 4 byte integer in little endian) at the index(the first argument).
+Returns a result with the set value or an error incase the byte size from the start index would exceed the buffer bounds.
+```cs
+const buffer = Buffer.new(4).unwrap();
+buffer.writeUInt32LE(0, 1337);
+```
+
+### Buffer.writeUInt16LE(Number, Number) -> Result\<Number>
+
+Writes a u16(unsigned 2 byte integer in little endian) at the index(the first argument).
+Returns a result with the set value or an error incase the byte size from the start index would exceed the buffer bounds.
+```cs
+const buffer = Buffer.new(2).unwrap();
+buffer.writeUInt16LE(0, 1337);
+```
+
+### Buffer.writeInt64LE(Number, Number) -> Result\<Number>
+
+Writes a i64(signed 8 byte integer in little endian) at the index(the first argument).
+Returns a result with the set value or an error incase the byte size from the start index would exceed the buffer bounds.
+```cs
+const buffer = Buffer.new(8).unwrap();
+buffer.writeInt64LE(0, 12000);
+```
+
+### Buffer.writeInt32LE(Number, Number) -> Result\<Number>
+
+Writes a i32(signed 4 byte integer in little endian) at the index(the first argument).
+Returns a result with the set value or an error incase the byte size from the start index would exceed the buffer bounds.
+```cs
+const buffer = Buffer.new(4).unwrap();
+buffer.writeInt32LE(0, 1337);
+```
+
+### Buffer.writeInt16LE(Number, Number) -> Result\<Number>
+
+Writes a i16(signed 2 byte integer in little endian) at the index(the first argument).
+Returns a result with the set value or an error incase the byte size from the start index would exceed the buffer bounds.
+```cs
+const buffer = Buffer.new(2).unwrap();
+buffer.writeInt16LE(0, 1337);
+```
+
+### Buffer.writeInt8(Number, Number) -> Result\<Number>
+
+Writes a i8(signed 1 byte integer) at the index(the first argument).
+Returns a result with the set value or an error incase the byte size from the start index would exceed the buffer bounds.
+**Note**: For the unsigned equivalent use set().
+
+```cs
+const buffer = Buffer.new(1).unwrap();
+buffer.writeInt8(0, -12);
+```
+
+### Buffer.writeFloatLE(Number, Number) -> Result\<Number>
+
+Writes a float(4 byte signed floating point number in little endian) at the index(the first argument).
+Returns a result with the set value or an error incase the byte size from the start index would exceed the buffer bounds.
+```cs
+const buffer = Buffer.new(4).unwrap();
+buffer.writeFloatLE(0, 14.34);
+```
+
+### Buffer.writeDoubleLE(Number, Number) -> Result\<Number>
+
+Writes a double(8 byte signed floating point number in little endian) at the index(the first argument).
+Returns a result with the set value or an error incase the byte size from the start index would exceed the buffer bounds.
+```cs
+const buffer = Buffer.new(8).unwrap();
+buffer.writeDoubleLE(0, 14.34);
+```
+
+### Buffer.readFloatLE(Number) -> Result\<Number>
+
+Returns the float(signed 4 byte floating point number in little endian) value given the starting index.
+If the given index + byte length does exceed the buffer bounds an error is returned.
+
+```cs
+const buffer = Buffer.new(4).unwrap();
+buffer.writeFloatLE(0, 14.34);
+print(buffer.readFloatLE(0).unwrap()) // 14.34
+```
+
+### Buffer.readDoubleLE(Number) -> Result\<Number>
+
+Returns the double(signed 8 byte floating point number in little endian) value given the starting index.
+If the given index + byte length does exceed the buffer bounds an error is returned.
+
+```cs
+const buffer = Buffer.new(8).unwrap();
+buffer.writeDoubleLE(0, 14.34);
+print(buffer.readDoubleLE(0).unwrap()) // 14.34
+```
+
+### Buffer.writeUInt64BE(Number, Number) -> Result\<Number>
+
+Writes a u64(unsigned 8 byte integer in big endian) at the index(the first argument).
+Returns a result with the set value or an error incase the byte size from the start index would exceed the buffer bounds.
+```cs
+const buffer = Buffer.new(8).unwrap();
+buffer.writeUInt64BE(0, 12000);
+```
+
+### Buffer.writeUInt32BE(Number, Number) -> Result\<Number>
+
+Writes a u32(unsigned 4 byte integer in big endian) at the index(the first argument).
+Returns a result with the set value or an error incase the byte size from the start index would exceed the buffer bounds.
+```cs
+const buffer = Buffer.new(4).unwrap();
+buffer.writeUInt32BE(0, 1337);
+```
+
+### Buffer.writeUInt16BE(Number, Number) -> Result\<Number>
+
+Writes a u16(unsigned 2 byte integer in big endian) at the index(the first argument).
+Returns a result with the set value or an error incase the byte size from the start index would exceed the buffer bounds.
+```cs
+const buffer = Buffer.new(2).unwrap();
+buffer.writeUInt16BE(0, 1337);
+```
+
+### Buffer.writeInt64BE(Number, Number) -> Result\<Number>
+
+Writes a i64(signed 8 byte integer in big endian) at the index(the first argument).
+Returns a result with the set value or an error incase the byte size from the start index would exceed the buffer bounds.
+```cs
+const buffer = Buffer.new(8).unwrap();
+buffer.writeInt64BE(0, 12000);
+```
+
+### Buffer.writeInt32BE(Number, Number) -> Result\<Number>
+
+Writes a i32(signed 4 byte integer in big endian) at the index(the first argument).
+Returns a result with the set value or an error incase the byte size from the start index would exceed the buffer bounds.
+```cs
+const buffer = Buffer.new(4).unwrap();
+buffer.writeInt32BE(0, 1337);
+```
+
+### Buffer.writeInt16BE(Number, Number) -> Result\<Number>
+
+Writes a i16(signed 2 byte integer in big endian) at the index(the first argument).
+Returns a result with the set value or an error incase the byte size from the start index would exceed the buffer bounds.
+```cs
+const buffer = Buffer.new(2).unwrap();
+buffer.writeInt16BE(0, 1337);
+```
+
+### Buffer.writeFloatBE(Number, Number) -> Result\<Number>
+
+Writes a float(4 byte signed floating point number in big endian) at the index(the first argument).
+Returns a result with the set value or an error incase the byte size from the start index would exceed the buffer bounds.
+```cs
+const buffer = Buffer.new(4).unwrap();
+buffer.writeFloatBE(0, 14.34);
+```
+
+### Buffer.writeDoubleBE(Number, Number) -> Result\<Number>
+
+Writes a double(8 byte signed floating point number in big endian) at the index(the first argument).
+Returns a result with the set value or an error incase the byte size from the start index would exceed the buffer bounds.
+```cs
+const buffer = Buffer.new(8).unwrap();
+buffer.writeDoubleBE(0, 14.34);
+```
+
+### Buffer.readUInt64BE(Number) -> Result\<Number>
+
+Returns the u64(unsigned 8 byte integer in big endian) value given the starting index.
+If the given index + byte length does exceed the buffer bounds an error is returned.
+**Note**: The maximum value supported is: `9007199254740992`, if a read of a larger value is attempted a error is returned.
+
+```cs
+const buffer = Buffer.new(8).unwrap();
+buffer.writeUInt64BE(0, 12000);
+print(buffer.readUInt64BE(0).unwrap()) // 12000
+```
+
+### Buffer.readUInt32BE(Number) -> Result\<Number>
+
+Returns the u32(unsigned 4 byte integer in big endian) value given the starting index.
+If the given index + byte length does exceed the buffer bounds an error is returned.
+
+```cs
+const buffer = Buffer.new(4).unwrap();
+buffer.writeUInt32BE(0, 1337);
+print(buffer.readUInt32BE(0).unwrap()) // 1337
+```
+
+### Buffer.readUInt16BE(Number) -> Result\<Number>
+
+Returns the u16(unsigned 2 byte integer in big endian) value given the starting index.
+If the given index + byte length does exceed the buffer bounds an error is returned.
+
+```cs
+const buffer = Buffer.new(2).unwrap();
+buffer.writeUInt16BE(0, 1337);
+print(buffer.readUInt16BE(0).unwrap()) // 1337
+```
+
+### Buffer.readInt64BE(Number) -> Result\<Number>
+
+Returns the i64(signed 8 byte integer in big endian) value given the starting index.
+If the given index + byte length does exceed the buffer bounds an error is returned.
+
+```cs
+const buffer = Buffer.new(8).unwrap();
+buffer.writeInt64BE(0, -12000);
+print(buffer.readInt64BE(0).unwrap()) // -12000
+```
+
+### Buffer.readInt32BE(Number) -> Result\<Number>
+
+Returns the i32(signed 4 byte integer in big endian) value given the starting index.
+If the given index + byte length does exceed the buffer bounds an error is returned.
+
+```cs
+const buffer = Buffer.new(4).unwrap();
+buffer.writeInt32BE(0, -1337);
+print(buffer.readInt32BE(0).unwrap()) // -1337
+```
+
+### Buffer.readInt16BE(Number) -> Result\<Number>
+
+Returns the i16(signed 2 byte integer in big endian) value given the starting index.
+If the given index + byte length does exceed the buffer bounds an error is returned.
+
+```cs
+const buffer = Buffer.new(2).unwrap();
+buffer.writeInt16BE(0, -1337);
+print(buffer.readInt16BE(0).unwrap()) // -1337
+```
+
+### Buffer.readFloatBE(Number) -> Result\<Number>
+
+Returns the float(signed 4 byte floating point number in big endian) value given the starting index.
+If the given index + byte length does exceed the buffer bounds an error is returned.
+
+```cs
+const buffer = Buffer.new(4).unwrap();
+buffer.writeFloatBE(0, 14.34);
+print(buffer.readFloatBE(0).unwrap()) // 14.34
+```
+
+### Buffer.readDoubleBE(Number) -> Result\<Number>
+
+Returns the double(signed 8 byte floating point number in big endian) value given the starting index.
+If the given index + byte length does exceed the buffer bounds an error is returned.
+
+```cs
+const buffer = Buffer.new(8).unwrap();
+buffer.writeDoubleBE(0, 14.34);
+print(buffer.readDoubleBE(0).unwrap()) // 14.34
+```
\ No newline at end of file
diff --git a/docs/docs/standard-lib/datetime.md b/docs/docs/standard-lib/datetime.md
index b6558bbd..2e27c3ad 100644
--- a/docs/docs/standard-lib/datetime.md
+++ b/docs/docs/standard-lib/datetime.md
@@ -1,7 +1,7 @@
 ---
 layout: default
 title: Datetime
-nav_order: 4
+nav_order: 5
 parent: Standard Library
 ---
 
diff --git a/docs/docs/standard-lib/env.md b/docs/docs/standard-lib/env.md
index 0ee26cf1..fb7ac73c 100644
--- a/docs/docs/standard-lib/env.md
+++ b/docs/docs/standard-lib/env.md
@@ -1,7 +1,7 @@
 ---
 layout: default
 title: Env
-nav_order: 5
+nav_order: 6
 parent: Standard Library
 ---
 
diff --git a/docs/docs/standard-lib/hashlib.md b/docs/docs/standard-lib/hashlib.md
index ea7063cc..a0ee80cf 100644
--- a/docs/docs/standard-lib/hashlib.md
+++ b/docs/docs/standard-lib/hashlib.md
@@ -1,7 +1,7 @@
 ---
 layout: default
 title: Hashlib
-nav_order: 6
+nav_order: 7
 parent: Standard Library
 ---
 
diff --git a/docs/docs/standard-lib/http.md b/docs/docs/standard-lib/http.md
index f45826f6..89a809a4 100644
--- a/docs/docs/standard-lib/http.md
+++ b/docs/docs/standard-lib/http.md
@@ -1,7 +1,7 @@
 ---
 layout: default
 title: HTTP
-nav_order: 7
+nav_order: 8
 parent: Standard Library
 ---
 
diff --git a/docs/docs/standard-lib/inspect.md b/docs/docs/standard-lib/inspect.md
index 30751860..32664ef6 100644
--- a/docs/docs/standard-lib/inspect.md
+++ b/docs/docs/standard-lib/inspect.md
@@ -1,7 +1,7 @@
 ---
 layout: default
 title: Inspect
-nav_order: 8
+nav_order: 9
 parent: Standard Library
 ---
 
diff --git a/docs/docs/standard-lib/io.md b/docs/docs/standard-lib/io.md
index 5d3071db..51a2c79f 100644
--- a/docs/docs/standard-lib/io.md
+++ b/docs/docs/standard-lib/io.md
@@ -1,7 +1,7 @@
 ---
 layout: default
 title: IO
-nav_order: 9
+nav_order: 10
 parent: Standard Library
 ---
 
diff --git a/docs/docs/standard-lib/json.md b/docs/docs/standard-lib/json.md
index ada1a8a7..cc2a73e5 100644
--- a/docs/docs/standard-lib/json.md
+++ b/docs/docs/standard-lib/json.md
@@ -1,7 +1,7 @@
 ---
 layout: default
 title: JSON
-nav_order: 10
+nav_order: 11
 parent: Standard Library
 ---
 
diff --git a/docs/docs/standard-lib/log.md b/docs/docs/standard-lib/log.md
index e14f0cc5..8f3e91a4 100644
--- a/docs/docs/standard-lib/log.md
+++ b/docs/docs/standard-lib/log.md
@@ -1,7 +1,7 @@
 ---
 layout: default
 title: Log
-nav_order: 11
+nav_order: 12
 parent: Standard Library
 ---
 
diff --git a/docs/docs/standard-lib/math.md b/docs/docs/standard-lib/math.md
index d7d94ae7..36266e76 100644
--- a/docs/docs/standard-lib/math.md
+++ b/docs/docs/standard-lib/math.md
@@ -1,7 +1,7 @@
 ---
 layout: default
 title: Math
-nav_order: 12
+nav_order: 13
 parent: Standard Library
 ---
 
diff --git a/docs/docs/standard-lib/net.md b/docs/docs/standard-lib/net.md
index 1d59f56a..6ecbf240 100644
--- a/docs/docs/standard-lib/net.md
+++ b/docs/docs/standard-lib/net.md
@@ -1,7 +1,7 @@
 ---
 layout: default
 title: Net
-nav_order: 13
+nav_order: 14
 parent: Standard Library
 ---
 
diff --git a/docs/docs/standard-lib/object.md b/docs/docs/standard-lib/object.md
index dc5cbaf9..3c2b76e4 100644
--- a/docs/docs/standard-lib/object.md
+++ b/docs/docs/standard-lib/object.md
@@ -1,7 +1,7 @@
 ---
 layout: default
 title: Object
-nav_order: 14
+nav_order: 15
 parent: Standard Library
 ---
 
diff --git a/docs/docs/standard-lib/path.md b/docs/docs/standard-lib/path.md
index acdef7c3..6b4af35d 100644
--- a/docs/docs/standard-lib/path.md
+++ b/docs/docs/standard-lib/path.md
@@ -1,7 +1,7 @@
 ---
 layout: default
 title: Path
-nav_order: 15
+nav_order: 16
 parent: Standard Library
 ---
 
diff --git a/docs/docs/standard-lib/process.md b/docs/docs/standard-lib/process.md
index 165f8b1c..35431043 100644
--- a/docs/docs/standard-lib/process.md
+++ b/docs/docs/standard-lib/process.md
@@ -1,7 +1,7 @@
 ---
 layout: default
 title: Process
-nav_order: 16
+nav_order: 17
 parent: Standard Library
 ---
 
diff --git a/docs/docs/standard-lib/queue.md b/docs/docs/standard-lib/queue.md
index a8db6d28..60e617bb 100644
--- a/docs/docs/standard-lib/queue.md
+++ b/docs/docs/standard-lib/queue.md
@@ -1,7 +1,7 @@
 ---
 layout: default
 title: Queue
-nav_order: 17
+nav_order: 18
 parent: Standard Library
 ---
 
diff --git a/docs/docs/standard-lib/random.md b/docs/docs/standard-lib/random.md
index b4f330dd..d5c26617 100644
--- a/docs/docs/standard-lib/random.md
+++ b/docs/docs/standard-lib/random.md
@@ -1,7 +1,7 @@
 ---
 layout: default
 title: Random
-nav_order: 18
+nav_order: 19
 parent: Standard Library
 ---
 
diff --git a/docs/docs/standard-lib/socket.md b/docs/docs/standard-lib/socket.md
index 8fcec833..bf84425f 100644
--- a/docs/docs/standard-lib/socket.md
+++ b/docs/docs/standard-lib/socket.md
@@ -1,7 +1,7 @@
 ---
 layout: default
 title: Socket
-nav_order: 19
+nav_order: 20
 parent: Standard Library
 ---
 
diff --git a/docs/docs/standard-lib/sqlite.md b/docs/docs/standard-lib/sqlite.md
index 2bf9c6ed..cc217fbd 100644
--- a/docs/docs/standard-lib/sqlite.md
+++ b/docs/docs/standard-lib/sqlite.md
@@ -1,7 +1,7 @@
 ---
 layout: default
 title: Sqlite
-nav_order: 20
+nav_order: 21
 parent: Standard Library
 ---
 
diff --git a/docs/docs/standard-lib/stack.md b/docs/docs/standard-lib/stack.md
index 10756fa8..5299b4c2 100644
--- a/docs/docs/standard-lib/stack.md
+++ b/docs/docs/standard-lib/stack.md
@@ -1,7 +1,7 @@
 ---
 layout: default
 title: Stack
-nav_order: 21
+nav_order: 22
 parent: Standard Library
 ---
 
diff --git a/docs/docs/standard-lib/system.md b/docs/docs/standard-lib/system.md
index acdaef63..7f5f23e5 100644
--- a/docs/docs/standard-lib/system.md
+++ b/docs/docs/standard-lib/system.md
@@ -1,7 +1,7 @@
 ---
 layout: default
 title: System
-nav_order: 22
+nav_order: 23
 parent: Standard Library
 ---
 
diff --git a/docs/docs/standard-lib/term.md b/docs/docs/standard-lib/term.md
index b46c7391..19331a0c 100644
--- a/docs/docs/standard-lib/term.md
+++ b/docs/docs/standard-lib/term.md
@@ -1,7 +1,7 @@
 ---
 layout: default
 title: Term
-nav_order: 23
+nav_order: 24
 parent: Standard Library
 ---
 
diff --git a/docs/docs/standard-lib/unittest.md b/docs/docs/standard-lib/unittest.md
index be88a70d..9a6021b7 100644
--- a/docs/docs/standard-lib/unittest.md
+++ b/docs/docs/standard-lib/unittest.md
@@ -1,7 +1,7 @@
 ---
 layout: default
 title: UnitTest
-nav_order: 24
+nav_order: 25
 parent: Standard Library
 ---
 
diff --git a/docs/docs/standard-lib/uuid.md b/docs/docs/standard-lib/uuid.md
index 2e6f0e93..8bbf2eee 100644
--- a/docs/docs/standard-lib/uuid.md
+++ b/docs/docs/standard-lib/uuid.md
@@ -1,7 +1,7 @@
 ---
 layout: default
 title: UUID
-nav_order: 25
+nav_order: 26
 parent: Standard Library
 ---
 
diff --git a/src/optionals/buffer.c b/src/optionals/buffer.c
new file mode 100644
index 00000000..10156939
--- /dev/null
+++ b/src/optionals/buffer.c
@@ -0,0 +1,1047 @@
+#include "buffer.h"
+
+typedef struct {
+    uint8_t *bytes;
+    int size;
+    bool bigEndian;
+} Buffer;
+
+#define AS_BUFFER(v) ((Buffer *)AS_ABSTRACT(v)->data)
+
+ObjAbstract *newBufferObj(DictuVM *vm, double capacity);
+
+void freeBuffer(DictuVM *vm, ObjAbstract *abstract) {
+    Buffer *buffer = (Buffer *)abstract->data;
+    FREE_ARRAY(vm, uint8_t, buffer->bytes, buffer->size);
+    FREE(vm, Buffer, abstract->data);
+}
+
+char *bufferToString(ObjAbstract *abstract) {
+    UNUSED(abstract);
+
+    char *bufferString = malloc(sizeof(char) * 9);
+    snprintf(bufferString, 9, "<Buffer>");
+    return bufferString;
+}
+
+uint8_t *swap(uint8_t *ptr, size_t len, bool bigEndian) {
+    if (len < 2)
+        return ptr;
+    if (!bigEndian && !IS_BIG_ENDIAN) {
+        return ptr;
+    } else if (IS_BIG_ENDIAN && bigEndian) {
+        return ptr;
+    }
+    int start = 0;
+    int end = (len)-1;
+    uint8_t temp;
+    while (start < end) {
+        temp = ptr[start];
+        ptr[start] = ptr[end];
+        ptr[end] = temp;
+        start++;
+        end--;
+    }
+    return ptr;
+}
+
+bool ensureSize(Buffer *buffer, size_t offset, size_t size) {
+    return buffer->size - offset >= size;
+}
+
+bool writeInternal(Buffer *buffer, size_t offset, uint8_t *data, size_t len) {
+    if (!ensureSize(buffer, offset, len))
+        return false;
+    memcpy(buffer->bytes + offset, data, len);
+    return true;
+}
+
+uint8_t *getReadPtr(Buffer *buffer, size_t offset, size_t len) {
+    if (!ensureSize(buffer, offset, len))
+        return NULL;
+    return buffer->bytes + offset;
+}
+
+static Value bufferResize(DictuVM *vm, int argCount, Value *args) {
+    if (argCount != 1) {
+        runtimeError(vm, "resize() takes 1 argument (%d given).", argCount);
+        return EMPTY_VAL;
+    }
+
+    if (!IS_NUMBER(args[1])) {
+        runtimeError(vm, "resize() size argument must be a number");
+        return EMPTY_VAL;
+    }
+
+    double capacity = AS_NUMBER(args[1]);
+    if (capacity <= 0 || capacity >= BUFFER_SIZE_MAX) {
+        return newResultError(
+            vm, "size must be greater than 0 and smaller than 2147483647");
+    }
+    Buffer *buffer = AS_BUFFER(args[0]);
+    buffer->bytes = reallocate(vm, buffer->bytes, buffer->size, capacity);
+    if (capacity > buffer->size) {
+        // 0 init everything if we grew the buffer
+        size_t added = capacity - buffer->size;
+        memset(buffer->bytes + buffer->size, 0, added);
+    }
+    buffer->size = capacity;
+    return newResultSuccess(vm, args[0]);
+}
+
+static Value bufferLen(DictuVM *vm, int argCount, Value *args) {
+    if (argCount != 0) {
+        runtimeError(vm, "len() takes no arguments");
+        return EMPTY_VAL;
+    }
+    Buffer *buffer = AS_BUFFER(args[0]);
+
+    return NUMBER_VAL(buffer->size);
+}
+
+static Value bufferValues(DictuVM *vm, int argCount, Value *args) {
+    if (argCount != 0) {
+        runtimeError(vm, "values() takes no arguments");
+        return EMPTY_VAL;
+    }
+    Buffer *buffer = AS_BUFFER(args[0]);
+    ObjList *list = newList(vm);
+    push(vm, OBJ_VAL(list));
+
+    for (int i = 0; i < buffer->size; ++i) {
+        writeValueArray(vm, &list->values, NUMBER_VAL(buffer->bytes[i]));
+    }
+    pop(vm);
+    return OBJ_VAL(list);
+}
+
+static Value bufferString(DictuVM *vm, int argCount, Value *args) {
+    if (argCount != 0) {
+        runtimeError(vm, "string() takes no arguments");
+        return EMPTY_VAL;
+    }
+    Buffer *buffer = AS_BUFFER(args[0]);
+
+    return OBJ_VAL(copyString(vm, (const char *)buffer->bytes, buffer->size));
+}
+static Value bufferWriteint8(DictuVM *vm, int argCount, Value *args) {
+    Buffer *buffer = AS_BUFFER(args[0]);
+    if (argCount != 2) {
+        runtimeError(vm, "writeInt8() takes 2 argument");
+        return EMPTY_VAL;
+    }
+
+    if (!IS_NUMBER(args[1])) {
+        runtimeError(vm,
+                      "writeInt8() index argument must be a number");
+        return EMPTY_VAL;
+    }
+    if (!IS_NUMBER(args[2])) {
+        runtimeError(vm,
+                    "writeInt8() value argument must be a number");
+        return EMPTY_VAL;
+    }
+    double index = AS_NUMBER(args[1]);
+    double value = AS_NUMBER(args[2]);
+
+    int8_t correctVal = (int8_t)value;
+
+    if (!writeInternal(
+            buffer, index,
+            swap((uint8_t *)&correctVal, sizeof(correctVal), buffer->bigEndian),
+            sizeof(correctVal)))
+        return newResultError(vm, "index must be smaller than buffer size - 1");
+    return newResultSuccess(vm, NUMBER_VAL(correctVal));
+}
+static Value bufferWriteUint16LE(DictuVM *vm, int argCount, Value *args) {
+    Buffer *buffer = AS_BUFFER(args[0]);
+    if (argCount != 2) {
+        runtimeError(vm, buffer->bigEndian
+                             ? "writeUInt16BE() takes 2 argument"
+                             : "writeUInt16LE() takes 2 argument");
+        return EMPTY_VAL;
+    }
+
+    if (!IS_NUMBER(args[1])) {
+        runtimeError(vm,
+                     buffer->bigEndian
+                         ? "writeUInt16BE() index argument must be a number"
+                         : "writeUInt16LE() index argument must be a number");
+        return EMPTY_VAL;
+    }
+    if (!IS_NUMBER(args[2])) {
+        runtimeError(vm,
+                     buffer->bigEndian
+                         ? "writeUInt16BE() value argument must be a number"
+                         : "writeUInt16LE() value argument must be a number");
+        return EMPTY_VAL;
+    }
+    double index = AS_NUMBER(args[1]);
+    double value = AS_NUMBER(args[2]);
+
+    uint16_t correctVal = (uint16_t)value;
+
+    if (!writeInternal(
+            buffer, index,
+            swap((uint8_t *)&correctVal, sizeof(correctVal), buffer->bigEndian),
+            sizeof(correctVal)))
+        return newResultError(vm, "index must be smaller than buffer size - 2");
+    return newResultSuccess(vm, NUMBER_VAL(correctVal));
+}
+
+static Value bufferWriteUint32LE(DictuVM *vm, int argCount, Value *args) {
+    Buffer *buffer = AS_BUFFER(args[0]);
+    if (argCount != 2) {
+        runtimeError(vm, buffer->bigEndian
+                             ? "writeUInt32BE() takes 2 argument"
+                             : "writeUInt32LE() takes 2 argument");
+        return EMPTY_VAL;
+    }
+
+    if (!IS_NUMBER(args[1])) {
+        runtimeError(vm,
+                     buffer->bigEndian
+                         ? "writeUInt32BE() index argument must be a number"
+                         : "writeUInt32LE() index argument must be a number");
+        return EMPTY_VAL;
+    }
+    if (!IS_NUMBER(args[2])) {
+        runtimeError(vm,
+                     buffer->bigEndian
+                         ? "writeUInt32BE() value argument must be a number"
+                         : "writeUInt32LE() value argument must be a number");
+        return EMPTY_VAL;
+    }
+    double index = AS_NUMBER(args[1]);
+    double value = AS_NUMBER(args[2]);
+
+    uint32_t correctVal = (uint32_t)value;
+    if (!writeInternal(
+            buffer, index,
+            swap((uint8_t *)&correctVal, sizeof(correctVal), buffer->bigEndian),
+            sizeof(correctVal)))
+        return newResultError(vm, "index must be smaller than buffer size - 4");
+    return newResultSuccess(vm, NUMBER_VAL(correctVal));
+}
+
+static Value bufferWriteUint64LE(DictuVM *vm, int argCount, Value *args) {
+    Buffer *buffer = AS_BUFFER(args[0]);
+    if (argCount != 2) {
+        runtimeError(vm, buffer->bigEndian
+                             ? "writeUInt64BE() takes 2 argument"
+                             : "writeUInt64LE() takes 2 argument");
+        return EMPTY_VAL;
+    }
+
+    if (!IS_NUMBER(args[1])) {
+        runtimeError(vm,
+                     buffer->bigEndian
+                         ? "writeUInt64BE() index argument must be a number"
+                         : "writeUInt64LE() index argument must be a number");
+        return EMPTY_VAL;
+    }
+    if (!IS_NUMBER(args[2])) {
+        runtimeError(vm,
+                     buffer->bigEndian
+                         ? "writeUInt64BE() value argument must be a number"
+                         : "writeUInt64LE() value argument must be a number");
+        return EMPTY_VAL;
+    }
+    double index = AS_NUMBER(args[1]);
+    double value = AS_NUMBER(args[2]);
+
+    uint64_t correctVal = (uint64_t)value;
+    if (!writeInternal(
+            buffer, index,
+            swap((uint8_t *)&correctVal, sizeof(correctVal), buffer->bigEndian),
+            sizeof(correctVal)))
+        return newResultError(vm, "index must be smaller than buffer size - 8");
+    return newResultSuccess(vm, NUMBER_VAL(correctVal));
+}
+
+static Value bufferWriteint64LE(DictuVM *vm, int argCount, Value *args) {
+    Buffer *buffer = AS_BUFFER(args[0]);
+    if (argCount != 2) {
+        runtimeError(vm, buffer->bigEndian ? "writeInt64BE() takes 2 argument"
+                                           : "writeInt64LE() takes 2 argument");
+        return EMPTY_VAL;
+    }
+
+    if (!IS_NUMBER(args[1])) {
+        runtimeError(vm,
+                     buffer->bigEndian
+                         ? "writeInt64BE() index argument must be a number"
+                         : "writeInt64LE() index argument must be a number");
+        return EMPTY_VAL;
+    }
+    if (!IS_NUMBER(args[2])) {
+        runtimeError(vm,
+                     buffer->bigEndian
+                         ? "writeInt64BE() value argument must be a number"
+                         : "writeInt64LE() value argument must be a number");
+        return EMPTY_VAL;
+    }
+    double index = AS_NUMBER(args[1]);
+    double value = AS_NUMBER(args[2]);
+    int64_t correctVal = (int64_t)value;
+    if (!writeInternal(
+            buffer, index,
+            swap((uint8_t *)&correctVal, sizeof(correctVal), buffer->bigEndian),
+            sizeof(correctVal)))
+        return newResultError(vm, "index must be smaller than buffer size - 8");
+    return newResultSuccess(vm, NUMBER_VAL(correctVal));
+}
+
+static Value bufferWriteint32LE(DictuVM *vm, int argCount, Value *args) {
+    Buffer *buffer = AS_BUFFER(args[0]);
+    if (argCount != 2) {
+        runtimeError(vm, buffer->bigEndian ? "writeInt32BE() takes 2 argument"
+                                           : "writeInt32LE() takes 2 argument");
+        return EMPTY_VAL;
+    }
+
+    if (!IS_NUMBER(args[1])) {
+        runtimeError(vm,
+                     buffer->bigEndian
+                         ? "writeInt32BE() index argument must be a number"
+                         : "writeInt32LE() index argument must be a number");
+        return EMPTY_VAL;
+    }
+    if (!IS_NUMBER(args[2])) {
+        runtimeError(vm,
+                     buffer->bigEndian
+                         ? "writeInt32BE() value argument must be a number"
+                         : "writeInt32LE() value argument must be a number");
+        return EMPTY_VAL;
+    }
+    double index = AS_NUMBER(args[1]);
+    double value = AS_NUMBER(args[2]);
+
+    int32_t correctVal = (int32_t)value;
+    if (!writeInternal(
+            buffer, index,
+            swap((uint8_t *)&correctVal, sizeof(correctVal), buffer->bigEndian),
+            sizeof(correctVal)))
+        return newResultError(vm, "index must be smaller than buffer size - 4");
+    return newResultSuccess(vm, NUMBER_VAL(correctVal));
+}
+
+static Value bufferWriteint16LE(DictuVM *vm, int argCount, Value *args) {
+    Buffer *buffer = AS_BUFFER(args[0]);
+    if (argCount != 2) {
+        runtimeError(vm, buffer->bigEndian ? "writeInt16BE() takes 2 argument"
+                                           : "writeInt16LE() takes 2 argument");
+        return EMPTY_VAL;
+    }
+
+    if (!IS_NUMBER(args[1])) {
+        runtimeError(vm,
+                     buffer->bigEndian
+                         ? "writeInt16BE() index argument must be a number"
+                         : "writeInt16LE() index argument must be a number");
+        return EMPTY_VAL;
+    }
+    if (!IS_NUMBER(args[2])) {
+        runtimeError(vm,
+                     buffer->bigEndian
+                         ? "writeInt16BE() value argument must be a number"
+                         : "writeInt16LE() value argument must be a number");
+        return EMPTY_VAL;
+    }
+    double index = AS_NUMBER(args[1]);
+    double value = AS_NUMBER(args[2]);
+
+    int16_t correctVal = (int16_t)value;
+    if (!writeInternal(
+            buffer, index,
+            swap((uint8_t *)&correctVal, sizeof(correctVal), buffer->bigEndian),
+            sizeof(correctVal)))
+        return newResultError(vm, "index must be smaller than buffer size - 2");
+    return newResultSuccess(vm, NUMBER_VAL(correctVal));
+}
+
+static Value bufferWritefloat32LE(DictuVM *vm, int argCount, Value *args) {
+    Buffer *buffer = AS_BUFFER(args[0]);
+    if (argCount != 2) {
+        runtimeError(vm, buffer->bigEndian ? "writeFloatBE() takes 2 argument"
+                                           : "writeFloatLE() takes 2 argument");
+        return EMPTY_VAL;
+    }
+
+    if (!IS_NUMBER(args[1])) {
+        runtimeError(vm,
+                     buffer->bigEndian
+                         ? "writeFloatBE() index argument must be a number"
+                         : "writeFloatLE() index argument must be a number");
+        return EMPTY_VAL;
+    }
+    if (!IS_NUMBER(args[2])) {
+        runtimeError(vm,
+                     buffer->bigEndian
+                         ? "writeFloatBE() value argument must be a number"
+                         : "writeFloatLE() value argument must be a number");
+        return EMPTY_VAL;
+    }
+    double index = AS_NUMBER(args[1]);
+    double value = AS_NUMBER(args[2]);
+
+    float correctVal = (float)value;
+    if (!writeInternal(
+            buffer, index,
+            swap((uint8_t *)&correctVal, sizeof(correctVal), buffer->bigEndian),
+            sizeof(correctVal)))
+        return newResultError(vm, "index must be smaller than buffer size - 4");
+    return newResultSuccess(vm, NUMBER_VAL(correctVal));
+}
+
+static Value bufferWritefloat64LE(DictuVM *vm, int argCount, Value *args) {
+    Buffer *buffer = AS_BUFFER(args[0]);
+    if (argCount != 2) {
+        runtimeError(vm, buffer->bigEndian
+                             ? "writeDoubleBE() takes 2 argument"
+                             : "writeDoubleLE() takes 2 argument");
+        return EMPTY_VAL;
+    }
+
+    if (!IS_NUMBER(args[1])) {
+        runtimeError(vm,
+                     buffer->bigEndian
+                         ? "writeDoubleBE() index argument must be a number"
+                         : "writeDoubleLE() index argument must be a number");
+        return EMPTY_VAL;
+    }
+    if (!IS_NUMBER(args[2])) {
+        runtimeError(vm,
+                     buffer->bigEndian
+                         ? "writeDoubleBE() value argument must be a number"
+                         : "writeDoubleLE() value argument must be a number");
+        return EMPTY_VAL;
+    }
+    double index = AS_NUMBER(args[1]);
+    double value = AS_NUMBER(args[2]);
+
+    double correctVal = value;
+
+    if (!writeInternal(
+            buffer, index,
+            swap((uint8_t *)&correctVal, sizeof(correctVal), buffer->bigEndian),
+            sizeof(correctVal)))
+        return newResultError(vm, "index must be smaller than buffer size - 8");
+    return newResultSuccess(vm, NUMBER_VAL(correctVal));
+}
+
+static Value bufferReadfloat64LE(DictuVM *vm, int argCount, Value *args) {
+    Buffer *buffer = AS_BUFFER(args[0]);
+    if (argCount != 1) {
+        runtimeError(vm, buffer->bigEndian ? "readDoubleBE() takes 1 argument"
+                                           : "readDoubleLE() takes 1 argument");
+        return EMPTY_VAL;
+    }
+
+    if (!IS_NUMBER(args[1])) {
+        runtimeError(vm,
+                     buffer->bigEndian
+                         ? "readDoubleBE() index argument must be a number"
+                         : "readDoubleLE() index argument must be a number");
+        return EMPTY_VAL;
+    }
+    double index = AS_NUMBER(args[1]);
+    double value;
+
+    uint8_t *ptr = getReadPtr(buffer, index, sizeof(value));
+    if (ptr == NULL)
+        return newResultError(vm, "index must be smaller than buffer size - 8");
+    memcpy(&value, ptr, sizeof(value));
+    swap((uint8_t *)&value, sizeof(value), buffer->bigEndian);
+
+    return newResultSuccess(vm, NUMBER_VAL(value));
+}
+
+static Value bufferReadfloat32LE(DictuVM *vm, int argCount, Value *args) {
+    Buffer *buffer = AS_BUFFER(args[0]);
+    if (argCount != 1) {
+        runtimeError(vm, buffer->bigEndian ? "readFloatBE() takes 1 argument"
+                                           : "readFloatLE() takes 1 argument");
+        return EMPTY_VAL;
+    }
+
+    if (!IS_NUMBER(args[1])) {
+        runtimeError(vm, buffer->bigEndian
+                             ? "readFloatBE() index argument must be a number"
+                             : "readFloatLE() index argument must be a number");
+        return EMPTY_VAL;
+    }
+    double index = AS_NUMBER(args[1]);
+    float value;
+
+    uint8_t *ptr = getReadPtr(buffer, index, sizeof(value));
+    if (ptr == NULL)
+        return newResultError(vm, "index must be smaller than buffer size - 4");
+    memcpy(&value, ptr, sizeof(value));
+    swap((uint8_t *)&value, sizeof(value), buffer->bigEndian);
+    return newResultSuccess(vm, NUMBER_VAL(value));
+}
+
+static Value bufferReadUint64LE(DictuVM *vm, int argCount, Value *args) {
+    Buffer *buffer = AS_BUFFER(args[0]);
+    if (argCount != 1) {
+        runtimeError(vm, buffer->bigEndian ? "readUInt64BE() takes 1 argument"
+                                           : "readUInt64LE() takes 1 argument");
+        return EMPTY_VAL;
+    }
+
+    if (!IS_NUMBER(args[1])) {
+        runtimeError(vm,
+                     buffer->bigEndian
+                         ? "readUInt64BE() index argument must be a number"
+                         : "readUInt64LE() index argument must be a number");
+        return EMPTY_VAL;
+    }
+    double index = AS_NUMBER(args[1]);
+    uint64_t value;
+
+    uint8_t *ptr = getReadPtr(buffer, index, sizeof(value));
+    if (ptr == NULL)
+        return newResultError(vm, "index must be smaller than buffer size - 8");
+    memcpy(&value, ptr, sizeof(value));
+    swap((uint8_t *)&value, sizeof(value), buffer->bigEndian);
+
+    // Above this value theres no guarantee that the integer value is correctly represented,
+    // so if are above that we don't allow it, 
+    const uint64_t MAX_VALUE = 9007199254740992;
+    if (value > MAX_VALUE){
+        return newResultError(vm,
+                              "value too large for internal representation");
+    }
+    return newResultSuccess(vm, NUMBER_VAL(value));
+}
+
+static Value bufferReadUint32LE(DictuVM *vm, int argCount, Value *args) {
+    Buffer *buffer = AS_BUFFER(args[0]);
+    if (argCount != 1) {
+        runtimeError(vm, buffer->bigEndian ? "readUInt32BE() takes 1 argument"
+                                           : "readUInt32LE() takes 1 argument");
+        return EMPTY_VAL;
+    }
+
+    if (!IS_NUMBER(args[1])) {
+        runtimeError(vm,
+                     buffer->bigEndian
+                         ? "readUInt32BE() index argument must be a number"
+                         : "readUInt32LE() index argument must be a number");
+        return EMPTY_VAL;
+    }
+    double index = AS_NUMBER(args[1]);
+    uint32_t value;
+    uint8_t *ptr = getReadPtr(buffer, index, sizeof(value));
+    if (ptr == NULL)
+        return newResultError(vm, "index must be smaller than buffer size - 4");
+    memcpy(&value, ptr, sizeof(value));
+    swap((uint8_t *)&value, sizeof(value), buffer->bigEndian);
+    return newResultSuccess(vm, NUMBER_VAL(value));
+}
+
+static Value bufferReadUint16LE(DictuVM *vm, int argCount, Value *args) {
+    Buffer *buffer = AS_BUFFER(args[0]);
+    if (argCount != 1) {
+        runtimeError(vm, buffer->bigEndian ? "readUInt16BE() takes 1 argument"
+                                           : "readUInt16LE() takes 1 argument");
+        return EMPTY_VAL;
+    }
+
+    if (!IS_NUMBER(args[1])) {
+        runtimeError(vm,
+                     buffer->bigEndian
+                         ? "readUInt16BE() index argument must be a number"
+                         : "readUInt16LE() index argument must be a number");
+        return EMPTY_VAL;
+    }
+    double index = AS_NUMBER(args[1]);
+
+    uint16_t value;
+    uint8_t *ptr = getReadPtr(buffer, index, sizeof(value));
+    if (ptr == NULL)
+        return newResultError(vm, "index must be smaller than buffer size - 2");
+    memcpy(&value, ptr, sizeof(value));
+    swap((uint8_t *)&value, sizeof(value), buffer->bigEndian);
+    return newResultSuccess(vm, NUMBER_VAL(value));
+}
+
+static Value bufferReadint64LE(DictuVM *vm, int argCount, Value *args) {
+    Buffer *buffer = AS_BUFFER(args[0]);
+    if (argCount != 1) {
+        runtimeError(vm, buffer->bigEndian ? "readInt64BE() takes 1 argument"
+                                           : "readInt64LE() takes 1 argument");
+        return EMPTY_VAL;
+    }
+
+    if (!IS_NUMBER(args[1])) {
+        runtimeError(vm, buffer->bigEndian
+                             ? "readInt64BE() index argument must be a number"
+                             : "readInt64LE() index argument must be a number");
+        return EMPTY_VAL;
+    }
+    double index = AS_NUMBER(args[1]);
+    int64_t value;
+    uint8_t *ptr = getReadPtr(buffer, index, sizeof(value));
+    if (ptr == NULL)
+        return newResultError(vm, "index must be smaller than buffer size - 8");
+    memcpy(&value, ptr, sizeof(value));
+
+    swap((uint8_t *)&value, sizeof(value), buffer->bigEndian);
+    // Above this value theres no guarantee that the integer value is correctly represented,
+    // so if are above that we don't allow it, 
+    const int64_t MAX_VALUE = 9007199254740992;
+    if (value > MAX_VALUE || value < -MAX_VALUE){
+        return newResultError(vm,
+                              "value too large for internal representation");
+    }
+    return newResultSuccess(vm, NUMBER_VAL(value));
+}
+
+static Value bufferReadint32LE(DictuVM *vm, int argCount, Value *args) {
+    Buffer *buffer = AS_BUFFER(args[0]);
+    if (argCount != 1) {
+        runtimeError(vm, buffer->bigEndian ? "readInt32BE() takes 1 argument"
+                                           : "readInt32LE() takes 1 argument");
+        return EMPTY_VAL;
+    }
+
+    if (!IS_NUMBER(args[1])) {
+        runtimeError(vm, buffer->bigEndian
+                             ? "readInt32BE() index argument must be a number"
+                             : "readInt32LE() index argument must be a number");
+        return EMPTY_VAL;
+    }
+    double index = AS_NUMBER(args[1]);
+
+    int32_t value;
+    uint8_t *ptr = getReadPtr(buffer, index, sizeof(value));
+    if (ptr == NULL)
+        return newResultError(vm, "index must be smaller than buffer size - 4");
+    memcpy(&value, ptr, sizeof(value));
+    swap((uint8_t *)&value, sizeof(value), buffer->bigEndian);
+    return newResultSuccess(vm, NUMBER_VAL(value));
+}
+
+static Value bufferReadint16LE(DictuVM *vm, int argCount, Value *args) {
+    Buffer *buffer = AS_BUFFER(args[0]);
+    if (argCount != 1) {
+        runtimeError(vm, buffer->bigEndian ? "readInt16BE() takes 1 argument"
+                                           : "readInt16LE() takes 1 argument");
+        return EMPTY_VAL;
+    }
+
+    if (!IS_NUMBER(args[1])) {
+        runtimeError(vm, buffer->bigEndian
+                             ? "readInt16BE() index argument must be a number"
+                             : "readInt16LE() index argument must be a number");
+        return EMPTY_VAL;
+    }
+    double index = AS_NUMBER(args[1]);
+
+    int16_t value;
+    uint8_t *ptr = getReadPtr(buffer, index, sizeof(value));
+    if (ptr == NULL)
+        return newResultError(vm, "index must be smaller than buffer size - 2");
+    memcpy(&value, ptr, sizeof(value));
+    swap((uint8_t *)&value, sizeof(value), buffer->bigEndian);
+    return newResultSuccess(vm, NUMBER_VAL(value));
+}
+
+static Value bufferReadint8(DictuVM *vm, int argCount, Value *args) {
+    Buffer *buffer = AS_BUFFER(args[0]);
+    if (argCount != 1) {
+        runtimeError(vm, "readInt8() takes 1 argument");
+        return EMPTY_VAL;
+    }
+
+    if (!IS_NUMBER(args[1])) {
+        runtimeError(vm, "readInt8() index argument must be a number");
+        return EMPTY_VAL;
+    }
+    double index = AS_NUMBER(args[1]);
+
+    int8_t value;
+    uint8_t *ptr = getReadPtr(buffer, index, sizeof(value));
+    if (ptr == NULL)
+        return newResultError(vm, "index must be smaller than buffer size - 1");
+    memcpy(&value, ptr, sizeof(value));
+    swap((uint8_t *)&value, sizeof(value), buffer->bigEndian);
+    return newResultSuccess(vm, NUMBER_VAL(value));
+}
+
+typedef Value buffer_func_t(DictuVM *vm, int argCount, Value *args);
+// is this hacky?
+static Value runBigEndian(DictuVM *vm, int argCount, Value *args,
+                          buffer_func_t *f) {
+    Buffer *buffer = AS_BUFFER(args[0]);
+    buffer->bigEndian = true;
+    Value result = f(vm, argCount, args);
+    buffer->bigEndian = false;
+    return result;
+}
+
+static Value bufferReadUint64BE(DictuVM *vm, int argCount, Value *args) {
+    return runBigEndian(vm, argCount, args, &bufferReadUint64LE);
+}
+
+static Value bufferReadUint32BE(DictuVM *vm, int argCount, Value *args) {
+    return runBigEndian(vm, argCount, args, &bufferReadUint32LE);
+}
+
+static Value bufferReadUint16BE(DictuVM *vm, int argCount, Value *args) {
+    return runBigEndian(vm, argCount, args, &bufferReadUint16LE);
+}
+
+static Value bufferReadint64BE(DictuVM *vm, int argCount, Value *args) {
+    return runBigEndian(vm, argCount, args, &bufferReadint64LE);
+}
+
+static Value bufferReadint32BE(DictuVM *vm, int argCount, Value *args) {
+    return runBigEndian(vm, argCount, args, &bufferReadint32LE);
+}
+
+static Value bufferReadint16BE(DictuVM *vm, int argCount, Value *args) {
+    return runBigEndian(vm, argCount, args, &bufferReadint16LE);
+}
+
+static Value bufferReadfloat32BE(DictuVM *vm, int argCount, Value *args) {
+    return runBigEndian(vm, argCount, args, &bufferReadfloat32LE);
+}
+
+static Value bufferReadfloat64BE(DictuVM *vm, int argCount, Value *args) {
+    return runBigEndian(vm, argCount, args, &bufferReadfloat64LE);
+}
+
+static Value bufferWriteUint64BE(DictuVM *vm, int argCount, Value *args) {
+    return runBigEndian(vm, argCount, args, &bufferWriteUint64LE);
+}
+
+static Value bufferWriteUint32BE(DictuVM *vm, int argCount, Value *args) {
+    return runBigEndian(vm, argCount, args, &bufferWriteUint32LE);
+}
+
+static Value bufferWriteUint16BE(DictuVM *vm, int argCount, Value *args) {
+    return runBigEndian(vm, argCount, args, &bufferWriteUint16LE);
+}
+
+static Value bufferWriteint64BE(DictuVM *vm, int argCount, Value *args) {
+    return runBigEndian(vm, argCount, args, &bufferWriteint64LE);
+}
+
+static Value bufferWriteint32BE(DictuVM *vm, int argCount, Value *args) {
+    return runBigEndian(vm, argCount, args, &bufferWriteint32LE);
+}
+
+static Value bufferWriteint16BE(DictuVM *vm, int argCount, Value *args) {
+    return runBigEndian(vm, argCount, args, &bufferWriteint16LE);
+}
+
+static Value bufferWritefloat32BE(DictuVM *vm, int argCount, Value *args) {
+    return runBigEndian(vm, argCount, args, &bufferWritefloat32LE);
+}
+
+static Value bufferWritefloat64BE(DictuVM *vm, int argCount, Value *args) {
+    return runBigEndian(vm, argCount, args, &bufferWritefloat64LE);
+}
+
+static Value bufferGet(DictuVM *vm, int argCount, Value *args) {
+    if (argCount != 1) {
+        runtimeError(vm, "get() takes 1 argument (%d given).", argCount);
+        return EMPTY_VAL;
+    }
+
+    if (!IS_NUMBER(args[1])) {
+        runtimeError(vm, "get() argument must be a number");
+        return EMPTY_VAL;
+    }
+
+    double index = AS_NUMBER(args[1]);
+    if (index < 0) {
+        return newResultError(vm, "index must be greater than -1");
+    }
+    Buffer *buffer = AS_BUFFER(args[0]);
+    if (index >= buffer->size) {
+        return newResultError(vm, "index must be smaller than buffer size");
+    }
+
+    return newResultSuccess(vm, NUMBER_VAL(buffer->bytes[(size_t)index]));
+}
+
+static Value bufferSet(DictuVM *vm, int argCount, Value *args) {
+    if (argCount != 2) {
+        runtimeError(vm, "set() takes 2 argument (%d given).", argCount);
+        return EMPTY_VAL;
+    }
+
+    if (!IS_NUMBER(args[1])) {
+        runtimeError(vm, "set() index argument must be a number");
+        return EMPTY_VAL;
+    }
+
+    if (!IS_NUMBER(args[2])) {
+        runtimeError(vm, "set() value argument must be a number");
+        return EMPTY_VAL;
+    }
+
+    double index = AS_NUMBER(args[1]);
+    double value = AS_NUMBER(args[2]);
+    if (index < 0) {
+        return newResultError(vm, "index must be greater than -1");
+    }
+    Buffer *buffer = AS_BUFFER(args[0]);
+    if (index >= buffer->size) {
+        return newResultError(vm, "index must be smaller than buffer size");
+    }
+
+    buffer->bytes[(size_t)index] = (uint8_t)value;
+
+    return newResultSuccess(vm, NUMBER_VAL(buffer->bytes[(size_t)index]));
+}
+
+static Value bufferWriteString(DictuVM *vm, int argCount, Value *args) {
+    if (argCount != 2) {
+        runtimeError(vm, "writeString() takes 2 argument (%d given).",
+                     argCount);
+        return EMPTY_VAL;
+    }
+
+    if (!IS_NUMBER(args[1])) {
+        runtimeError(vm, "writeString() index argument must be a number");
+        return EMPTY_VAL;
+    }
+
+    if (!IS_STRING(args[2])) {
+        runtimeError(vm, "writeString() value argument must be a string");
+        return EMPTY_VAL;
+    }
+
+    double index = AS_NUMBER(args[1]);
+    ObjString *str = AS_STRING(args[2]);
+    if (index < 0) {
+        return newResultError(vm, "index must be greater than -1");
+    }
+    Buffer *buffer = AS_BUFFER(args[0]);
+    if (index >= buffer->size) {
+        return newResultError(vm, "index must be smaller than buffer size");
+    }
+
+    if (buffer->size - index < str->length) {
+        return newResultError(vm,
+                              "buffer is not large enough to fit the string");
+    }
+    memcpy(buffer->bytes + (size_t)index, str->chars, str->length);
+    return newResultSuccess(vm, NIL_VAL);
+}
+
+static Value bufferReadString(DictuVM *vm, int argCount, Value *args) {
+    Buffer *buffer = AS_BUFFER(args[0]);
+    size_t start = 0;
+    size_t end = buffer->size;
+    int length = buffer->size;
+    if (argCount > 0) {
+        if (!IS_NUMBER(args[1])) {
+            runtimeError(vm, "readString() start argument must be a number");
+            return EMPTY_VAL;
+        }
+        double startParam = AS_NUMBER(args[1]);
+        if (startParam >= buffer->size) {
+            return newResultError(vm,
+                                  "start greater or equals than buffer length");
+        } else {
+            start = startParam;
+            length = end - start;
+        }
+    }
+    if (argCount == 2) {
+        if (!IS_NUMBER(args[2])) {
+            runtimeError(vm, "readString() end argument must be a number");
+            return EMPTY_VAL;
+        }
+        double endParam = AS_NUMBER(args[2]);
+        if (endParam > buffer->size) {
+            return newResultError(vm, "end greater than buffer length");
+        } else {
+            end = endParam;
+            length = end - start;
+        }
+    }
+    if (length <= 0) {
+        return newResultError(vm, "string length is 0");
+    }
+    return newResultSuccess(
+        vm,
+        OBJ_VAL(copyString(vm, (const char *)buffer->bytes + start, length)));
+}
+
+static Value bufferSubArray(DictuVM *vm, int argCount, Value *args) {
+    Buffer *buffer = AS_BUFFER(args[0]);
+    size_t start = 0;
+    size_t end = buffer->size;
+    int length = buffer->size;
+    if (argCount > 0) {
+        if (!IS_NUMBER(args[1])) {
+            runtimeError(vm, "subarray() start argument must be a number");
+            return EMPTY_VAL;
+        }
+        double startParam = AS_NUMBER(args[1]);
+        if (startParam >= buffer->size) {
+            return newResultError(vm,
+                                  "start greater or equals than buffer length");
+        } else {
+            start = startParam;
+            length = end - start;
+        }
+    }
+    if (argCount == 2) {
+        if (!IS_NUMBER(args[2])) {
+            runtimeError(vm, "subarray() end argument must be a number");
+            return EMPTY_VAL;
+        }
+        double endParam = AS_NUMBER(args[2]);
+        if (endParam > buffer->size) {
+            return newResultError(vm, "end greater than buffer length");
+        } else {
+            end = endParam;
+            length = end - start;
+        }
+    }
+    if (length <= 0) {
+        return newResultError(vm, "array length is 0");
+    }
+    ObjAbstract *newBuffer = newBufferObj(vm, length);
+    Buffer *nb = (Buffer *)newBuffer->data;
+    for (int i = 0; i < length; i++) {
+        nb->bytes[i] = buffer->bytes[start + i];
+    }
+    return newResultSuccess(vm, OBJ_VAL(newBuffer));
+}
+
+ObjAbstract *newBufferObj(DictuVM *vm, double capacity) {
+    ObjAbstract *abstract = newAbstract(vm, freeBuffer, bufferToString);
+    push(vm, OBJ_VAL(abstract));
+
+    Buffer *buffer = ALLOCATE(vm, Buffer, 1);
+    buffer->bigEndian = false;
+    buffer->bytes = ALLOCATE(vm, uint8_t, capacity);
+    memset(buffer->bytes, 0, capacity);
+    buffer->size = capacity;
+
+    /**
+     * Setup Buffer object methods
+     */
+    defineNative(vm, &abstract->values, "resize", bufferResize);
+    defineNative(vm, &abstract->values, "set", bufferSet);
+    defineNative(vm, &abstract->values, "get", bufferGet);
+    defineNative(vm, &abstract->values, "subarray", bufferSubArray);
+    defineNative(vm, &abstract->values, "string", bufferString);
+    defineNative(vm, &abstract->values, "len", bufferLen);
+    defineNative(vm, &abstract->values, "values", bufferValues);
+
+    defineNative(vm, &abstract->values, "writeString", bufferWriteString);
+    defineNative(vm, &abstract->values, "readString", bufferReadString);
+
+    defineNative(vm, &abstract->values, "readUInt64LE", bufferReadUint64LE);
+    defineNative(vm, &abstract->values, "readUInt32LE", bufferReadUint32LE);
+    defineNative(vm, &abstract->values, "readUInt16LE", bufferReadUint16LE);
+    defineNative(vm, &abstract->values, "readInt64LE", bufferReadint64LE);
+    defineNative(vm, &abstract->values, "readInt32LE", bufferReadint32LE);
+    defineNative(vm, &abstract->values, "readInt16LE", bufferReadint16LE);
+    defineNative(vm, &abstract->values, "readInt8", bufferReadint8);
+
+    defineNative(vm, &abstract->values, "readFloatLE", bufferReadfloat32LE);
+    defineNative(vm, &abstract->values, "readDoubleLE", bufferReadfloat64LE);
+
+    defineNative(vm, &abstract->values, "writeUInt64LE", bufferWriteUint64LE);
+    defineNative(vm, &abstract->values, "writeUInt32LE", bufferWriteUint32LE);
+    defineNative(vm, &abstract->values, "writeUInt16LE", bufferWriteUint16LE);
+    defineNative(vm, &abstract->values, "writeInt64LE", bufferWriteint64LE);
+    defineNative(vm, &abstract->values, "writeInt32LE", bufferWriteint32LE);
+    defineNative(vm, &abstract->values, "writeInt16LE", bufferWriteint16LE);
+    defineNative(vm, &abstract->values, "writeInt8", bufferWriteint8);
+
+    defineNative(vm, &abstract->values, "writeFloatLE", bufferWritefloat32LE);
+    defineNative(vm, &abstract->values, "writeDoubleLE", bufferWritefloat64LE);
+
+    defineNative(vm, &abstract->values, "readUInt64BE", bufferReadUint64BE);
+    defineNative(vm, &abstract->values, "readUInt32BE", bufferReadUint32BE);
+    defineNative(vm, &abstract->values, "readUInt16BE", bufferReadUint16BE);
+    defineNative(vm, &abstract->values, "readInt64BE", bufferReadint64BE);
+    defineNative(vm, &abstract->values, "readInt32BE", bufferReadint32BE);
+    defineNative(vm, &abstract->values, "readInt16BE", bufferReadint16BE);
+
+    defineNative(vm, &abstract->values, "readFloatBE", bufferReadfloat32BE);
+    defineNative(vm, &abstract->values, "readDoubleBE", bufferReadfloat64BE);
+
+    defineNative(vm, &abstract->values, "writeUInt64BE", bufferWriteUint64BE);
+    defineNative(vm, &abstract->values, "writeUInt32BE", bufferWriteUint32BE);
+    defineNative(vm, &abstract->values, "writeUInt16BE", bufferWriteUint16BE);
+    defineNative(vm, &abstract->values, "writeInt64BE", bufferWriteint64BE);
+    defineNative(vm, &abstract->values, "writeInt32BE", bufferWriteint32BE);
+    defineNative(vm, &abstract->values, "writeInt16BE", bufferWriteint16BE);
+
+    defineNative(vm, &abstract->values, "writeFloatBE", bufferWritefloat32BE);
+    defineNative(vm, &abstract->values, "writeDoubleBE", bufferWritefloat64BE);
+
+    abstract->data = buffer;
+    pop(vm);
+
+    return abstract;
+}
+
+static Value newBuffer(DictuVM *vm, int argCount, Value *args) {
+    if (argCount != 1) {
+        runtimeError(vm, "new() takes 1 argument (%d given).", argCount);
+        return EMPTY_VAL;
+    }
+
+    if (!IS_NUMBER(args[0])) {
+        runtimeError(vm, "new() argument must be a numbers");
+        return EMPTY_VAL;
+    }
+
+    double capacity = AS_NUMBER(args[0]);
+    if (capacity <= 0 || capacity >= BUFFER_SIZE_MAX) {
+        return newResultError(
+            vm, "capacity must be greater than 0 and less than 2147483647");
+    }
+
+    return newResultSuccess(vm, OBJ_VAL(newBufferObj(vm, capacity)));
+}
+
+static Value newBufferFromString(DictuVM *vm, int argCount, Value *args) {
+    if (argCount != 1) {
+        runtimeError(vm, "fromString() takes 1 argument (%d given).", argCount);
+        return EMPTY_VAL;
+    }
+
+    if (!IS_STRING(args[0])) {
+        runtimeError(vm, "fromString() argument must be a string");
+        return EMPTY_VAL;
+    }
+
+    ObjString *str = AS_STRING(args[0]);
+    if (str->length <= 0) {
+        return newResultError(vm, "string length needs to be greater than 0");
+    }
+    ObjAbstract *b = newBufferObj(vm, str->length);
+    Buffer *buffer = (Buffer *)b->data;
+    memcpy(buffer->bytes, str->chars, str->length);
+    return newResultSuccess(vm, OBJ_VAL(b));
+}
+
+Value createBufferModule(DictuVM *vm) {
+    ObjString *name = copyString(vm, "Buffer", 6);
+    push(vm, OBJ_VAL(name));
+    ObjModule *module = newModule(vm, name);
+    push(vm, OBJ_VAL(module));
+
+    defineNative(vm, &module->values, "new", newBuffer);
+    defineNative(vm, &module->values, "fromString", newBufferFromString);
+
+    pop(vm);
+    pop(vm);
+
+    return OBJ_VAL(module);
+}
\ No newline at end of file
diff --git a/src/optionals/buffer.h b/src/optionals/buffer.h
new file mode 100644
index 00000000..9d77f06e
--- /dev/null
+++ b/src/optionals/buffer.h
@@ -0,0 +1,14 @@
+#ifndef dictu_buffer_h
+#define dictu_buffer_h
+
+
+#include "optionals.h"
+#include "../vm/vm.h"
+
+#define BUFFER_SIZE_MAX 2147483647
+
+#define IS_BIG_ENDIAN (!*(unsigned char *)&(uint16_t){1})
+
+Value createBufferModule(DictuVM *vm);
+
+#endif //dictu_buffer_h
\ No newline at end of file
diff --git a/src/optionals/optionals.c b/src/optionals/optionals.c
index d76a5e3a..f175f2d7 100644
--- a/src/optionals/optionals.c
+++ b/src/optionals/optionals.c
@@ -30,6 +30,7 @@ BuiltinModules modules[] = {
     {"HTTP", &createHTTPModule, true},
 #endif
     {"BigInt", &createBigIntModule, false},
+    {"Buffer", &createBufferModule, false},
     {NULL, NULL, false}
 };
 
diff --git a/src/optionals/optionals.h b/src/optionals/optionals.h
index f39f11c0..169218c2 100644
--- a/src/optionals/optionals.h
+++ b/src/optionals/optionals.h
@@ -27,6 +27,7 @@
 #include "stack.h"
 #include "bigint.h"
 #include "object/object.h"
+#include "buffer.h"
 #include "unittest/unittest.h"
 
 typedef Value (*BuiltinModule)(DictuVM *vm);
diff --git a/tests/buffer/allocate.du b/tests/buffer/allocate.du
new file mode 100644
index 00000000..2005c3c8
--- /dev/null
+++ b/tests/buffer/allocate.du
@@ -0,0 +1,27 @@
+/**
+* allocate.du
+*
+* Testing the buffer.new() and buffer.fromString() methods
+*
+* .new(Number) creates a new Buffer with the given size.
+* .newFromString(String) creates a Buffer from the given String.
+*/
+from UnitTest import UnitTest;
+import Buffer;
+
+class TestBufferAllocate < UnitTest {
+
+    testBufferAllocate() {
+        const b = Buffer.new(10).unwrap();
+        this.assertEquals(b.len(), 10);
+        this.assertEquals(b.values(), [0,0,0,0,0,0,0,0,0,0]);
+    }
+    testBufferAllocateString() {
+        const b = Buffer.fromString("Dictu!").unwrap();
+        this.assertEquals(b.len(), 6);
+        this.assertEquals(b.string(), "Dictu!");
+    }
+
+}
+
+TestBufferAllocate().run();
\ No newline at end of file
diff --git a/tests/buffer/get.du b/tests/buffer/get.du
new file mode 100644
index 00000000..63ab3c6a
--- /dev/null
+++ b/tests/buffer/get.du
@@ -0,0 +1,32 @@
+/**
+* get.du
+*
+* Testing the buffer.get() method
+*
+* .get(Number) returns the given value at the index.
+*/
+from UnitTest import UnitTest;
+import Buffer;
+
+class TestBufferGet < UnitTest {
+    testBufferGet() {
+        const b = Buffer.fromString("Dictu!").unwrap();
+        const check = b.values();
+        for(var i = 0; i < b.len(); i+= 1) {
+            const res = b.get(i);
+            this.assertEquals(res.success(), true);
+            this.assertEquals(res.unwrap(), check[i]);
+        }
+    }
+    testBufferGetOutOfBounds() {
+        const b = Buffer.new(4).unwrap();
+        var res = b.get(4);
+        this.assertEquals(res.success(), false);
+        this.assertEquals(res.unwrapError(), "index must be smaller than buffer size");
+        res = b.get(-1);
+        this.assertEquals(res.success(), false);
+        this.assertEquals(res.unwrapError(), "index must be greater than -1");
+    }
+}
+
+TestBufferGet().run();
diff --git a/tests/buffer/import.du b/tests/buffer/import.du
new file mode 100644
index 00000000..b603d4a0
--- /dev/null
+++ b/tests/buffer/import.du
@@ -0,0 +1,15 @@
+/**
+* import.du
+*
+* General import file for all the Buffer tests
+*/
+
+// buffer.values and buffer.len are used a lot throughout the tests.
+import "allocate.du";
+import "set.du";
+import "get.du";
+import "resize.du";
+import "string.du";
+import "stringFuncs.du";
+import "subarray.du";
+import "integers.du";
\ No newline at end of file
diff --git a/tests/buffer/integers.du b/tests/buffer/integers.du
new file mode 100644
index 00000000..7a9421ad
--- /dev/null
+++ b/tests/buffer/integers.du
@@ -0,0 +1,63 @@
+/**
+* integers.du
+*
+* Testing the buffer integers methods.
+*
+*/
+from UnitTest import UnitTest;
+import Buffer;
+
+class TestBufferIntegers < UnitTest {
+    runTest(size, v, f, rf) {
+        const buffer = Buffer.new(size).unwrap();
+        var res = f(buffer, v, false);
+        this.assertEquals(res.success(), true);
+        res = rf(buffer, false);
+        const leArray = buffer.values();
+        this.assertEquals(res.success(), true);
+        this.assertEquals(res.unwrap(), v);
+        res = f(buffer, v, true);
+        this.assertEquals(res.success(), true);
+        res = rf(buffer, true);
+        this.assertEquals(res.success(), true);
+        this.assertEquals(res.unwrap(), v);
+        const beArray = buffer.values();
+        leArray.reverse();
+        this.assertEquals(leArray, beArray);
+    }
+
+    testBufferIntegers() {
+
+        this.runTest(1, -123, def(buffer, v, bigEndian) => bigEndian ? buffer.writeInt8(0, v) : buffer.writeInt8(0, v),
+        def(buffer, bigEndian) => bigEndian ? buffer.readInt8(0) : buffer.readInt8(0));
+
+        this.runTest(2, 2000, def(buffer, v, bigEndian) => bigEndian ? buffer.writeUInt16BE(0, v) : buffer.writeUInt16LE(0, v),
+        def(buffer, bigEndian) => bigEndian ? buffer.readUInt16BE(0) : buffer.readUInt16LE(0));
+        this.runTest(2, -4321, def(buffer, v, bigEndian) => bigEndian ? buffer.writeInt16BE(0, v) : buffer.writeInt16LE(0, v),
+        def(buffer, bigEndian) => bigEndian ? buffer.readInt16BE(0) : buffer.readInt16LE(0));
+
+        this.runTest(4, 2300, def(buffer, v, bigEndian) => bigEndian ? buffer.writeUInt32BE(0, v) : buffer.writeUInt32LE(0, v),
+        def(buffer, bigEndian) => bigEndian ? buffer.readUInt32BE(0) : buffer.readUInt32LE(0));
+        this.runTest(4, -2345, def(buffer, v, bigEndian) => bigEndian ? buffer.writeInt32BE(0, v) : buffer.writeInt32LE(0, v),
+        def(buffer, bigEndian) => bigEndian ? buffer.readInt32BE(0) : buffer.readInt32LE(0));
+
+        this.runTest(8, 20000000, def(buffer, v, bigEndian) => bigEndian ? buffer.writeUInt64BE(0, v) : buffer.writeUInt64LE(0, v),
+        def(buffer, bigEndian) => bigEndian ? buffer.readUInt64BE(0) : buffer.readUInt64LE(0));
+        this.runTest(8, -20000000, def(buffer, v, bigEndian) => bigEndian ? buffer.writeInt64BE(0, v) : buffer.writeInt64LE(0, v),
+        def(buffer, bigEndian) => bigEndian ? buffer.readInt64BE(0) : buffer.readInt64LE(0));
+
+        this.runTest(8, 234.34534, def(buffer, v, bigEndian) => bigEndian ? buffer.writeDoubleBE(0, v) : buffer.writeDoubleLE(0, v),
+        def(buffer, bigEndian) => bigEndian ? buffer.readDoubleBE(0) : buffer.readDoubleLE(0));
+        this.runTest(8, -234.34534, def(buffer, v, bigEndian) => bigEndian ? buffer.writeDoubleBE(0, v) : buffer.writeDoubleLE(0, v),
+        def(buffer, bigEndian) => bigEndian ? buffer.readDoubleBE(0) : buffer.readDoubleLE(0));
+
+        this.runTest(4, 1, def(buffer, v, bigEndian) => bigEndian ? buffer.writeFloatBE(0, v) : buffer.writeFloatLE(0, v),
+        def(buffer, bigEndian) => bigEndian ? buffer.readFloatBE(0) : buffer.readFloatLE(0));
+        this.runTest(4, -1, def(buffer, v, bigEndian) => bigEndian ? buffer.writeFloatBE(0, v) : buffer.writeFloatLE(0, v),
+        def(buffer, bigEndian) => bigEndian ? buffer.readFloatBE(0) : buffer.readFloatLE(0));
+
+    }
+
+}
+
+TestBufferIntegers().run();
diff --git a/tests/buffer/resize.du b/tests/buffer/resize.du
new file mode 100644
index 00000000..b27e3755
--- /dev/null
+++ b/tests/buffer/resize.du
@@ -0,0 +1,36 @@
+/**
+* resize.du
+*
+* Testing the buffer.resize() methods
+*
+* .resize(Number) resizes the Buffer to the given size
+*/
+from UnitTest import UnitTest;
+import Buffer;
+
+class TestBufferResize < UnitTest {
+
+    testBufferResize() {
+        const b = Buffer.new(10).unwrap();
+        this.assertEquals(b.len(), 10);
+        this.assertEquals(b.values(), [0,0,0,0,0,0,0,0,0,0]);
+        b.resize(15);
+        this.assertEquals(b.len(), 15);
+        this.assertEquals(b.values(), [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]);
+        b.resize(1);
+        this.assertEquals(b.len(), 1);
+        this.assertEquals(b.values(), [0]);
+    }
+    testBufferResizeOutOfBounds() {
+        const b = Buffer.new(5).unwrap();
+        var res = b.resize(-1);
+        this.assertEquals(res.success(), false);
+        this.assertEquals(res.unwrapError(), "size must be greater than 0 and smaller than 2147483647");
+        res = b.resize(2147483647);
+        this.assertEquals(res.success(), false);
+        this.assertEquals(res.unwrapError(), "size must be greater than 0 and smaller than 2147483647");
+    }
+
+}
+
+TestBufferResize().run();
diff --git a/tests/buffer/set.du b/tests/buffer/set.du
new file mode 100644
index 00000000..5b4e12a4
--- /dev/null
+++ b/tests/buffer/set.du
@@ -0,0 +1,33 @@
+/**
+* set.du
+*
+* Testing the buffer.set() method
+*
+* .set(Number, Number) sets a given integer value into the buffer;
+*/
+from UnitTest import UnitTest;
+import Buffer;
+
+class TestBufferSet < UnitTest {
+    testBufferSet() {
+        const b = Buffer.new(8).unwrap();
+        const check = [];
+        for(var i = 0; i < b.len(); i+= 1) {
+            const res = b.set(i, i*2);
+            this.assertEquals(res.success(), true);
+            check.push(i*2);
+        }
+        this.assertEquals(b.values(), check);
+    }
+    testBufferSetOutOfBounds() {
+        const b = Buffer.new(4).unwrap();
+        var res = b.set(4, 0);
+        this.assertEquals(res.success(), false);
+        this.assertEquals(res.unwrapError(), "index must be smaller than buffer size");
+        res = b.set(-1, 0);
+        this.assertEquals(res.success(), false);
+        this.assertEquals(res.unwrapError(), "index must be greater than -1");
+    }
+}
+
+TestBufferSet().run();
diff --git a/tests/buffer/string.du b/tests/buffer/string.du
new file mode 100644
index 00000000..ee4a4a4a
--- /dev/null
+++ b/tests/buffer/string.du
@@ -0,0 +1,19 @@
+/**
+* string.du
+*
+* Testing the buffer.string() method
+*
+* .string() returns a string of the buffer.
+*/
+from UnitTest import UnitTest;
+import Buffer;
+
+class TestBufferString < UnitTest {
+
+    testBufferString() {
+        const b = Buffer.fromString("Dictu!").unwrap();
+        this.assertEquals(b.string(), "Dictu!");
+    }
+}
+
+TestBufferString().run();
diff --git a/tests/buffer/stringFuncs.du b/tests/buffer/stringFuncs.du
new file mode 100644
index 00000000..6e156c14
--- /dev/null
+++ b/tests/buffer/stringFuncs.du
@@ -0,0 +1,49 @@
+/**
+* stringFuncs.du
+*
+* Testing the buffer.readString() and buffer.writeString() methods
+*
+* .writeString(Number -> Optional) writes a string into the buffer
+* .readString(Number -> Optional, Number -> Optional) returns a result of the string given optionally index and end.
+*/
+from UnitTest import UnitTest;
+import Buffer;
+
+class TestBufferStringFuncs < UnitTest {
+
+    testBufferReadString() {
+        const b = Buffer.fromString("Dictu!").unwrap();
+        var res = b.readString(0, b.len()-1);
+        this.assertEquals(res.success(), true);
+        this.assertEquals(res.unwrap(), "Dictu");
+        res = b.readString(2);
+        this.assertEquals(res.success(), true);
+        this.assertEquals(res.unwrap(), "ctu!");
+    }
+    testBufferWriteString() {
+        const b = Buffer.new(10).unwrap();
+        const res = b.writeString(0, "Dictu!");
+        this.assertEquals(res.success(), true);
+    }
+    testBufferWriteStringOutOfBounds() {
+        const b = Buffer.new(4).unwrap();
+        const res = b.writeString(0, "Dictu!");
+        this.assertEquals(res.success(), false);
+        this.assertEquals(res.unwrapError(), "buffer is not large enough to fit the string");
+    }
+    testBufferReadStringOutOfBounds() {
+        const b = Buffer.fromString("Dictu!").unwrap();
+        var res = b.readString(23);
+        this.assertEquals(res.success(), false);
+        this.assertEquals(res.unwrapError(), "start greater or equals than buffer length");
+        res = b.readString(3,3);
+        this.assertEquals(res.success(), false);
+        this.assertEquals(res.unwrapError(), "string length is 0");
+        res = b.readString(3,34);
+        this.assertEquals(res.success(), false);
+        this.assertEquals(res.unwrapError(), "end greater than buffer length");
+    }
+
+}
+
+TestBufferStringFuncs().run();
diff --git a/tests/buffer/subarray.du b/tests/buffer/subarray.du
new file mode 100644
index 00000000..1ac61b64
--- /dev/null
+++ b/tests/buffer/subarray.du
@@ -0,0 +1,46 @@
+/**
+* subarray.du
+*
+* Testing the buffer.subarray() method.
+*
+* .subarray(Number -> Optional, Number -> Optional) returns a subarray given optionally the index and end.
+*/
+from UnitTest import UnitTest;
+import Buffer;
+
+class TestBufferSubArray < UnitTest {
+
+    testBufferSubarray() {
+        const b = Buffer.new(10).unwrap();
+        var sub = b.subarray(0);
+        this.assertEquals(sub.success(), true);
+        var v = sub.unwrap();
+        this.assertEquals(v.values(), b.values());
+        sub = b.subarray(5);
+        this.assertEquals(sub.success(), true);
+        v = sub.unwrap();
+        this.assertEquals(v.values(), [0,0,0,0,0]);
+    }
+    testBufferSubarrayStr() {
+        const b = Buffer.fromString("Dictu is awesome!").unwrap();
+        const sub = b.subarray(0, 5);
+        this.assertEquals(sub.success(), true);
+        const v = sub.unwrap();
+        this.assertEquals(v.string(), "Dictu");
+    }
+    testBufferSubarrayOutOfBounds() {
+        const b = Buffer.fromString("Dictu!").unwrap();
+        var res = b.subarray(25);
+        this.assertEquals(res.success(), false);
+        this.assertEquals(res.unwrapError(), "start greater or equals than buffer length");
+        res = b.subarray(0, 25);
+        this.assertEquals(res.success(), false);
+        this.assertEquals(res.unwrapError(), "end greater than buffer length");
+        res = b.subarray(0, 0);
+        this.assertEquals(res.success(), false);
+        this.assertEquals(res.unwrapError(), "array length is 0");
+
+    }
+}
+
+TestBufferSubArray().run();
diff --git a/tests/process/kill.du b/tests/process/kill.du
index c15162be..c528e31e 100644
--- a/tests/process/kill.du
+++ b/tests/process/kill.du
@@ -17,8 +17,9 @@ class TestProcessKill < UnitTest {
         this.assertEquals(res, "No such process");
     }
 
-    testProcessKillNoSignal() {
-        Process.exec(["sleep", "3600"]);
+    // TODO: Look into this test
+    testProcessKillNoSignal_skipped() {
+        Process.exec(["sleep", "100"]);
 
         const out = Process.run(["pgrep", "sleep"], true).unwrap();
         const pids = out.split("\n");
diff --git a/tests/runTests.du b/tests/runTests.du
index b239da43..9c163615 100644
--- a/tests/runTests.du
+++ b/tests/runTests.du
@@ -53,6 +53,7 @@ import "random/import.du";
 import "hashlib/import.du";
 import "object/import.du";
 import "term/import.du";
+import "buffer/import.du";
 
 // If we got here no runtime errors were thrown, therefore all tests passed.
 print("All tests passed successfully!");