diff --git a/src/coders/json.cpp b/src/coders/json.cpp
index 0f72a5bfb..e18209981 100644
--- a/src/coders/json.cpp
+++ b/src/coders/json.cpp
@@ -302,7 +302,7 @@ void JObject::num(std::string key, float& dst) const {
     dst = getNum(key, dst);
 }
 
-void JObject::num(std::string key, u_char8& dst) const {
+void JObject::num(std::string key, u_char& dst) const {
     dst = getInteger(key, dst);
 }
 
diff --git a/src/coders/json.h b/src/coders/json.h
index 497a5edbd..51fc08db2 100644
--- a/src/coders/json.h
+++ b/src/coders/json.h
@@ -86,7 +86,7 @@ namespace json {
         void num(std::string key, uint& dst) const;
         void num(std::string key, int64_t& dst) const;
         void num(std::string key, uint64_t& dst) const;
-        void num(std::string key, u_char8& dst) const;
+        void num(std::string key, u_char& dst) const;
         void num(std::string key, double& dst) const;
         JObject* obj(std::string key) const;
         JArray* arr(std::string key) const;
diff --git a/src/coders/png.cpp b/src/coders/png.cpp
index d022fd1da..61b2e3e7d 100644
--- a/src/coders/png.cpp
+++ b/src/coders/png.cpp
@@ -16,7 +16,7 @@
 #include <png.h>
 
 // returns 0 if all-right, 1 otherwise
-int _png_write(const char* filename, u_int width, u_int height, const u_char8* data, bool alpha) {
+int _png_write(const char* filename, u_int width, u_int height, const u_char* data, bool alpha) {
     u_int pixsize = alpha ? 4 : 3;
 
 	// Open file for writing (binary mode)
@@ -355,5 +355,5 @@ Texture* png::load_texture(std::string filename) {
 }
 
 void png::write_image(std::string filename, const ImageData* image) {
-    _png_write(filename.c_str(), image->getWidth(), image->getHeight(), (const u_char8*)image->getData(), image->getFormat() == ImageFormat::rgba8888);
+    _png_write(filename.c_str(), image->getWidth(), image->getHeight(), (const u_char*)image->getData(), image->getFormat() == ImageFormat::rgba8888);
 }
\ No newline at end of file
diff --git a/src/constants.h b/src/constants.h
index 0b135aa4a..0a03abb15 100644
--- a/src/constants.h
+++ b/src/constants.h
@@ -11,8 +11,8 @@ const int CHUNK_W = 16;
 const int CHUNK_H = 256;
 const int CHUNK_D = 16;
 
-const uint VOXEL_USER_BITS = 8;
-constexpr uint VOXEL_USER_BITS_OFFSET = sizeof(blockstate_t)*8-VOXEL_USER_BITS;
+const u_int VOXEL_USER_BITS = 8;
+constexpr u_int VOXEL_USER_BITS_OFFSET = sizeof(blockstate_t)*8-VOXEL_USER_BITS;
 
 /* Chunk volume (count of voxels per Chunk) */
 constexpr int CHUNK_VOL = (CHUNK_W * CHUNK_H * CHUNK_D);
@@ -21,7 +21,7 @@ constexpr int CHUNK_VOL = (CHUNK_W * CHUNK_H * CHUNK_D);
 const blockid_t BLOCK_VOID = std::numeric_limits<blockid_t>::max();
 const blockid_t MAX_BLOCKS = BLOCK_VOID;
 
-inline uint vox_index(int x, int y, int z, int w=CHUNK_W, int d=CHUNK_D) {
+inline u_int vox_index(int x, int y, int z, int w=CHUNK_W, int d=CHUNK_D) {
 	return (y * d + z) * w + x;
 }
 
diff --git a/src/engine.cpp b/src/engine.cpp
index a125663ee..644840805 100644
--- a/src/engine.cpp
+++ b/src/engine.cpp
@@ -65,7 +65,7 @@ Engine::Engine(EngineSettings& settings, EnginePaths* paths)
 		}
 	}
 
-	Audio::initialize();
+	// Audio::initialize();
 	gui = std::make_unique<gui::GUI>();
     if (settings.ui.language == "auto") {
         settings.ui.language = langs::locale_by_envlocale(platform::detect_locale(), paths->getResources());
@@ -126,7 +126,7 @@ Engine::~Engine() {
     scripting::close();
 	screen = nullptr;
 
-	Audio::finalize();
+	// Audio::finalize();
 
 	std::cout << "-- shutting down" << std::endl;
     assets.reset();
diff --git a/src/engine.h b/src/engine.h
index 01d2cf073..c65303108 100644
--- a/src/engine.h
+++ b/src/engine.h
@@ -36,7 +36,7 @@ class Engine {
 	EnginePaths* paths;
     std::unique_ptr<ResPaths> resPaths = nullptr;
 
-	uint64_t frame = 0;
+	u_long frame = 0;
 	double lastTime = 0.0;
 	double delta = 0.0;
 
diff --git a/src/files/WorldConverter.cpp b/src/files/WorldConverter.cpp
index ea40387b8..26759ac96 100644
--- a/src/files/WorldConverter.cpp
+++ b/src/files/WorldConverter.cpp
@@ -53,7 +53,7 @@ void WorldConverter::convertNext() {
         for (uint cx = 0; cx < REGION_SIZE; cx++) {
             int gx = cx + x * REGION_SIZE;
             int gz = cz + z * REGION_SIZE;
-            std::unique_ptr<u_char8[]> data (wfile->getChunk(gx, gz));
+            std::unique_ptr<u_char[]> data (wfile->getChunk(gx, gz));
             if (data == nullptr)
                 continue;
             if (wfile->getVoxelRegionVersion(x, z) != REGION_FORMAT_VERSION) {
diff --git a/src/files/WorldFiles.cpp b/src/files/WorldFiles.cpp
index 59b28a5f5..47f5f010c 100644
--- a/src/files/WorldFiles.cpp
+++ b/src/files/WorldFiles.cpp
@@ -34,7 +34,7 @@ regfile::regfile(fs::path filename) : file(filename) {
     file.read(header, REGION_HEADER_SIZE);
     
     // avoid of use strcmp_s
-    if (std::string(header, strlen(REGION_FORMAT_MAGIC)) != REGION_FORMAT_MAGIC) {
+    if (std::string(header, std::strlen(REGION_FORMAT_MAGIC)) != REGION_FORMAT_MAGIC) {
         throw std::runtime_error("invalid region file magic number");
     }
     version = header[8];
@@ -45,7 +45,7 @@ regfile::regfile(fs::path filename) : file(filename) {
 }
 
 WorldRegion::WorldRegion() {
-	chunksData = new u_char8*[REGION_CHUNKS_COUNT]{};
+	chunksData = new u_char*[REGION_CHUNKS_COUNT]{};
 	sizes = new uint32_t[REGION_CHUNKS_COUNT]{};
 }
 
@@ -64,7 +64,7 @@ bool WorldRegion::isUnsaved() const {
 	return unsaved;
 }
 
-u_char8** WorldRegion::getChunks() const {
+u_char** WorldRegion::getChunks() const {
 	return chunksData;
 }
 
@@ -72,14 +72,14 @@ uint32_t* WorldRegion::getSizes() const {
 	return sizes;
 }
 
-void WorldRegion::put(uint x, uint z, u_char8* data, uint32_t size) {
+void WorldRegion::put(uint x, uint z, u_char* data, uint32_t size) {
 	size_t chunk_index = z * REGION_SIZE + x;
 	delete[] chunksData[chunk_index];
 	chunksData[chunk_index] = data;
 	sizes[chunk_index] = size;
 }
 
-u_char8* WorldRegion::getChunkData(uint x, uint z) {
+u_char* WorldRegion::getChunkData(uint x, uint z) {
 	return chunksData[z * REGION_SIZE + x];
 }
 
@@ -91,7 +91,7 @@ WorldFiles::WorldFiles(fs::path directory, const DebugSettings& settings)
 	: directory(directory), 
 	  generatorTestMode(settings.generatorTestMode),
 	  doWriteLights(settings.doWriteLights) {
-	compressionBuffer.reset(new u_char8[CHUNK_DATA_LEN * 2]);
+	compressionBuffer.reset(new u_char[CHUNK_DATA_LEN * 2]);
 }
 
 WorldFiles::~WorldFiles(){
@@ -113,20 +113,20 @@ WorldRegion* WorldFiles::getOrCreateRegion(regionsmap& regions, int x, int z) {
 	return region;
 }
 
-u_char8* WorldFiles::compress(const u_char8* src, size_t srclen, size_t& len) {
-    u_char8* buffer = this->compressionBuffer.get();
+u_char* WorldFiles::compress(const u_char* src, size_t srclen, size_t& len) {
+    u_char* buffer = this->compressionBuffer.get();
     
-	len = extrle::encode(src, srclen, buffer);
-	u_char8* data = new u_char8[len];
+	len = rle::encode((voxel_t *)src, srclen, (voxel_t *)buffer);
+	u_char* data = new u_char[len];
 	for (size_t i = 0; i < len; i++) {
 		data[i] = buffer[i];
 	}
 	return data;
 }
 
-u_char8* WorldFiles::decompress(const u_char8* src, size_t srclen, size_t dstlen) {
-	u_char8* decompressed = new u_char8[dstlen];
-	extrle::decode(src, srclen, decompressed);
+u_char* WorldFiles::decompress(const u_char* src, size_t srclen, size_t dstlen) {
+	u_char* decompressed = new u_char[dstlen];
+	rle::decode((voxel_t *)src, srclen, (voxel_t *)decompressed);
 	return decompressed;
 }
 
@@ -160,7 +160,7 @@ int WorldFiles::getVoxelRegionsVersion() {
  * @param x chunk.x
  * @param z chunk.z
  */
-void WorldFiles::put(int x, int z, const u_char8* voxelData) {
+void WorldFiles::put(int x, int z, const u_char* voxelData) {
     int regionX = floordiv(x, REGION_SIZE);
 	int regionZ = floordiv(z, REGION_SIZE);
 	int localX = x - (regionX * REGION_SIZE);
@@ -170,7 +170,7 @@ void WorldFiles::put(int x, int z, const u_char8* voxelData) {
 		WorldRegion* region = getOrCreateRegion(regions, regionX, regionZ);
 		region->setUnsaved(true);
 		size_t compressedSize;
-		u_char8* data = compress(voxelData, CHUNK_DATA_LEN, compressedSize);
+		u_char* data = compress(voxelData, CHUNK_DATA_LEN, compressedSize);
 		region->put(localX, localZ, data, compressedSize);
 	}
 }
@@ -188,8 +188,8 @@ void WorldFiles::put(Chunk* chunk){
 
 	/* Writing Voxels */ {
         size_t compressedSize;
-        std::unique_ptr<u_char8[]> chunk_data (chunk->encode());
-		u_char8* data = compress(chunk_data.get(), CHUNK_DATA_LEN, compressedSize);
+        std::unique_ptr<u_char[]> chunk_data (chunk->encode());
+		u_char* data = compress(chunk_data.get(), CHUNK_DATA_LEN, compressedSize);
 
 		WorldRegion* region = getOrCreateRegion(regions, regionX, regionZ);
 		region->setUnsaved(true);
@@ -197,8 +197,8 @@ void WorldFiles::put(Chunk* chunk){
 	}
 	if (doWriteLights && chunk->isLighted()) {
         size_t compressedSize;
-        std::unique_ptr<u_char8[]> light_data (chunk->lightmap->encode());
-		u_char8* data = compress(light_data.get(), LIGHTMAP_DATA_LEN, compressedSize);
+        std::unique_ptr<u_char[]> light_data (chunk->lightmap->encode());
+		u_char* data = compress(light_data.get(), LIGHTMAP_DATA_LEN, compressedSize);
 
 		WorldRegion* region = getOrCreateRegion(lights, regionX, regionZ);
 		region->setUnsaved(true);
@@ -256,20 +256,20 @@ fs::path WorldFiles::getPacksFile() const {
 	return directory/fs::path("packs.list");
 }
 
-u_char8* WorldFiles::getChunk(int x, int z){
+u_char* WorldFiles::getChunk(int x, int z){
 	return getData(regions, getRegionsFolder(), x, z, REGION_LAYER_VOXELS);
 }
 
 /* Get cached lights for chunk at x,z 
  * @return lights data or nullptr */
 light_t* WorldFiles::getLights(int x, int z) {
-	std::unique_ptr<u_char8> data (getData(lights, getLightsFolder(), x, z, REGION_LAYER_LIGHTS));
+	std::unique_ptr<u_char> data (getData(lights, getLightsFolder(), x, z, REGION_LAYER_LIGHTS));
 	if (data == nullptr)
 		return nullptr;
 	return Lightmap::decode(data.get());
 }
 
-u_char8* WorldFiles::getData(regionsmap& regions, const fs::path& folder, 
+u_char* WorldFiles::getData(regionsmap& regions, const fs::path& folder, 
                            int x, int z, int layer) {
 	int regionX = floordiv(x, REGION_SIZE);
 	int regionZ = floordiv(z, REGION_SIZE);
@@ -278,7 +278,7 @@ u_char8* WorldFiles::getData(regionsmap& regions, const fs::path& folder,
 	int localZ = z - (regionZ * REGION_SIZE);
 
 	WorldRegion* region = getOrCreateRegion(regions, regionX, regionZ);
-	u_char8* data = region->getChunkData(localX, localZ);
+	u_char* data = region->getChunkData(localX, localZ);
 	if (data == nullptr) {
 		uint32_t size;
 		data = readChunkData(x, z, size, folder, layer);
@@ -312,7 +312,7 @@ regfile* WorldFiles::getRegFile(glm::ivec3 coord, const fs::path& folder) {
     return openRegFiles[coord].get();
 }
 
-u_char8* WorldFiles::readChunkData(int x, 
+u_char* WorldFiles::readChunkData(int x, 
                                  int z, 
                                  uint32_t& length, 
                                  fs::path folder, 
@@ -339,14 +339,14 @@ u_char8* WorldFiles::readChunkData(int x,
 	uint32_t offset;
 	file.seekg(table_offset + chunkIndex * 4);
 	file.read((char*)(&offset), 4);
-	offset = dataio::read_int32_big((const u_char8*)(&offset), 0);
+	offset = dataio::read_int32_big((const u_char*)(&offset), 0);
 	if (offset == 0){
 		return nullptr;
 	}
 	file.seekg(offset);
 	file.read((char*)(&offset), 4);
-	length = dataio::read_int32_big((const u_char8*)(&offset), 0);
-	u_char8* data = new u_char8[length];
+	length = dataio::read_int32_big((const u_char*)(&offset), 0);
+	u_char* data = new u_char[length];
 	file.read((char*)data, length);
 	if (data == nullptr) {
 		std::cerr << "ERROR: failed to read data of chunk x("<< x <<"), z("<< z <<")" << std::endl;
@@ -359,7 +359,7 @@ u_char8* WorldFiles::readChunkData(int x,
  * (see REGION_LAYER_* constants)
  */
 void WorldFiles::fetchChunks(WorldRegion* region, int x, int z, fs::path folder, int layer) {
-    u_char8** chunks = region->getChunks();
+    u_char** chunks = region->getChunks();
 	uint32_t* sizes = region->getSizes();
 
     for (size_t i = 0; i < REGION_CHUNKS_COUNT; i++) {
@@ -396,18 +396,18 @@ void WorldFiles::writeRegion(int x, int z, WorldRegion* entry, fs::path folder,
 	char intbuf[4]{};
 	uint offsets[REGION_CHUNKS_COUNT]{};
 	
-    u_char8** region = entry->getChunks();
+    u_char** region = entry->getChunks();
 	uint32_t* sizes = entry->getSizes();
     
 	for (size_t i = 0; i < REGION_CHUNKS_COUNT; i++) {
-		u_char8* chunk = region[i];
+		u_char* chunk = region[i];
 		if (chunk == nullptr){
 			offsets[i] = 0;
 		} else {
 			offsets[i] = offset;
 
 			size_t compressedSize = sizes[i];
-			dataio::write_int32_big(compressedSize, (u_char8*)intbuf, 0);
+			dataio::write_int32_big(compressedSize, (u_char*)intbuf, 0);
 			offset += 4 + compressedSize;
 
 			file.write(intbuf, 4);
@@ -415,7 +415,7 @@ void WorldFiles::writeRegion(int x, int z, WorldRegion* entry, fs::path folder,
 		}
 	}
 	for (size_t i = 0; i < REGION_CHUNKS_COUNT; i++) {
-		dataio::write_int32_big(offsets[i], (u_char8*)intbuf, 0);
+		dataio::write_int32_big(offsets[i], (u_char*)intbuf, 0);
 		file.write(intbuf, 4);
 	}
 }
diff --git a/src/files/WorldFiles.h b/src/files/WorldFiles.h
index b5f7cd008..33de31175 100644
--- a/src/files/WorldFiles.h
+++ b/src/files/WorldFiles.h
@@ -41,21 +41,21 @@ public:
 };
 
 class WorldRegion {
-	u_char8** chunksData;
+	u_char** chunksData;
 	uint32_t* sizes;
 	bool unsaved = false;
 public:
 	WorldRegion();
 	~WorldRegion();
 
-	void put(uint x, uint z, u_char8* data, uint32_t size);
-	u_char8* getChunkData(uint x, uint z);
+	void put(uint x, uint z, u_char* data, uint32_t size);
+	u_char* getChunkData(uint x, uint z);
 	uint getChunkDataSize(uint x, uint z);
 
 	void setUnsaved(bool unsaved);
 	bool isUnsaved() const;
 
-	u_char8** getChunks() const;
+	u_char** getChunks() const;
 	uint32_t* getSizes() const;
 };
 
@@ -89,16 +89,16 @@ class WorldFiles {
 	   @param src source buffer
 	   @param srclen length of source buffer
 	   @param len (out argument) length of result buffer */
-	u_char8* compress(const u_char8* src, size_t srclen, size_t& len);
+	u_char* compress(const u_char* src, size_t srclen, size_t& len);
 
 	/* Decompress buffer with extrle
 	   @param src compressed buffer
 	   @param srclen length of compressed buffer
 	   @param dstlen max expected length of source buffer
 	*/
-	u_char8* decompress(const u_char8* src, size_t srclen, size_t dstlen);
+	u_char* decompress(const u_char* src, size_t srclen, size_t dstlen);
 
-	u_char8* readChunkData(int x, int y, 
+	u_char* readChunkData(int x, int y, 
 						 uint32_t& length, 
 						 std::filesystem::path folder,
                          int layer);
@@ -108,7 +108,7 @@ class WorldFiles {
 	void writeRegions(regionsmap& regions,
 					  const std::filesystem::path& folder, int layer);
 
-	u_char8* getData(regionsmap& regions,
+	u_char* getData(regionsmap& regions,
 				   const std::filesystem::path& folder,
 				   int x, int z, int layer);
     
@@ -121,7 +121,7 @@ public:
 	regionsmap regions;
 	regionsmap lights;
 	std::filesystem::path directory;
-	std::unique_ptr<u_char8[]> compressionBuffer;
+	std::unique_ptr<u_char[]> compressionBuffer;
 	bool generatorTestMode;
 	bool doWriteLights;
 
@@ -129,12 +129,12 @@ public:
 	~WorldFiles();
 
 	void put(Chunk* chunk);
-    void put(int x, int z, const u_char8* voxelData);
+    void put(int x, int z, const u_char* voxelData);
 
     int getVoxelRegionVersion(int x, int z);
     int getVoxelRegionsVersion();
 
-	u_char8* getChunk(int x, int z);
+	u_char* getChunk(int x, int z);
 	light_t* getLights(int x, int z);
 
 	bool readWorldInfo(World* world);
diff --git a/src/files/binary_io.cpp b/src/files/binary_io.cpp
index a1a53b584..c49c6f43e 100644
--- a/src/files/binary_io.cpp
+++ b/src/files/binary_io.cpp
@@ -4,7 +4,7 @@
 #include <limits>
 #include <stdexcept>
 
-void BinaryWriter::put(u_char8 b) {
+void BinaryWriter::put(u_char b) {
     buffer.push_back(b);
 }
 
@@ -22,7 +22,7 @@ void BinaryWriter::put(const std::string& s) {
         throw std::domain_error("length > INT16_MAX");
     }
     putInt16(len);
-    put((const u_char8*)s.data(), len);
+    put((const u_char*)s.data(), len);
 }
 
 void BinaryWriter::putShortStr(const std::string& s) {
@@ -31,10 +31,10 @@ void BinaryWriter::putShortStr(const std::string& s) {
         throw std::domain_error("length > 255");
     }
     put(len);
-    put((const u_char8*)s.data(), len);
+    put((const u_char*)s.data(), len);
 }
 
-void BinaryWriter::put(const u_char8* arr, size_t size) {
+void BinaryWriter::put(const u_char* arr, size_t size) {
     buffer.reserve(buffer.size() + size);
     for (size_t i = 0; i < size; i++) {
         buffer.push_back(arr[i]);
@@ -75,7 +75,7 @@ void BinaryWriter::putFloat32(float val) {
     putInt32(value.vali32);
 }
 
-BinaryReader::BinaryReader(const u_char8* data, size_t size)
+BinaryReader::BinaryReader(const u_char* data, size_t size)
     : data(data), size(size), pos(0) {
 }
 
@@ -84,14 +84,14 @@ void BinaryReader::checkMagic(const char* data, size_t size) {
         throw std::runtime_error("invalid magic number");
     }
     for (size_t i = 0; i < size; i++) {
-        if (this->data[pos + i] != (u_char8)data[i]){
+        if (this->data[pos + i] != (u_char)data[i]){
             throw std::runtime_error("invalid magic number");
         }
     }
     pos += size;
 }
 
-u_char8 BinaryReader::get() {
+u_char BinaryReader::get() {
     if (pos == size) {
         throw std::underflow_error("buffer underflow");
     }
@@ -152,7 +152,7 @@ std::string BinaryReader::getString() {
 }
 
 std::string BinaryReader::getShortString() {
-    u_char8 length = get();
+    u_char length = get();
     if (pos+length > size) {
         throw std::underflow_error("unexpected end");
     }
diff --git a/src/files/binary_io.h b/src/files/binary_io.h
index b3d308b5b..a47140718 100644
--- a/src/files/binary_io.h
+++ b/src/files/binary_io.h
@@ -6,35 +6,35 @@
 #include "../typedefs.h"
 
 class BinaryWriter {
-    std::vector<u_char8> buffer;
+    std::vector<u_char> buffer;
 public:
-    void put(u_char8 b);
+    void put(u_char b);
     void putCStr(const char* str);
     void putInt16(int16_t val);
     void putInt32(int32_t val);
     void putInt64(int64_t val);
     void putFloat32(float val);
     void put(const std::string& s);
-    void put(const u_char8* arr, size_t size);
+    void put(const u_char* arr, size_t size);
     void putShortStr(const std::string& s);
 
     inline size_t size() const {
         return buffer.size();
     }
-    inline const u_char8* data() const {
+    inline const u_char* data() const {
         return buffer.data();
     }
 };
 
 class BinaryReader {
-    const u_char8* data;
+    const u_char* data;
     size_t size;
     size_t pos;
 public:
-    BinaryReader(const u_char8* data, size_t size);
+    BinaryReader(const u_char* data, size_t size);
 
     void checkMagic(const char* data, size_t size);
-    u_char8 get();
+    u_char get();
     int16_t getInt16();
     int32_t getInt32();
     int64_t getInt64();
diff --git a/src/files/rle.cpp b/src/files/rle.cpp
index 87bece206..b38921ffc 100644
--- a/src/files/rle.cpp
+++ b/src/files/rle.cpp
@@ -1,90 +1,93 @@
 #include "rle.h"
+// template <class T>
+// size_t rle::decode(const T* src, size_t srclen, T* dst) {
+// 	size_t offset = 0;
+// 	for (size_t i = 0; i < srclen;) {
+// 		T len = src[i++];
+// 		T c = src[i++];
+// 		for (size_t j = 0; j <= len; j++) {
+// 			dst[offset++] = c;
+// 		}
+// 	}
+// 	return offset;
+// }
 
-size_t rle::decode(const u_char8* src, size_t srclen, u_char8* dst) {
-	size_t offset = 0;
-	for (size_t i = 0; i < srclen;) {
-		u_char8 len = src[i++];
-		u_char8 c = src[i++];
-		for (size_t j = 0; j <= len; j++) {
-			dst[offset++] = c;
-		}
-	}
-	return offset;
-}
-
-size_t rle::encode(const u_char8* src, size_t srclen, u_char8* dst) {
-	if (srclen == 0) {
-		return 0;
-	}
-	size_t offset = 0;
-	u_char8 counter = 0;
-	u_char8 c = src[0];
-	for (size_t i = 1; i < srclen; i++) {
-		u_char8 cnext = src[i];
-		if (cnext != c || counter == 255) {
-			dst[offset++] = counter;
-			dst[offset++] = c;
-			c = cnext;
-			counter = 0;
-		}
-		else {
-			counter++;
-		}
-	}
-	dst[offset++] = counter;
-	dst[offset++] = c;
-	return offset;
-}
+// template <class T>
+// size_t rle::encode(const T* src, size_t srclen, T* dst) {
+// 	if (srclen == 0) {
+// 		return 0;
+// 	}
+// 	size_t offset = 0;
+// 	u_int counter = 0;
+// 	T c = src[0];
+// 	for (size_t i = 1; i < srclen; i++) {
+// 		T cnext = src[i];
+// 		if (cnext != c || counter == 255) {
+// 			dst[offset++] = counter;
+// 			dst[offset++] = c;
+// 			c = cnext;
+// 			counter = 0;
+// 		}
+// 		else {
+// 			counter++;
+// 		}
+// 	}
+// 	dst[offset++] = counter;
+// 	dst[offset++] = c;
+// 	return offset;
+// }
 
 
-size_t extrle::decode(const u_char8* src, size_t srclen, u_char8* dst) {
-	size_t offset = 0;
-	for (size_t i = 0; i < srclen;) {
-		uint len = src[i++];
-		if (len & 0x80) {
-			len &= 0x7F;
-			len |= ((uint)src[i++]) << 7;
-		}
-		u_char8 c = src[i++];
-		for (size_t j = 0; j <= len; j++) {
-			dst[offset++] = c;
-		}
-	}
-	return offset;
-}
+// template <class T>
+// size_t extrle::decode(const T* src, size_t srclen, T* dst) {
+// 	size_t offset = 0;
+// 	for (size_t i = 0; i < srclen;) {
+// 		T len = src[i++];
+// 		if (len & 0x80) {
+// 			len &= 0x7F;
+// 			len |= ((T)src[i++]) << 7;
+// 		}
+// 		T c = src[i++];
+// 		for (size_t j = 0; j <= len; j++) {
+// 			dst[offset++] = c;
+// 		}
+// 	}
+// 	return offset;
+// }
 
-size_t extrle::encode(const u_char8* src, size_t srclen, u_char8* dst) {
-	if (srclen == 0) {
-		return 0;
-	}
-	size_t offset = 0;
-	uint counter = 0;
-	u_char8 c = src[0];
-	for (size_t i = 1; i < srclen; i++) {
-		u_char8 cnext = src[i];
-		if (cnext != c || counter == max_sequence) {
-			if (counter >= 0x80) {
-				dst[offset++] = 0x80 | (counter & 0x7F);
-				dst[offset++] = counter >> 7;
-			}
-			else {
-				dst[offset++] = counter;
-			}
-			dst[offset++] = c;
-			c = cnext;
-			counter = 0;
-		}
-		else {
-			counter++;
-		}
-	}
-	if (counter >= 0x80) {
-		dst[offset++] = 0x80 | (counter & 0x7F);
-		dst[offset++] = counter >> 7;
-	}
-	else {
-		dst[offset++] = counter;
-	}
-	dst[offset++] = c;
-	return offset;
-}
+// template <class T>
+// size_t extrle::encode(const T* src, size_t srclen, T* dst) {
+// 	if (srclen == 0) {
+// 		return 0;
+// 	}
+// 	size_t offset = 0;
+// 	u_int counter = 0;
+// 	T c = src[0];
+// 	for (size_t i = 1; i < srclen; i++) {
+// 		T cnext = src[i];
+// 		if (cnext != c || counter == max_sequence) {
+// 			if (counter >= 0x80) {
+// 				dst[offset++] = 0x80 | (counter & 0x7F);
+// 				dst[offset++] = counter >> 7;
+// 			}
+// 			else {
+// 				dst[offset++] = counter;
+// 			}
+// 			dst[offset++] = c;
+// 			c = cnext;
+// 			counter = 0;
+// 		}
+// 		else {
+// 			counter++;
+// 		}
+// 	}
+// 	if (counter >= 0x80) {
+// 		dst[offset++] = 0x80 | (counter & 0x7F);
+// 		dst[offset++] = counter >> 7;
+// 	}
+// 	else {
+// 		dst[offset++] = counter;
+// 	}
+// 	dst[offset++] = c;
+// 	return offset;
+// }
diff --git a/src/files/rle.h b/src/files/rle.h
index b9f4c71af..d116e7a0e 100644
--- a/src/files/rle.h
+++ b/src/files/rle.h
@@ -4,14 +4,44 @@
 #include "../typedefs.h"
 
 namespace rle {
-	size_t encode(const u_char8* src, size_t length, u_char8* dst);
-	size_t decode(const u_char8* src, size_t length, u_char8* dst);
-}
+	
+	template <class T>
+	T decode(const T* src, T srclen, T* dst) {
+		T offset = 0;
+		for (T i = 0; i < srclen / sizeof(T);) {
+			T len = src[i++];
+			T c = src[i++];
+			for (T j = 0; j <= len; j++) {
+				dst[offset++] = c;
+			}
+		}
+		return offset*sizeof(T);
+	}
 
-namespace extrle {
-	constexpr uint max_sequence = 0x7FFF;
-	size_t encode(const u_char8* src, size_t length, u_char8* dst);
-	size_t decode(const u_char8* src, size_t length, u_char8* dst);
+	template <class T>
+	T encode(const T* src, T srclen, T* dst) {
+		if (srclen == 0) {
+			return 0;
+		}
+		T offset = 0;
+		u_int counter = 0;
+		T c = src[0];
+		for (T i = 1; i < srclen / sizeof(T); i++) {
+			T cnext = src[i];
+			if (cnext != c || counter == 255) {
+				dst[offset++] = counter;
+				dst[offset++] = c;
+				c = cnext;
+				counter = 0;
+			}
+			else {
+				counter++;
+			}
+		}
+		dst[offset++] = counter;
+		dst[offset++] = c;
+		return offset*sizeof(T);
+	}
 }
 
 #endif // FILES_RLE_H_
diff --git a/src/frontend/hud.cpp b/src/frontend/hud.cpp
index 7f441af50..fa605f450 100644
--- a/src/frontend/hud.cpp
+++ b/src/frontend/hud.cpp
@@ -125,7 +125,7 @@ HudRenderer::HudRenderer(Engine* engine,
 	panel->add(shared_ptr<Label>(create_label([this](){
 		auto player = this->level->player;
 		auto indices = this->level->content->indices;
-		auto str_ = L"dir: "+std::to_wstring(player->selectedVoxel.getDir()) + L"  signal: "+std::to_wstring(player->selectedVoxel.getSig());
+		auto str_ = L"dir: "+std::to_wstring(player->selectedVoxel.dir) + L"  signal: "+std::to_wstring(player->selectedVoxel.signal);
 		return str_;
 	})));
 	panel->add(shared_ptr<Label>(create_label([this](){
diff --git a/src/graphics/Batch3D.cpp b/src/graphics/Batch3D.cpp
index b60987c35..bfd480400 100644
--- a/src/graphics/Batch3D.cpp
+++ b/src/graphics/Batch3D.cpp
@@ -23,7 +23,7 @@ Batch3D::Batch3D(size_t capacity)
 	mesh = new Mesh(buffer, 0, attrs);
 	index = 0;
 
-	u_char8 pixels[] = {
+	u_char pixels[] = {
 		255, 255, 255, 255,
 	};
 	blank = new Texture(pixels, 1, 1, GL_RGBA);
diff --git a/src/graphics/BlocksRenderer.cpp b/src/graphics/BlocksRenderer.cpp
index 98b4615a6..3d8e44b09 100644
--- a/src/graphics/BlocksRenderer.cpp
+++ b/src/graphics/BlocksRenderer.cpp
@@ -187,7 +187,7 @@ void BlocksRenderer::blockXSprite(int x, int y, int z,
 /* AABB blocks render method */
 void BlocksRenderer::blockAABB(const ivec3& icoord,
 							   const UVRegion(&texfaces)[6], 
-							   const Block* block, u_char8 rotation,
+							   const Block* block, u_char rotation,
                                bool lights) {
 	AABB hitbox = block->hitbox;
 	vec3 size = hitbox.size();
@@ -221,9 +221,9 @@ void BlocksRenderer::blockAABB(const ivec3& icoord,
 void BlocksRenderer::blockCube(int x, int y, int z, 
 									 const UVRegion(&texfaces)[6], 
 									 const Block* block, 
-									 u_char8 states,
+									 voxel_t dir,
                                      bool lights) {
-	u_char8 group = block->drawGroup;
+	u_char group = block->drawGroup;
 
 	vec3 X(1, 0, 0);
 	vec3 Y(0, 1, 0);
@@ -231,7 +231,7 @@ void BlocksRenderer::blockCube(int x, int y, int z,
 	vec3 coord(x, y, z);
 	if (block->rotatable) {
 		auto& rotations = block->rotations;
-		auto& orient = rotations.variants[states & BLOCK_DIR_MASK];
+		auto& orient = rotations.variants[dir];
 		X = orient.axisX;
 		Y = orient.axisY;
 		Z = orient.axisZ;
@@ -258,7 +258,7 @@ void BlocksRenderer::blockCube(int x, int y, int z,
 }
 
 // Does block allow to see other blocks sides (is it transparent)
-bool BlocksRenderer::isOpen(int x, int y, int z, u_char8 group) const {
+bool BlocksRenderer::isOpen(int x, int y, int z, u_char group) const {
 	blockid_t id = voxelsBuffer->pickBlockId(chunk->x * CHUNK_W + x, 
 											 y, 
 											 chunk->z * CHUNK_D + z);
@@ -340,7 +340,7 @@ void BlocksRenderer::render(const voxel* voxels) {
 			int z = (i / CHUNK_D) % CHUNK_W;
 			switch (def.model) {
 			case BlockModel::block:
-                blockCube(x, y, z, texfaces, &def, vox.states, !def.rt.emissive);
+                blockCube(x, y, z, texfaces, &def, vox.dir, !def.rt.emissive);
 				break;
 			case BlockModel::xsprite: {
 				blockXSprite(x, y, z, vec3(1.0f), 
@@ -348,7 +348,7 @@ void BlocksRenderer::render(const voxel* voxels) {
 				break;
 			}
 			case BlockModel::aabb: {
-				blockAABB(ivec3(x,y,z), texfaces, &def, vox.getDir(), !def.rt.emissive);
+				blockAABB(ivec3(x,y,z), texfaces, &def, vox.dir, !def.rt.emissive);
 				break;
 			}
 			default:
diff --git a/src/graphics/BlocksRenderer.h b/src/graphics/BlocksRenderer.h
index c59f38192..53da34646 100644
--- a/src/graphics/BlocksRenderer.h
+++ b/src/graphics/BlocksRenderer.h
@@ -60,16 +60,16 @@ class BlocksRenderer {
 		const UVRegion& region,
         bool lights);
 	
-	void blockCube(int x, int y, int z, const UVRegion(&faces)[6], const Block* block, u_char8 states, bool lights);
+	void blockCube(int x, int y, int z, const UVRegion(&faces)[6], const Block* block, voxel_t dir, bool lights);
 	void blockAABB(const glm::ivec3& coord,
                     const UVRegion(&faces)[6], 
                     const Block* block, 
-                    u_char8 rotation,
+                    u_char rotation,
                     bool lights);
 	void blockXSprite(int x, int y, int z, const glm::vec3& size, const UVRegion& face1, const UVRegion& face2, float spread);
 
 	bool isOpenForLight(int x, int y, int z) const;
-	bool isOpen(int x, int y, int z, u_char8 group) const;
+	bool isOpen(int x, int y, int z, u_char group) const;
 
 	glm::vec4 pickLight(int x, int y, int z) const;
 	glm::vec4 pickLight(const glm::ivec3& coord) const;
diff --git a/src/graphics/ImageData.cpp b/src/graphics/ImageData.cpp
index 8911884b4..8682dad2f 100644
--- a/src/graphics/ImageData.cpp
+++ b/src/graphics/ImageData.cpp
@@ -14,8 +14,8 @@ inline int max(int a, int b) {
 ImageData::ImageData(ImageFormat format, uint width, uint height) 
     : format(format), width(width), height(height) {
     switch (format) {
-        case ImageFormat::rgb888: data = new u_char8[width*height*3]{}; break;
-        case ImageFormat::rgba8888: data = new u_char8[width*height*4]{}; break;
+        case ImageFormat::rgb888: data = new u_char[width*height*3]{}; break;
+        case ImageFormat::rgba8888: data = new u_char[width*height*4]{}; break;
         default:
             throw std::runtime_error("format is not supported");
     }
@@ -29,7 +29,7 @@ ImageData::~ImageData() {
     switch (format) {
         case ImageFormat::rgb888:
         case ImageFormat::rgba8888:
-            delete[] (u_char8*)data;
+            delete[] (u_char*)data;
             break;
     }
 }
@@ -40,11 +40,11 @@ void ImageData::flipX() {
         case ImageFormat::rgb888:
         case ImageFormat::rgba8888: {
             size = (format == ImageFormat::rgba8888) ? 4 : 3;
-            u_char8* pixels = (u_char8*)data;
+            u_char* pixels = (u_char*)data;
             for (uint y = 0; y < height; y++) {
                 for (uint x = 0; x < width/2; x++) {
                     for (uint c = 0; c < size; c++) {
-                        u_char8 temp = pixels[(y * width + x) * size + c];
+                        u_char temp = pixels[(y * width + x) * size + c];
                         pixels[(y * width + x) * size + c] = pixels[(y * width + (width - x - 1)) * size + c];
                         pixels[(y * width + (width - x - 1)) * size + c] = temp;
                     }
@@ -63,11 +63,11 @@ void ImageData::flipY() {
         case ImageFormat::rgb888:
         case ImageFormat::rgba8888: {
             size = (format == ImageFormat::rgba8888) ? 4 : 3;
-            u_char8* pixels = (u_char8*)data;
+            u_char* pixels = (u_char*)data;
             for (uint y = 0; y < height/2; y++) {
                 for (uint x = 0; x < width; x++) {
                     for (uint c = 0; c < size; c++) {
-                        u_char8 temp = pixels[(y * width + x) * size + c];
+                        u_char temp = pixels[(y * width + x) * size + c];
                         pixels[(y * width + x) * size + c] = 
                                pixels[((height-y-1) * width + x) * size + c];
                         pixels[((height-y-1) * width + x) * size + c] = temp;
@@ -95,8 +95,8 @@ void ImageData::blit(const ImageData* image, int x, int y) {
 }
 
 void ImageData::blitRGB_on_RGBA(const ImageData* image, int x, int y) {
-    ubyte* pixels = static_cast<ubyte*>(data);
-    ubyte* source = static_cast<ubyte*>(image->getData());
+    u_char* pixels = static_cast<u_char*>(data);
+    u_char* source = static_cast<u_char*>(image->getData());
     uint srcwidth = image->getWidth();
     uint srcheight = image->getHeight();
 
@@ -122,8 +122,8 @@ void ImageData::blitMatchingFormat(const ImageData* image, int x, int y) {
         default:
             throw std::runtime_error("only unsigned byte formats supported");    
     }
-    u_char8* pixels = static_cast<u_char8*>(data);
-    u_char8* source = static_cast<u_char8*>(image->getData());
+    u_char* pixels = static_cast<u_char*>(data);
+    u_char* source = static_cast<u_char*>(image->getData());
     uint srcwidth = image->getWidth();
     uint srcheight = image->getHeight();
 
@@ -150,7 +150,7 @@ void ImageData::extrude(int x, int y, int w, int h) {
         default:
             throw std::runtime_error("only unsigned byte formats supported");    
     }
-    u_char8* pixels = static_cast<u_char8*>(data);
+    u_char* pixels = static_cast<u_char*>(data);
 
     int rx = x + w - 1;
     int ry = y + h - 1;
@@ -237,7 +237,7 @@ void ImageData::extrude(int x, int y, int w, int h) {
 }
 
 void ImageData::fixAlphaColor() {
-    u_char8* pixels = static_cast<u_char8*>(data); 
+    u_char* pixels = static_cast<u_char*>(data); 
 
     // Fixing black transparent pixels for Mip-Mapping
     for (uint ly = 0; ly < height-1; ly++) {
@@ -265,8 +265,8 @@ ImageData* add_atlas_margins(ImageData* image, int grid_size) {
     int dstwidth = srcwidth + grid_size * 2;
     int dstheight = srcheight + grid_size * 2;
 
-    const u_char8* srcdata = (const u_char8*)image->getData(); 
-    u_char8* dstdata = new u_char8[dstwidth*dstheight * 4];
+    const u_char* srcdata = (const u_char*)image->getData(); 
+    u_char* dstdata = new u_char[dstwidth*dstheight * 4];
 
     int imgres = image->getWidth() / grid_size; 
     for (int row = 0; row < grid_size; row++) {
diff --git a/src/graphics/Mesh.h b/src/graphics/Mesh.h
index 7a7249ecc..ebcf37c60 100644
--- a/src/graphics/Mesh.h
+++ b/src/graphics/Mesh.h
@@ -5,7 +5,7 @@
 #include "../typedefs.h"
 
 struct vattr {
-	u_char8 size;
+	u_char size;
 };
 
 class Mesh {
diff --git a/src/graphics/Texture.cpp b/src/graphics/Texture.cpp
index afb3104a0..0f0502ee5 100644
--- a/src/graphics/Texture.cpp
+++ b/src/graphics/Texture.cpp
@@ -8,7 +8,7 @@ Texture::Texture(uint id, int width, int height)
 	: id(id), width(width), height(height) {
 }
 
-Texture::Texture(u_char8* data, int width, int height, uint format) 
+Texture::Texture(u_char* data, int width, int height, uint format) 
 	: width(width), height(height) {
 	glGenTextures(1, &id);
 	glBindTexture(GL_TEXTURE_2D, id);
@@ -30,7 +30,7 @@ void Texture::bind(){
 	glBindTexture(GL_TEXTURE_2D, id);
 }
 
-void Texture::reload(u_char8* data){
+void Texture::reload(u_char* data){
 	glBindTexture(GL_TEXTURE_2D, id);
 	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0,
 		GL_RGBA, GL_UNSIGNED_BYTE, (GLvoid *) data);
@@ -48,5 +48,5 @@ Texture* Texture::from(const ImageData* image) {
 		default:
 			throw std::runtime_error("unsupported image data format");
 	}
-	return new Texture((u_char8*)data, width, height, format);
+	return new Texture((u_char*)data, width, height, format);
 }
\ No newline at end of file
diff --git a/src/graphics/Texture.h b/src/graphics/Texture.h
index de068a6a7..0edad16f2 100644
--- a/src/graphics/Texture.h
+++ b/src/graphics/Texture.h
@@ -12,11 +12,11 @@ public:
 	int width;
 	int height;
 	Texture(uint id, int width, int height);
-	Texture(u_char8* data, int width, int height, uint format);
+	Texture(u_char* data, int width, int height, uint format);
 	~Texture();
 
 	void bind();
-	void reload(u_char8* data);
+	void reload(u_char* data);
 
 	static Texture* from(const ImageData* image);
 };
diff --git a/src/lighting/Lightmap.cpp b/src/lighting/Lightmap.cpp
index e71774d8e..63c1bc900 100644
--- a/src/lighting/Lightmap.cpp
+++ b/src/lighting/Lightmap.cpp
@@ -27,18 +27,18 @@ void Lightmap::set(light_t* map) {
 
 static_assert(sizeof(light_t) == 2, "replace dataio calls to new light_t");
 
-u_char8* Lightmap::encode() const {
-	u_char8* buffer = new u_char8[LIGHTMAP_DATA_LEN];
+u_char* Lightmap::encode() const {
+	u_char* buffer = new u_char[LIGHTMAP_DATA_LEN];
 	for (uint i = 0; i < CHUNK_VOL; i+=2) {
 		buffer[i/2] = ((map[i] >> 12) & 0xF) | ((map[i+1] >> 8) & 0xF0);
 	}
 	return buffer;
 }
 
-light_t* Lightmap::decode(u_char8* buffer) {
+light_t* Lightmap::decode(u_char* buffer) {
 	light_t* lights = new light_t[CHUNK_VOL];
 	for (uint i = 0; i < CHUNK_VOL; i+=2) {
-		u_char8 b = buffer[i/2];
+		u_char b = buffer[i/2];
 		lights[i] = ((b & 0xF) << 12);
 		lights[i+1] = ((b & 0xF0) << 8);
 	} 
diff --git a/src/lighting/Lightmap.h b/src/lighting/Lightmap.h
index 5ba5ca4b3..f9b962358 100644
--- a/src/lighting/Lightmap.h
+++ b/src/lighting/Lightmap.h
@@ -80,12 +80,12 @@ public:
 		return r | (g << 4) | (b << 8) | (s << 12);
 	}
 
-	static inline light_t extract(light_t light, u_char8 channel) {
+	static inline light_t extract(light_t light, u_char channel) {
 		return (light >> (channel << 2)) & 0xF;
 	}
 
-	u_char8* encode() const;
-	static light_t* decode(u_char8* buffer);
+	u_char* encode() const;
+	static light_t* decode(u_char* buffer);
 };
 
 #endif /* LIGHTING_LIGHTMAP_H_ */
diff --git a/src/logic/BlocksController.cpp b/src/logic/BlocksController.cpp
index ac74f6142..985765414 100644
--- a/src/logic/BlocksController.cpp
+++ b/src/logic/BlocksController.cpp
@@ -57,7 +57,7 @@ void BlocksController::updateSides(int x, int y, int z) {
 }
 
 void BlocksController::breakBlock(Player* player, const Block* def, int x, int y, int z) {
-    chunks->set(x,y,z, voxel{0,0});
+    chunks->set(x,y,z, voxel());
     lighting->onBlockSet(x,y,z, 0);
     if (def->rt.funcsset.onbroken) {
         scripting::on_block_broken(player, def, x, y, z);
@@ -75,10 +75,9 @@ void BlocksController::updateBlock(int x, int y, int z) {
         return;
     }
     if (def->rt.funcsset.update) {
-        int states = vox->states;
-        int id = vox->id;
+        voxel tmp = *vox;
         scripting::update_block(def, x, y, z);
-        if (states != vox->states || id!= vox->id)
+        if (tmp != *vox)
             updateSides(x, y, z);
     }
 }
diff --git a/src/logic/PlayerController.cpp b/src/logic/PlayerController.cpp
index 2dc7faa72..d9e227bac 100644
--- a/src/logic/PlayerController.cpp
+++ b/src/logic/PlayerController.cpp
@@ -229,7 +229,6 @@ void PlayerController::updateInteraction(){
 	if (vox != nullptr){
 		player->selectedVoxel = *vox;
 		selectedBlockId = vox->id;
-		selectedBlockStates = vox->states;
 		selectedBlockPosition = iend;
 		selectedPointPosition = end;
 		selectedBlockNormal = norm;
@@ -242,21 +241,21 @@ void PlayerController::updateInteraction(){
 		if (def->rotatable){
 			const std::string& name = def->rotations.name;
 			if (name == "pipe") {
-				if 		(norm.x < 0.0f) voxel.setDir(BLOCK_DIR_WEST);
-				else if (norm.x > 0.0f) voxel.setDir(BLOCK_DIR_EAST);
-				else if (norm.y > 0.0f) voxel.setDir(BLOCK_DIR_UP);
-				else if (norm.y < 0.0f) voxel.setDir(BLOCK_DIR_DOWN);
-				else if (norm.z > 0.0f) voxel.setDir(BLOCK_DIR_NORTH);
-				else if (norm.z < 0.0f) voxel.setDir(BLOCK_DIR_SOUTH);
+				if 		(norm.x < 0.0f) voxel.dir = (voxel_t)VOX_DIR::WEST;
+				else if (norm.x > 0.0f) voxel.dir = (voxel_t)VOX_DIR::EAST;
+				else if (norm.y > 0.0f) voxel.dir = (voxel_t)VOX_DIR::UP;
+				else if (norm.y < 0.0f) voxel.dir = (voxel_t)VOX_DIR::DOWN;
+				else if (norm.z > 0.0f) voxel.dir = (voxel_t)VOX_DIR::NORTH;
+				else if (norm.z < 0.0f) voxel.dir = (voxel_t)VOX_DIR::SOUTH;
 			} else if (name == "pane") {
 				glm::vec3 vec = camera->dir;
 				if (abs(vec.x) > abs(vec.z)){
-					if (vec.x > 0.0f) voxel.setDir(BLOCK_DIR_EAST);
-					if (vec.x < 0.0f) voxel.setDir(BLOCK_DIR_WEST);
+					if (vec.x > 0.0f) voxel.dir = (voxel_t)VOX_DIR::EAST;
+					if (vec.x < 0.0f) voxel.dir = (voxel_t)VOX_DIR::WEST;
 				}
 				if (abs(vec.x) < abs(vec.z)){
-					if (vec.z > 0.0f) voxel.setDir(BLOCK_DIR_SOUTH);
-					if (vec.z < 0.0f) voxel.setDir(BLOCK_DIR_NORTH);
+					if (vec.z > 0.0f) voxel.dir = (voxel_t)VOX_DIR::SOUTH;
+					if (vec.z < 0.0f) voxel.dir = (voxel_t)VOX_DIR::NORTH;
 				}
 			}
 		}
@@ -300,7 +299,7 @@ void PlayerController::updateInteraction(){
 			player->chosenBlock = chunks->get(x,y,z)->id;
 		}
 	} else {
-		player->selectedVoxel = voxel{0, 0};
+		player->selectedVoxel = voxel();
 		selectedBlockId = -1;
 		selectedBlockStates = 0;
 	}
diff --git a/src/logic/scripting/api_lua.cpp b/src/logic/scripting/api_lua.cpp
index 1e2048695..7954b18a6 100644
--- a/src/logic/scripting/api_lua.cpp
+++ b/src/logic/scripting/api_lua.cpp
@@ -2,22 +2,115 @@
 #include "scripting.h"
 
 #include <glm/glm.hpp>
+#include <bit>
 
-#include "../../physics/Hitbox.h"
-#include "../../objects/Player.h"
 #include "../../world/Level.h"
+#include "../../objects/Player.h"
+#include "../../physics/Hitbox.h"
+#include "../../window/Camera.h"
+
 #include "../../content/Content.h"
 #include "../../voxels/Block.h"
 #include "../../voxels/Chunks.h"
 #include "../../voxels/voxel.h"
 #include "../../lighting/Lighting.h"
 
-int l_block_name(lua_State* L) {
+
+
+/**
+ *       ,--------,
+ *:      | PLAYER |
+ *       |--------'--------------------------------------,
+ *       | get_player_pos():                             |
+ *       |     return x:float, y:float, z:float          |
+ *       |                                               |
+ *       | set_player_pos(x:float, y:float, z:float)     |
+ *       |                                               |
+ *       | get_player_rot():                             |
+ *       |     return x:float, y:float                   |
+ *       |                                               |
+ *       | set_player_rot(x:float, y:float)              |
+ *       |                                               |
+ *       | get_player_front():                           |
+ *       |     return x:float, y:float, z:float          |
+ *       |                                               |
+ *TODO   | set_player_front(x:float, y:float, z:float)   |
+ *       '-----------------------------------------------'
+ */
+
+int l_get_player_pos(lua_State* L) {
+    glm::vec3 pos = scripting::level->player->hitbox->position;
+    lua_pushnumber(L, pos.x);
+    lua_pushnumber(L, pos.y);
+    lua_pushnumber(L, pos.z);
+    return 3;
+}
+int l_set_player_pos(lua_State* L) {
+    double x = lua_tonumber(L, 1);
+    double y = lua_tonumber(L, 2);
+    double z = lua_tonumber(L, 3);
+    scripting::level->player->hitbox->position = glm::vec3(x, y, z);
+    return 0;
+}
+
+int l_get_player_rot(lua_State* L) {
+    glm::vec2 rot = scripting::level->player->cam;
+    lua_pushnumber(L, rot.x);
+    lua_pushnumber(L, rot.y);
+    return 2;
+}
+int l_set_player_rot(lua_State* L) {
+    double x = lua_tonumber(L, 1);
+    double y = lua_tonumber(L, 2);
+    scripting::level->player->cam = glm::vec2(x, y);
+    return 0;
+}
+
+int l_get_player_front(lua_State* L) {
+    glm::vec3 front = scripting::level->player->camera->front;
+    lua_pushnumber(L, front.x);
+    lua_pushnumber(L, front.y);
+    lua_pushnumber(L, front.z);
+    return 3;
+}
+// TODO: set_player_front(x:float, y:float, z:float);
+
+
+
+/**
+ *       ,--------,
+ *:      | VOXELS |
+ *       |--------'---------------------------------------,
+ *       | pars_vox(vox:long):                            |
+ *       |     return id:short, variant:char,             |
+ *       |            dir:char, signal:char, states:int   |
+ *       |                                                |
+ *       | creat_vox(id:short, variant:char, dir:char,    |
+ *       |           signal:char, states:int):            |
+ *       |     return vox:long                            |
+ *       |                                                |
+ *       | idv_2_name(id:short, variant:char):            |
+ *       |     return name:str                            |
+ *       |                                                |
+ *       | name_2_idv(name:str):                          |
+ *       |     return id:short, variant:char              |
+ *       '------------------------------------------------'
+ */
+
+int l_block_id_2_name(lua_State* L) {
     int id = lua_tointeger(L, 1);
     lua_pushstring(L, scripting::content->indices->getBlockDef(id)->name.c_str());
     return 1;
 }
 
+int l_block_name_2_id(lua_State* L) {
+    auto name = lua_tostring(L, 1);
+    lua_pushinteger(L, scripting::content->requireBlock(name)->rt.id);
+    return 1;
+}
+
+
+
 int l_is_solid_at(lua_State* L) {
     int x = lua_tointeger(L, 1);
     int y = lua_tointeger(L, 2);
@@ -32,21 +125,14 @@ int l_blocks_count(lua_State* L) {
     return 1;
 }
 
-int l_block_index(lua_State* L) {
-    auto name = lua_tostring(L, 1);
-    lua_pushinteger(L, scripting::content->requireBlock(name)->rt.id);
-    return 1;
-}
 
 int l_set_block(lua_State* L) {
-    voxel voxel;
     int x = lua_tointeger(L, 1);
     int y = lua_tointeger(L, 2);
     int z = lua_tointeger(L, 3);
-    voxel.id = lua_tointeger(L, 4);
-    voxel.states = lua_tointeger(L, 5);
-    scripting::level->chunks->set(x, y, z, voxel);
-    scripting::level->lighting->onBlockSet(x,y,z, voxel.id);
+    voxel vox = std::bit_cast<voxel>(lua_tointeger(L, 4));
+    scripting::level->chunks->set(x, y, z, vox);
+    scripting::level->lighting->onBlockSet(x,y,z, vox.id);
     return 0;
 }
 
@@ -55,68 +141,8 @@ int l_get_block(lua_State* L) {
     int y = lua_tointeger(L, 2);
     int z = lua_tointeger(L, 3);
     voxel* vox = scripting::level->chunks->get(x, y, z);
-    int id = vox == nullptr ? -1 : vox->id;
-    lua_pushinteger(L, id);
-    return 1;
-}
-
-inline int lua_pushivec3(lua_State* L, int x, int y, int z) {
-    lua_pushinteger(L, x);
-    lua_pushinteger(L, y);
-    lua_pushinteger(L, z);
-    return 3;
-}
-
-int l_get_player_pos(lua_State* L) {
-    glm::vec3 pos = scripting::level->player->hitbox->position;
-    lua_pushnumber(L, pos.x);
-    lua_pushnumber(L, pos.y);
-    lua_pushnumber(L, pos.z);
-    return 3;
-}
-
-int l_get_player_rot(lua_State* L) {
-    glm::vec2 rot = scripting::level->player->cam;
-    lua_pushnumber(L, rot.x);
-    lua_pushnumber(L, rot.y);
-    return 2;
-}
-
-int l_set_player_rot(lua_State* L) {
-    double x = lua_tonumber(L, 1);
-    double y = lua_tonumber(L, 2);
-    glm::vec2& cam = scripting::level->player->cam;
-    cam.x = x;
-    cam.y = y;
-    return 0;
-}
-
-int l_set_player_pos(lua_State* L) {
-    double x = lua_tonumber(L, 1);
-    double y = lua_tonumber(L, 2);
-    double z = lua_tonumber(L, 3);
-    scripting::level->player->hitbox->position = glm::vec3(x, y, z);
-    return 0;
-}
-
-// old functions, not recommended to use
-int l_get_block_states(lua_State* L) {
-    int x = lua_tointeger(L, 1);
-    int y = lua_tointeger(L, 2);
-    int z = lua_tointeger(L, 3);
-    voxel* vox = scripting::level->chunks->get(x, y, z);
-    int states = vox == nullptr ? 0 : vox->states;
-    lua_pushinteger(L, states);
-    return 1;
-}
-
-
-int l_is_replaceable_at(lua_State* L) {
-    int x = lua_tointeger(L, 1);
-    int y = lua_tointeger(L, 2);
-    int z = lua_tointeger(L, 3);
-
-    lua_pushboolean(L, scripting::level->chunks->isReplaceableBlock(x, y, z));
+    voxel_t vox_ = std::bit_cast<voxel_t>(vox);
+    lua_pushinteger(L, vox_);
     return 1;
 }
 
@@ -126,8 +152,7 @@ int l_get_block_dir(lua_State* L) {
         y = lua_tointeger(L, 2),
         z = lua_tointeger(L, 3);
     voxel* vox = scripting::level->chunks->get(x, y, z);
-    int states = vox->getDir();
-    lua_pushinteger(L, states);
+    lua_pushinteger(L, vox->dir);
     return 1;
 }
 int l_set_block_dir(lua_State* L) {
@@ -136,7 +161,7 @@ int l_set_block_dir(lua_State* L) {
         z = lua_tointeger(L, 3),
         s = lua_tointeger(L, 4);
     voxel* vox = scripting::level->chunks->get(x, y, z);
-    vox->setDir(s);
+    vox->dir = s;
     return 0;
 }
 
@@ -145,61 +170,19 @@ int l_get_block_sig(lua_State* L) {
         y = lua_tointeger(L, 2),
         z = lua_tointeger(L, 3);
     voxel* vox = scripting::level->chunks->get(x, y, z);
-    bool sig = vox->getSig();
-    lua_pushboolean(L, sig);
+    lua_pushinteger(L, vox->signal);
     return 1;
 }
 int l_set_block_sig(lua_State* L) {
     int x = lua_tointeger(L, 1),
         y = lua_tointeger(L, 2),
         z = lua_tointeger(L, 3);
-    bool s = lua_toboolean(L, 4);
+    bool sig = lua_tointeger(L, 4);
     voxel* vox = scripting::level->chunks->get(x, y, z);
-    vox->setSig(s);
+    vox->signal = sig;
     return 0;
 }
 
-int l_get_block_custom_state(lua_State* L) {
-    int x = lua_tointeger(L, 1),
-        y = lua_tointeger(L, 2),
-        z = lua_tointeger(L, 3),
-        i = lua_tointeger(L, 4);
-    voxel* vox = scripting::level->chunks->get(x, y, z);
-    bool state = vox->getCustomState(i);
-    lua_pushboolean(L, state);
-    return 1;
-}
-int l_set_block_custom_state(lua_State* L) {
-    int x = lua_tointeger(L, 1),
-        y = lua_tointeger(L, 2),
-        z = lua_tointeger(L, 3),
-        i = lua_tointeger(L, 4);
-    bool s = lua_toboolean(L, 5);
-    voxel* vox = scripting::level->chunks->get(x, y, z);
-    vox->setCustomState(i, s);
-    return 0;
-}
-
-int l_get_block_custom_value(lua_State* L) {
-    int x = lua_tointeger(L, 1),
-        y = lua_tointeger(L, 2),
-        z = lua_tointeger(L, 3);
-    voxel* vox = scripting::level->chunks->get(x, y, z);
-    int state = vox->getCustomValue();
-    lua_pushinteger(L, state);
-    return 1;
-}
-int l_set_block_custom_value(lua_State* L) {
-    int x = lua_tointeger(L, 1),
-        y = lua_tointeger(L, 2),
-        z = lua_tointeger(L, 3),
-        v = lua_tointeger(L, 4);
-    voxel* vox = scripting::level->chunks->get(x, y, z);
-    vox->setCustomValue(v);
-    return 0;
-}
-
-// for specific modes
 int l_get_block_custom_bits(lua_State* L) {
     int x = lua_tointeger(L, 1);
     int y = lua_tointeger(L, 2);
@@ -228,6 +211,26 @@ int l_set_block_custom_bits(lua_State* L) {
     return 0;
 }
 
+// old functions, not recommended to use
+// int l_get_block_states(lua_State* L) {
+//     int x = lua_tointeger(L, 1);
+//     int y = lua_tointeger(L, 2);
+//     int z = lua_tointeger(L, 3);
+//     voxel* vox = scripting::level->chunks->get(x, y, z);
+//     int states = vox == nullptr ? 0 : vox->states;
+//     lua_pushinteger(L, states);
+//     return 1;
+// }
+
+
+int l_is_replaceable_at(lua_State* L) {
+    int x = lua_tointeger(L, 1);
+    int y = lua_tointeger(L, 2);
+    int z = lua_tointeger(L, 3);
+
+    lua_pushboolean(L, scripting::level->chunks->isReplaceableBlock(x, y, z));
+    return 1;
+}
 
 inline int lua_pushivec3(lua_State* L, int x, int y, int z) {
     lua_pushinteger(L, x);
@@ -248,7 +251,7 @@ int l_get_block_x(lua_State* L) {
     if (!def->rotatable) {
         return lua_pushivec3(L, 1, 0, 0);
     } else {
-        const CoordSystem& rot = def->rotations.variants[vox->getDir()];
+        const CoordSystem& rot = def->rotations.variants[vox->dir];
         return lua_pushivec3(L, rot.axisX.x, rot.axisX.y, rot.axisX.z);
     }
 }
@@ -264,7 +267,7 @@ int l_get_block_y(lua_State* L) {
     if (!def->rotatable) {
         return lua_pushivec3(L, 0, 1, 0);
     } else {
-        const CoordSystem& rot = def->rotations.variants[vox->getDir()];
+        const CoordSystem& rot = def->rotations.variants[vox->dir];
         return lua_pushivec3(L, rot.axisY.x, rot.axisY.y, rot.axisY.z);
     }
 }
@@ -280,7 +283,7 @@ int l_get_block_z(lua_State* L) {
     if (!def->rotatable) {
         return lua_pushivec3(L, 0, 0, 1);
     } else {
-        const CoordSystem& rot = def->rotations.variants[vox->getDir()];
+        const CoordSystem& rot = def->rotations.variants[vox->dir];
         return lua_pushivec3(L, rot.axisZ.x, rot.axisZ.y, rot.axisZ.z);
     }
 }
@@ -290,8 +293,12 @@ int l_get_block_z(lua_State* L) {
                                     lua_setglobal(L, NAME))
 
 void apilua::create_funcs(lua_State* L) {
-    lua_addfunc(L, l_block_index, "block_index");
-    lua_addfunc(L, l_block_name, "block_name");
+    // old functions
+        lua_addfunc(L, l_block_id_2_name, "block_index");
+        lua_addfunc(L, l_block_name_2_id, "block_name");
+    
+    lua_addfunc(L, l_block_id_2_name, "block_id_2_name");
+    lua_addfunc(L, l_block_name_2_id, "block_name_2_id");
     lua_addfunc(L, l_blocks_count, "blocks_count");
     lua_addfunc(L, l_is_solid_at, "is_solid_at");
     lua_addfunc(L, l_is_replaceable_at, "is_replaceable_at");
@@ -305,14 +312,10 @@ void apilua::create_funcs(lua_State* L) {
     lua_addfunc(L, l_get_player_rot, "get_player_rot");
     lua_addfunc(L, l_set_player_rot, "set_player_rot");
 
-    lua_addfunc(L, l_get_block_states, "get_block_states"); // old function
+    // lua_addfunc(L, l_get_block_states, "get_block_states"); // old function
 
     lua_addfunc(L, l_get_block_dir, "get_block_dir");
     lua_addfunc(L, l_set_block_dir, "set_block_dir");
-    lua_addfunc(L, l_get_block_custom_state, "get_block_custom_state");
-    lua_addfunc(L, l_set_block_custom_state, "set_block_custom_state");
-    lua_addfunc(L, l_get_block_custom_value, "get_block_custom_value");
-    lua_addfunc(L, l_set_block_custom_value, "set_block_custom_value");
     lua_addfunc(L, l_get_block_sig, "get_block_sig");
     lua_addfunc(L, l_set_block_sig, "set_block_sig");
     lua_addfunc(L, l_get_block_x, "get_block_X");
diff --git a/src/maths/voxmaths.h b/src/maths/voxmaths.h
index 4eee56d60..72327c6fe 100644
--- a/src/maths/voxmaths.h
+++ b/src/maths/voxmaths.h
@@ -25,15 +25,15 @@ inline int min(int a, int b) {
 	return (a < b) ? a : b;
 }
 
-inline int64_t max(int64_t a, int64_t b) {
+inline long max(long a, long b) {
 	return (a > b) ? a : b;
 }
 
-inline int64_t min(int64_t a, int64_t b) {
+inline long min(long a, long b) {
 	return (a < b) ? a : b;
 }
 
-static unsigned int g_seed;
+static u_int g_seed;
 
 inline void fast_srand(int seed) {
 	g_seed = seed;
@@ -44,7 +44,7 @@ inline int fast_rand(void) {
 	return (g_seed >> 16) & 0x7FFF;
 }
 
-inline light_t light_pack(u_char8 r, u_char8 g, u_char8 b, u_char8 s) {
+inline light_t light_pack(u_char r, u_char g, u_char b, u_char s) {
 	return r | (g << 4) | (b << 8) | (s << 12);
 }
 
diff --git a/src/objects/Player.h b/src/objects/Player.h
index 7c90c36b8..068446a65 100644
--- a/src/objects/Player.h
+++ b/src/objects/Player.h
@@ -36,7 +36,7 @@ public:
 	bool noclip = false;
 	bool debug = false;
 	int chosenBlock;
-	voxel selectedVoxel {0, 0};
+	voxel selectedVoxel {0};
 
 	glm::vec2 cam = {};
 
diff --git a/src/physics/PhysicsSolver.cpp b/src/physics/PhysicsSolver.cpp
index 6171412bf..68874851b 100644
--- a/src/physics/PhysicsSolver.cpp
+++ b/src/physics/PhysicsSolver.cpp
@@ -16,7 +16,7 @@ void PhysicsSolver::step(
 		Chunks* chunks, 
 		Hitbox* hitbox, 
 		float delta, 
-		uint substeps, 
+		u_int substeps, 
 		bool shifting,
 		float gravityScale,
 		bool collisions)
@@ -26,7 +26,7 @@ void PhysicsSolver::step(
 	float s = 2.0f/BLOCK_AABB_GRID;
 
 	hitbox->grounded = false;
-	for (uint i = 0; i < substeps; i++) {
+	for (u_int i = 0; i < substeps; i++) {
 		vec3& pos = hitbox->position;
 		vec3& half = hitbox->halfsize;
 		vec3& vel = hitbox->velocity;
diff --git a/src/physics/PhysicsSolver.h b/src/physics/PhysicsSolver.h
index 6784b417a..9d028b519 100644
--- a/src/physics/PhysicsSolver.h
+++ b/src/physics/PhysicsSolver.h
@@ -14,7 +14,7 @@ public:
 	void step(Chunks* chunks,
 			Hitbox* hitbox,
 			float delta,
-			uint substeps,
+			u_int substeps,
 			bool shifting,
 			float gravityScale,
 			bool collisions);
diff --git a/src/settings.h b/src/settings.h
index dc21070fb..5d0d8e8c7 100644
--- a/src/settings.h
+++ b/src/settings.h
@@ -25,11 +25,11 @@ struct DisplaySettings {
 
 struct ChunksSettings {
     /* Max milliseconds that engine uses for chunks loading only */
-	uint loadSpeed = 10;
+	u_int loadSpeed = 10;
 	/* Radius of chunks loading zone (chunk is unit) */
-	uint loadDistance = 22;
+	u_int loadDistance = 22;
 	/* Buffer zone where chunks are not unloading (chunk is unit)*/
-	uint padding = 2;
+	u_int padding = 2;
 };
 
 struct CameraSettings {
diff --git a/src/typedefs.h b/src/typedefs.h
index 369fdaf45..eb073fc2f 100644
--- a/src/typedefs.h
+++ b/src/typedefs.h
@@ -4,12 +4,7 @@
 #include <stdlib.h>
 #include <stdint.h>
 
-
-typedef uint8_t u_char8;
-typedef uint16_t u_short16;
-typedef uint32_t u_int32;
-typedef uint64_t u_long64;
-
+typedef uint64_t voxel_t;
 typedef uint16_t blockid_t;
 typedef uint16_t blockstate_t;
 typedef uint16_t light_t;
diff --git a/src/util/data_io.h b/src/util/data_io.h
index 3dd36e337..ad663948e 100644
--- a/src/util/data_io.h
+++ b/src/util/data_io.h
@@ -5,19 +5,19 @@
 
 namespace dataio {
     /* Read big-endian 16 bit signed integer from bytes */
-    inline int16_t read_int16_big(const u_char8* src, size_t offset) {
+    inline int16_t read_int16_big(const u_char* src, size_t offset) {
         return (src[offset] << 8) | 
                (src[offset+1]);
     }
     /* Read big-endian 32 bit signed integer from bytes */
-    inline int32_t read_int32_big(const u_char8* src, size_t offset) {
+    inline int32_t read_int32_big(const u_char* src, size_t offset) {
         return (src[offset] << 24) | 
                (src[offset+1] << 16) | 
                (src[offset+2] << 8) | 
                (src[offset+3]);
     }
     /* Read big-endian 64 bit signed integer from bytes */
-    inline int64_t read_int64_big(const u_char8* src, size_t offset) {
+    inline int64_t read_int64_big(const u_char* src, size_t offset) {
         return (int64_t(src[offset]) << 56) | 
                (int64_t(src[offset+1]) << 48) | 
                (int64_t(src[offset+2]) << 40) | 
@@ -28,19 +28,19 @@ namespace dataio {
                (int64_t(src[offset+7]));
     }
     /* Write big-endian 16 bit signed integer to bytes */
-    inline void write_int16_big(int16_t value, u_char8* dest, size_t offset) {
+    inline void write_int16_big(int16_t value, u_char* dest, size_t offset) {
         dest[offset] = (char) (value >> 8 & 255);
         dest[offset+1] = (char) (value >> 0 & 255);
     }
     /* Write big-endian 32 bit signed integer to bytes */
-    inline void write_int32_big(int32_t value, u_char8* dest, size_t offset) {
+    inline void write_int32_big(int32_t value, u_char* dest, size_t offset) {
         dest[offset] = (char) (value >> 24 & 255);
         dest[offset+1] = (char) (value >> 16 & 255);
         dest[offset+2] = (char) (value >> 8 & 255);
         dest[offset+3] = (char) (value >> 0 & 255);
     }
     /* Write big-endian 64 bit signed integer to bytes */
-    inline void write_int64_big(int64_t value, u_char8* dest, size_t offset) {
+    inline void write_int64_big(int64_t value, u_char* dest, size_t offset) {
         dest[offset] = (char) (value >> 56 & 255);
         dest[offset+1] = (char) (value >> 48 & 255);
         dest[offset+2] = (char) (value >> 40 & 255);
diff --git a/src/util/stringutil.cpp b/src/util/stringutil.cpp
index b423f6245..17cf3b861 100644
--- a/src/util/stringutil.cpp
+++ b/src/util/stringutil.cpp
@@ -6,31 +6,31 @@
 #include <stdexcept>
 #include <algorithm>
 
-std::wstring util::lfill(std::wstring s, uint length, wchar_t c) {
+std::wstring util::lfill(std::wstring s, u_int length, wchar_t c) {
     if (s.length() >= length) {
         return s;
     }
     std::wstringstream ss;
-    for (uint i = 0; i < length-s.length(); i++) {
+    for (u_int i = 0; i < length-s.length(); i++) {
         ss << c;
     }
     ss << s;
     return ss.str();
 }
 
-std::wstring util::rfill(std::wstring s, uint length, wchar_t c) {
+std::wstring util::rfill(std::wstring s, u_int length, wchar_t c) {
     if (s.length() >= length) {
         return s;
     }
     std::wstringstream ss;
     ss << s;
-    for (uint i = 0; i < length-s.length(); i++) {
+    for (u_int i = 0; i < length-s.length(); i++) {
         ss << c;
     }
     return ss.str();
 }
 
-uint util::encode_utf8(uint32_t c, u_char8* bytes) {
+u_int util::encode_utf8(u_int c, u_char* bytes) {
     if (c < 0x80) {
         bytes[0] = ((c >> 0) & 0x7F) | 0x00;
         return 1;
@@ -55,8 +55,8 @@ uint util::encode_utf8(uint32_t c, u_char8* bytes) {
 struct utf_t {
 	char mask;
 	char lead;
-	uint32_t beg;
-	uint32_t end;
+	u_int beg;
+	u_int end;
 	int bits_stored;
 };
 
@@ -71,8 +71,8 @@ const utf_t utf[] = {
 };
 
 
-inline uint utf8_len(u_char8 cp) {
-    uint len = 0;
+inline u_int utf8_len(u_char cp) {
+    u_int len = 0;
 	for (const utf_t* u = utf; u->mask; ++u) {
 		if((cp >= u->beg) && (cp <= u->end)) {
 			break;
@@ -85,12 +85,12 @@ inline uint utf8_len(u_char8 cp) {
 	return len;
 }
 
-extern uint32_t util::decode_utf8(uint& size, const char* chr) {
+extern u_int util::decode_utf8(u_int& size, const char* chr) {
 	size = utf8_len(*chr);
 	int shift = utf[0].bits_stored * (size - 1);
-	uint32_t code = (*chr++ & utf[size].mask) << shift;
+	u_int code = (*chr++ & utf[size].mask) << shift;
 
-	for(uint i = 1; i < size; ++i, ++chr) {
+	for(u_int i = 1; i < size; ++i, ++chr) {
 		shift -= utf[0].bits_stored;
 		code |= ((char)*chr & utf[0].mask) << shift;
 	}
@@ -101,8 +101,8 @@ std::string util::wstr2str_utf8(const std::wstring ws) {
     std::vector<char> chars;
     char buffer[4];
     for (wchar_t wc : ws) {
-        uint size = encode_utf8((uint)wc, (u_char8*)buffer);
-        for (uint i = 0; i < size; i++) {
+        u_int size = encode_utf8((u_int)wc, (u_char*)buffer);
+        for (u_int i = 0; i < size; i++) {
             chars.push_back(buffer[i]);
         }
     }
@@ -112,7 +112,7 @@ std::string util::wstr2str_utf8(const std::wstring ws) {
 std::wstring util::str2wstr_utf8(const std::string s) {
     std::vector<wchar_t> chars;
     size_t pos = 0;
-    uint size = 0;
+    u_int size = 0;
     while (pos < s.length()) {
         chars.push_back(decode_utf8(size, &s.at(pos)));
         pos += size;
diff --git a/src/util/stringutil.h b/src/util/stringutil.h
index 2cb384e77..7993b8653 100644
--- a/src/util/stringutil.h
+++ b/src/util/stringutil.h
@@ -5,11 +5,11 @@
 #include "../typedefs.h"
 
 namespace util {
-    extern std::wstring lfill(std::wstring s, uint length, wchar_t c);
-    extern std::wstring rfill(std::wstring s, uint length, wchar_t c);
+    extern std::wstring lfill(std::wstring s, u_int length, wchar_t c);
+    extern std::wstring rfill(std::wstring s, u_int length, wchar_t c);
 
-    extern uint encode_utf8(uint32_t c, u_char8* bytes);
-    extern uint32_t decode_utf8(uint& size, const char* bytes);
+    extern u_int encode_utf8(u_int c, u_char* bytes);
+    extern u_int decode_utf8(u_int& size, const char* bytes);
     extern std::string wstr2str_utf8(const std::wstring ws);
     extern std::wstring str2wstr_utf8(const std::string s);
     extern bool is_integer(std::string text);
diff --git a/src/util/timeutil.cpp b/src/util/timeutil.cpp
index e299bec11..1c1a1800d 100644
--- a/src/util/timeutil.cpp
+++ b/src/util/timeutil.cpp
@@ -9,7 +9,7 @@ using std::chrono::microseconds;
 timeutil::Timer::Timer() {
     start = high_resolution_clock::now();
 }
-int64_t timeutil::Timer::stop() {
+long timeutil::Timer::stop() {
     return duration_cast<microseconds>(high_resolution_clock::now()-start).count();
 }
 
diff --git a/src/util/timeutil.h b/src/util/timeutil.h
index 786d2a91b..12c53bbe7 100644
--- a/src/util/timeutil.h
+++ b/src/util/timeutil.h
@@ -9,7 +9,7 @@ namespace timeutil {
         std::chrono::high_resolution_clock::time_point start;
     public:
         Timer();
-        int64_t stop();
+        long stop();
     };
 
 /*  Timer that stops and prints time when destructor called
diff --git a/src/voxel_engine.cpp b/src/voxel_engine.cpp
index a1a3bd116..a8846dc45 100644
--- a/src/voxel_engine.cpp
+++ b/src/voxel_engine.cpp
@@ -46,7 +46,7 @@ int main(int argc, char** argv) {
 			load_controls(controls_file.string(), text);
 		}
 		engine.mainloop();
-		
+
 		std::cout << "-- saving settings" << std::endl;
 		files::write_string(settings_file, wrapper->write());
 		files::write_string(controls_file, write_controls());
@@ -55,5 +55,8 @@ int main(int argc, char** argv) {
 		std::cerr << "could not to initialize engine" << std::endl;
 		std::cerr << err.what() << std::endl;
 	}
+	catch (...) {
+		std::cerr << "break" << std::endl;
+	}
 	return EXIT_SUCCESS;
 }
diff --git a/src/voxels/Block.h b/src/voxels/Block.h
index 80b6d35c8..a2dde2861 100644
--- a/src/voxels/Block.h
+++ b/src/voxels/Block.h
@@ -7,14 +7,14 @@
 #include "../maths/aabb.h"
 #include "../typedefs.h"
 
-const uint FACE_MX = 0;
-const uint FACE_PX = 1;
-const uint FACE_MY = 2;
-const uint FACE_PY = 3;
-const uint FACE_MZ = 4;
-const uint FACE_PZ = 5;
+const u_int FACE_MX = 0;
+const u_int FACE_PX = 1;
+const u_int FACE_MY = 2;
+const u_int FACE_PY = 3;
+const u_int FACE_MZ = 4;
+const u_int FACE_PZ = 5;
 
-const uint BLOCK_AABB_GRID = 16;
+const u_int BLOCK_AABB_GRID = 16;
 
 struct block_funcs_set {
 	bool init: 1;
diff --git a/src/voxels/Chunk.cpp b/src/voxels/Chunk.cpp
index f0c7b6747..89d566775 100644
--- a/src/voxels/Chunk.cpp
+++ b/src/voxels/Chunk.cpp
@@ -12,7 +12,6 @@ Chunk::Chunk(int xpos, int zpos) : x(xpos), z(zpos){
 	voxels = new voxel[CHUNK_VOL];
 	for (size_t i = 0; i < CHUNK_VOL; i++) {
 		voxels[i].id = 2;
-		voxels[i].states = 0;
 	}
 	lightmap = new Lightmap();
 	renderData.vertices = nullptr;
@@ -74,13 +73,18 @@ Chunk* Chunk::clone() const {
 
     Total size: (CHUNK_VOL * 4) bytes
 */
-u_char8* Chunk::encode() const {
-	u_char8* buffer = new u_char8[CHUNK_DATA_LEN];
+u_char* Chunk::encode() const {
+	u_char* buffer = new u_char[CHUNK_DATA_LEN];
+	voxel_t* tmp_voxs = (voxel_t *)this->voxels;
 	for (size_t i = 0; i < CHUNK_VOL; i++) {
-		buffer[i] = voxels[i].id >> 8;
-        buffer[CHUNK_VOL+i] = voxels[i].id & 0xFF;
-		buffer[CHUNK_VOL*2 + i] = voxels[i].states >> 8;
-        buffer[CHUNK_VOL*3 + i] = voxels[i].states & 0xFF;
+		((voxel_t*)buffer)[i] = tmp_voxs[i];
+        // buffer[CHUNK_VOL+i] = tmp_voxs[i] >> 8;
+		// buffer[CHUNK_VOL*2 + i] = tmp_voxs[i] >> 16;
+        // buffer[CHUNK_VOL*3 + i] = tmp_voxs[i] >> 24;
+		// buffer[CHUNK_VOL*4 + i] = tmp_voxs[i] >> 32;
+        // buffer[CHUNK_VOL*5 + i] = tmp_voxs[i] >> 40;
+		// buffer[CHUNK_VOL*6 + i] = tmp_voxs[i] >> 48;
+        // buffer[CHUNK_VOL*7 + i] = tmp_voxs[i] >> 56;
 	}
 	return buffer;
 }
@@ -89,18 +93,22 @@ u_char8* Chunk::encode() const {
 /**
  * @return true if all is fine
  **/
-bool Chunk::decode(u_char8* data) {
+bool Chunk::decode(u_char* data) {
 	for (size_t i = 0; i < CHUNK_VOL; i++) {
 		voxel& vox = voxels[i];
 
-        u_char8 bid1 = data[i];
-        u_char8 bid2 = data[CHUNK_VOL + i];
-        
-        u_char8 bst1 = data[CHUNK_VOL*2 + i];
-        u_char8 bst2 = data[CHUNK_VOL*3 + i];
+		vox = ((voxel_t*)data)[i];
+        // u_char b1 = data[i];
+        // u_char b2 = data[CHUNK_VOL + i];
+        // u_char b3 = data[CHUNK_VOL*2 + i];
+        // u_char b4 = data[CHUNK_VOL*3 + i];
+        // u_char b3 = data[CHUNK_VOL*4 + i];
+        // u_char b4 = data[CHUNK_VOL*5 + i];
+        // u_char b3 = data[CHUNK_VOL*6 + i];
+        // u_char b4 = data[CHUNK_VOL*7 + i];
 
-		vox.id = (blockid_t(bid1) << 8) | (blockid_t(bid2));
-        vox.states = (blockstate_t(bst1) << 8) | (blockstate_t(bst2));
+		// vox.id = (blockid_t(bid1) << 8) | (blockid_t(bid2));
+        // vox.states = (blockstate_t(bst1) << 8) | (blockstate_t(bst2));
 	}
 	return true;
 }
@@ -108,7 +116,7 @@ bool Chunk::decode(u_char8* data) {
 /*
  * Convert chunk voxels data from 16 bit to 32 bit
  */
-void Chunk::fromOld(u_char8* data) {
+void Chunk::fromOld(u_char* data) {
     for (size_t i = 0; i < CHUNK_VOL; i++) {
         data[i + CHUNK_VOL*3] = data[i + CHUNK_VOL];
         data[i + CHUNK_VOL] = data[i];
@@ -117,7 +125,7 @@ void Chunk::fromOld(u_char8* data) {
     }
 }
 
-void Chunk::convert(u_char8* data, const ContentLUT* lut) {
+void Chunk::convert(u_char* data, const ContentLUT* lut) {
     for (size_t i = 0; i < CHUNK_VOL; i++) {
         // see encode method to understand what the hell is going on here
         blockid_t id = ((blockid_t(data[i]) << 8) | 
diff --git a/src/voxels/Chunk.h b/src/voxels/Chunk.h
index 768f552f0..2a731e5e3 100644
--- a/src/voxels/Chunk.h
+++ b/src/voxels/Chunk.h
@@ -3,6 +3,7 @@
 
 #include <stdlib.h>
 #include "../constants.h"
+#include "voxel.h"
 
 struct ChunkFlag{
 	static const int MODIFIED = 0x1;
@@ -12,9 +13,8 @@ struct ChunkFlag{
 	static const int UNSAVED = 0x10;
 	static const int LOADED_LIGHTS = 0x20;
 };
-#define CHUNK_DATA_LEN (CHUNK_VOL*4)
+#define CHUNK_DATA_LEN (CHUNK_VOL*sizeof(voxel))
 
-struct voxel;
 class Lightmap;
 class ContentLUT;
 
@@ -75,11 +75,11 @@ public:
 
 	inline void setReady(bool newState) {SETFLAGS(ChunkFlag::READY, newState);}
 
-	u_char8* encode() const;
-	bool decode(u_char8* data);
+	u_char* encode() const;
+	bool decode(u_char* data);
 
-    static void fromOld(u_char8* data);
-    static void convert(u_char8* data, const ContentLUT* lut);
+    static void fromOld(u_char* data);
+    static void convert(u_char* data, const ContentLUT* lut);
 };
 
 #endif /* VOXELS_CHUNK_H_ */
diff --git a/src/voxels/Chunks.cpp b/src/voxels/Chunks.cpp
index cded6e86f..d6c629e38 100644
--- a/src/voxels/Chunks.cpp
+++ b/src/voxels/Chunks.cpp
@@ -75,7 +75,7 @@ const AABB* Chunks::isObstacleAt(float x, float y, float z){
 	const Block* def = contentIds->getBlockDef(v->id);
 	if (def->obstacle) {
 		const AABB& hitbox = def->rotatable 
-							 ? def->rt.hitboxes[v->getDir()] 
+							 ? def->rt.hitboxes[v->dir] 
 							 : def->hitbox;
 		if (def->rt.solid) {
 			return &hitbox;
@@ -109,7 +109,7 @@ bool Chunks::isObstacleBlock(int x, int y, int z) {
 	return contentIds->getBlockDef(v->id)->obstacle;
 }
 
-u_char8 Chunks::getLight(int x, int y, int z, int channel){
+u_char Chunks::getLight(int x, int y, int z, int channel){
 	x -= ox * CHUNK_W;
 	z -= oz * CHUNK_D;
 	int cx = floordiv(x, CHUNK_W);
@@ -177,8 +177,7 @@ void Chunks::set(int x, int y, int z, voxel voxel) {
 		return;
 	int lx = x - cx * CHUNK_W;
 	int lz = z - cz * CHUNK_D;
-	chunk->voxels[(y * CHUNK_D + lz) * CHUNK_W + lx].id = voxel.id;
-	chunk->voxels[(y * CHUNK_D + lz) * CHUNK_W + lx].states = voxel.states;
+	chunk->voxels[(y * CHUNK_D + lz) * CHUNK_W + lx] = voxel;
 	chunk->setUnsaved(true);
 	chunk->setModified(true);
 
@@ -251,7 +250,7 @@ voxel* Chunks::rayCast(vec3 start,
 			
 			if (!def->rt.solid) {
 				const AABB& box = def->rotatable 
-								  ? def->rt.hitboxes[voxel->getDir()] 
+								  ? def->rt.hitboxes[voxel->dir] 
 								  : def->hitbox;
 				scalar_t distance;
 				Ray ray(start, dir);
@@ -349,7 +348,7 @@ vec3 Chunks::rayCastToObstacle(vec3 start, vec3 dir, float maxDist) {
 		if (def->obstacle) {
 			if (!def->rt.solid) {
 				const AABB& box = def->rotatable
-					? def->rt.hitboxes[voxel->getDir()]
+					? def->rt.hitboxes[voxel->dir]
 					: def->hitbox;
 				scalar_t distance;
 				ivec3 norm;
@@ -403,7 +402,7 @@ void Chunks::setCenter(int x, int z) {
 }
 
 void Chunks::translate(int dx, int dz){
-	for (uint i = 0; i < volume; i++){
+	for (u_int i = 0; i < volume; i++){
 		chunksSecond[i] = nullptr;
 	}
 	for (int z = 0; z < d; z++){
diff --git a/src/voxels/Chunks.h b/src/voxels/Chunks.h
index 9462e7840..b8f6d9b23 100644
--- a/src/voxels/Chunks.h
+++ b/src/voxels/Chunks.h
@@ -41,7 +41,7 @@ public:
 	Chunk* getChunkByVoxel(int x, int y, int z);
 	voxel* get(int x, int y, int z);
 	light_t getLight(int x, int y, int z);
-	u_char8 getLight(int x, int y, int z, int channel);
+	u_char getLight(int x, int y, int z, int channel);
 	void set(int x, int y, int z, voxel voxel);
 
 	voxel* rayCast(glm::vec3 start, 
diff --git a/src/voxels/ChunksStorage.cpp b/src/voxels/ChunksStorage.cpp
index f901b84fd..b3905b3a1 100644
--- a/src/voxels/ChunksStorage.cpp
+++ b/src/voxels/ChunksStorage.cpp
@@ -60,7 +60,7 @@ std::shared_ptr<Chunk> ChunksStorage::create(int x, int z) {
 
     auto chunk = std::make_shared<Chunk>(x, z);
 	store(chunk);
-	std::unique_ptr<u_char8[]> data(world->wfile->getChunk(chunk->x, chunk->z));
+	std::unique_ptr<u_char[]> data(world->wfile->getChunk(chunk->x, chunk->z));
 	if (data) {
 		chunk->decode(data.get());
 		chunk->setLoaded(true);
@@ -111,7 +111,7 @@ void ChunksStorage::getVoxels(VoxelsVolume* volume, bool backlight) const {
 						for (int lx = max(x, cx * CHUNK_W);
 							lx < min(x + w, (cx + 1) * CHUNK_W);
 							lx++) {
-							uint idx = vox_index(lx - x, ly - y, lz - z, w, d);
+							u_int idx = vox_index(lx - x, ly - y, lz - z, w, d);
 							voxels[idx].id = BLOCK_VOID;
 							lights[idx] = 0;
 						}
@@ -128,8 +128,8 @@ void ChunksStorage::getVoxels(VoxelsVolume* volume, bool backlight) const {
 						for (int lx = max(x, cx * CHUNK_W);
 							lx < min(x + w, (cx + 1) * CHUNK_W);
 							lx++) {
-							uint vidx = vox_index(lx - x, ly - y, lz - z, w, d);
-							uint cidx = vox_index(lx - cx * CHUNK_W, ly, 
+							u_int vidx = vox_index(lx - x, ly - y, lz - z, w, d);
+							u_int cidx = vox_index(lx - cx * CHUNK_W, ly, 
 										lz - cz * CHUNK_D, CHUNK_W, CHUNK_D);
 							voxels[vidx] = cvoxels[cidx];
 							light_t light = clights[cidx];
diff --git a/src/voxels/ChunksStorage.h b/src/voxels/ChunksStorage.h
index 5607d1d28..77dc933c2 100644
--- a/src/voxels/ChunksStorage.h
+++ b/src/voxels/ChunksStorage.h
@@ -26,7 +26,7 @@ public:
 	void getVoxels(VoxelsVolume* volume, bool backlight=false) const;
 	std::shared_ptr<Chunk> create(int x, int z);
 
-	light_t getLight(int x, int y, int z, u_char8 channel) const;
+	light_t getLight(int x, int y, int z, u_char channel) const;
 };
 
 
diff --git a/src/voxels/WorldGenerator.cpp b/src/voxels/WorldGenerator.cpp
index 43dc6bbc0..c4df5f000 100644
--- a/src/voxels/WorldGenerator.cpp
+++ b/src/voxels/WorldGenerator.cpp
@@ -63,10 +63,10 @@ public:
 };
 
 class PseudoRandom {
-	unsigned short seed;
+	u_short seed;
 public:
 	PseudoRandom(){
-		seed = (unsigned short)time(0);
+		seed = (u_short)time(0);
 	}
 
 	int rand(){
@@ -81,11 +81,11 @@ public:
 	}
 
 	void setSeed(int number){
-		seed = ((unsigned short)(number*23729) ^ (unsigned short)(number+16786));
+		seed = ((u_short)(number*23729) ^ (u_short)(number+16786));
 		rand();
 	}
 	void setSeed(int number1,int number2){
-		seed = (((unsigned short)(number1*23729) | (unsigned short)(number2%16786)) ^ (unsigned short)(number2*number1));
+		seed = (((u_short)(number1*23729) | (u_short)(number2%16786)) ^ (u_short)(number2*number1));
 		rand();
 	}
 };
@@ -150,7 +150,7 @@ int generate_tree(fnl_state *noise,
 	if (height < SEA_LEVEL+1)
 		return 0;
 	int lx = cur_x - centerX;
-	int radius = random->rand() % 4 + 2;
+	int radius = random->rand() % 4 + 5;
 	int ly = cur_y - height - 3 * radius;
 	int lz = cur_z - centerZ;
 	if (lx == 0 && lz == 0 && cur_y - height < (3*radius + radius/2))
@@ -161,7 +161,7 @@ int generate_tree(fnl_state *noise,
 }
 
 void WorldGenerator::generate(voxel* voxels, int cx, int cz, int seed){
-	const int treesTile = 12;
+	const int treesTile = 16;
 	fnl_state noise = fnlCreateState();
 	noise.noise_type = FNL_NOISE_OPENSIMPLEX2;
 	noise.seed = seed * 60617077 % 25896307;
@@ -183,8 +183,8 @@ void WorldGenerator::generate(voxel* voxels, int cx, int cz, int seed){
 			float send = fnlGetNoise2D(&noise, cur_x * 0.1 - 633, cur_z * 0.1 + 1000);
 				float cliff = pow((send + abs(send)) / 2, 2);
 				float w = pow(fmax(-abs(height-SEA_LEVEL)+4,0)/6,2) * cliff;
-				float h1 = -abs(height-SEA_LEVEL - 0.03);
-				float h2 = abs(height-SEA_LEVEL + 0.04);
+				float h1 = -abs(height-SEA_LEVEL - 0.06);
+				float h2 = abs(height-SEA_LEVEL + 0.08);
 				float h = (h1 + h2)*100;
 				height += (h * w);
 			heights.set(MAPS::HEIGHT, cur_x, cur_z, height);
@@ -203,19 +203,19 @@ void WorldGenerator::generate(voxel* voxels, int cx, int cz, int seed){
 
 			for (int cur_y = 0; cur_y < CHUNK_H; cur_y++){
 				// int cur_y = y;
-				int id = cur_y < SEA_LEVEL ? idWater : BLOCK_AIR;
-				int states = 0;
+				voxel vox;
+				vox.id = cur_y < SEA_LEVEL ? idWater : BLOCK_AIR;
 				if ((cur_y == (int)height) && (SEA_LEVEL-2 < cur_y)) {
-					id = idGrassBlock;
+					vox.id = idGrassBlock;
 				} else if (cur_y < (height - 6)){
-					id = idStone;
+					vox.id = idStone;
 				} else if (cur_y < height){
-					id = idDirt;
+					vox.id = idDirt;
 				} else {
 					int tree = generate_tree(&noise, &randomtree, heights, cur_x, cur_y, cur_z, treesTile, idWood, idLeaves);
 					if (tree) {
-						id = tree;
-						states = BLOCK_DIR_UP;
+						vox.id = tree;
+						vox.dir = (voxel_t)VOX_DIR::UP;
 					}
 				}
 				float send = fmax(heights.get(MAPS::SEND, cur_x, cur_z), heights.get(MAPS::CLIFF, cur_x, cur_z));
@@ -224,24 +224,23 @@ void WorldGenerator::generate(voxel* voxels, int cx, int cz, int seed){
 										+
 						(5*send)) < cur_y + (height - 0.01- (int)height))
 						&& (cur_y < height)){
-					id = idSand;
+					vox.id = idSand;
 				}
 				if (cur_y <= 2)
-					id = idBazalt;
+					vox.id = idBazalt;
 
 				randomgrass.setSeed(cur_x,cur_z);
-				if ((id == 0) && ((height > SEA_LEVEL+0.4) || (send > 0.1)) && ((int)(height + 1) == cur_y) && ((unsigned short)randomgrass.rand() > 56000)){
-					id = idGrass;
+				if ((vox.id == 0) && ((height > SEA_LEVEL+0.4) || (send > 0.1)) && ((int)(height + 1) == cur_y) && ((u_short)randomgrass.rand() > 56000)){
+					vox.id = idGrass;
 				}
-				if ((id == 0) && (height > SEA_LEVEL+0.4) && ((int)(height + 1) == cur_y) && ((unsigned short)randomgrass.rand() > 65000)){
-					id = idFlower;
+				if ((vox.id == 0) && (height > SEA_LEVEL+0.4) && ((int)(height + 1) == cur_y) && ((u_short)randomgrass.rand() > 65000)){
+					vox.id = idFlower;
 				}
-				if ((height > SEA_LEVEL+1) && ((int)(height + 1) == cur_y) && ((unsigned short)randomgrass.rand() > 65533)){
-					id = idWood;
-					states = BLOCK_DIR_UP;
+				if ((height > SEA_LEVEL+1) && ((int)(height + 1) == cur_y) && ((u_short)randomgrass.rand() > 65533)){
+					vox.id = idWood;
+					vox.dir = (voxel_t)VOX_DIR::UP;
 				}
-				voxels[(cur_y * CHUNK_D + z) * CHUNK_W + x].id = id;
-				voxels[(cur_y * CHUNK_D + z) * CHUNK_W + x].states = states;
+				voxels[(cur_y * CHUNK_D + z) * CHUNK_W + x] = vox;
 			}
 		}
 	}
diff --git a/src/voxels/voxel.h b/src/voxels/voxel.h
index efb9fb9c5..473b9faca 100644
--- a/src/voxels/voxel.h
+++ b/src/voxels/voxel.h
@@ -2,129 +2,115 @@
 #define VOXELS_VOXEL_H_
 
 #include "../typedefs.h"
+#include <bit>
+#include <cstring>
 
-const u_int32 BLOCK_DIR_NORTH = 0x0;
-const u_int32 BLOCK_DIR_WEST = 0x1;
-const u_int32 BLOCK_DIR_SOUTH = 0x2;
-const u_int32 BLOCK_DIR_EAST = 0x3;
-const u_int32 BLOCK_DIR_UP = 0x4;
-const u_int32 BLOCK_DIR_DOWN = 0x5;
+namespace std {
+	#ifndef __cpp_lib_bit_cast
+	
+	// #include <type_traits>
+
+	template<class To, class From>
+	enable_if_t<
+		sizeof(To) == sizeof(From) &&
+		is_trivially_copyable_v<From> &&
+		is_trivially_copyable_v<To>,
+		To>
+	// constexpr support needs compiler magic
+	bit_cast(const From& src) noexcept
+	{
+		// static_assert(is_trivially_constructible_v<To>,
+		// 	"This implementation additionally requires "
+		// 	"destination type to be trivially constructible");
+	
+		To dst;
+		memcpy(&dst, &src, sizeof(To));
+		return dst;
+	}
+	#endif
+}
 
 
-const u_int32 BLOCK_DIR_MASK       = 0b111;
-const u_int32 BLOCK_DIR_OFFSET     = 0x0;
+/**
+ *    ,------------------------------------------------------------------------------------------------------------------------------------,
+ *    |                                                                                                                                    |
+ *    |                     ,---------------------,                                                                                        |
+ *    |                     |  OLD VOXEL BIT MAP  |                                                                                        |
+ *    |                     '---------------------'                                                                                        |
+ *    | 0                               16    19 20     24      28      32                                                                 |
+ *    | |                               |     | /       |       |       |                                                                  |
+ *    | |# # # # # # # # # # # # # # # #|# # #|#|# # # #|# # # #|#'#'#'#|                                                                  |
+ *    |                 id                dir / \ variant  value  4states                                                                  |
+ *    |                                      |sig|                                                                                         |
+ *    |                                                                                                                                    |
+ *    |                                                                                                                                    |
+ *    |                                                      ,---------------------,                                                       |
+ *:   |                                                      |  NEW VOXEL BIT MAP  |                                                       |
+ *    |                                                      '---------------------'                                                       |
+ *    | 0                               16              24      28      32              40              48              56              64 |
+ *    | |                               |               |       |       |               :               :               :               |  |
+ *    | |# # # # # # # # # # # # # # # #'# # # # # # # #|# # # #|# # # #|# # # # # # # #'# # # # # # # #'# # # # # # # #'# # # # # # # #|  |
+ *    |                 id                   variant      dir     signal                        custom bits states                         |
+ *    |                                                                                                                                    |
+ *    '------------------------------------------------------------------------------------------------------------------------------------'
+ */
 
-const u_int32 BLOCK_SIG_MASK       = 0b1;
-const u_int32 BLOCK_SIG_OFFSET     = 0x3;
+enum class VOX_DIR:voxel_t {
+	NORTH,
+	WEST,
+	SOUTH,
+	EAST,
+	UP,
+	DOWN
+};
 
-const u_int32 BLOCK_VARIANT_MASK   = 0b1111;
-const u_int32 BLOCK_VARIANT_OFFSET = 0x4;
+enum class VOX_ROT:voxel_t {
+	NN,
+	WW,
+	SS,
+	EE,
+	NW,
+	WS,
+	SE,
+	EN
+};
 
-const u_int32 BLOCK_BITS_MASK      = 0b11111111;
-const u_int32 BLOCK_BITS_OFFSET    = 0x8;
-const u_int32   BLOCK_VALUE_MASK   = 0b1111;
-const u_int32   BLOCK_VALUE_OFFSET = 0x8;
-const u_int32   BLOCK_STATE_MASK   = 0b1111;
-const u_int32   BLOCK_STATE_OFFSET = 0xC;
+struct voxel
+{
+	voxel_t id:16 = 0;
+	voxel_t variant:8 = 0;
+	voxel_t dir:4 = 0;
+	voxel_t signal:4 = 0;
+	voxel_t bits:32 = 0;
 
+	voxel() = default;
 
-//*                           VOXEL BIT MAP                               |
-//*-----------------------------------------------------------------------|
-//*   0                               16    19 20     24      28      32  |
-//*   |                               |     | /       |       |       |   |
-//*   |* * * * * * * * * * * * * * * *|* * *|*|* * * *|* * * *|*'*'*'*|   |
-//*                   id                dir / \ variant  value  4states   |
-//*                                        |sig|                          |
-//*-----------------------------------------------------------------------|
+	voxel(voxel_t vox) : voxel(std::bit_cast<voxel>(vox)) {
 
-
-
-//TODO                                        NEW VOXEL BIT MAP                                           |
-//*-------------------------------------------------------------------------------------------------------|
-//*   0                               16              24      28 29   32              40              48  |
-//*   |                               |               |       | /     | 8 bool states |     value     |   |
-//*   |# # # # # # # # # # # # # # # #'# # # # # # # #|# # # #|#|# # #|#`#`#`#`#`#`#`#'# # # # # # # #|   |
-//*                   id                   sub id      variant/ \ dir          dynamic bits states        |
-//*                                                          |sig|                                        |
-//*-------------------------------------------------------------------------------------------------------|
-
-
-
-struct voxel {
-	blockid_t id;
-	u_short16 states;
-
-	inline u_int32 getId()  const {
-		return id;
 	}
 
-	inline u_char8 getDir() const {
-		return (states >> BLOCK_DIR_OFFSET) & BLOCK_DIR_MASK;
+	explicit operator voxel_t() const {
+		return std::bit_cast<voxel_t>(*this);
+	};
+
+	inline u_char getCustomBits(u_char offset, u_char len) const {
+		return (bits >> (offset)) & ((1 << len) - 1);
 	}
 
-	inline void setDir(u_char8 dir) {
-		states &= ~BLOCK_DIR_MASK << BLOCK_DIR_OFFSET;
-		states |= dir << BLOCK_DIR_OFFSET;
+	inline void setCustomBits(u_char offset, u_char len, u_char value) {
+		int mask = ((1 << len) - 1);
+		value &= mask;
+		bits &= ~(mask << offset);
+		bits |= value << offset;
 	}
 
-	inline u_char8 getVariant() const {
-		return (states >> BLOCK_VALUE_OFFSET) & BLOCK_VARIANT_MASK;
+	bool operator==(const voxel& other) const {
+		return id == other.id && variant == other.variant && dir == other.dir && signal == other.signal && bits == other.bits;
 	}
 
-	inline void setVariant(u_char8 variant) {
-		states &= ~BLOCK_VARIANT_MASK << BLOCK_VARIANT_OFFSET;
-		states |= variant << BLOCK_VARIANT_OFFSET;
-	}
-
-
-	inline u_char8 getCustomBits(u_char8 offset, u_char8 len) const {
-		return (states >> (BLOCK_BITS_OFFSET + offset)) & ((1 << len) - 1);
-	}
-
-	inline void setCustomBits(u_char8 offset, u_char8 len, u_char8 value) {
-		int len_musk = ((1 << len) - 1);
-		offset += BLOCK_BITS_OFFSET;
-		value &= len_musk;
-		states &= ~(len_musk << offset);
-		states |= value << offset;
-	}
-
-
-	// id of the state in range 0 to 3
-	inline bool getCustomState(u_char8 id) const {
-		return states & (1 << id+24);
-	}
-
-	// id of the state in range 0 to 3
-	inline void setCustomState(u_char8 id, bool state) {
-		if (state) {
-			states |= (1 << id+24);
-		} else {
-			states &= ~(1 << id+24);
-		}
-	}
-
-	// can use value in range 0 to 15
-	inline u_char8 getCustomValue() const {
-		return states >> 20;
-	}
-
-	/* if the block has a custom state you
-	   can use value in range 0 to 15 else
-	   you can use value in range 0 to 255 */
-	inline void setCustomValue(u_char8 value) {
-		states &= ~(0xF << 20);
-		states |= (value << 20);
-	}
-
-	inline bool getSig() const {
-		return (states >> BLOCK_SIG_OFFSET) & BLOCK_SIG_MASK;
-	}
-
-	inline void setSig(bool sig) {
-		states &= ~(BLOCK_SIG_MASK << BLOCK_SIG_OFFSET);
-		states |= sig << BLOCK_SIG_OFFSET;
-	}
+	bool operator!=(const voxel& other) const {
+        return!(*this == other);
+    }
 };
 
 #endif /* VOXELS_VOXEL_H_ */
diff --git a/src/window/Events.cpp b/src/window/Events.cpp
index 1f63f1002..1d56081ce 100644
--- a/src/window/Events.cpp
+++ b/src/window/Events.cpp
@@ -5,14 +5,14 @@
 #include <string.h>
 
 bool Events::_keys[KEYS_BUFFER_SIZE] = {};
-uint Events::_frames[KEYS_BUFFER_SIZE] = {};
-uint Events::_current = 0;
+u_int Events::_frames[KEYS_BUFFER_SIZE] = {};
+u_int Events::_current = 0;
 int Events::scroll = 0;
 glm::vec2 Events::delta = {};
 glm::vec2 Events::cursor = {};
 bool Events::cursor_drag = false;
 bool Events::_cursor_locked = false;
-std::vector<uint> Events::codepoints;
+std::vector<u_int> Events::codepoints;
 std::vector<int> Events::pressedKeys;
 std::unordered_map<std::string, Binding> Events::bindings;
 
diff --git a/src/window/Events.h b/src/window/Events.h
index 247f7cc98..bfe85ce80 100644
--- a/src/window/Events.h
+++ b/src/window/Events.h
@@ -8,22 +8,20 @@
 #include <vector>
 #include <unordered_map>
 
-typedef unsigned int uint;
-
 const short KEYS_BUFFER_SIZE = 1036;
 const short _MOUSE_KEYS_OFFSET = 1024;
 
 class Events {
 public:
 	static bool _keys[KEYS_BUFFER_SIZE];
-	static uint _frames[KEYS_BUFFER_SIZE];
-	static uint _current;
+	static u_int _frames[KEYS_BUFFER_SIZE];
+	static u_int _current;
     static int scroll;
     static glm::vec2 delta;
     static glm::vec2 cursor;
     static bool cursor_drag;
 	static bool _cursor_locked;
-	static std::vector<uint> codepoints;
+	static std::vector<u_int> codepoints;
 	static std::vector<int> pressedKeys;
 	static std::unordered_map<std::string, Binding> bindings;
 
diff --git a/src/window/Window.cpp b/src/window/Window.cpp
index d1f06c862..84d4ba717 100644
--- a/src/window/Window.cpp
+++ b/src/window/Window.cpp
@@ -15,8 +15,8 @@ GLFWwindow* Window::window = nullptr;
 DisplaySettings* Window::settings = nullptr;
 std::stack<vec4> Window::scissorStack;
 vec4 Window::scissorArea;
-uint Window::width = 0;
-uint Window::height = 0;
+u_int Window::width = 0;
+u_int Window::height = 0;
 int Window::posX = 0;
 int Window::posY = 0;
 
@@ -292,7 +292,7 @@ DisplaySettings* Window::getSettings() {
 }
 
 ImageData* Window::takeScreenshot() {
-	u_char8* data = new u_char8[width * height * 3];
+	u_char* data = new u_char[width * height * 3];
 	glPixelStorei(GL_PACK_ALIGNMENT, 1);
 	glReadPixels(0, 0, width, height, GL_RGB, GL_UNSIGNED_BYTE, data);
 	return new ImageData(ImageFormat::rgb888, width, height, data);
@@ -307,10 +307,10 @@ bool Window::tryToMaximize(GLFWwindow* window, GLFWmonitor* monitor) {
 	glm::ivec4 workArea(0);
 	glfwGetWindowFrameSize(window, &windowFrame.x, &windowFrame.y, &windowFrame.z, &windowFrame.w);
 	glfwGetMonitorWorkarea(monitor, &workArea.x, &workArea.y, &workArea.z, &workArea.w);
-	if (Window::width > (uint)workArea.z) Window::width = (uint)workArea.z;
-	if (Window::height > (uint)workArea.w) Window::height = (uint)workArea.w;
-	if (Window::width >= (uint)(workArea.z - (windowFrame.x + windowFrame.z)) &&
-		Window::height >= (uint)(workArea.w - (windowFrame.y + windowFrame.w))) {
+	if (Window::width > (u_int)workArea.z) Window::width = (u_int)workArea.z;
+	if (Window::height > (u_int)workArea.w) Window::height = (u_int)workArea.w;
+	if (Window::width >= (u_int)(workArea.z - (windowFrame.x + windowFrame.z)) &&
+		Window::height >= (u_int)(workArea.w - (windowFrame.y + windowFrame.w))) {
 		glfwMaximizeWindow(window);
 		return true;
 	}
diff --git a/src/window/Window.h b/src/window/Window.h
index 4fb7ed347..de477d063 100644
--- a/src/window/Window.h
+++ b/src/window/Window.h
@@ -24,8 +24,8 @@ class Window {
 public:
 	static int posX;
 	static int posY;
-	static uint width;
-	static uint height;
+	static u_int width;
+	static u_int height;
 	static int initialize(DisplaySettings& settings);
 	static void terminate();
 
diff --git a/src/world/Level.cpp b/src/world/Level.cpp
index 702163a90..ce568d373 100644
--- a/src/world/Level.cpp
+++ b/src/world/Level.cpp
@@ -19,7 +19,7 @@ Level::Level(World* world, const Content* content, Player* player, EngineSetting
 		settings(settings) {
     physics = new PhysicsSolver(glm::vec3(0, -22.6f, 0));
 
-    uint matrixSize = (settings.chunks.loadDistance+
+    u_int matrixSize = (settings.chunks.loadDistance+
 					   settings.chunks.padding) * 2;
     chunks = new Chunks(matrixSize, matrixSize, 0, 0, 
 						world->wfile, events, content);
diff --git a/src/world/World.cpp b/src/world/World.cpp
index 4ba787932..073133417 100644
--- a/src/world/World.cpp
+++ b/src/world/World.cpp
@@ -25,7 +25,7 @@ world_load_error::world_load_error(string message) : std::runtime_error(message)
 
 World::World(string name, 
 			 path directory, 
-			 uint64_t seed, 
+			 u_long seed, 
 			 EngineSettings& settings,
 			 const Content* content,
 			 const std::vector<ContentPack> packs) 
@@ -71,7 +71,7 @@ const float DEF_PLAYER_SPEED = 4.0f;
 
 Level* World::create(string name, 
 					path directory, 
-					uint64_t seed,
+					u_long seed,
 					EngineSettings& settings, 
 					const Content* content,
 					const std::vector<ContentPack>& packs) {
diff --git a/src/world/World.h b/src/world/World.h
index 6f2c7743f..7c14f47f2 100644
--- a/src/world/World.h
+++ b/src/world/World.h
@@ -30,7 +30,7 @@ class World {
 public:
 	std::string name;
 	WorldFiles* wfile;
-	uint64_t seed;
+	u_long seed;
 
 	/* Day/night loop timer in range 0..1 
 	   0.0 - is midnight
@@ -41,7 +41,7 @@ public:
 
 	World(std::string name, 
 		  std::filesystem::path directory, 
-		  uint64_t seed, 
+		  u_long seed, 
 		  EngineSettings& settings,
 		  const Content* content,
 		  std::vector<ContentPack> packs);
@@ -55,7 +55,7 @@ public:
 
 	static Level* create(std::string name, 
 						 std::filesystem::path directory, 
-						 uint64_t seed, 
+						 u_long seed, 
 						 EngineSettings& settings, 
 						 const Content* content,
 						 const std::vector<ContentPack>& packs);