diff --git a/src/coders/json.cpp b/src/coders/json.cpp
index 3cfd37659..0f72a5bfb 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, ubyte& dst) const {
+void JObject::num(std::string key, u_char8& dst) const {
     dst = getInteger(key, dst);
 }
 
diff --git a/src/coders/json.h b/src/coders/json.h
index dd1708640..497a5edbd 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, ubyte& dst) const;
+        void num(std::string key, u_char8& 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 411df7a74..d022fd1da 100644
--- a/src/coders/png.cpp
+++ b/src/coders/png.cpp
@@ -16,8 +16,8 @@
 #include <png.h>
 
 // returns 0 if all-right, 1 otherwise
-int _png_write(const char* filename, uint width, uint height, const ubyte* data, bool alpha) {
-    uint pixsize = alpha ? 4 : 3;
+int _png_write(const char* filename, u_int width, u_int height, const u_char8* data, bool alpha) {
+    u_int pixsize = alpha ? 4 : 3;
 
 	// Open file for writing (binary mode)
 	FILE* fp = fopen(filename, "wb");
@@ -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 ubyte*)image->getData(), image->getFormat() == ImageFormat::rgba8888);
+    _png_write(filename.c_str(), image->getWidth(), image->getHeight(), (const u_char8*)image->getData(), image->getFormat() == ImageFormat::rgba8888);
 }
\ No newline at end of file
diff --git a/src/files/WorldConverter.cpp b/src/files/WorldConverter.cpp
index de171ab30..ea40387b8 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<ubyte[]> data (wfile->getChunk(gx, gz));
+            std::unique_ptr<u_char8[]> 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 10ceb1ec8..59b28a5f5 100644
--- a/src/files/WorldFiles.cpp
+++ b/src/files/WorldFiles.cpp
@@ -45,7 +45,7 @@ regfile::regfile(fs::path filename) : file(filename) {
 }
 
 WorldRegion::WorldRegion() {
-	chunksData = new ubyte*[REGION_CHUNKS_COUNT]{};
+	chunksData = new u_char8*[REGION_CHUNKS_COUNT]{};
 	sizes = new uint32_t[REGION_CHUNKS_COUNT]{};
 }
 
@@ -64,7 +64,7 @@ bool WorldRegion::isUnsaved() const {
 	return unsaved;
 }
 
-ubyte** WorldRegion::getChunks() const {
+u_char8** WorldRegion::getChunks() const {
 	return chunksData;
 }
 
@@ -72,14 +72,14 @@ uint32_t* WorldRegion::getSizes() const {
 	return sizes;
 }
 
-void WorldRegion::put(uint x, uint z, ubyte* data, uint32_t size) {
+void WorldRegion::put(uint x, uint z, u_char8* data, uint32_t size) {
 	size_t chunk_index = z * REGION_SIZE + x;
 	delete[] chunksData[chunk_index];
 	chunksData[chunk_index] = data;
 	sizes[chunk_index] = size;
 }
 
-ubyte* WorldRegion::getChunkData(uint x, uint z) {
+u_char8* 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 ubyte[CHUNK_DATA_LEN * 2]);
+	compressionBuffer.reset(new u_char8[CHUNK_DATA_LEN * 2]);
 }
 
 WorldFiles::~WorldFiles(){
@@ -113,19 +113,19 @@ WorldRegion* WorldFiles::getOrCreateRegion(regionsmap& regions, int x, int z) {
 	return region;
 }
 
-ubyte* WorldFiles::compress(const ubyte* src, size_t srclen, size_t& len) {
-    ubyte* buffer = this->compressionBuffer.get();
+u_char8* WorldFiles::compress(const u_char8* src, size_t srclen, size_t& len) {
+    u_char8* buffer = this->compressionBuffer.get();
     
 	len = extrle::encode(src, srclen, buffer);
-	ubyte* data = new ubyte[len];
+	u_char8* data = new u_char8[len];
 	for (size_t i = 0; i < len; i++) {
 		data[i] = buffer[i];
 	}
 	return data;
 }
 
-ubyte* WorldFiles::decompress(const ubyte* src, size_t srclen, size_t dstlen) {
-	ubyte* decompressed = new ubyte[dstlen];
+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);
 	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 ubyte* voxelData) {
+void WorldFiles::put(int x, int z, const u_char8* 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 ubyte* voxelData) {
 		WorldRegion* region = getOrCreateRegion(regions, regionX, regionZ);
 		region->setUnsaved(true);
 		size_t compressedSize;
-		ubyte* data = compress(voxelData, CHUNK_DATA_LEN, compressedSize);
+		u_char8* 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<ubyte[]> chunk_data (chunk->encode());
-		ubyte* data = compress(chunk_data.get(), CHUNK_DATA_LEN, compressedSize);
+        std::unique_ptr<u_char8[]> chunk_data (chunk->encode());
+		u_char8* 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<ubyte[]> light_data (chunk->lightmap->encode());
-		ubyte* data = compress(light_data.get(), LIGHTMAP_DATA_LEN, compressedSize);
+        std::unique_ptr<u_char8[]> light_data (chunk->lightmap->encode());
+		u_char8* 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");
 }
 
-ubyte* WorldFiles::getChunk(int x, int z){
+u_char8* 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<ubyte> data (getData(lights, getLightsFolder(), x, z, REGION_LAYER_LIGHTS));
+	std::unique_ptr<u_char8> data (getData(lights, getLightsFolder(), x, z, REGION_LAYER_LIGHTS));
 	if (data == nullptr)
 		return nullptr;
 	return Lightmap::decode(data.get());
 }
 
-ubyte* WorldFiles::getData(regionsmap& regions, const fs::path& folder, 
+u_char8* 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 @@ ubyte* WorldFiles::getData(regionsmap& regions, const fs::path& folder,
 	int localZ = z - (regionZ * REGION_SIZE);
 
 	WorldRegion* region = getOrCreateRegion(regions, regionX, regionZ);
-	ubyte* data = region->getChunkData(localX, localZ);
+	u_char8* 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();
 }
 
-ubyte* WorldFiles::readChunkData(int x, 
+u_char8* WorldFiles::readChunkData(int x, 
                                  int z, 
                                  uint32_t& length, 
                                  fs::path folder, 
@@ -339,14 +339,14 @@ ubyte* WorldFiles::readChunkData(int x,
 	uint32_t offset;
 	file.seekg(table_offset + chunkIndex * 4);
 	file.read((char*)(&offset), 4);
-	offset = dataio::read_int32_big((const ubyte*)(&offset), 0);
+	offset = dataio::read_int32_big((const u_char8*)(&offset), 0);
 	if (offset == 0){
 		return nullptr;
 	}
 	file.seekg(offset);
 	file.read((char*)(&offset), 4);
-	length = dataio::read_int32_big((const ubyte*)(&offset), 0);
-	ubyte* data = new ubyte[length];
+	length = dataio::read_int32_big((const u_char8*)(&offset), 0);
+	u_char8* data = new u_char8[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 @@ ubyte* WorldFiles::readChunkData(int x,
  * (see REGION_LAYER_* constants)
  */
 void WorldFiles::fetchChunks(WorldRegion* region, int x, int z, fs::path folder, int layer) {
-    ubyte** chunks = region->getChunks();
+    u_char8** 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]{};
 	
-    ubyte** region = entry->getChunks();
+    u_char8** region = entry->getChunks();
 	uint32_t* sizes = entry->getSizes();
     
 	for (size_t i = 0; i < REGION_CHUNKS_COUNT; i++) {
-		ubyte* chunk = region[i];
+		u_char8* chunk = region[i];
 		if (chunk == nullptr){
 			offsets[i] = 0;
 		} else {
 			offsets[i] = offset;
 
 			size_t compressedSize = sizes[i];
-			dataio::write_int32_big(compressedSize, (ubyte*)intbuf, 0);
+			dataio::write_int32_big(compressedSize, (u_char8*)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], (ubyte*)intbuf, 0);
+		dataio::write_int32_big(offsets[i], (u_char8*)intbuf, 0);
 		file.write(intbuf, 4);
 	}
 }
diff --git a/src/files/WorldFiles.h b/src/files/WorldFiles.h
index d85b02210..b5f7cd008 100644
--- a/src/files/WorldFiles.h
+++ b/src/files/WorldFiles.h
@@ -41,21 +41,21 @@ public:
 };
 
 class WorldRegion {
-	ubyte** chunksData;
+	u_char8** chunksData;
 	uint32_t* sizes;
 	bool unsaved = false;
 public:
 	WorldRegion();
 	~WorldRegion();
 
-	void put(uint x, uint z, ubyte* data, uint32_t size);
-	ubyte* getChunkData(uint x, uint z);
+	void put(uint x, uint z, u_char8* data, uint32_t size);
+	u_char8* getChunkData(uint x, uint z);
 	uint getChunkDataSize(uint x, uint z);
 
 	void setUnsaved(bool unsaved);
 	bool isUnsaved() const;
 
-	ubyte** getChunks() const;
+	u_char8** 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 */
-	ubyte* compress(const ubyte* src, size_t srclen, size_t& len);
+	u_char8* compress(const u_char8* 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
 	*/
-	ubyte* decompress(const ubyte* src, size_t srclen, size_t dstlen);
+	u_char8* decompress(const u_char8* src, size_t srclen, size_t dstlen);
 
-	ubyte* readChunkData(int x, int y, 
+	u_char8* 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);
 
-	ubyte* getData(regionsmap& regions,
+	u_char8* 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<ubyte[]> compressionBuffer;
+	std::unique_ptr<u_char8[]> compressionBuffer;
 	bool generatorTestMode;
 	bool doWriteLights;
 
@@ -129,12 +129,12 @@ public:
 	~WorldFiles();
 
 	void put(Chunk* chunk);
-    void put(int x, int z, const ubyte* voxelData);
+    void put(int x, int z, const u_char8* voxelData);
 
     int getVoxelRegionVersion(int x, int z);
     int getVoxelRegionsVersion();
 
-	ubyte* getChunk(int x, int z);
+	u_char8* 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 c16083a3b..a1a53b584 100644
--- a/src/files/binary_io.cpp
+++ b/src/files/binary_io.cpp
@@ -4,7 +4,7 @@
 #include <limits>
 #include <stdexcept>
 
-void BinaryWriter::put(ubyte b) {
+void BinaryWriter::put(u_char8 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 ubyte*)s.data(), len);
+    put((const u_char8*)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 ubyte*)s.data(), len);
+    put((const u_char8*)s.data(), len);
 }
 
-void BinaryWriter::put(const ubyte* arr, size_t size) {
+void BinaryWriter::put(const u_char8* 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 ubyte* data, size_t size)
+BinaryReader::BinaryReader(const u_char8* 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] != (ubyte)data[i]){
+        if (this->data[pos + i] != (u_char8)data[i]){
             throw std::runtime_error("invalid magic number");
         }
     }
     pos += size;
 }
 
-ubyte BinaryReader::get() {
+u_char8 BinaryReader::get() {
     if (pos == size) {
         throw std::underflow_error("buffer underflow");
     }
@@ -152,7 +152,7 @@ std::string BinaryReader::getString() {
 }
 
 std::string BinaryReader::getShortString() {
-    ubyte length = get();
+    u_char8 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 ac7a7299f..b3d308b5b 100644
--- a/src/files/binary_io.h
+++ b/src/files/binary_io.h
@@ -6,35 +6,35 @@
 #include "../typedefs.h"
 
 class BinaryWriter {
-    std::vector<ubyte> buffer;
+    std::vector<u_char8> buffer;
 public:
-    void put(ubyte b);
+    void put(u_char8 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 ubyte* arr, size_t size);
+    void put(const u_char8* arr, size_t size);
     void putShortStr(const std::string& s);
 
     inline size_t size() const {
         return buffer.size();
     }
-    inline const ubyte* data() const {
+    inline const u_char8* data() const {
         return buffer.data();
     }
 };
 
 class BinaryReader {
-    const ubyte* data;
+    const u_char8* data;
     size_t size;
     size_t pos;
 public:
-    BinaryReader(const ubyte* data, size_t size);
+    BinaryReader(const u_char8* data, size_t size);
 
     void checkMagic(const char* data, size_t size);
-    ubyte get();
+    u_char8 get();
     int16_t getInt16();
     int32_t getInt32();
     int64_t getInt64();
diff --git a/src/files/rle.cpp b/src/files/rle.cpp
index 5a5c57143..87bece206 100644
--- a/src/files/rle.cpp
+++ b/src/files/rle.cpp
@@ -1,10 +1,10 @@
 #include "rle.h"
 
-size_t rle::decode(const ubyte* src, size_t srclen, ubyte* dst) {
+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;) {
-		ubyte len = src[i++];
-		ubyte c = src[i++];
+		u_char8 len = src[i++];
+		u_char8 c = src[i++];
 		for (size_t j = 0; j <= len; j++) {
 			dst[offset++] = c;
 		}
@@ -12,15 +12,15 @@ size_t rle::decode(const ubyte* src, size_t srclen, ubyte* dst) {
 	return offset;
 }
 
-size_t rle::encode(const ubyte* src, size_t srclen, ubyte* dst) {
+size_t rle::encode(const u_char8* src, size_t srclen, u_char8* dst) {
 	if (srclen == 0) {
 		return 0;
 	}
 	size_t offset = 0;
-	ubyte counter = 0;
-	ubyte c = src[0];
+	u_char8 counter = 0;
+	u_char8 c = src[0];
 	for (size_t i = 1; i < srclen; i++) {
-		ubyte cnext = src[i];
+		u_char8 cnext = src[i];
 		if (cnext != c || counter == 255) {
 			dst[offset++] = counter;
 			dst[offset++] = c;
@@ -37,7 +37,7 @@ size_t rle::encode(const ubyte* src, size_t srclen, ubyte* dst) {
 }
 
 
-size_t extrle::decode(const ubyte* src, size_t srclen, ubyte* dst) {
+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++];
@@ -45,7 +45,7 @@ size_t extrle::decode(const ubyte* src, size_t srclen, ubyte* dst) {
 			len &= 0x7F;
 			len |= ((uint)src[i++]) << 7;
 		}
-		ubyte c = src[i++];
+		u_char8 c = src[i++];
 		for (size_t j = 0; j <= len; j++) {
 			dst[offset++] = c;
 		}
@@ -53,15 +53,15 @@ size_t extrle::decode(const ubyte* src, size_t srclen, ubyte* dst) {
 	return offset;
 }
 
-size_t extrle::encode(const ubyte* src, size_t srclen, ubyte* dst) {
+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;
-	ubyte c = src[0];
+	u_char8 c = src[0];
 	for (size_t i = 1; i < srclen; i++) {
-		ubyte cnext = src[i];
+		u_char8 cnext = src[i];
 		if (cnext != c || counter == max_sequence) {
 			if (counter >= 0x80) {
 				dst[offset++] = 0x80 | (counter & 0x7F);
diff --git a/src/files/rle.h b/src/files/rle.h
index 0dcbe0427..b9f4c71af 100644
--- a/src/files/rle.h
+++ b/src/files/rle.h
@@ -4,14 +4,14 @@
 #include "../typedefs.h"
 
 namespace rle {
-	size_t encode(const ubyte* src, size_t length, ubyte* dst);
-	size_t decode(const ubyte* src, size_t length, ubyte* dst);
+	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);
 }
 
 namespace extrle {
 	constexpr uint max_sequence = 0x7FFF;
-	size_t encode(const ubyte* src, size_t length, ubyte* dst);
-	size_t decode(const ubyte* src, size_t length, ubyte* dst);
+	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);
 }
 
 #endif // FILES_RLE_H_
diff --git a/src/frontend/hud.cpp b/src/frontend/hud.cpp
index 2e8b7b3ca..7f441af50 100644
--- a/src/frontend/hud.cpp
+++ b/src/frontend/hud.cpp
@@ -87,7 +87,7 @@ HudRenderer::HudRenderer(Engine* engine,
 	uicamera->perspective = false;
 	uicamera->flipped = true;
 
-	Panel* panel = new Panel(vec2(250, 200), vec4(5.0f), 1.0f);
+	Panel* panel = new Panel(vec2(350, 300), vec4(5.0f), 1.0f);
 	debugPanel = shared_ptr<UINode>(panel);
 	panel->listenInterval(1.0f, [this]() {
 		fpsString = std::to_wstring(fpsMax)+L" / "+std::to_wstring(fpsMin);
@@ -115,12 +115,18 @@ HudRenderer::HudRenderer(Engine* engine,
 		auto indices = this->level->content->indices;
 		auto def = indices->getBlockDef(player->selectedVoxel.id);
 		std::wstringstream stream;
-		stream << std::hex << this->level->player->selectedVoxel.states;
-		if (def) {
+
+		if (def)
 			stream << L" (" << util::str2wstr_utf8(def->name) << L")";
-		}
-		return L"block: "+std::to_wstring(player->selectedVoxel.id)+
-		       L" "+stream.str();
+
+		return	L"block: "+std::to_wstring(player->selectedVoxel.id)+
+				L" "+stream.str();
+	})));
+	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());
+		return str_;
 	})));
 	panel->add(shared_ptr<Label>(create_label([this](){
 		return L"seed: "+std::to_wstring(this->level->world->seed);
diff --git a/src/graphics/Batch3D.cpp b/src/graphics/Batch3D.cpp
index 1fda4c65d..b60987c35 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;
 
-	ubyte pixels[] = {
+	u_char8 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 ae064844a..98b4615a6 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, ubyte rotation,
+							   const Block* block, u_char8 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, 
-									 ubyte states,
+									 u_char8 states,
                                      bool lights) {
-	ubyte group = block->drawGroup;
+	u_char8 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_ROT_MASK];
+		auto& orient = rotations.variants[states & BLOCK_DIR_MASK];
 		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, ubyte group) const {
+bool BlocksRenderer::isOpen(int x, int y, int z, u_char8 group) const {
 	blockid_t id = voxelsBuffer->pickBlockId(chunk->x * CHUNK_W + x, 
 											 y, 
 											 chunk->z * CHUNK_D + z);
@@ -348,7 +348,7 @@ void BlocksRenderer::render(const voxel* voxels) {
 				break;
 			}
 			case BlockModel::aabb: {
-				blockAABB(ivec3(x,y,z), texfaces, &def, vox.rotation(), !def.rt.emissive);
+				blockAABB(ivec3(x,y,z), texfaces, &def, vox.getDir(), !def.rt.emissive);
 				break;
 			}
 			default:
diff --git a/src/graphics/BlocksRenderer.h b/src/graphics/BlocksRenderer.h
index 23a380f04..c59f38192 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, ubyte states, bool lights);
+	void blockCube(int x, int y, int z, const UVRegion(&faces)[6], const Block* block, u_char8 states, bool lights);
 	void blockAABB(const glm::ivec3& coord,
                     const UVRegion(&faces)[6], 
                     const Block* block, 
-                    ubyte rotation,
+                    u_char8 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, ubyte group) const;
+	bool isOpen(int x, int y, int z, u_char8 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 824178a72..8911884b4 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 ubyte[width*height*3]{}; break;
-        case ImageFormat::rgba8888: data = new ubyte[width*height*4]{}; break;
+        case ImageFormat::rgb888: data = new u_char8[width*height*3]{}; break;
+        case ImageFormat::rgba8888: data = new u_char8[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[] (ubyte*)data;
+            delete[] (u_char8*)data;
             break;
     }
 }
@@ -40,11 +40,11 @@ void ImageData::flipX() {
         case ImageFormat::rgb888:
         case ImageFormat::rgba8888: {
             size = (format == ImageFormat::rgba8888) ? 4 : 3;
-            ubyte* pixels = (ubyte*)data;
+            u_char8* pixels = (u_char8*)data;
             for (uint y = 0; y < height; y++) {
                 for (uint x = 0; x < width/2; x++) {
                     for (uint c = 0; c < size; c++) {
-                        ubyte temp = pixels[(y * width + x) * size + c];
+                        u_char8 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;
-            ubyte* pixels = (ubyte*)data;
+            u_char8* pixels = (u_char8*)data;
             for (uint y = 0; y < height/2; y++) {
                 for (uint x = 0; x < width; x++) {
                     for (uint c = 0; c < size; c++) {
-                        ubyte temp = pixels[(y * width + x) * size + c];
+                        u_char8 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;
@@ -122,8 +122,8 @@ void ImageData::blitMatchingFormat(const ImageData* image, int x, int y) {
         default:
             throw std::runtime_error("only unsigned byte formats supported");    
     }
-    ubyte* pixels = static_cast<ubyte*>(data);
-    ubyte* source = static_cast<ubyte*>(image->getData());
+    u_char8* pixels = static_cast<u_char8*>(data);
+    u_char8* source = static_cast<u_char8*>(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");    
     }
-    ubyte* pixels = static_cast<ubyte*>(data);
+    u_char8* pixels = static_cast<u_char8*>(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() {
-    ubyte* pixels = static_cast<ubyte*>(data); 
+    u_char8* pixels = static_cast<u_char8*>(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 ubyte* srcdata = (const ubyte*)image->getData(); 
-    ubyte* dstdata = new ubyte[dstwidth*dstheight * 4];
+    const u_char8* srcdata = (const u_char8*)image->getData(); 
+    u_char8* dstdata = new u_char8[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 4f2742228..7a7249ecc 100644
--- a/src/graphics/Mesh.h
+++ b/src/graphics/Mesh.h
@@ -5,7 +5,7 @@
 #include "../typedefs.h"
 
 struct vattr {
-	ubyte size;
+	u_char8 size;
 };
 
 class Mesh {
diff --git a/src/graphics/Texture.cpp b/src/graphics/Texture.cpp
index 0d5ae803b..afb3104a0 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(ubyte* data, int width, int height, uint format) 
+Texture::Texture(u_char8* 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(ubyte* data){
+void Texture::reload(u_char8* 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((ubyte*)data, width, height, format);
+	return new Texture((u_char8*)data, width, height, format);
 }
\ No newline at end of file
diff --git a/src/graphics/Texture.h b/src/graphics/Texture.h
index 4e85cb860..de068a6a7 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(ubyte* data, int width, int height, uint format);
+	Texture(u_char8* data, int width, int height, uint format);
 	~Texture();
 
 	void bind();
-	void reload(ubyte* data);
+	void reload(u_char8* data);
 
 	static Texture* from(const ImageData* image);
 };
diff --git a/src/lighting/Lightmap.cpp b/src/lighting/Lightmap.cpp
index f86989645..e71774d8e 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");
 
-ubyte* Lightmap::encode() const {
-	ubyte* buffer = new ubyte[LIGHTMAP_DATA_LEN];
+u_char8* Lightmap::encode() const {
+	u_char8* buffer = new u_char8[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(ubyte* buffer) {
+light_t* Lightmap::decode(u_char8* buffer) {
 	light_t* lights = new light_t[CHUNK_VOL];
 	for (uint i = 0; i < CHUNK_VOL; i+=2) {
-		ubyte b = buffer[i/2];
+		u_char8 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 14fb9d7f1..5ba5ca4b3 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, ubyte channel) {
+	static inline light_t extract(light_t light, u_char8 channel) {
 		return (light >> (channel << 2)) & 0xF;
 	}
 
-	ubyte* encode() const;
-	static light_t* decode(ubyte* buffer);
+	u_char8* encode() const;
+	static light_t* decode(u_char8* buffer);
 };
 
 #endif /* LIGHTING_LIGHTMAP_H_ */
diff --git a/src/logic/BlocksController.cpp b/src/logic/BlocksController.cpp
index a84b7fdfc..ac74f6142 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, 0, 0);
+    chunks->set(x,y,z, voxel{0,0});
     lighting->onBlockSet(x,y,z, 0);
     if (def->rt.funcsset.onbroken) {
         scripting::on_block_broken(player, def, x, y, z);
@@ -75,7 +75,11 @@ void BlocksController::updateBlock(int x, int y, int z) {
         return;
     }
     if (def->rt.funcsset.update) {
+        int states = vox->states;
+        int id = vox->id;
         scripting::update_block(def, x, y, z);
+        if (states != vox->states || id!= vox->id)
+            updateSides(x, y, z);
     }
 }
 
diff --git a/src/logic/PlayerController.cpp b/src/logic/PlayerController.cpp
index 5bf1c785c..2dc7faa72 100644
--- a/src/logic/PlayerController.cpp
+++ b/src/logic/PlayerController.cpp
@@ -236,27 +236,27 @@ void PlayerController::updateInteraction(){
 		int x = iend.x;
 		int y = iend.y;
 		int z = iend.z;
-		uint8_t states = 0;
+		voxel voxel;
 
 		Block* def = contentIds->getBlockDef(player->chosenBlock);
 		if (def->rotatable){
 			const std::string& name = def->rotations.name;
 			if (name == "pipe") {
-				if (norm.x < 0.0f) states = BLOCK_DIR_WEST;
-				else if (norm.x > 0.0f) states = BLOCK_DIR_EAST;
-				else if (norm.y > 0.0f) states = BLOCK_DIR_UP;
-				else if (norm.y < 0.0f) states = BLOCK_DIR_DOWN;
-				else if (norm.z > 0.0f) states = BLOCK_DIR_NORTH;
-				else if (norm.z < 0.0f) states = BLOCK_DIR_SOUTH;
+				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);
 			} else if (name == "pane") {
 				glm::vec3 vec = camera->dir;
 				if (abs(vec.x) > abs(vec.z)){
-					if (vec.x > 0.0f) states = BLOCK_DIR_EAST;
-					if (vec.x < 0.0f) states = BLOCK_DIR_WEST;
+					if (vec.x > 0.0f) voxel.setDir(BLOCK_DIR_EAST);
+					if (vec.x < 0.0f) voxel.setDir(BLOCK_DIR_WEST);
 				}
 				if (abs(vec.x) < abs(vec.z)){
-					if (vec.z > 0.0f) states = BLOCK_DIR_SOUTH;
-					if (vec.z < 0.0f) states = BLOCK_DIR_NORTH;
+					if (vec.z > 0.0f) voxel.setDir(BLOCK_DIR_SOUTH);
+					if (vec.z < 0.0f) voxel.setDir(BLOCK_DIR_NORTH);
 				}
 			}
 		}
@@ -285,7 +285,8 @@ void PlayerController::updateInteraction(){
                         chosenBlock = 0;
                     }
                     if (chosenBlock != vox->id) {
-                        chunks->set(x, y, z, chosenBlock, states);
+						voxel.id = chosenBlock;
+                        chunks->set(x, y, z, voxel);
                         lighting->onBlockSet(x,y,z, chosenBlock);
                         if (def->rt.funcsset.onplaced) {
                             scripting::on_block_placed(player, def, x, y, z);
@@ -299,6 +300,7 @@ void PlayerController::updateInteraction(){
 			player->chosenBlock = chunks->get(x,y,z)->id;
 		}
 	} else {
+		player->selectedVoxel = voxel{0, 0};
 		selectedBlockId = -1;
 		selectedBlockStates = 0;
 	}
diff --git a/src/logic/scripting/api_lua.cpp b/src/logic/scripting/api_lua.cpp
index da16ed881..1e2048695 100644
--- a/src/logic/scripting/api_lua.cpp
+++ b/src/logic/scripting/api_lua.cpp
@@ -39,13 +39,14 @@ int l_block_index(lua_State* L) {
 }
 
 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);
-    int id = lua_tointeger(L, 4);    
-    int states = lua_tointeger(L, 5);
-    scripting::level->chunks->set(x, y, z, id, states);
-    scripting::level->lighting->onBlockSet(x,y,z, id);
+    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);
     return 0;
 }
 
@@ -66,57 +67,6 @@ inline int lua_pushivec3(lua_State* L, int x, int y, int z) {
     return 3;
 }
 
-int l_get_block_x(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);
-    if (vox == nullptr) {
-        return lua_pushivec3(L, 1, 0, 0);
-    }
-    const Block* def = scripting::level->content->indices->getBlockDef(vox->id);
-    if (!def->rotatable) {
-        return lua_pushivec3(L, 1, 0, 0);
-    } else {
-        const CoordSystem& rot = def->rotations.variants[vox->rotation()];
-        return lua_pushivec3(L, rot.axisX.x, rot.axisX.y, rot.axisX.z);
-    }
-}
-
-int l_get_block_y(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);
-    if (vox == nullptr) {
-        return lua_pushivec3(L, 0, 1, 0);
-    }
-    const Block* def = scripting::level->content->indices->getBlockDef(vox->id);
-    if (!def->rotatable) {
-        return lua_pushivec3(L, 0, 1, 0);
-    } else {
-        const CoordSystem& rot = def->rotations.variants[vox->rotation()];
-        return lua_pushivec3(L, rot.axisY.x, rot.axisY.y, rot.axisY.z);
-    }
-}
-
-int l_get_block_z(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);
-    if (vox == nullptr) {
-        return lua_pushivec3(L, 0, 0, 1);
-    }
-    const Block* def = scripting::level->content->indices->getBlockDef(vox->id);
-    if (!def->rotatable) {
-        return lua_pushivec3(L, 0, 0, 1);
-    } else {
-        const CoordSystem& rot = def->rotations.variants[vox->rotation()];
-        return lua_pushivec3(L, rot.axisZ.x, rot.axisZ.y, rot.axisZ.z);
-    }
-}
-
 int l_get_player_pos(lua_State* L) {
     glm::vec3 pos = scripting::level->player->hitbox->position;
     lua_pushnumber(L, pos.x);
@@ -149,6 +99,7 @@ int l_set_player_pos(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);
@@ -159,41 +110,6 @@ int l_get_block_states(lua_State* L) {
     return 1;
 }
 
-int l_get_block_user_bits(lua_State* L) {
-    int x = lua_tointeger(L, 1);
-    int y = lua_tointeger(L, 2);
-    int z = lua_tointeger(L, 3);
-    int offset = lua_tointeger(L, 4) + VOXEL_USER_BITS_OFFSET;
-    int bits = lua_tointeger(L, 5);
-
-    voxel* vox = scripting::level->chunks->get(x, y, z);
-    if (vox == nullptr) {
-        lua_pushinteger(L, 0);
-        return 1;
-    }
-    uint mask = ((1 << bits) - 1) << offset;
-    uint data = (vox->states & mask) >> offset;
-    lua_pushinteger(L, data);
-    return 1;
-}
-
-int l_set_block_user_bits(lua_State* L) {
-    int x = lua_tointeger(L, 1);
-    int y = lua_tointeger(L, 2);
-    int z = lua_tointeger(L, 3);
-    int offset = lua_tointeger(L, 4) + VOXEL_USER_BITS_OFFSET;
-    int bits = lua_tointeger(L, 5);
-
-    uint mask = (1 << bits) - 1;
-    int value = lua_tointeger(L, 6) & mask;
-    
-    voxel* vox = scripting::level->chunks->get(x, y, z);
-    if (vox == nullptr) {
-        return 0;
-    }
-    vox->states = (vox->states & (~mask)) | (value << offset);
-    return 0;
-}
 
 int l_is_replaceable_at(lua_State* L) {
     int x = lua_tointeger(L, 1);
@@ -204,6 +120,172 @@ int l_is_replaceable_at(lua_State* L) {
     return 1;
 }
 
+
+int l_get_block_dir(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 states = vox->getDir();
+    lua_pushinteger(L, states);
+    return 1;
+}
+int l_set_block_dir(lua_State* L) {
+    int x = lua_tointeger(L, 1),
+        y = lua_tointeger(L, 2),
+        z = lua_tointeger(L, 3),
+        s = lua_tointeger(L, 4);
+    voxel* vox = scripting::level->chunks->get(x, y, z);
+    vox->setDir(s);
+    return 0;
+}
+
+int l_get_block_sig(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);
+    bool sig = vox->getSig();
+    lua_pushboolean(L, sig);
+    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);
+    voxel* vox = scripting::level->chunks->get(x, y, z);
+    vox->setSig(s);
+    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);
+    int z = lua_tointeger(L, 3);
+    int offset = lua_tointeger(L, 4);
+    int bits = lua_tointeger(L, 5);
+
+    voxel* vox = scripting::level->chunks->get(x, y, z);
+    if (vox == nullptr)
+        lua_pushinteger(L, 0);
+    else
+        lua_pushinteger(L, vox->getCustomBits(offset, bits));
+    return 1;
+}
+int l_set_block_custom_bits(lua_State* L) {
+    int x = lua_tointeger(L, 1);
+    int y = lua_tointeger(L, 2);
+    int z = lua_tointeger(L, 3);
+    int offset = lua_tointeger(L, 4);
+    int bits = lua_tointeger(L, 5);
+    int value = lua_tointeger(L, 6);
+
+    voxel* vox = scripting::level->chunks->get(x, y, z);
+    if (vox != nullptr)
+        vox->setCustomBits(offset, bits, value);
+    return 0;
+}
+
+
+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_block_x(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);
+    if (vox == nullptr) {
+        return lua_pushivec3(L, 1, 0, 0);
+    }
+    const Block* def = scripting::level->content->indices->getBlockDef(vox->id);
+    if (!def->rotatable) {
+        return lua_pushivec3(L, 1, 0, 0);
+    } else {
+        const CoordSystem& rot = def->rotations.variants[vox->getDir()];
+        return lua_pushivec3(L, rot.axisX.x, rot.axisX.y, rot.axisX.z);
+    }
+}
+int l_get_block_y(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);
+    if (vox == nullptr) {
+        return lua_pushivec3(L, 0, 1, 0);
+    }
+    const Block* def = scripting::level->content->indices->getBlockDef(vox->id);
+    if (!def->rotatable) {
+        return lua_pushivec3(L, 0, 1, 0);
+    } else {
+        const CoordSystem& rot = def->rotations.variants[vox->getDir()];
+        return lua_pushivec3(L, rot.axisY.x, rot.axisY.y, rot.axisY.z);
+    }
+}
+int l_get_block_z(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);
+    if (vox == nullptr) {
+        return lua_pushivec3(L, 0, 0, 1);
+    }
+    const Block* def = scripting::level->content->indices->getBlockDef(vox->id);
+    if (!def->rotatable) {
+        return lua_pushivec3(L, 0, 0, 1);
+    } else {
+        const CoordSystem& rot = def->rotations.variants[vox->getDir()];
+        return lua_pushivec3(L, rot.axisZ.x, rot.axisZ.y, rot.axisZ.z);
+    }
+}
+
+
 #define lua_addfunc(L, FUNC, NAME) (lua_pushcfunction(L, FUNC),\
                                     lua_setglobal(L, NAME))
 
@@ -222,7 +304,20 @@ void apilua::create_funcs(lua_State* L) {
     lua_addfunc(L, l_set_player_pos, "set_player_pos");
     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");
-    lua_addfunc(L, l_get_block_user_bits, "get_block_user_bits");
-    lua_addfunc(L, l_set_block_user_bits, "set_block_user_bits");
+
+    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");
+    lua_addfunc(L, l_get_block_y, "get_block_Y");
+    lua_addfunc(L, l_get_block_z, "get_block_Z");
+    lua_addfunc(L, l_get_block_custom_bits, "get_block_custom_bits");
+    lua_addfunc(L, l_set_block_custom_bits, "set_block_custom_bits");
 }
diff --git a/src/maths/voxmaths.h b/src/maths/voxmaths.h
index da17c8156..4eee56d60 100644
--- a/src/maths/voxmaths.h
+++ b/src/maths/voxmaths.h
@@ -44,7 +44,7 @@ inline int fast_rand(void) {
 	return (g_seed >> 16) & 0x7FFF;
 }
 
-inline light_t light_pack(ubyte r, ubyte g, ubyte b, ubyte s) {
+inline light_t light_pack(u_char8 r, u_char8 g, u_char8 b, u_char8 s) {
 	return r | (g << 4) | (b << 8) | (s << 12);
 }
 
diff --git a/src/typedefs.h b/src/typedefs.h
index f1915c2fd..369fdaf45 100644
--- a/src/typedefs.h
+++ b/src/typedefs.h
@@ -4,10 +4,11 @@
 #include <stdlib.h>
 #include <stdint.h>
 
-typedef unsigned int uint;
 
-// use for bytes arrays
-typedef uint8_t ubyte;
+typedef uint8_t u_char8;
+typedef uint16_t u_short16;
+typedef uint32_t u_int32;
+typedef uint64_t u_long64;
 
 typedef uint16_t blockid_t;
 typedef uint16_t blockstate_t;
diff --git a/src/util/data_io.h b/src/util/data_io.h
index 0f23a3dc3..3dd36e337 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 ubyte* src, size_t offset) {
+    inline int16_t read_int16_big(const u_char8* 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 ubyte* src, size_t offset) {
+    inline int32_t read_int32_big(const u_char8* 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 ubyte* src, size_t offset) {
+    inline int64_t read_int64_big(const u_char8* 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, ubyte* dest, size_t offset) {
+    inline void write_int16_big(int16_t value, u_char8* 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, ubyte* dest, size_t offset) {
+    inline void write_int32_big(int32_t value, u_char8* 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, ubyte* dest, size_t offset) {
+    inline void write_int64_big(int64_t value, u_char8* 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 54b157067..b423f6245 100644
--- a/src/util/stringutil.cpp
+++ b/src/util/stringutil.cpp
@@ -30,7 +30,7 @@ std::wstring util::rfill(std::wstring s, uint length, wchar_t c) {
     return ss.str();
 }
 
-uint util::encode_utf8(uint32_t c, ubyte* bytes) {
+uint util::encode_utf8(uint32_t c, u_char8* bytes) {
     if (c < 0x80) {
         bytes[0] = ((c >> 0) & 0x7F) | 0x00;
         return 1;
@@ -71,7 +71,7 @@ const utf_t utf[] = {
 };
 
 
-inline uint utf8_len(ubyte cp) {
+inline uint utf8_len(u_char8 cp) {
     uint len = 0;
 	for (const utf_t* u = utf; u->mask; ++u) {
 		if((cp >= u->beg) && (cp <= u->end)) {
@@ -101,7 +101,7 @@ 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, (ubyte*)buffer);
+        uint size = encode_utf8((uint)wc, (u_char8*)buffer);
         for (uint i = 0; i < size; i++) {
             chars.push_back(buffer[i]);
         }
diff --git a/src/util/stringutil.h b/src/util/stringutil.h
index b1db1fe84..2cb384e77 100644
--- a/src/util/stringutil.h
+++ b/src/util/stringutil.h
@@ -8,7 +8,7 @@ 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 uint encode_utf8(uint32_t c, ubyte* bytes);
+    extern uint encode_utf8(uint32_t c, u_char8* bytes);
     extern uint32_t decode_utf8(uint& size, const char* bytes);
     extern std::string wstr2str_utf8(const std::wstring ws);
     extern std::wstring str2wstr_utf8(const std::string s);
diff --git a/src/voxels/Chunk.cpp b/src/voxels/Chunk.cpp
index a9afb823a..f0c7b6747 100644
--- a/src/voxels/Chunk.cpp
+++ b/src/voxels/Chunk.cpp
@@ -74,8 +74,8 @@ Chunk* Chunk::clone() const {
 
     Total size: (CHUNK_VOL * 4) bytes
 */
-ubyte* Chunk::encode() const {
-	ubyte* buffer = new ubyte[CHUNK_DATA_LEN];
+u_char8* Chunk::encode() const {
+	u_char8* buffer = new u_char8[CHUNK_DATA_LEN];
 	for (size_t i = 0; i < CHUNK_VOL; i++) {
 		buffer[i] = voxels[i].id >> 8;
         buffer[CHUNK_VOL+i] = voxels[i].id & 0xFF;
@@ -85,18 +85,19 @@ ubyte* Chunk::encode() const {
 	return buffer;
 }
 
+/**
 /**
  * @return true if all is fine
  **/
-bool Chunk::decode(ubyte* data) {
+bool Chunk::decode(u_char8* data) {
 	for (size_t i = 0; i < CHUNK_VOL; i++) {
 		voxel& vox = voxels[i];
 
-        ubyte bid1 = data[i];
-        ubyte bid2 = data[CHUNK_VOL + i];
+        u_char8 bid1 = data[i];
+        u_char8 bid2 = data[CHUNK_VOL + i];
         
-        ubyte bst1 = data[CHUNK_VOL*2 + i];
-        ubyte bst2 = data[CHUNK_VOL*3 + i];
+        u_char8 bst1 = data[CHUNK_VOL*2 + i];
+        u_char8 bst2 = data[CHUNK_VOL*3 + i];
 
 		vox.id = (blockid_t(bid1) << 8) | (blockid_t(bid2));
         vox.states = (blockstate_t(bst1) << 8) | (blockstate_t(bst2));
@@ -107,7 +108,7 @@ bool Chunk::decode(ubyte* data) {
 /*
  * Convert chunk voxels data from 16 bit to 32 bit
  */
-void Chunk::fromOld(ubyte* data) {
+void Chunk::fromOld(u_char8* 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];
@@ -116,7 +117,7 @@ void Chunk::fromOld(ubyte* data) {
     }
 }
 
-void Chunk::convert(ubyte* data, const ContentLUT* lut) {
+void Chunk::convert(u_char8* 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 f92dc8360..768f552f0 100644
--- a/src/voxels/Chunk.h
+++ b/src/voxels/Chunk.h
@@ -75,11 +75,11 @@ public:
 
 	inline void setReady(bool newState) {SETFLAGS(ChunkFlag::READY, newState);}
 
-	ubyte* encode() const;
-	bool decode(ubyte* data);
+	u_char8* encode() const;
+	bool decode(u_char8* data);
 
-    static void fromOld(ubyte* data);
-    static void convert(ubyte* data, const ContentLUT* lut);
+    static void fromOld(u_char8* data);
+    static void convert(u_char8* data, const ContentLUT* lut);
 };
 
 #endif /* VOXELS_CHUNK_H_ */
diff --git a/src/voxels/Chunks.cpp b/src/voxels/Chunks.cpp
index ff11ae2b7..cded6e86f 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->rotation()] 
+							 ? def->rt.hitboxes[v->getDir()] 
 							 : 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;
 }
 
-ubyte Chunks::getLight(int x, int y, int z, int channel){
+u_char8 Chunks::getLight(int x, int y, int z, int channel){
 	x -= ox * CHUNK_W;
 	z -= oz * CHUNK_D;
 	int cx = floordiv(x, CHUNK_W);
@@ -163,7 +163,7 @@ Chunk* Chunks::getChunk(int x, int z){
 	return chunks[z * w + x].get();
 }
 
-void Chunks::set(int x, int y, int z, int id, uint8_t states){
+void Chunks::set(int x, int y, int z, voxel voxel) {
 	if (y < 0 || y >= CHUNK_H)
 		return;
 	x -= ox * CHUNK_W;
@@ -177,14 +177,14 @@ void Chunks::set(int x, int y, int z, int id, uint8_t states){
 		return;
 	int lx = x - cx * CHUNK_W;
 	int lz = z - cz * CHUNK_D;
-	chunk->voxels[(y * CHUNK_D + lz) * CHUNK_W + lx].id = id;
-	chunk->voxels[(y * CHUNK_D + lz) * CHUNK_W + lx].states = states;
+	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->setUnsaved(true);
 	chunk->setModified(true);
 
 	if (y < chunk->bottom) chunk->bottom = y;
 	else if (y + 1 > chunk->top) chunk->top = y + 1;
-	else if (id == 0) chunk->updateHeights();
+	else if (voxel.id == 0) chunk->updateHeights();
 
 	if (lx == 0 && (chunk = getChunk(cx+ox-1, cz+oz)))
 		chunk->setModified(true);
@@ -251,7 +251,7 @@ voxel* Chunks::rayCast(vec3 start,
 			
 			if (!def->rt.solid) {
 				const AABB& box = def->rotatable 
-								  ? def->rt.hitboxes[voxel->rotation()] 
+								  ? def->rt.hitboxes[voxel->getDir()] 
 								  : def->hitbox;
 				scalar_t distance;
 				Ray ray(start, dir);
@@ -349,7 +349,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->rotation()]
+					? def->rt.hitboxes[voxel->getDir()]
 					: def->hitbox;
 				scalar_t distance;
 				ivec3 norm;
diff --git a/src/voxels/Chunks.h b/src/voxels/Chunks.h
index f76a9e7c6..9462e7840 100644
--- a/src/voxels/Chunks.h
+++ b/src/voxels/Chunks.h
@@ -41,8 +41,8 @@ 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);
-	ubyte getLight(int x, int y, int z, int channel);
-	void set(int x, int y, int z, int id, uint8_t states);
+	u_char8 getLight(int x, int y, int z, int channel);
+	void set(int x, int y, int z, voxel voxel);
 
 	voxel* rayCast(glm::vec3 start, 
 				   glm::vec3 dir, 
diff --git a/src/voxels/ChunksStorage.cpp b/src/voxels/ChunksStorage.cpp
index 57ba04003..f901b84fd 100644
--- a/src/voxels/ChunksStorage.cpp
+++ b/src/voxels/ChunksStorage.cpp
@@ -14,18 +14,22 @@
 #include "../lighting/Lightmap.h"
 #include "../typedefs.h"
 
+using glm::ivec2;
+using std::unique_ptr;
+using std::shared_ptr;
+
 ChunksStorage::ChunksStorage(Level* level) : level(level) {
 }
 
 ChunksStorage::~ChunksStorage() {
 }
 
-void ChunksStorage::store(std::shared_ptr<Chunk> chunk) {
-	chunksMap[glm::ivec2(chunk->x, chunk->z)] = chunk;
+void ChunksStorage::store(shared_ptr<Chunk> chunk) {
+	chunksMap[ivec2(chunk->x, chunk->z)] = chunk;
 }
 
-std::shared_ptr<Chunk> ChunksStorage::get(int x, int z) const {
-	auto found = chunksMap.find(glm::ivec2(x, z));
+shared_ptr<Chunk> ChunksStorage::get(int x, int z) const {
+	auto found = chunksMap.find(ivec2(x, z));
 	if (found == chunksMap.end()) {
 		return nullptr;
 	}
@@ -33,7 +37,7 @@ std::shared_ptr<Chunk> ChunksStorage::get(int x, int z) const {
 }
 
 void ChunksStorage::remove(int x, int z) {
-	auto found = chunksMap.find(glm::ivec2(x, z));
+	auto found = chunksMap.find(ivec2(x, z));
 	if (found != chunksMap.end()) {
 		chunksMap.erase(found->first);
 	}
@@ -56,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<ubyte[]> data(world->wfile->getChunk(chunk->x, chunk->z));
+	std::unique_ptr<u_char8[]> data(world->wfile->getChunk(chunk->x, chunk->z));
 	if (data) {
 		chunk->decode(data.get());
 		chunk->setLoaded(true);
@@ -97,7 +101,7 @@ void ChunksStorage::getVoxels(VoxelsVolume* volume, bool backlight) const {
 	// cw*ch chunks will be scanned
 	for (int cz = scz; cz < scz + ch; cz++) {
 		for (int cx = scx; cx < scx + cw; cx++) {
-			auto found = chunksMap.find(glm::ivec2(cx, cz));
+			auto found = chunksMap.find(ivec2(cx, cz));
 			if (found == chunksMap.end()) {
 				// no chunk loaded -> filling with BLOCK_VOID
 				for (int ly = y; ly < y + h; ly++) {
diff --git a/src/voxels/ChunksStorage.h b/src/voxels/ChunksStorage.h
index e6549c5ab..5607d1d28 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, ubyte channel) const;
+	light_t getLight(int x, int y, int z, u_char8 channel) const;
 };
 
 
diff --git a/src/voxels/voxel.h b/src/voxels/voxel.h
index c94397b1e..efb9fb9c5 100644
--- a/src/voxels/voxel.h
+++ b/src/voxels/voxel.h
@@ -3,28 +3,127 @@
 
 #include "../typedefs.h"
 
-const int BLOCK_DIR_NORTH = 0x0;
-const int BLOCK_DIR_WEST = 0x1;
-const int BLOCK_DIR_SOUTH = 0x2;
-const int BLOCK_DIR_EAST = 0x3;
-const int BLOCK_DIR_UP = 0x4;
-const int BLOCK_DIR_DOWN = 0x5;
+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;
+
+
+const u_int32 BLOCK_DIR_MASK       = 0b111;
+const u_int32 BLOCK_DIR_OFFSET     = 0x0;
+
+const u_int32 BLOCK_SIG_MASK       = 0b1;
+const u_int32 BLOCK_SIG_OFFSET     = 0x3;
+
+const u_int32 BLOCK_VARIANT_MASK   = 0b1111;
+const u_int32 BLOCK_VARIANT_OFFSET = 0x4;
+
+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;
+
+
+//*                           VOXEL BIT MAP                               |
+//*-----------------------------------------------------------------------|
+//*   0                               16    19 20     24      28      32  |
+//*   |                               |     | /       |       |       |   |
+//*   |* * * * * * * * * * * * * * * *|* * *|*|* * * *|* * * *|*'*'*'*|   |
+//*                   id                dir / \ variant  value  4states   |
+//*                                        |sig|                          |
+//*-----------------------------------------------------------------------|
+
+
+
+//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|                                        |
+//*-------------------------------------------------------------------------------------------------------|
+
 
-// limited to 8 block orientations
-const int BLOCK_ROT_MASK =     0b0000'0111;
-// limited to 32 block variants
-const int BLOCK_VARIANT_MASK = 0b1111'1000;
 
 struct voxel {
 	blockid_t id;
-	blockstate_t states;
+	u_short16 states;
 
-	inline uint8_t rotation() const {
-		return states & BLOCK_ROT_MASK;
+	inline u_int32 getId()  const {
+		return id;
 	}
 
-	inline uint8_t variant() const {
-		return (states & BLOCK_VARIANT_MASK) >> 3;
+	inline u_char8 getDir() const {
+		return (states >> BLOCK_DIR_OFFSET) & BLOCK_DIR_MASK;
+	}
+
+	inline void setDir(u_char8 dir) {
+		states &= ~BLOCK_DIR_MASK << BLOCK_DIR_OFFSET;
+		states |= dir << BLOCK_DIR_OFFSET;
+	}
+
+	inline u_char8 getVariant() const {
+		return (states >> BLOCK_VALUE_OFFSET) & BLOCK_VARIANT_MASK;
+	}
+
+	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;
 	}
 };
 
diff --git a/src/window/Window.cpp b/src/window/Window.cpp
index 2e8344b0c..d1f06c862 100644
--- a/src/window/Window.cpp
+++ b/src/window/Window.cpp
@@ -292,7 +292,7 @@ DisplaySettings* Window::getSettings() {
 }
 
 ImageData* Window::takeScreenshot() {
-	ubyte* data = new ubyte[width * height * 3];
+	u_char8* data = new u_char8[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);