diff --git a/src/ox/fs/filestore.hpp b/src/ox/fs/filestore.hpp
index cd60fd3fa..84972fa6e 100644
--- a/src/ox/fs/filestore.hpp
+++ b/src/ox/fs/filestore.hpp
@@ -16,13 +16,13 @@ template<typename FsT>
 class FileStore {
 
 	public:
-		typedef ox::std::uint16_t InodeId_t;
+                typedef uint16_t InodeId_t;
 		typedef FsT FsSize_t;
 
 		struct StatInfo {
 			InodeId_t inodeId;
 			FsSize_t  size;
-			ox::std::uint8_t fileType;
+                        uint8_t fileType;
 		};
 
 	private:
@@ -31,20 +31,17 @@ class FileStore {
 			FsSize_t prev, next;
 			FsSize_t dataLen;
 			InodeId_t id;
-			ox::std::uint8_t refs;
-			ox::std::uint8_t fileType;
+                        uint8_t refs;
+                        uint8_t fileType;
 			FsSize_t left, right;
 
 			FsSize_t size();
 			void setId(InodeId_t);
                         void setData(void *data, FsSize_t size);
 			void *data();
-
-			private:
-				Inode() = default;
 		};
 
-		ox::std::uint32_t m_fsType;
+                uint32_t m_fsType;
 		FsSize_t m_size;
 		FsSize_t m_rootInode;
 
@@ -55,7 +52,7 @@ class FileStore {
 		 * @param data the contents of the file
 		 * @param dataLen the number of bytes data points to
 		 */
-		int write(void *data, FsSize_t dataLen, ox::std::uint8_t fileType = 0);
+                int write(void *data, FsSize_t dataLen, uint8_t fileType = 0);
 
 		/**
 		 * Writes the given data to a "file" with the given id.
@@ -63,7 +60,7 @@ class FileStore {
 		 * @param data the contents of the file
 		 * @param dataLen the number of bytes data points to
 		 */
-		int write(InodeId_t id, void *data, FsSize_t dataLen, ox::std::uint8_t fileType = 0);
+                int write(InodeId_t id, void *data, FsSize_t dataLen, uint8_t fileType = 0);
 
 		/**
 		 * Removes the inode of the given ID.
@@ -95,9 +92,9 @@ class FileStore {
 		 */
 		FsSize_t size();
 
-		static ox::std::uint8_t version();
+                static uint8_t version();
 
-		static ox::std::uint8_t *format(ox::std::uint8_t *buffer, FsSize_t size, ox::std::uint32_t fsType = 0);
+                static uint8_t *format(uint8_t *buffer, FsSize_t size, uint32_t fsType = 0);
 
 	private:
 		/**
@@ -169,11 +166,11 @@ class FileStore {
 		 */
 		void updateInodeAddress(InodeId_t id, FsSize_t addr);
 
-		ox::std::uint8_t *begin() {
-			return (ox::std::uint8_t*) this;
+                uint8_t *begin() {
+                        return (uint8_t*) this;
 		}
 
-		ox::std::uint8_t *end() {
+                uint8_t *end() {
 			return begin() + this->m_size;
 		}
 
@@ -218,12 +215,12 @@ void *FileStore<FsSize_t>::Inode::data() {
 // FileStore
 
 template<typename FsSize_t>
-int FileStore<FsSize_t>::write(void *data, FsSize_t dataLen, ox::std::uint8_t fileType) {
+int FileStore<FsSize_t>::write(void *data, FsSize_t dataLen, uint8_t fileType) {
 	return 1;
 }
 
 template<typename FsSize_t>
-int FileStore<FsSize_t>::write(InodeId_t id, void *data, FsSize_t dataLen, ox::std::uint8_t fileType) {
+int FileStore<FsSize_t>::write(InodeId_t id, void *data, FsSize_t dataLen, uint8_t fileType) {
 	auto retval = 1;
 	const FsSize_t size = sizeof(Inode) + dataLen;
 	auto inode = (Inode*) alloc(size);
@@ -414,10 +411,10 @@ FsSize_t FileStore<FsSize_t>::nextInodeAddr() {
 template<typename FsSize_t>
 void *FileStore<FsSize_t>::alloc(FsSize_t size) {
 	FsSize_t next = nextInodeAddr();
-	if ((next + size) > (ox::std::uint64_t) end()) {
+        if ((next + size) > (uint64_t) end()) {
 		compress(firstInode());
 		next = nextInodeAddr();
-		if ((next + size) > (ox::std::uint64_t) end()) {
+                if ((next + size) > (uint64_t) end()) {
 			return nullptr;
 		}
 	}
@@ -483,7 +480,7 @@ FsSize_t FileStore<FsSize_t>::ptr(void *ptr) {
 #ifdef _MSC_VER
 #pragma warning(disable:4244)
 #endif
-	return ((ox::std::uint8_t*) ptr) - begin();
+        return ((uint8_t*) ptr) - begin();
 #ifdef _MSC_VER
 #pragma warning(default:4244)
 #endif
@@ -500,12 +497,12 @@ typename FileStore<FsSize_t>::Inode *FileStore<FsSize_t>::lastInode() {
 }
 
 template<typename FsSize_t>
-ox::std::uint8_t FileStore<FsSize_t>::version() {
+uint8_t FileStore<FsSize_t>::version() {
 	return 1;
 };
 
 template<typename FsSize_t>
-ox::std::uint8_t *FileStore<FsSize_t>::format(ox::std::uint8_t *buffer, FsSize_t size, ox::std::uint32_t fsType) {
+uint8_t *FileStore<FsSize_t>::format(uint8_t *buffer, FsSize_t size, uint32_t fsType) {
 	ox_memset(buffer, 0, size);
 
 	auto *fs = (FileStore*) buffer;
@@ -515,12 +512,12 @@ ox::std::uint8_t *FileStore<FsSize_t>::format(ox::std::uint8_t *buffer, FsSize_t
 	((Inode*) (fs + 1))->prev = fs->firstInode();
 	fs->lastInode()->next = sizeof(FileStore<FsSize_t>);
 
-	return (ox::std::uint8_t*) buffer;
+        return (uint8_t*) buffer;
 }
 
-typedef FileStore<ox::std::uint16_t> FileStore16;
-typedef FileStore<ox::std::uint32_t> FileStore32;
-typedef FileStore<ox::std::uint64_t> FileStore64;
+typedef FileStore<uint16_t> FileStore16;
+typedef FileStore<uint32_t> FileStore32;
+typedef FileStore<uint64_t> FileStore64;
 
 }
 }
diff --git a/src/ox/fs/filesystem.cpp b/src/ox/fs/filesystem.cpp
index a61ef4d14..d4405c97b 100644
--- a/src/ox/fs/filesystem.cpp
+++ b/src/ox/fs/filesystem.cpp
@@ -11,7 +11,7 @@ namespace ox {
 namespace fs {
 
 FileSystem *createFileSystem(void *buff) {
-	auto type = *((ox::std::uint32_t*) buff);
+	auto type = *((uint32_t*) buff);
 	FileSystem *fs = nullptr;
 
 	switch (type) {
diff --git a/src/ox/fs/filesystem.hpp b/src/ox/fs/filesystem.hpp
index ea0e3e7ee..58476c3ad 100644
--- a/src/ox/fs/filesystem.hpp
+++ b/src/ox/fs/filesystem.hpp
@@ -27,24 +27,24 @@ enum FileType {
 };
 
 struct FileStat {
-	ox::std::uint64_t inode;
-	ox::std::uint64_t size;
-	ox::std::uint8_t  fileType;
+	uint64_t inode;
+	uint64_t size;
+	uint8_t  fileType;
 };
 
 class FileSystem {
 	public:
 		virtual ~FileSystem() {};
 
-		virtual int read(ox::std::uint64_t inode, void *buffer, ox::std::uint64_t size) = 0;
+		virtual int read(uint64_t inode, void *buffer, uint64_t size) = 0;
 
-		virtual ox::std::uint8_t *read(ox::std::uint64_t inode, ox::std::uint64_t *size) = 0;
+		virtual uint8_t *read(uint64_t inode, uint64_t *size) = 0;
 
-		virtual int remove(ox::std::uint64_t inode) = 0;
+		virtual int remove(uint64_t inode) = 0;
 
-		virtual int write(ox::std::uint64_t inode, void *buffer, ox::std::uint64_t size, ox::std::uint8_t fileType = NormalFile) = 0;
+		virtual int write(uint64_t inode, void *buffer, uint64_t size, uint8_t fileType = NormalFile) = 0;
 
-		virtual FileStat stat(ox::std::uint64_t inode) = 0;
+		virtual FileStat stat(uint64_t inode) = 0;
 };
 
 FileSystem *createFileSystem(void *buff);
@@ -93,19 +93,19 @@ class FileSystemTemplate: public FileSystem {
 
 		int read(const char *path, void *buffer);
 
-		ox::std::uint8_t *read(ox::std::uint64_t inode, ox::std::uint64_t *size) override;
+		uint8_t *read(uint64_t inode, uint64_t *size) override;
 
-		int read(ox::std::uint64_t inode, void *buffer, ox::std::uint64_t size) override;
+		int read(uint64_t inode, void *buffer, uint64_t size) override;
 
-		int remove(ox::std::uint64_t inode) override;
+		int remove(uint64_t inode) override;
 
-		int write(ox::std::uint64_t inode, void *buffer, ox::std::uint64_t size, ox::std::uint8_t fileType) override;
+		int write(uint64_t inode, void *buffer, uint64_t size, uint8_t fileType) override;
 
 		FileStat stat(const char *path);
 
-		FileStat stat(ox::std::uint64_t inode) override;
+		FileStat stat(uint64_t inode) override;
 
-		static ox::std::uint8_t *format(void *buffer, typename FileStore::FsSize_t size, bool useDirectories);
+		static uint8_t *format(void *buffer, typename FileStore::FsSize_t size, bool useDirectories);
 };
 
 template<typename FileStore>
@@ -131,7 +131,7 @@ FileStat FileSystemTemplate<FileStore>::stat(const char *path) {
 #pragma warning(disable:4244)
 #endif
 template<typename FileStore>
-FileStat FileSystemTemplate<FileStore>::stat(ox::std::uint64_t inode) {
+FileStat FileSystemTemplate<FileStore>::stat(uint64_t inode) {
 	FileStat stat;
 	auto s = store->stat(inode);
 	stat.size = s.size;
@@ -147,7 +147,7 @@ FileStat FileSystemTemplate<FileStore>::stat(ox::std::uint64_t inode) {
 #pragma warning(disable:4244)
 #endif
 template<typename FileStore>
-int FileSystemTemplate<FileStore>::read(ox::std::uint64_t inode, void *buffer, ox::std::uint64_t size) {
+int FileSystemTemplate<FileStore>::read(uint64_t inode, void *buffer, uint64_t size) {
 	auto err = 1;
 	auto s = store->stat(inode);
 	if (size == s.size) {
@@ -163,9 +163,9 @@ int FileSystemTemplate<FileStore>::read(ox::std::uint64_t inode, void *buffer, o
 #pragma warning(disable:4244)
 #endif
 template<typename FileStore>
-ox::std::uint8_t *FileSystemTemplate<FileStore>::read(ox::std::uint64_t inode, ox::std::uint64_t *size) {
+uint8_t *FileSystemTemplate<FileStore>::read(uint64_t inode, uint64_t *size) {
 	auto s = store->stat(inode);
-	auto buff = new ox::std::uint8_t[s.size];
+	auto buff = new uint8_t[s.size];
 	if (size) {
 		*size = s.size;
 	}
@@ -183,7 +183,7 @@ ox::std::uint8_t *FileSystemTemplate<FileStore>::read(ox::std::uint64_t inode, o
 #pragma warning(disable:4244)
 #endif
 template<typename FileStore>
-int FileSystemTemplate<FileStore>::remove(ox::std::uint64_t inode) {
+int FileSystemTemplate<FileStore>::remove(uint64_t inode) {
 	return store->remove(inode);
 }
 #ifdef _MSC_VER
@@ -194,7 +194,7 @@ int FileSystemTemplate<FileStore>::remove(ox::std::uint64_t inode) {
 #pragma warning(disable:4244)
 #endif
 template<typename FileStore>
-int FileSystemTemplate<FileStore>::write(ox::std::uint64_t inode, void *buffer, ox::std::uint64_t size, ox::std::uint8_t fileType) {
+int FileSystemTemplate<FileStore>::write(uint64_t inode, void *buffer, uint64_t size, uint8_t fileType) {
 	return store->write(inode, buffer, size, fileType);
 }
 #ifdef _MSC_VER
@@ -205,8 +205,8 @@ int FileSystemTemplate<FileStore>::write(ox::std::uint64_t inode, void *buffer,
 #pragma warning(disable:4244)
 #endif
 template<typename FileStore>
-ox::std::uint8_t *FileSystemTemplate<FileStore>::format(void *buffer, typename FileStore::FsSize_t size, bool useDirectories) {
-	buffer = FileStore::format((ox::std::uint8_t*) buffer, size, FS_TYPE);
+uint8_t *FileSystemTemplate<FileStore>::format(void *buffer, typename FileStore::FsSize_t size, bool useDirectories) {
+	buffer = FileStore::format((uint8_t*) buffer, size, FS_TYPE);
 	auto fs = createFileSystem(buffer);
 
 	if (buffer && useDirectories) {
@@ -216,7 +216,7 @@ ox::std::uint8_t *FileSystemTemplate<FileStore>::format(void *buffer, typename F
 		fs->write(INODE_ROOT_DIR, dirBuff, useDirectories);
 	}
 
-	return (ox::std::uint8_t*) buffer;
+	return (uint8_t*) buffer;
 }
 #ifdef _MSC_VER
 #pragma warning(default:4244)
diff --git a/src/ox/fs/oxfstool.cpp b/src/ox/fs/oxfstool.cpp
index 32d2f1a2f..baed8b380 100644
--- a/src/ox/fs/oxfstool.cpp
+++ b/src/ox/fs/oxfstool.cpp
@@ -27,7 +27,7 @@ const static auto usage = "usage:\n"
 "\toxfs write <FS file> <inode> <insertion file>";
 
 char *loadFileBuff(const char *path, ::size_t *sizeOut = nullptr) {
-	FILE *file = fopen(path, "rb");
+	auto file = fopen(path, "rb");
 	if (file) {
 		fseek(file, 0, SEEK_END);
 		const auto size = ftell(file);
@@ -44,7 +44,7 @@ char *loadFileBuff(const char *path, ::size_t *sizeOut = nullptr) {
 	}
 }
 
-ox::std::uint64_t bytes(const char *str) {
+uint64_t bytes(const char *str) {
 	auto size = ::ox_strlen(str);
 	const auto lastChar = str[size-1];
 	auto multiplier = 1;
@@ -69,7 +69,7 @@ ox::std::uint64_t bytes(const char *str) {
 				multiplier = -1;
 		}
 	}
-	const auto retval = ((ox::std::uint64_t) ::ox_atoi(copy)) * multiplier;
+	const auto retval = ((uint64_t) ::ox_atoi(copy)) * multiplier;
 	delete copy;
 	return  retval;
 }
@@ -81,14 +81,14 @@ int format(int argc, char **args) {
 		auto type = ox_atoi(args[2]);
 		auto size = bytes(args[3]);
 		auto path = args[4];
-		auto buff = (ox::std::uint8_t*) malloc(size);
+		auto buff = (uint8_t*) malloc(size);
 
 		printf("Size: %llu bytes\n", size);
 		printf("Type: %d\n", type);
 
 		if (size < sizeof(FileStore64)) {
 			err = 1;
-			fprintf(stderr, "File system size %llu too small, must be at least %llu\n", (ox::std::uint64_t) size, (ox::std::uint64_t) sizeof(FileStore64));
+			fprintf(stderr, "File system size %llu too small, must be at least %llu\n", (uint64_t) size, (uint64_t) sizeof(FileStore64));
 		}
 
 		if (!err) {
@@ -137,7 +137,7 @@ int read(int argc, char **args) {
 		auto fsPath = args[2];
 		auto inode = ox_atoi(args[3]);
 		::size_t fsSize;
-		ox::std::uint64_t fileSize;
+		uint64_t fileSize;
 
 		auto fsBuff = loadFileBuff(fsPath, &fsSize);
 		
@@ -155,7 +155,7 @@ int read(int argc, char **args) {
 				delete fs;
 				free(fsBuff);
 			} else {
-				fprintf(stderr, "Invalid file system type: %d.\n", *(ox::std::uint32_t*) fsBuff);
+				fprintf(stderr, "Invalid file system type: %d.\n", *(uint32_t*) fsBuff);
 			}
 		} else {
 			fprintf(stderr, "Could not open file: %s\n", fsPath);
@@ -170,7 +170,7 @@ int write(int argc, char **args) {
 		auto fsPath = args[2];
 		auto inode = ox_atoi(args[3]);
 		auto srcPath = args[4];
-		::size_t srcSize;
+		size_t srcSize;
 
 		auto fsFile = fopen(fsPath, "rb");
 		if (fsFile) {
@@ -191,7 +191,7 @@ int write(int argc, char **args) {
 						fprintf(stderr, "Could not write to file system.\n");
 					}
 				} else {
-					fprintf(stderr, "Invalid file system type: %d.\n", *(ox::std::uint32_t*) fsBuff);
+					fprintf(stderr, "Invalid file system type: %d.\n", *(uint32_t*) fsBuff);
 					err = 1;
 				}
 
@@ -227,7 +227,7 @@ int remove(int argc, char **args) {
 	if (argc >= 4) {
 		auto fsPath = args[2];
 		auto inode = ox_atoi(args[3]);
-		::size_t fsSize;
+		size_t fsSize;
 
 		auto fsBuff = loadFileBuff(fsPath, &fsSize);
 		if (fsBuff) {
diff --git a/src/ox/fs/test/filestore_format.cpp b/src/ox/fs/test/filestore_format.cpp
index 4ebe87fba..bc910d12f 100644
--- a/src/ox/fs/test/filestore_format.cpp
+++ b/src/ox/fs/test/filestore_format.cpp
@@ -11,8 +11,8 @@ using namespace ox::fs;
 
 int main() {
 	const auto size = 65535;
-	ox::std::uint8_t volume[size];
-	ox::std::uint32_t err = 0;
+	uint8_t volume[size];
+	uint32_t err = 0;
 	FileStore32::format(volume, size);
 	return err;
 }
diff --git a/src/ox/fs/test/filestoreio.cpp b/src/ox/fs/test/filestoreio.cpp
index 64fbd8c34..5c0ba5f0b 100644
--- a/src/ox/fs/test/filestoreio.cpp
+++ b/src/ox/fs/test/filestoreio.cpp
@@ -14,8 +14,8 @@ using namespace ox::std;
 
 template<typename FileStore>
 int test() {
-	const ox::std::uint16_t size = ~0;
-	ox::std::uint8_t volume[size];
+	const uint16_t size = ~0;
+	uint8_t volume[size];
 	char out[6];
 	typename FileStore::FsSize_t outSize;
 	FileStore::format(volume, size);
diff --git a/src/ox/fs/test/filesystem_format.cpp b/src/ox/fs/test/filesystem_format.cpp
index 0ae4be1e6..e62e833ca 100644
--- a/src/ox/fs/test/filesystem_format.cpp
+++ b/src/ox/fs/test/filesystem_format.cpp
@@ -13,8 +13,8 @@ using namespace ox::std;
 
 template<typename FileSystem>
 int test() {
-	const ox::std::uint16_t size = ~0;
-	ox::std::uint8_t volume[size];
+	const uint16_t size = ~0;
+	uint8_t volume[size];
 	FileSystem::format(volume, size, true);
 	return 0;
 }
diff --git a/src/ox/std/types.hpp b/src/ox/std/types.hpp
index b2cf64751..0c62a2472 100644
--- a/src/ox/std/types.hpp
+++ b/src/ox/std/types.hpp
@@ -7,9 +7,6 @@
  */
 #pragma once
 
-namespace ox {
-namespace std {
-
 typedef char               int8_t;
 typedef unsigned char      uint8_t;
 typedef short              int16_t;
@@ -20,6 +17,9 @@ typedef unsigned           uint_t;
 typedef long long          int64_t;
 typedef unsigned long long uint64_t;
 
+namespace ox {
+namespace std {
+
 typedef uint32_t Error;
 
 }
@@ -28,9 +28,9 @@ typedef uint32_t Error;
 #if defined(_LP64) || defined(__ppc64__) || defined(__aarch64__)
 typedef unsigned long size_t;
 #elif defined(_WIN64)
-typedef ox::std::uint64_t size_t;
+typedef uint64_t size_t;
 #elif defined(_LP32) || defined(__ppc__) || defined(_WIN32) || defined(__arm__)
-typedef ox::std::uint32_t size_t;
+typedef uint32_t size_t;
 #else
 #error size_t undefined
 #endif