pke: major serialization refactor, first-pass

12 files changed, 999 insertions, 461 deletions

diff --git a/src/kve.hpp b/src/kve.hpp
new file mode 100644
index 0000000..a590a09
--- /dev/null
+++ b/src/kve.hpp
@@ -0,0 +1,22 @@
+#ifndef PKE_KVE_HPP
+#define PKE_KVE_HPP
+
+#include "pk.h"
+
+struct pke_kve {
+	const char *key;
+	const char *val;
+	const char *end;
+};
+
+struct pke_kve_container;
+struct pke_kve_container {
+	pk_handle srlztn_handle;
+	pk_cstr type_code;
+	pk_membucket *bkt;
+	pk_arr_t<pk_handle> child_handles;
+	pk_arr_t<pke_kve_container*> children;
+	pk_arr_t<pke_kve> arr;
+};
+
+#endif /* PKE_KVE_HPP */
diff --git a/src/scene.cpp b/src/scene.cpp
index 58e9c44..7c38385 100644
--- a/src/scene.cpp
+++ b/src/scene.cpp
@@ -60,9 +60,8 @@ struct pke_scene *pke_scene_get_by_path(const char *file_path) {
 		return nullptr;
 	}
 	srlztn_deserialize_helper *h = pke_deserialize_init(pkeSettings.mem.bkt);
-	h->i = &f;
 	h->scene = pke_scene_create(file_path);
-	pke_deserialize_file_scene(h);
+	pke_deserialize_scene_from_stream(f, h);
 	pke_deserialize_teardown(h);
 	return h->scene;
 }
diff --git a/src/serialization-camera.cpp b/src/serialization-camera.cpp
index 714ea2c..963853e 100644
--- a/src/serialization-camera.cpp
+++ b/src/serialization-camera.cpp
@@ -1,6 +1,8 @@
 
 #include "serialization-camera.hpp"
 
+#include "camera.hpp"
+#include "pk.h"
 #include "serialization-component.hpp"
 #include "ecs.hpp"
 #include "math-helpers.hpp"
@@ -8,53 +10,95 @@
 
 #include <BulletCollision/CollisionShapes/btCollisionShape.h>
 
+#include "serialization.hpp"
 #include "vendor-glm-include.hpp"
 
-bool pke_serialize_camera(srlztn_serialize_helper *h, const PkeCamera *cam) {
+pk_handle pke_serialize_camera(srlztn_serialize_helper *h, const PkeCamera *cam) {
 	assert(h != nullptr);
 	assert(cam != nullptr);
+	char *s;
+	pk_handle inst_pos_handle;
+	pke_kve kve{};
+	pke_kve_container kvec{};
+	InstPos baseInst{};
+	btTransform trans;
+	glm::vec3 glm_pos;
+	glm::quat quat_rot;
+	glm::vec3 glm_scale;
+
 	if (PK_HAS_FLAG(cam->entity_flags, ENTITY_FLAG_DO_NOT_SERIALIZE)) {
-		return false;
-	}
-	PkeCamera c{};
-	if (cam->uuid != pk_uuid_zed && cam->uuid != pk_uuid_max) {
-		h->o << SRLZTN_CAMERA_UUID << cam->uuid << std::endl;
-	}
-	if (cam->type != c.type) {
-		h->o << SRLZTN_CAMERA_TYPE << int(static_cast<PkeCameraType_T>(cam->type)) << std::endl;
-	}
-	if (cam->view != c.view) {
-		h->o << SRLZTN_CAMERA_ORIENTATION << int(static_cast<PkeCameraView_T>(cam->view)) << std::endl;
-	}
-	if (cam->phys.target_inst_uuid != pk_uuid_zed) {
-		h->o << SRLZTN_CAMERA_TARGET_INSTANCE_UUID << cam->phys.target_inst_uuid << std::endl;
-	}
-	if (cam->isPrimary != c.isPrimary) {
-		h->o << SRLZTN_CAMERA_IS_PRIMARY << cam->isPrimary << std::endl;
+		return PK_HANDLE_MAX;
 	}
 
 	CompInstance &comp = *ECS_GetInstance(cam->phys.instHandle);
-	InstPos baseInst{};
 	baseInst.posRot = btTransform{};
 	baseInst.posRot.setIdentity();
 	baseInst.scale = btVector3(1, 1, 1);
-	btTransform trans;
 	comp.bt.motionState->getWorldTransform(trans);
 	btVector3 scale = comp.bt.rigidBody->getCollisionShape()->getLocalScaling();
 	btVector3 pos = trans.getOrigin();
 	btQuaternion rot = trans.getRotation();
-
-	glm::vec3 glm_pos;
-	glm::quat quat_rot;
-	glm::vec3 glm_scale;
 	BulletToGlm(pos, glm_pos);
 	BulletToGlm(rot, quat_rot);
 	BulletToGlm(scale, glm_scale);
-	pke_serialize_inst_pos(h, glm_pos, quat_rot, glm_scale);
-	return true;
+	inst_pos_handle = pke_serialize_inst_pos(h, glm_pos, quat_rot, glm_scale);
+
+	kvec.srlztn_handle = h->handle_head;
+	kvec.type_code = cstring_to_pk_cstr(SRLZTN_OBJ_CAMERA);
+	kvec.bkt = h->bkt;
+	kvec.arr.bkt = h->bkt;
+	kvec.children.bkt = h->bkt;
+	kvec.child_handles.bkt = h->bkt;
+	h->handle_head.itemIndex++;
+	pk_arr_append_t(&kvec.child_handles, inst_pos_handle);
+
+	if (cam->uuid != pk_uuid_zed && cam->uuid != pk_uuid_max) {
+		kve.key = SRLZTN_CAMERA_UUID;
+		s = pk_new<char>(37, h->bkt);
+		sprintf(s, pk_uuid_printf_format, pk_uuid_printf_var(cam->uuid));
+		kve.val = s;
+		kve.end = SRLZTN_KVE_END;
+		pk_arr_append_t(&kvec.arr, kve);
+	}
+	{
+		kve.key = SRLZTN_CAMERA_TYPE;
+		s = pk_new<char>(5, h->bkt);
+		sprintf(s, "0x%.2X", static_cast<PkeCameraType_T>(cam->type));
+		kve.val = s;
+		kve.end = SRLZTN_KVE_END;
+		pk_arr_append_t(&kvec.arr, kve);
+	}
+	{
+		kve.key = SRLZTN_CAMERA_ORIENTATION;
+		s = pk_new<char>(5, h->bkt);
+		sprintf(s, "0x%.2X", static_cast<PkeCameraView_T>(cam->view));
+		kve.val = s;
+		kve.end = SRLZTN_KVE_END;
+		pk_arr_append_t(&kvec.arr, kve);
+	}
+	if (cam->phys.target_inst_uuid != pk_uuid_zed) {
+		kve.key = SRLZTN_CAMERA_TARGET_INSTANCE_UUID;
+		s = pk_new<char>(37, h->bkt);
+		sprintf(s, pk_uuid_printf_format, pk_uuid_printf_var(cam->phys.target_inst_uuid));
+		kve.val = s;
+		kve.end = SRLZTN_KVE_END;
+		pk_arr_append_t(&kvec.arr, kve);
+	}
+	if (cam->isPrimary) {
+		kve.key = SRLZTN_CAMERA_IS_PRIMARY;
+		s = pk_new<char>(2, h->bkt);
+		sprintf(s, "%i", cam->isPrimary);
+		kve.val = s;
+		kve.end = SRLZTN_KVE_END;
+		pk_arr_append_t(&kvec.arr, kve);
+	}
+
+	pk_arr_append_t(&h->kvp_containers, kvec);
+	return kvec.srlztn_handle;
 }
 
-bool pke_deserialize_camera(srlztn_deserialize_helper *h) {
+void pke_deserialize_camera(srlztn_deserialize_helper *h, pke_kve_container *kvec) {
+	uint32_t i;
 	PK_STN_RES stn_res = PK_STN_RES(0);
 	PkeCamera cam{};
 	cam.type = PKE_CAMERA_TYPE_PERSPECTIVE;
@@ -67,8 +111,16 @@ bool pke_deserialize_camera(srlztn_deserialize_helper *h) {
 	instPos.mass = 1;
 	instPos.posRot.setIdentity();
 	instPos.scale = btVector3(1, 1, 1);
-	while (h->i->getline(h->read_line, h->read_line_len)) {
-		if (strcmp(h->read_line, SRLZTN_OBJ_END) == 0) {
+
+	for (i = 0; i < kvec->children.next; ++i) {
+		pke_kve_container *child_kvec = kvec->children[i];
+		if (strncmp(child_kvec->type_code.val, SRLZTN_OBJ_INSTANCE_POSITION, strlen(SRLZTN_OBJ_INSTANCE_POSITION)) == 0) {
+			pke_deserialize_inst_pos(h, child_kvec, pos, quat_rot, scale);
+		}
+	}
+
+	for (i = 0; i < kvec->arr.next; ++i) {
+		if (strcmp(kvec->arr[i].key, SRLZTN_OBJ_END) == 0) {
 
 			uint32_t targetInstanceIndex = -1;
 			if (target_uuid != pk_uuid_zed) {
@@ -97,49 +149,41 @@ bool pke_deserialize_camera(srlztn_deserialize_helper *h) {
 			if (rCam.isPrimary == true) {
 				ActiveCamera = &rCam;
 			}
-			return true;
-		}
-		if (pke_deserialize_inst_pos(h, pos, quat_rot, scale)) {
-			continue;
+			return;
 		}
-		if (strncmp(h->read_line, SRLZTN_CAMERA_UUID, strlen(SRLZTN_CAMERA_TYPE)) == 0) {
-			uint64_t prefixLen = strlen(SRLZTN_CAMERA_UUID);
-			(h->read_line + prefixLen) >> cam.uuid;
+		if (strncmp(kvec->arr[i].key, SRLZTN_CAMERA_UUID, strlen(SRLZTN_CAMERA_TYPE)) == 0) {
+			kvec->arr[i].val >> cam.uuid;
 			continue;
 		}
-		if (strncmp(h->read_line, SRLZTN_CAMERA_TYPE, strlen(SRLZTN_CAMERA_TYPE)) == 0) {
-			uint64_t prefixLen = strlen(SRLZTN_CAMERA_TYPE);
+		if (strncmp(kvec->arr[i].key, SRLZTN_CAMERA_TYPE, strlen(SRLZTN_CAMERA_TYPE)) == 0) {
 			PkeCameraType_T cam_type;
-			stn_res = pk_stn(&cam_type, h->read_line + prefixLen, nullptr);
+			stn_res = pk_stn(&cam_type, kvec->arr[i].val, nullptr);
 			cam.type = PkeCameraType(cam_type);
 			if (stn_res != PK_STN_RES_SUCCESS) {
-				fprintf(stderr, "[%s] Err '%u' parsing camera type from: '%s'\n", __FILE__, stn_res, h->read_line);
+				fprintf(stderr, "[%s] Err '%u' parsing camera type from: '%s'\n", __FILE__, stn_res, kvec->arr[i].val);
 			}
 			continue;
 		}
-		if (strncmp(h->read_line, SRLZTN_CAMERA_ORIENTATION, strlen(SRLZTN_CAMERA_ORIENTATION)) == 0) {
-			uint64_t prefixLen = strlen(SRLZTN_CAMERA_ORIENTATION);
+		if (strncmp(kvec->arr[i].key, SRLZTN_CAMERA_ORIENTATION, strlen(SRLZTN_CAMERA_ORIENTATION)) == 0) {
 			PkeCameraView_T cam_view;
-			stn_res = pk_stn(&cam_view, h->read_line + prefixLen, nullptr);
+			stn_res = pk_stn(&cam_view, kvec->arr[i].val, nullptr);
 			cam.view = PkeCameraView(cam_view);
 			if (stn_res != PK_STN_RES_SUCCESS) {
-				fprintf(stderr, "[%s] Err '%u' parsing camera view from: '%s'\n", __FILE__, stn_res, h->read_line);
+				fprintf(stderr, "[%s] Err '%u' parsing camera view from: '%s'\n", __FILE__, stn_res, kvec->arr[i].val);
 			}
 			continue;
 		}
-		if (strstr(h->read_line, SRLZTN_CAMERA_TARGET_INSTANCE_UUID)) {
-			uint64_t prefixLen = strlen(SRLZTN_CAMERA_TARGET_INSTANCE_UUID);
-			(h->read_line + prefixLen) >> target_uuid;
+		if (strstr(kvec->arr[i].key, SRLZTN_CAMERA_TARGET_INSTANCE_UUID)) {
+			kvec->arr[i].val >> target_uuid;
 			continue;
 		}
-		if (strstr(h->read_line, SRLZTN_CAMERA_IS_PRIMARY)) {
-			uint64_t prefixLen = strlen(SRLZTN_CAMERA_IS_PRIMARY);
-			stn_res = pk_stn(&cam.isPrimary, h->read_line + prefixLen, nullptr);
+		if (strstr(kvec->arr[i].key, SRLZTN_CAMERA_IS_PRIMARY)) {
+			stn_res = pk_stn(&cam.isPrimary, kvec->arr[i].val, nullptr);
 			if (stn_res != PK_STN_RES_SUCCESS) {
-				fprintf(stderr, "[%s] Err '%u' parsing camera primary from: '%s'\n", __FILE__, stn_res, h->read_line);
+				fprintf(stderr, "[%s] Err '%u' parsing camera primary from: '%s'\n", __FILE__, stn_res, kvec->arr[i].val);
 			}
 			continue;
 		}
 	}
-	return false;
+	return;
 }
diff --git a/src/serialization-camera.hpp b/src/serialization-camera.hpp
index ddc2ec4..b72575a 100644
--- a/src/serialization-camera.hpp
+++ b/src/serialization-camera.hpp
@@ -4,8 +4,8 @@
 #include "serialization.hpp"
 #include "camera.hpp"
 
-bool pke_serialize_camera(srlztn_serialize_helper *helper, const PkeCamera *cam);
+pk_handle pke_serialize_camera(srlztn_serialize_helper *helper, const PkeCamera *cam);
 
-bool pke_deserialize_camera(srlztn_deserialize_helper *helper);
+void pke_deserialize_camera(srlztn_deserialize_helper *helper, pke_kve_container *kvec);
 
 #endif /* PKE_SERIALIZATION_CAMERA_HPP */
diff --git a/src/serialization-component.cpp b/src/serialization-component.cpp
index 8867339..7514a14 100644
--- a/src/serialization-component.cpp
+++ b/src/serialization-component.cpp
@@ -10,89 +10,99 @@
 
 #include "pk.h"
 
-#define SRLZTN_FLOAT_WIDTH 10
-
-bool pke_serialize_inst_pos(srlztn_serialize_helper *h, const glm::vec3 pos, const glm::quat quat_rot, const glm::vec3 scale) {
+pk_handle pke_serialize_inst_pos(srlztn_serialize_helper *h, const glm::vec3 pos, const glm::quat quat_rot, const glm::vec3 scale) {
+	char *s;
+	int len;
+	pke_kve kve{};
+	pke_kve_container kvec{};
+	kvec.srlztn_handle = h->handle_head;
+	kvec.type_code = cstring_to_pk_cstr(SRLZTN_OBJ_INSTANCE_POSITION);
+	kvec.bkt = h->bkt;
+	kvec.arr.bkt = h->bkt;
+	kvec.children.bkt = h->bkt;
+	kvec.child_handles.bkt = h->bkt;
+	h->handle_head.itemIndex++;
 	if (pos != glm::vec3(0)) {
-		h->o << SRLZTN_POSROT_POS << "["
-			<< std::setw(SRLZTN_FLOAT_WIDTH) << pos[0] << ","
-			<< std::setw(SRLZTN_FLOAT_WIDTH) << pos[1] << ","
-			<< std::setw(SRLZTN_FLOAT_WIDTH) << pos[2] << "]" << std::endl;
+		kve.key = SRLZTN_POSROT_POS;
+		len = snprintf(NULL, 0, "%f%s%f%s%f", pos[0], SRLZTN_NUM_SEPARATOR, pos[1], SRLZTN_NUM_SEPARATOR, pos[2]);
+		s = pk_new<char>(len+1, h->bkt);
+		sprintf(s, "%f%s%f%s%f", pos[0], SRLZTN_NUM_SEPARATOR, pos[1], SRLZTN_NUM_SEPARATOR, pos[2]);
+		kve.val = s;
+		kve.end = SRLZTN_KVE_END;
+		pk_arr_append_t(&kvec.arr, kve);
 	}
 	if (quat_rot != glm::quat{}) {
-		h->o << SRLZTN_POSROT_ROT << "["
-			<< std::setw(SRLZTN_FLOAT_WIDTH) << quat_rot[0] << ","
-			<< std::setw(SRLZTN_FLOAT_WIDTH) << quat_rot[1] << ","
-			<< std::setw(SRLZTN_FLOAT_WIDTH) << quat_rot[2] << ","
-			<< std::setw(SRLZTN_FLOAT_WIDTH) << quat_rot[3] << "]" << std::endl;
+		kve.key = SRLZTN_POSROT_ROT;
+		len = snprintf(NULL, 0, "%f%s%f%s%f%s%f", quat_rot[0], SRLZTN_NUM_SEPARATOR, quat_rot[1], SRLZTN_NUM_SEPARATOR, quat_rot[2], SRLZTN_NUM_SEPARATOR, quat_rot[3]);
+		s = pk_new<char>(len+1, h->bkt);
+		sprintf(s, "%f%s%f%s%f%s%f", quat_rot[0], SRLZTN_NUM_SEPARATOR, quat_rot[1], SRLZTN_NUM_SEPARATOR, quat_rot[2], SRLZTN_NUM_SEPARATOR, quat_rot[3]);
+		kve.val = s;
+		kve.end = SRLZTN_KVE_END;
+		pk_arr_append_t(&kvec.arr, kve);
 	}
 	if (scale != glm::vec3(1)) {
-		h->o << SRLZTN_POSROT_SCALE << "["
-			<< std::setw(SRLZTN_FLOAT_WIDTH) << scale[0] << ","
-			<< std::setw(SRLZTN_FLOAT_WIDTH) << scale[1] << ","
-			<< std::setw(SRLZTN_FLOAT_WIDTH) << scale[2] << "]" << std::endl;
+		kve.key = SRLZTN_POSROT_SCALE;
+		len = snprintf(NULL, 0, "%f%s%f%s%f", scale[0], SRLZTN_NUM_SEPARATOR, scale[1], SRLZTN_NUM_SEPARATOR, scale[2]);
+		s = pk_new<char>(len+1, h->bkt);
+		sprintf(s, "%f%s%f%s%f", scale[0], SRLZTN_NUM_SEPARATOR, scale[1], SRLZTN_NUM_SEPARATOR, scale[2]);
+		kve.val = s;
+		kve.end = SRLZTN_KVE_END;
+		pk_arr_append_t(&kvec.arr, kve);
 	}
-	return true;
+	pk_arr_append_t(&h->kvp_containers, kvec);
+	return kvec.srlztn_handle;
 }
 
-bool pke_deserialize_inst_pos(srlztn_deserialize_helper *h, glm::vec3 &pos, glm::quat &quat_rot, glm::vec3 &scale) {
+void pke_deserialize_inst_pos(srlztn_deserialize_helper *h, pke_kve_container *kvec, glm::vec3 &pos, glm::quat &quat_rot, glm::vec3 &scale) {
+	(void)h;
+	char *pEnd = nullptr;
+	uint32_t i, index;
 	const char *starting_char;
-	uint64_t prefix_len;
 	PK_STN_RES stn_res;
-	if (strstr(h->read_line, SRLZTN_POSROT_POS)) {
-		prefix_len = strlen(SRLZTN_POSROT_POS);
-		starting_char = strchr(h->read_line + prefix_len, '[') + 1;
-		assert(starting_char != nullptr);
-		char *pEnd = nullptr;
-		long index = 0;
-		do {
-			assert(index < 3);
-			stn_res = pk_stn(&pos[index], starting_char, &pEnd);
-			if (stn_res != PK_STN_RES_SUCCESS) return false;
-			starting_char = pEnd + 1;
-			++index;
-		} while (*pEnd != ']');
-		return true;
-	}
-	if (strstr(h->read_line, SRLZTN_POSROT_ROT)) {
-		prefix_len = strlen(SRLZTN_POSROT_ROT);
-		starting_char = strchr(h->read_line + prefix_len, '[') + 1;
-		assert(starting_char != nullptr);
-		char *pEnd = nullptr;
-		long index = 0;
-		do {
-			assert(index < 4);
-			stn_res = pk_stn(&quat_rot[index], starting_char, &pEnd);
-			if (stn_res != PK_STN_RES_SUCCESS) return false;
-			starting_char = pEnd + 1;
-			++index;
-		} while (*pEnd != ']');
-		return true;
-	}
-	if (strstr(h->read_line, SRLZTN_POSROT_SCALE)) {
-		prefix_len = strlen(SRLZTN_POSROT_SCALE);
-		starting_char = strchr(h->read_line + prefix_len, '[') + 1;
-		assert(starting_char != nullptr);
-		char *pEnd = nullptr;
-		long index = 0;
-		do {
-			assert(index < 3);
-			stn_res = pk_stn(&scale[index], starting_char, &pEnd);
-			if (stn_res != PK_STN_RES_SUCCESS) return false;
-			starting_char = pEnd + 1;
-			++index;
-		} while (*pEnd != ']');
-		return true;
+	for (i = 0; i < kvec->arr.next; ++i) {
+		if (strstr(kvec->arr[i].key, SRLZTN_POSROT_POS)) {
+			starting_char = kvec->arr[i].val;
+			index = 0;
+			do {
+				assert(index < 3);
+				stn_res = pk_stn(&pos[index], starting_char, &pEnd);
+				if (stn_res != PK_STN_RES_SUCCESS) break;
+				starting_char = pEnd + 1;
+				++index;
+			} while (*pEnd != '\0');
+		}
+		if (strstr(kvec->arr[i].key, SRLZTN_POSROT_ROT)) {
+			starting_char = kvec->arr[i].val;
+			index = 0;
+			do {
+				assert(index < 4);
+				stn_res = pk_stn(&quat_rot[index], starting_char, &pEnd);
+				if (stn_res != PK_STN_RES_SUCCESS) break;
+				starting_char = pEnd + 1;
+				++index;
+			} while (*pEnd != '\0');
+		}
+		if (strstr(kvec->arr[i].key, SRLZTN_POSROT_SCALE)) {
+			starting_char = kvec->arr[i].val;
+			index = 0;
+			do {
+				assert(index < 3);
+				stn_res = pk_stn(&scale[index], starting_char, &pEnd);
+				if (stn_res != PK_STN_RES_SUCCESS) break;
+				starting_char = pEnd + 1;
+				++index;
+			} while (*pEnd != '\0');
+		}
 	}
-	return false;
 }
 
-bool pke_serialize_instance(srlztn_serialize_helper *h, const CompInstance *comp) {
+pk_handle pke_serialize_instance(srlztn_serialize_helper *h, const CompInstance *comp) {
 	EntityType *et = nullptr;
-	if (comp->grBindsHandle != GrBindsHandle_MAX) {
-		et = EntityType_FindByEntityHandle(ECS_GetGrBinds(comp->grBindsHandle)->entHandle);
-	}
-
+	char *s;
+	int len;
+	pk_handle inst_pos_handle;
+	pke_kve kve{};
+	pke_kve_container kvec{};
 	CompInstance c{};
 	glm::vec3 pos;
 	glm::quat quat_rot;
@@ -113,44 +123,98 @@ bool pke_serialize_instance(srlztn_serialize_helper *h, const CompInstance *comp
 		BulletToGlm(comp->bt.rigidBody->getCollisionShape()->getLocalScaling(), scale);
 	}
 
+	inst_pos_handle = pke_serialize_inst_pos(h, pos, quat_rot, scale);
+
+	kvec.srlztn_handle = h->handle_head;
+	kvec.type_code = cstring_to_pk_cstr(SRLZTN_OBJ_INSTANCE);
+	kvec.bkt = h->bkt;
+	kvec.arr.bkt = h->bkt;
+	kvec.children.bkt = h->bkt;
+	kvec.child_handles.bkt = h->bkt;
+	h->handle_head.itemIndex++;
+	pk_arr_append_t(&kvec.child_handles, inst_pos_handle);
+
+	if (comp->grBindsHandle != GrBindsHandle_MAX) {
+		et = EntityType_FindByEntityHandle(ECS_GetGrBinds(comp->grBindsHandle)->entHandle);
+	}
+
 	if (comp->uuid != pk_uuid_zed && comp->uuid != pk_uuid_max) {
-		h->o << SRLZTN_INSTANCE_COMPONENT_UUID << comp->uuid << std::endl;
+		kve.key = SRLZTN_INSTANCE_COMPONENT_UUID;
+		s = pk_new<char>(37, h->bkt);
+		sprintf(s, pk_uuid_printf_format, pk_uuid_printf_var(comp->uuid));
+		kve.val = s;
+		kve.end = SRLZTN_KVE_END;
+		pk_arr_append_t(&kvec.arr, kve);
 	}
 	if (et != nullptr) {
-		h->o << SRLZTN_INSTANCE_COMPONENT_ENTITY_TYPE_CODE << et->entityTypeCode.val << std::endl;
+		kve.key = SRLZTN_INSTANCE_COMPONENT_ENTITY_TYPE_CODE;
+		s = pk_new<char>(et->entityTypeCode.reserved, h->bkt);
+		sprintf(s, "%s", et->entityTypeCode.val);
+		kve.val = s;
+		kve.end = SRLZTN_KVE_END;
+		pk_arr_append_t(&kvec.arr, kve);
 	}
-
-	pke_serialize_inst_pos(h, pos, quat_rot, scale);
-
 	if (mass != 1) {
-		h->o << SRLZTN_INSTANCE_COMPONENT_MASS << mass << std::endl;
+		kve.key = SRLZTN_INSTANCE_COMPONENT_MASS;
+		len = snprintf(NULL, 0, "%f", mass);
+		s = pk_new<char>(len+1, h->bkt);
+		sprintf(s, "%f", mass);
+		kve.val = s;
+		kve.end = SRLZTN_KVE_END;
+		pk_arr_append_t(&kvec.arr, kve);
 	}
 	if (collisionLayer != c.physicsLayer) {
-		h->o << SRLZTN_INSTANCE_COMPONENT_COLLISION_LAYER << static_cast<PhysicsCollision_T>(collisionLayer) << std::endl;
+		kve.key = SRLZTN_INSTANCE_COMPONENT_COLLISION_LAYER;
+		len = snprintf(NULL, 0, "%lu", static_cast<PhysicsCollision_T>(collisionLayer));
+		s = pk_new<char>(len+1, h->bkt);
+		sprintf(s, "%lu", static_cast<PhysicsCollision_T>(collisionLayer));
+		kve.val = s;
+		kve.end = SRLZTN_KVE_END;
+		pk_arr_append_t(&kvec.arr, kve);
 	}
 	if (collisionMask != c.physicsMask) {
-		h->o << SRLZTN_INSTANCE_COMPONENT_COLLISION_MASK << static_cast<PhysicsCollision_T>(collisionMask) << std::endl;
+		kve.key = SRLZTN_INSTANCE_COMPONENT_COLLISION_MASK;
+		len = snprintf(NULL, 0, "%lu", static_cast<PhysicsCollision_T>(collisionMask));
+		s = pk_new<char>(len+1, h->bkt);
+		sprintf(s, "%lu", static_cast<PhysicsCollision_T>(collisionMask));
+		kve.val = s;
+		kve.end = SRLZTN_KVE_END;
+		pk_arr_append_t(&kvec.arr, kve);
 	}
 	if (comp->collisionCallback.name[0] != '\0') {
-		h->o << SRLZTN_INSTANCE_COMPONENT_COLLISION_CB_SIGNATURE << comp->collisionCallback.name << std::endl;
+		kve.key = SRLZTN_INSTANCE_COMPONENT_COLLISION_CB_SIGNATURE;
+		s = pk_new<char>(CallbackSignatureLength + 1, h->bkt);
+		sprintf(s, "%s", comp->collisionCallback.name);
+		kve.val = s;
+		kve.end = SRLZTN_KVE_END;
+		pk_arr_append_t(&kvec.arr, kve);
 	}
 
-	return true;
+	pk_arr_append_t(&h->kvp_containers, kvec);
+	return kvec.srlztn_handle;
 }
 
-bool pke_deserialize_instance(srlztn_deserialize_helper *h) {
-	uint64_t prefix_len;
+void pke_deserialize_instance(srlztn_deserialize_helper *h, pke_kve_container *kvec) {
+	uint32_t i;
 	PK_STN_RES stn_res;
 	EntityType *et_ptr = nullptr;
-	float mass;
+	float mass = 1;
 	InstPos inst_pos;
 	CompInstance comp{};
 	glm::vec3 pos = glm::vec3(0);
 	glm::quat quat_rot = glm::quat(0, 0, 0, 1);
 	glm::vec3 scale = glm::vec3(1);
 	comp.collisionCallback.name[0] = '\0';
-	while (h->i->getline(h->read_line, h->read_line_len)) {
-		if (strstr(SRLZTN_OBJ_END, h->read_line)) {
+
+	for (i = 0; i < kvec->children.next; ++i) {
+		pke_kve_container *child_kvec = kvec->children[i];
+		if (strncmp(child_kvec->type_code.val, SRLZTN_OBJ_INSTANCE_POSITION, strlen(SRLZTN_OBJ_INSTANCE_POSITION)) == 0) {
+			pke_deserialize_inst_pos(h, child_kvec, pos, quat_rot, scale);
+		}
+	}
+
+	for (i = 0; i < kvec->arr.next; ++i) {
+		if (strstr(SRLZTN_OBJ_END, kvec->arr[i].key)) {
 			if (et_ptr == nullptr) {
 				fprintf(stdout, "[Game::DeserializeInstance] Unknown EntityTypeCode, skipping instance.\n");
 				break;
@@ -196,46 +260,40 @@ bool pke_deserialize_instance(srlztn_deserialize_helper *h) {
 					pk_arr_append(&h->mapping, &map);
 				}
 			}
-			return true;
-		}
-		if (strstr(h->read_line, SRLZTN_INSTANCE_COMPONENT_UUID)) {
-			prefix_len = strlen(SRLZTN_INSTANCE_COMPONENT_UUID);
-			(h->read_line + prefix_len) >> comp.uuid ;
-			continue;
 		}
-		if (strstr(h->read_line, SRLZTN_INSTANCE_COMPONENT_ENTITY_TYPE_CODE)) {
-			prefix_len = strlen(SRLZTN_INSTANCE_COMPONENT_ENTITY_TYPE_CODE);
-			if (strlen(h->read_line + prefix_len) > 1) {
-				et_ptr = EntityType_FindByTypeCode(h->read_line + prefix_len);
-			}
+		if (strstr(kvec->arr[i].key, SRLZTN_INSTANCE_COMPONENT_UUID)) {
+			kvec->arr[i].val >> comp.uuid ;
 			continue;
 		}
-		if (strstr(h->read_line, SRLZTN_INSTANCE_COMPONENT_MASS)) {
-			prefix_len = strlen(SRLZTN_INSTANCE_COMPONENT_MASS);
-			stn_res = pk_stn(&mass, h->read_line + prefix_len, nullptr);
-			if (stn_res != PK_STN_RES_SUCCESS) return false;
+		if (strstr(kvec->arr[i].key, SRLZTN_INSTANCE_COMPONENT_ENTITY_TYPE_CODE)) {
+			et_ptr = EntityType_FindByTypeCode(kvec->arr[i].val);
 			continue;
 		}
-		if (strstr(h->read_line, SRLZTN_INSTANCE_COMPONENT_COLLISION_LAYER)) {
-			prefix_len = strlen(SRLZTN_INSTANCE_COMPONENT_COLLISION_LAYER);
-			stn_res = pk_stn(&comp.physicsLayer, h->read_line + prefix_len, nullptr, 10);
-			if (stn_res != PK_STN_RES_SUCCESS) return false;
+		if (strstr(kvec->arr[i].key, SRLZTN_INSTANCE_COMPONENT_MASS)) {
+			stn_res = pk_stn(&mass, kvec->arr[i].val, nullptr);
+			if (stn_res != PK_STN_RES_SUCCESS) {
+				fprintf(stderr, "[pke_deserialize_instance] Failed to parse %s", SRLZTN_INSTANCE_COMPONENT_MASS);
+			}
 			continue;
 		}
-		if (strstr(h->read_line, SRLZTN_INSTANCE_COMPONENT_COLLISION_MASK)) {
-			prefix_len = strlen(SRLZTN_INSTANCE_COMPONENT_COLLISION_MASK);
-			stn_res = pk_stn(&comp.physicsMask, h->read_line + prefix_len, nullptr, 10);
-			if (stn_res != PK_STN_RES_SUCCESS) return false;
+		if (strstr(kvec->arr[i].key, SRLZTN_INSTANCE_COMPONENT_COLLISION_LAYER)) {
+			stn_res = pk_stn(&comp.physicsLayer, kvec->arr[i].val, nullptr, 10);
+			if (stn_res != PK_STN_RES_SUCCESS) {
+				fprintf(stderr, "[pke_deserialize_instance] Failed to parse %s", SRLZTN_INSTANCE_COMPONENT_COLLISION_LAYER);
+			}
 			continue;
 		}
-		if (strstr(h->read_line, SRLZTN_INSTANCE_COMPONENT_COLLISION_CB_SIGNATURE)) {
-			prefix_len = strlen(SRLZTN_INSTANCE_COMPONENT_COLLISION_CB_SIGNATURE);
-			strncpy(comp.collisionCallback.name, h->read_line + prefix_len, 16);
+		if (strstr(kvec->arr[i].key, SRLZTN_INSTANCE_COMPONENT_COLLISION_MASK)) {
+			stn_res = pk_stn(&comp.physicsMask, kvec->arr[i].val, nullptr, 10);
+			if (stn_res != PK_STN_RES_SUCCESS) {
+				fprintf(stderr, "[pke_deserialize_instance] Failed to parse %s", SRLZTN_INSTANCE_COMPONENT_COLLISION_MASK);
+			}
 			continue;
 		}
-		if (pke_deserialize_inst_pos(h, pos, quat_rot, scale)) {
+		if (strstr(kvec->arr[i].key, SRLZTN_INSTANCE_COMPONENT_COLLISION_CB_SIGNATURE)) {
+			strncpy(comp.collisionCallback.name, kvec->arr[i].val, 16);
 			continue;
 		}
 	}
-	return false;
+	return;
 }
diff --git a/src/serialization-component.hpp b/src/serialization-component.hpp
index a01d235..7020479 100644
--- a/src/serialization-component.hpp
+++ b/src/serialization-component.hpp
@@ -6,10 +6,10 @@
 
 #include "vendor-glm-include.hpp"
 
-bool pke_serialize_inst_pos(srlztn_serialize_helper *h, const glm::vec3 pos, const glm::quat quat_rot, const glm::vec3 scale);
-bool pke_deserialize_inst_pos(srlztn_deserialize_helper *h, glm::vec3 &pos, glm::quat &quat_rot, glm::vec3 &scale);
+pk_handle pke_serialize_inst_pos(srlztn_serialize_helper *h, const glm::vec3 pos, const glm::quat quat_rot, const glm::vec3 scale);
+void pke_deserialize_inst_pos(srlztn_deserialize_helper *h, pke_kve_container *kvec, glm::vec3 &pos, glm::quat &quat_rot, glm::vec3 &scale);
 
-bool pke_serialize_instance(srlztn_serialize_helper *h, const CompInstance *comp);
-bool pke_deserialize_instance(srlztn_deserialize_helper *h);
+pk_handle pke_serialize_instance(srlztn_serialize_helper *h, const CompInstance *comp);
+void pke_deserialize_instance(srlztn_deserialize_helper *h, pke_kve_container *kvec);
 
 #endif /* PKE_SERIALIZATION_COMPONENT_HPP */
diff --git a/src/serialization-font.cpp b/src/serialization-font.cpp
index 60ba61d..761643c 100644
--- a/src/serialization-font.cpp
+++ b/src/serialization-font.cpp
@@ -1,143 +1,205 @@
 
 #include "serialization-font.hpp"
+
 #include "pk.h"
-#include <sstream>
 
-bool pke_serialize_font_render(srlztn_serialize_helper *h, FontRender *fr) {
+pk_handle pke_serialize_font_render(srlztn_serialize_helper *h, FontRender *fr) {
 	assert(h != nullptr);
 	assert(fr != nullptr);
+	char *s;
+	pk_handle inst_pos_handle;
+	pke_kve kve{};
+	pke_kve_container kvec{};
+
 	if (PK_HAS_FLAG(fr->entity_flags, ENTITY_FLAG_DO_NOT_SERIALIZE)) {
-		return false;
+		return PK_HANDLE_MAX;
 	}
+
+	kvec.srlztn_handle = h->handle_head;
+	kvec.type_code = cstring_to_pk_cstr(SRLZTN_OBJ_CAMERA);
+	kvec.bkt = h->bkt;
+	kvec.arr.bkt = h->bkt;
+	kvec.children.bkt = h->bkt;
+	kvec.child_handles.bkt = h->bkt;
+	h->handle_head.itemIndex++;
+	pk_arr_append_t(&kvec.child_handles, inst_pos_handle);
+
 	if (fr->uuid != pk_uuid_zed && fr->uuid != pk_uuid_max) {
-		h->o << SRLZTN_UI_FONT_RENDER_UUID << std::endl;
+		kve.key = SRLZTN_UI_BOX_UUID;
+		s = pk_new<char>(37, h->bkt);
+		sprintf(s, pk_uuid_printf_format, pk_uuid_printf_var(fr->uuid));
+		kve.val = s;
+		kve.end = SRLZTN_KVE_END;
+		pk_arr_append_t(&kvec.arr, kve);
 	}
 	if (fr->text.val != nullptr) {
-		h->o << SRLZTN_UI_FONT_RENDER_TEXT_BEGIN << std::endl;
-		h->o << fr->text.val << std::endl;
-		h->o << SRLZTN_UI_FONT_RENDER_TEXT_END << std::endl;
+		kve.key = SRLZTN_UI_FONT_RENDER_TEXT_BEGIN;
+		s = pk_new<char>(fr->text.reserved, h->bkt);
+		sprintf(s, "%s", fr->text.val);
+		kve.val = s;
+		kve.end = SRLZTN_MULTILINE_END;
+		pk_arr_append_t(&kvec.arr, kve);
 	}
+
+	pk_arr_append_t(&h->kvp_containers, kvec);
 	return pke_serialize_font_render_settings(h, &fr->settings);
 }
 
-bool pke_deserialize_font_render(srlztn_deserialize_helper *h, FontRender *fr) {
+void pke_deserialize_font_render(srlztn_deserialize_helper *h, pke_kve_container *kvec, FontRender *fr) {
 	assert(h != nullptr);
 	assert(fr != nullptr);
-	uint64_t prefix_len;
-	if (strncmp(h->read_line, SRLZTN_UI_FONT_RENDER_UUID, strlen(SRLZTN_UI_FONT_RENDER_UUID)) == 0) {
-		prefix_len = strlen(SRLZTN_UI_FONT_RENDER_UUID);
-		(h->read_line + prefix_len) >> fr->uuid;
-		return true;
-	}
-	if (strncmp(h->read_line, SRLZTN_UI_FONT_RENDER_TEXT_BEGIN, strlen(SRLZTN_UI_FONT_RENDER_TEXT_BEGIN)) == 0) {
-		// TODO replace with something that doesn't give the code stds
-		std::ostringstream ss{};
-		bool first = true;
-		while (h->i->getline(h->read_line, h->read_line_len)) {
-			if (strncmp(h->read_line, SRLZTN_UI_FONT_RENDER_TEXT_END, strlen(SRLZTN_UI_FONT_RENDER_TEXT_END)) == 0) {
-				std::string s = ss.str();
-				fr->text = cstring_to_pk_cstr(s.c_str());
-				break;
-			}
-			if (!first) {
-				first = false;
-				ss << std::endl;
-			}
-			ss << h->read_line;
+	uint32_t i;
+	char *s;
+	for (i = 0; i < kvec->arr.next; ++i) {
+		if (strncmp(kvec->arr[i].key, SRLZTN_UI_FONT_RENDER_UUID, strlen(SRLZTN_UI_FONT_RENDER_UUID)) == 0) {
+			kvec->arr[i].val >> fr->uuid;
+			continue;
+		}
+		if (strncmp(kvec->arr[i].key, SRLZTN_UI_FONT_RENDER_TEXT_BEGIN, strlen(SRLZTN_UI_FONT_RENDER_TEXT_BEGIN)) == 0) {
+			fr->text.length = strlen(kvec->arr[i].val) + 1;
+			fr->text.reserved = fr->text.reserved + 1;
+			// TODO specific bkt
+			s = pk_new<char>(fr->text.reserved, NULL);
+			fr->text.val = s;
+			continue;
 		}
-		return true;
 	}
-	return false;
 }
 
-bool pke_serialize_font_render_settings(srlztn_serialize_helper *h, FontRenderSettings *frs) {
+pk_handle pke_serialize_font_render_settings(srlztn_serialize_helper *h, FontRenderSettings *frs) {
+	char *s;
+	pke_kve kve{};
+	pke_kve_container kvec{};
+	int len;
+
+	kvec.srlztn_handle = h->handle_head;
+	kvec.type_code = cstring_to_pk_cstr(SRLZTN_OBJ_FONT_RENDER_SETTINGS);
+	kvec.bkt = h->bkt;
+	kvec.arr.bkt = h->bkt;
+	kvec.children.bkt = h->bkt;
+	kvec.child_handles.bkt = h->bkt;
+	h->handle_head.itemIndex++;
+
 	if (frs->char_scale != 0.0) {
-		h->o << SRLZTN_UI_FONT_RENDER_SETTINGS_CHAR_SCALE << frs->char_scale << std::endl;
+		kve.key = SRLZTN_UI_FONT_RENDER_SETTINGS_CHAR_SCALE;
+		len = snprintf(NULL, 0, "%f", frs->char_scale);
+		s = pk_new<char>(len+1, h->bkt);
+		sprintf(s, "%f", frs->char_scale);
+		kve.val = s;
+		kve.end = SRLZTN_KVE_END;
+		pk_arr_append_t(&kvec.arr, kve);
 	}
 	if (frs->line_height_scale != 0.0) {
-		h->o << SRLZTN_UI_FONT_RENDER_SETTINGS_LINE_HEIGHT_SCALE << frs->line_height_scale << std::endl;
+		kve.key = SRLZTN_UI_FONT_RENDER_SETTINGS_LINE_HEIGHT_SCALE;
+		len = snprintf(NULL, 0, "%f", frs->line_height_scale);
+		s = pk_new<char>(len+1, h->bkt);
+		sprintf(s, "%f", frs->line_height_scale);
+		kve.val = s;
+		kve.end = SRLZTN_KVE_END;
+		pk_arr_append_t(&kvec.arr, kve);
 	}
 	if (frs->char_spacing_scale != 0.0) {
-		h->o << SRLZTN_UI_FONT_RENDER_SETTINGS_CHAR_SPACING_SCALE << frs->char_spacing_scale << std::endl;
+		kve.key = SRLZTN_UI_FONT_RENDER_SETTINGS_CHAR_SPACING_SCALE;
+		len = snprintf(NULL, 0, "%f", frs->char_spacing_scale);
+		s = pk_new<char>(len+1, h->bkt);
+		sprintf(s, "%f", frs->char_spacing_scale);
+		kve.val = s;
+		kve.end = SRLZTN_KVE_END;
+		pk_arr_append_t(&kvec.arr, kve);
 	}
 	if (frs->surface_area_size != glm::ivec2(0)) {
-		h->o << SRLZTN_UI_FONT_RENDER_SETTINGS_SURFACE_AREA_SIZE << frs->surface_area_size.x << SRLZTN_FILE_NUM_SEPARATOR << frs->surface_area_size.y << std::endl;
+		kve.key = SRLZTN_UI_FONT_RENDER_SETTINGS_SURFACE_AREA_SIZE;
+		len = snprintf(NULL, 0, "%d, %d", frs->surface_area_size.x, frs->surface_area_size.y);
+		s = pk_new<char>(len+1, h->bkt);
+		sprintf(s, "%d, %d", frs->surface_area_size.x, frs->surface_area_size.y);
+		kve.val = s;
+		kve.end = SRLZTN_KVE_END;
+		pk_arr_append_t(&kvec.arr, kve);
 	}
 	if (frs->surface_area_pos != glm::ivec2(0)) {
-		h->o << SRLZTN_UI_FONT_RENDER_SETTINGS_SURFACE_AREA_POS << frs->surface_area_pos.x << SRLZTN_FILE_NUM_SEPARATOR << frs->surface_area_pos.y << std::endl;
+		kve.key = SRLZTN_UI_FONT_RENDER_SETTINGS_SURFACE_AREA_POS;
+		len = snprintf(NULL, 0, "%d, %d", frs->surface_area_pos.x, frs->surface_area_pos.y);
+		s = pk_new<char>(len+1, h->bkt);
+		sprintf(s, "%d, %d", frs->surface_area_pos.x, frs->surface_area_pos.y);
+		kve.val = s;
+		kve.end = SRLZTN_KVE_END;
+		pk_arr_append_t(&kvec.arr, kve);
 	}
 	if (frs->surface_area_type_flags != FONT_RENDER_SURFACE_AREA_TYPE_FLAGS_NONE) {
-		h->o << SRLZTN_UI_FONT_RENDER_SETTINGS_SURFACE_AREA_FLAGS << FONT_RENDER_SURFACE_AREA_TYPE_FLAG_T(frs->surface_area_type_flags) << std::endl;
+		kve.key = SRLZTN_UI_FONT_RENDER_SETTINGS_SURFACE_AREA_FLAGS;
+		s = pk_new<char>(5, h->bkt);
+		sprintf(s, "0x%.2X", FONT_RENDER_SURFACE_AREA_TYPE_FLAG_T(frs->surface_area_type_flags));
+		kve.val = s;
+		kve.end = SRLZTN_KVE_END;
+		pk_arr_append_t(&kvec.arr, kve);
 	}
-	return true;
+
+	pk_arr_append_t(&h->kvp_containers, kvec);
+	return kvec.srlztn_handle;
 }
 
-bool pke_deserialize_font_render_settings(srlztn_deserialize_helper *h, FontRenderSettings *frs) {
-	uint64_t prefix_len;
+void pke_deserialize_font_render_settings(srlztn_deserialize_helper *h, pke_kve_container *kvec, FontRenderSettings *frs) {
+	(void)h;
+	uint32_t i;
 	PK_STN_RES stn_res;
 	char *str_end;
-	if (strncmp(h->read_line, SRLZTN_UI_FONT_RENDER_SETTINGS_CHAR_SCALE, strlen(SRLZTN_UI_FONT_RENDER_SETTINGS_CHAR_SCALE)) == 0) {
-		prefix_len = strlen(SRLZTN_UI_FONT_RENDER_SETTINGS_CHAR_SCALE);
-		stn_res = pk_stn(&frs->char_scale, h->read_line + prefix_len, &str_end);
-		if (stn_res != PK_STN_RES_SUCCESS) {
-			fprintf(stderr, "[%s] Err '%u' parsing '%s' primary from: '%s'\n", __FILE__, stn_res, SRLZTN_UI_FONT_RENDER_SETTINGS_CHAR_SCALE, h->read_line);
-		}
-		return true;
-	}
-	if (strncmp(h->read_line, SRLZTN_UI_FONT_RENDER_SETTINGS_LINE_HEIGHT_SCALE, strlen(SRLZTN_UI_FONT_RENDER_SETTINGS_LINE_HEIGHT_SCALE)) == 0) {
-		prefix_len = strlen(SRLZTN_UI_FONT_RENDER_SETTINGS_LINE_HEIGHT_SCALE);
-		stn_res = pk_stn(&frs->line_height_scale, h->read_line + prefix_len, &str_end);
-		if (stn_res != PK_STN_RES_SUCCESS) {
-			fprintf(stderr, "[%s] Err '%u' parsing '%s' primary from: '%s'\n", __FILE__, stn_res, SRLZTN_UI_FONT_RENDER_SETTINGS_LINE_HEIGHT_SCALE, h->read_line);
-		}
-		return true;
-	}
-	if (strncmp(h->read_line, SRLZTN_UI_FONT_RENDER_SETTINGS_CHAR_SPACING_SCALE, strlen(SRLZTN_UI_FONT_RENDER_SETTINGS_CHAR_SPACING_SCALE)) == 0) {
-		prefix_len = strlen(SRLZTN_UI_FONT_RENDER_SETTINGS_CHAR_SPACING_SCALE);
-		stn_res = pk_stn(&frs->char_spacing_scale, h->read_line + prefix_len, &str_end);
-		if (stn_res != PK_STN_RES_SUCCESS) {
-			fprintf(stderr, "[%s] Err '%u' parsing '%s' primary from: '%s'\n", __FILE__, stn_res, SRLZTN_UI_FONT_RENDER_SETTINGS_CHAR_SPACING_SCALE, h->read_line);
+	for (i = 0; i < kvec->arr.next; ++i) {
+		if (strncmp(kvec->arr[i].key, SRLZTN_UI_FONT_RENDER_SETTINGS_CHAR_SCALE, strlen(SRLZTN_UI_FONT_RENDER_SETTINGS_CHAR_SCALE)) == 0) {
+			stn_res = pk_stn(&frs->char_scale, kvec->arr[i].val, &str_end);
+			if (stn_res != PK_STN_RES_SUCCESS) {
+				fprintf(stderr, "[%s] Err '%u' parsing '%s' primary from: '%s'\n", __FILE__, stn_res, SRLZTN_UI_FONT_RENDER_SETTINGS_CHAR_SCALE, kvec->arr[i].val);
+			}
+			continue;
 		}
-		return true;
-	}
-	if (strncmp(h->read_line, SRLZTN_UI_FONT_RENDER_SETTINGS_SURFACE_AREA_SIZE, strlen(SRLZTN_UI_FONT_RENDER_SETTINGS_SURFACE_AREA_SIZE)) == 0) {
-		prefix_len = strlen(SRLZTN_UI_FONT_RENDER_SETTINGS_SURFACE_AREA_SIZE);
-		stn_res = pk_stn(&frs->surface_area_size.x, h->read_line + prefix_len, &str_end);
-		if (stn_res != PK_STN_RES_SUCCESS) {
-			fprintf(stderr, "[%s] Err '%u' parsing '%s' (x) primary from: '%s'\n", __FILE__, stn_res, SRLZTN_UI_FONT_RENDER_SETTINGS_SURFACE_AREA_SIZE, h->read_line);
-			return true;
+		if (strncmp(kvec->arr[i].key, SRLZTN_UI_FONT_RENDER_SETTINGS_LINE_HEIGHT_SCALE, strlen(SRLZTN_UI_FONT_RENDER_SETTINGS_LINE_HEIGHT_SCALE)) == 0) {
+			stn_res = pk_stn(&frs->line_height_scale, kvec->arr[i].val, &str_end);
+			if (stn_res != PK_STN_RES_SUCCESS) {
+				fprintf(stderr, "[%s] Err '%u' parsing '%s' primary from: '%s'\n", __FILE__, stn_res, SRLZTN_UI_FONT_RENDER_SETTINGS_LINE_HEIGHT_SCALE, kvec->arr[i].val);
+			}
+			continue;
 		}
-		prefix_len += strchr(h->read_line + prefix_len, ',') - (h->read_line + prefix_len);
-		stn_res = pk_stn(&frs->surface_area_size.y, h->read_line + prefix_len, &str_end);
-		if (stn_res != PK_STN_RES_SUCCESS) {
-			fprintf(stderr, "[%s] Err '%u' parsing '%s' (y) primary from: '%s'\n", __FILE__, stn_res, SRLZTN_UI_FONT_RENDER_SETTINGS_SURFACE_AREA_SIZE, h->read_line);
+		if (strncmp(kvec->arr[i].key, SRLZTN_UI_FONT_RENDER_SETTINGS_CHAR_SPACING_SCALE, strlen(SRLZTN_UI_FONT_RENDER_SETTINGS_CHAR_SPACING_SCALE)) == 0) {
+			stn_res = pk_stn(&frs->char_spacing_scale, kvec->arr[i].val, &str_end);
+			if (stn_res != PK_STN_RES_SUCCESS) {
+				fprintf(stderr, "[%s] Err '%u' parsing '%s' primary from: '%s'\n", __FILE__, stn_res, SRLZTN_UI_FONT_RENDER_SETTINGS_CHAR_SPACING_SCALE, kvec->arr[i].val);
+			}
+			continue;
 		}
-		return true;
-	}
-	if (strncmp(h->read_line, SRLZTN_UI_FONT_RENDER_SETTINGS_SURFACE_AREA_POS, strlen(SRLZTN_UI_FONT_RENDER_SETTINGS_SURFACE_AREA_POS)) == 0) {
-		prefix_len = strlen(SRLZTN_UI_FONT_RENDER_SETTINGS_SURFACE_AREA_POS);
-		stn_res = pk_stn(&frs->surface_area_pos.x, h->read_line + prefix_len, &str_end);
-		if (stn_res != PK_STN_RES_SUCCESS) {
-			fprintf(stderr, "[%s] Err '%u' parsing '%s' (x) primary from: '%s'\n", __FILE__, stn_res, SRLZTN_UI_FONT_RENDER_SETTINGS_SURFACE_AREA_POS, h->read_line);
-			return true;
+		if (strncmp(kvec->arr[i].key, SRLZTN_UI_FONT_RENDER_SETTINGS_SURFACE_AREA_SIZE, strlen(SRLZTN_UI_FONT_RENDER_SETTINGS_SURFACE_AREA_SIZE)) == 0) {
+			stn_res = pk_stn(&frs->surface_area_size.x, kvec->arr[i].val, &str_end);
+			if (stn_res != PK_STN_RES_SUCCESS) {
+				fprintf(stderr, "[%s] Err '%u' parsing '%s' (x) primary from: '%s'\n", __FILE__, stn_res, SRLZTN_UI_FONT_RENDER_SETTINGS_SURFACE_AREA_SIZE, kvec->arr[i].val);
+				continue;
+			}
+			size_t prefix_len = strchr(kvec->arr[i].val, ',') - (kvec->arr[i].val);
+			stn_res = pk_stn(&frs->surface_area_size.y, kvec->arr[i].val + prefix_len, &str_end);
+			if (stn_res != PK_STN_RES_SUCCESS) {
+				fprintf(stderr, "[%s] Err '%u' parsing '%s' (y) primary from: '%s'\n", __FILE__, stn_res, SRLZTN_UI_FONT_RENDER_SETTINGS_SURFACE_AREA_SIZE, kvec->arr[i].val);
+			}
+			continue;
 		}
-		prefix_len += strchr(h->read_line + prefix_len, ',') - (h->read_line + prefix_len);
-		stn_res = pk_stn(&frs->surface_area_pos.y, h->read_line + prefix_len, &str_end);
-		if (stn_res != PK_STN_RES_SUCCESS) {
-			fprintf(stderr, "[%s] Err '%u' parsing '%s' (y) primary from: '%s'\n", __FILE__, stn_res, SRLZTN_UI_FONT_RENDER_SETTINGS_SURFACE_AREA_POS, h->read_line);
+		if (strncmp(kvec->arr[i].key, SRLZTN_UI_FONT_RENDER_SETTINGS_SURFACE_AREA_POS, strlen(SRLZTN_UI_FONT_RENDER_SETTINGS_SURFACE_AREA_POS)) == 0) {
+			stn_res = pk_stn(&frs->surface_area_pos.x, kvec->arr[i].val, &str_end);
+			if (stn_res != PK_STN_RES_SUCCESS) {
+				fprintf(stderr, "[%s] Err '%u' parsing '%s' (x) primary from: '%s'\n", __FILE__, stn_res, SRLZTN_UI_FONT_RENDER_SETTINGS_SURFACE_AREA_POS, kvec->arr[i].val);
+				continue;
+			}
+			size_t prefix_len = strchr(kvec->arr[i].val, ',') - (kvec->arr[i].val);
+			stn_res = pk_stn(&frs->surface_area_pos.y, kvec->arr[i].val + prefix_len, &str_end);
+			if (stn_res != PK_STN_RES_SUCCESS) {
+				fprintf(stderr, "[%s] Err '%u' parsing '%s' (y) primary from: '%s'\n", __FILE__, stn_res, SRLZTN_UI_FONT_RENDER_SETTINGS_SURFACE_AREA_POS, kvec->arr[i].val);
+			}
+			continue;
 		}
-		return true;
-	}
-	if (strncmp(h->read_line, SRLZTN_UI_FONT_RENDER_SETTINGS_SURFACE_AREA_FLAGS, strlen(SRLZTN_UI_FONT_RENDER_SETTINGS_SURFACE_AREA_FLAGS)) == 0) {
-		prefix_len = strlen(SRLZTN_UI_FONT_RENDER_SETTINGS_SURFACE_AREA_FLAGS);
-		FONT_RENDER_SURFACE_AREA_TYPE_FLAG_T flags;
-		stn_res = pk_stn(&flags, h->read_line + prefix_len, &str_end);
-		if (stn_res != PK_STN_RES_SUCCESS) {
-			fprintf(stderr, "[%s] Err '%u' parsing '%s' primary from: '%s'\n", __FILE__, stn_res, SRLZTN_UI_FONT_RENDER_SETTINGS_SURFACE_AREA_FLAGS, h->read_line);
-			return true;
+		if (strncmp(kvec->arr[i].key, SRLZTN_UI_FONT_RENDER_SETTINGS_SURFACE_AREA_FLAGS, strlen(SRLZTN_UI_FONT_RENDER_SETTINGS_SURFACE_AREA_FLAGS)) == 0) {
+			FONT_RENDER_SURFACE_AREA_TYPE_FLAG_T flags;
+			stn_res = pk_stn(&flags, kvec->arr[i].val, &str_end);
+			if (stn_res != PK_STN_RES_SUCCESS) {
+				fprintf(stderr, "[%s] Err '%u' parsing '%s' primary from: '%s'\n", __FILE__, stn_res, SRLZTN_UI_FONT_RENDER_SETTINGS_SURFACE_AREA_FLAGS, kvec->arr[i].val);
+				continue;
+			}
+			frs->surface_area_type_flags = FONT_RENDER_SURFACE_AREA_TYPE_FLAG(flags);
+			continue;
 		}
-		frs->surface_area_type_flags = FONT_RENDER_SURFACE_AREA_TYPE_FLAG(flags);
-		return true;
 	}
-	return false;
 }
diff --git a/src/serialization-font.hpp b/src/serialization-font.hpp
index 9261a19..e41f974 100644
--- a/src/serialization-font.hpp
+++ b/src/serialization-font.hpp
@@ -4,10 +4,10 @@
 #include "serialization.hpp"
 #include "font.hpp"
 
-bool pke_serialize_font_render(srlztn_serialize_helper *h, FontRender *fr);
-bool pke_deserialize_font_render(srlztn_deserialize_helper *h, FontRender **fr);
+pk_handle pke_serialize_font_render(srlztn_serialize_helper *h, FontRender *fr);
+void pke_deserialize_font_render(srlztn_deserialize_helper *h, pke_kve_container *kvec, FontRender *fr);
 
-bool pke_serialize_font_render_settings(srlztn_serialize_helper *h, FontRenderSettings *frs);
-bool pke_deserialize_font_render_settings(srlztn_deserialize_helper *h, FontRenderSettings *frs);
+pk_handle pke_serialize_font_render_settings(srlztn_serialize_helper *h, FontRenderSettings *frs);
+void pke_deserialize_font_render_settings(srlztn_deserialize_helper *h, pke_kve_container *kvec, FontRenderSettings *frs);
 
 #endif /* PKE_SERIALIZATION_FONT_HPP */
diff --git a/src/serialization-static-ui.cpp b/src/serialization-static-ui.cpp
index ca17c10..78e5c39 100644
--- a/src/serialization-static-ui.cpp
+++ b/src/serialization-static-ui.cpp
@@ -5,123 +5,230 @@
 #include "serialization-font.hpp"
 #include "static-ui.hpp"
 
-bool pke_serialize_ui_box_internal(srlztn_serialize_helper *h, pke_ui_box_type_data_text *data) {
+pk_handle pke_serialize_ui_box_internal(srlztn_serialize_helper *h, pke_ui_box_type_data_text *data) {
+	char *s;
+	pk_handle font_render_handle;
+	pke_kve kve{};
+	pke_kve_container kvec{};
+
+	font_render_handle = pke_serialize_font_render_settings(h, &data->font_render_settings);
+
+	kvec.srlztn_handle = h->handle_head;
+	kvec.type_code = cstring_to_pk_cstr(SRLZTN_OBJ_UI_BOX);
+	kvec.bkt = h->bkt;
+	kvec.arr.bkt = h->bkt;
+	kvec.children.bkt = h->bkt;
+	kvec.child_handles.bkt = h->bkt;
+	h->handle_head.itemIndex++;
+	if (font_render_handle != PK_HANDLE_MAX) {
+		pk_arr_append_t(&kvec.child_handles, font_render_handle);
+	}
+
 	if (data->font_render_uuid != pk_uuid_zed) {
-		h->o << SRLZTN_UI_BOX_DATA_TEXT_FONT_RENDER_UUID << data->font_render_uuid << std::endl;
+		kve.key = SRLZTN_UI_BOX_DATA_TEXT_FONT_RENDER_UUID;
+		s = pk_new<char>(37, h->bkt);
+		sprintf(s, pk_uuid_printf_format, pk_uuid_printf_var(data->font_render_uuid));
+		kve.val = s;
+		kve.end = SRLZTN_KVE_END;
+		pk_arr_append_t(&kvec.arr, kve);
 	}
-	pke_serialize_font_render_settings(h, &data->font_render_settings);
-	return true;
+
+	pk_arr_append_t(&h->kvp_containers, kvec);
+	return kvec.srlztn_handle;
 }
 
-bool pke_deserialize_ui_box_internal(srlztn_deserialize_helper *h, pke_ui_box_type_data_text *data) {
-	uint64_t prefix_len;
-	if (strstr(SRLZTN_UI_BOX_DATA_TEXT_FONT_RENDER_UUID, h->read_line)) {
-		prefix_len = strlen(SRLZTN_UI_BOX_UUID);
-		(h->read_line + prefix_len) >> data->font_render_uuid;
-		return true;
+void pke_deserialize_ui_box_internal(srlztn_deserialize_helper *h, pke_kve_container *kvec, pke_ui_box_type_data_text *data) {
+	assert(kvec->children.next == 1);
+
+	pke_deserialize_font_render_settings(h, kvec, &data->font_render_settings);
+
+	if (strstr(SRLZTN_UI_BOX_DATA_TEXT_FONT_RENDER_UUID, kvec->arr[0].key)) {
+		kvec->arr[0].val >> data->font_render_uuid;
 	}
-	return pke_deserialize_font_render_settings(h, &data->font_render_settings);
-	return false;
 }
 
-bool pke_serialize_ui_box(srlztn_serialize_helper *h, pke_ui_box *box) {
+pk_handle pke_serialize_ui_box(srlztn_serialize_helper *h, pke_ui_box *box) {
+	char *s;
+	int len;
+	pk_handle internal_type_handle = PK_HANDLE_MAX;
+	pke_kve kve{};
+	pke_kve_container kvec{};
+
+	if (box->type == PKE_UI_BOX_TYPE_TEXT) {
+		pke_ui_box_type_data_text *d = reinterpret_cast<pke_ui_box_type_data_text *>(box->type_data);
+		internal_type_handle = pke_serialize_ui_box_internal(h, d);
+	}
+
+	kvec.srlztn_handle = h->handle_head;
+	kvec.type_code = cstring_to_pk_cstr(SRLZTN_OBJ_UI_BOX);
+	kvec.bkt = h->bkt;
+	kvec.arr.bkt = h->bkt;
+	kvec.children.bkt = h->bkt;
+	kvec.child_handles.bkt = h->bkt;
+	h->handle_head.itemIndex++;
+	if (internal_type_handle != PK_HANDLE_MAX) {
+		pk_arr_append_t(&kvec.child_handles, internal_type_handle);
+	}
+
 	if (box->uuid != pk_uuid_zed && box->uuid != pk_uuid_max) {
-		h->o << SRLZTN_UI_BOX_UUID << box->uuid << std::endl;
+		kve.key = SRLZTN_UI_BOX_UUID;
+		s = pk_new<char>(37, h->bkt);
+		sprintf(s, pk_uuid_printf_format, pk_uuid_printf_var(box->uuid));
+		kve.val = s;
+		kve.end = SRLZTN_KVE_END;
+		pk_arr_append_t(&kvec.arr, kve);
 	}
 	if (box->parentHandle != EntityHandle_MAX) {
 		Entity_Base *e = ECS_GetEntity(box->parentHandle);
-		h->o << SRLZTN_UI_BOX_PARENT_UUID << e->uuid << std::endl;
+		kve.key = SRLZTN_UI_BOX_PARENT_UUID;
+		s = pk_new<char>(37, h->bkt);
+		sprintf(s, pk_uuid_printf_format, pk_uuid_printf_var(e->uuid));
+		kve.val = s;
+		kve.end = SRLZTN_KVE_END;
+		pk_arr_append_t(&kvec.arr, kve);
 	}
 	if (box->flags != PKE_UI_BOX_FLAG_NONE) {
-		h->o << SRLZTN_UI_BOX_FLAGS << (PKE_UI_BOX_FLAG_T)box->flags << std::endl;
+		kve.key = SRLZTN_UI_BOX_FLAGS;
+		s = pk_new<char>(19, h->bkt);
+		sprintf(s, "0x%.2lX", static_cast<PKE_UI_BOX_FLAG_T>(box->flags));
+		kve.val = s;
+		kve.end = SRLZTN_KVE_END;
+		pk_arr_append_t(&kvec.arr, kve);
 	}
 	if (box->pos_top_left_x != 0.0) {
-		h->o << SRLZTN_UI_BOX_POS_TOP_LEFT_X << box->pos_top_left_x << std::endl;
+		kve.key = SRLZTN_UI_BOX_POS_TOP_LEFT_X;
+		len = snprintf(NULL, 0, "%f", box->pos_top_left_x);
+		s = pk_new<char>(len+1, h->bkt);
+		sprintf(s, "%f", box->pos_top_left_x);
+		kve.val = s;
+		kve.end = SRLZTN_KVE_END;
+		pk_arr_append_t(&kvec.arr, kve);
 	}
 	if (box->pos_top_left_y != 0.0) {
-		h->o << SRLZTN_UI_BOX_POS_TOP_LEFT_Y << box->pos_top_left_y << std::endl;
+		kve.key = SRLZTN_UI_BOX_POS_TOP_LEFT_Y;
+		len = snprintf(NULL, 0, "%f", box->pos_top_left_y);
+		s = pk_new<char>(len+1, h->bkt);
+		sprintf(s, "%f", box->pos_top_left_y);
+		kve.val = s;
+		kve.end = SRLZTN_KVE_END;
+		pk_arr_append_t(&kvec.arr, kve);
 	}
 	if (box->min_width != 0.0) {
-		h->o << SRLZTN_UI_BOX_MIN_WIDTH << box->min_width << std::endl;
+		kve.key = SRLZTN_UI_BOX_MIN_WIDTH;
+		len = snprintf(NULL, 0, "%f", box->min_width);
+		s = pk_new<char>(len+1, h->bkt);
+		sprintf(s, "%f", box->min_width);
+		kve.val = s;
+		kve.end = SRLZTN_KVE_END;
+		pk_arr_append_t(&kvec.arr, kve);
 	}
 	if (box->min_height != 0.0) {
-		h->o << SRLZTN_UI_BOX_MIN_HEIGHT << box->min_height << std::endl;
+		kve.key = SRLZTN_UI_BOX_MIN_HEIGHT;
+		len = snprintf(NULL, 0, "%f", box->min_height);
+		s = pk_new<char>(len+1, h->bkt);
+		sprintf(s, "%f", box->min_height);
+		kve.val = s;
+		kve.end = SRLZTN_KVE_END;
+		pk_arr_append_t(&kvec.arr, kve);
 	}
 	if (box->max_width != 0.0) {
-		h->o << SRLZTN_UI_BOX_MAX_WIDTH << box->max_width << std::endl;
+		kve.key = SRLZTN_UI_BOX_MAX_WIDTH;
+		len = snprintf(NULL, 0, "%f", box->max_width);
+		s = pk_new<char>(len+1, h->bkt);
+		sprintf(s, "%f", box->max_width);
+		kve.val = s;
+		kve.end = SRLZTN_KVE_END;
+		pk_arr_append_t(&kvec.arr, kve);
 	}
 	if (box->max_height != 0.0) {
-		h->o << SRLZTN_UI_BOX_MAX_HEIGHT << box->max_height << std::endl;
+		kve.key = SRLZTN_UI_BOX_MAX_HEIGHT;
+		len = snprintf(NULL, 0, "%f", box->max_height);
+		s = pk_new<char>(len+1, h->bkt);
+		sprintf(s, "%f", box->max_height);
+		kve.val = s;
+		kve.end = SRLZTN_KVE_END;
+		pk_arr_append_t(&kvec.arr, kve);
 	}
 	if (box->flex_weight != 0.0) {
-		h->o << SRLZTN_UI_BOX_FLEX_WEIGHT << box->flex_weight << std::endl;
+		kve.key = SRLZTN_UI_BOX_FLEX_WEIGHT;
+		len = snprintf(NULL, 0, "%f", box->flex_weight);
+		s = pk_new<char>(len+1, h->bkt);
+		sprintf(s, "%f", box->flex_weight);
+		kve.val = s;
+		kve.end = SRLZTN_KVE_END;
+		pk_arr_append_t(&kvec.arr, kve);
 	}
 	if (box->type != PKE_UI_BOX_TYPE_STANDARD) {
-		h->o << SRLZTN_UI_BOX_TYPE << (PKE_UI_BOX_TYPE_T)box->type << std::endl;
+		kve.key = SRLZTN_UI_BOX_FLAGS;
+		s = pk_new<char>(5, h->bkt);
+		sprintf(s, "0x%.2X", static_cast<PKE_UI_BOX_TYPE_T>(box->type));
+		kve.val = s;
+		kve.end = SRLZTN_KVE_END;
+		pk_arr_append_t(&kvec.arr, kve);
 	}
 	if (box->flex_direction != 0) {
-		h->o << SRLZTN_UI_BOX_FLEX_DIRECTION << box->flex_direction << std::endl;
+		kve.key = SRLZTN_UI_BOX_FLEX_DIRECTION;
+		s = pk_new<char>(5, h->bkt);
+		sprintf(s, "%u", box->flex_direction);
+		kve.val = s;
+		kve.end = SRLZTN_KVE_END;
+		pk_arr_append_t(&kvec.arr, kve);
 	}
 	if (box->layer != 0) {
-		h->o << SRLZTN_UI_BOX_LAYER << box->layer << std::endl;
+		kve.key = SRLZTN_UI_BOX_LAYER;
+		s = pk_new<char>(5, h->bkt);
+		sprintf(s, "%u", box->layer);
+		kve.val = s;
+		kve.end = SRLZTN_KVE_END;
+		pk_arr_append_t(&kvec.arr, kve);
 	}
-	if (box->type == PKE_UI_BOX_TYPE_TEXT) {
-		pke_ui_box_type_data_text *d = reinterpret_cast<pke_ui_box_type_data_text *>(box->type_data);
-		pke_serialize_ui_box_internal(h, d);
-	}
-	return true;
+
+	pk_arr_append_t(&h->kvp_containers, kvec);
+	return kvec.srlztn_handle;
 }
 
-bool pke_deserialize_ui_box(srlztn_deserialize_helper *h) {
+void pke_deserialize_ui_box(srlztn_deserialize_helper *h, pke_kve_container *kvec) {
+
+	/* How this works, a concrete example
+	 *
+	 * wrapper box > type_text box > { type_text data + FRSettings }
+	 *
+	 * 1. wrapper box parse & create
+	 * 2. box_type text starts parse
+	 *  a. parse type_data (one child only) (by reference)
+	 *   1. parse font-render settings (by reference)
+	 *
+	 */
+
+	uint32_t i;
 	uint64_t prefix_len;
 	PK_STN_RES res;
 	char *stn_end;
 	pke_ui_box bx{};
 	pke_ui_box *parent_box = nullptr;
-	void *type_data = nullptr;
-	memset(&bx, 0, sizeof(pke_ui_box));
 	bx.type_data = nullptr;
-	while (h->i->getline(h->read_line, h->read_line_len)) {
-		if (strstr(SRLZTN_OBJ_END, h->read_line)) {
-			pke_ui_box *box;
-			if (parent_box == nullptr) {
-				box = pke_ui_box_new_root(bx.type, bx.uuid);
-			} else {
-				box = pke_ui_box_new_child(parent_box, bx.type, bx.uuid);
-			}
-			box->flags = bx.flags;
-			box->pos_top_left_x = bx.pos_top_left_x;
-			box->pos_top_left_y = bx.pos_top_left_y;
-			box->min_width = bx.min_width;
-			box->min_height = bx.min_height;
-			box->max_width = bx.max_width;
-			box->max_height = bx.max_height;
-			box->flex_weight = bx.flex_weight;
-			box->type = bx.type;
-			box->flex_direction = bx.flex_direction;
-			box->layer = bx.layer;
-			return true;
-		}
-		if (strstr(SRLZTN_UI_BOX_UUID, h->read_line)) {
+
+	for (i = 0; i < kvec->arr.next; ++i) {
+		if (strstr(SRLZTN_UI_BOX_UUID, kvec->arr[i].key)) {
 			prefix_len = strlen(SRLZTN_UI_BOX_UUID);
-			(h->read_line + prefix_len) >> bx.uuid;
+			(kvec->arr[i].val + prefix_len) >> bx.uuid;
 			continue;
 		}
-		if (strstr(SRLZTN_UI_BOX_PARENT_UUID, h->read_line)) {
+		if (strstr(SRLZTN_UI_BOX_PARENT_UUID, kvec->arr[i].key)) {
 			uint32_t target_instance_index = -1;
 			pk_uuid id;
 			prefix_len = strlen(SRLZTN_UI_BOX_PARENT_UUID);
-			(h->read_line + prefix_len) >> id;
+			(kvec->arr[i].val + prefix_len) >> id;
 			target_instance_index = pk_arr_find_first_index(&h->mapping, &id, srlztn_mapping_find_first_handle_by_uuid);
 			if (target_instance_index != uint32_t(-1)) {
 				parent_box = static_cast<pke_ui_box*>(h->mapping[target_instance_index].created_entity);
 			}
 			continue;
 		}
-		if (strstr(SRLZTN_UI_BOX_FLAGS, h->read_line)) {
+		if (strstr(SRLZTN_UI_BOX_FLAGS, kvec->arr[i].key)) {
 			prefix_len = strlen(SRLZTN_UI_BOX_FLAGS);
 			PKE_UI_BOX_FLAG_T flags;
-			res = pk_stn(&flags, h->read_line + prefix_len, &stn_end);
+			res = pk_stn(&flags, kvec->arr[i].val + prefix_len, &stn_end);
 			if (res != PK_STN_RES_SUCCESS) {
 				fprintf(stderr, "[pke_deserialize_ui_box] Failed to parse value for: '%s', err: %i", SRLZTN_UI_BOX_FLAGS, res);
 				continue;
@@ -129,90 +236,90 @@ bool pke_deserialize_ui_box(srlztn_deserialize_helper *h) {
 			bx.flags = PKE_UI_BOX_FLAG(flags);
 			continue;
 		}
-		if (strstr(SRLZTN_UI_BOX_POS_TOP_LEFT_X, h->read_line)) {
+		if (strstr(SRLZTN_UI_BOX_POS_TOP_LEFT_X, kvec->arr[i].key)) {
 			prefix_len = strlen(SRLZTN_UI_BOX_POS_TOP_LEFT_X);
-			res = pk_stn(&bx.pos_top_left_x, h->read_line + prefix_len, &stn_end);
+			res = pk_stn(&bx.pos_top_left_x, kvec->arr[i].val + prefix_len, &stn_end);
 			if (res != PK_STN_RES_SUCCESS) {
 				fprintf(stderr, "[pke_deserialize_ui_box] Failed to parse value for: '%s', err: %i", SRLZTN_UI_BOX_POS_TOP_LEFT_X, res);
 				continue;
 			}
 			continue;
 		}
-		if (strstr(SRLZTN_UI_BOX_POS_TOP_LEFT_Y, h->read_line)) {
+		if (strstr(SRLZTN_UI_BOX_POS_TOP_LEFT_Y, kvec->arr[i].key)) {
 			prefix_len = strlen(SRLZTN_UI_BOX_POS_TOP_LEFT_Y);
-			res = pk_stn(&bx.pos_top_left_y, h->read_line + prefix_len, &stn_end);
+			res = pk_stn(&bx.pos_top_left_y, kvec->arr[i].val + prefix_len, &stn_end);
 			if (res != PK_STN_RES_SUCCESS) {
 				fprintf(stderr, "[pke_deserialize_ui_box] Failed to parse value for: '%s', err: %i", SRLZTN_UI_BOX_POS_TOP_LEFT_Y, res);
 				continue;
 			}
 			continue;
 		}
-		if (strstr(SRLZTN_UI_BOX_MIN_WIDTH, h->read_line)) {
+		if (strstr(SRLZTN_UI_BOX_MIN_WIDTH, kvec->arr[i].key)) {
 			prefix_len = strlen(SRLZTN_UI_BOX_MIN_WIDTH);
-			res = pk_stn(&bx.min_width, h->read_line + prefix_len, &stn_end);
+			res = pk_stn(&bx.min_width, kvec->arr[i].val + prefix_len, &stn_end);
 			if (res != PK_STN_RES_SUCCESS) {
 				fprintf(stderr, "[pke_deserialize_ui_box] Failed to parse value for: '%s', err: %i", SRLZTN_UI_BOX_MIN_WIDTH, res);
 				continue;
 			}
 			continue;
 		}
-		if (strstr(SRLZTN_UI_BOX_MIN_HEIGHT, h->read_line)) {
+		if (strstr(SRLZTN_UI_BOX_MIN_HEIGHT, kvec->arr[i].key)) {
 			prefix_len = strlen(SRLZTN_UI_BOX_MIN_HEIGHT);
-			res = pk_stn(&bx.min_width, h->read_line + prefix_len, &stn_end);
+			res = pk_stn(&bx.min_width, kvec->arr[i].val + prefix_len, &stn_end);
 			if (res != PK_STN_RES_SUCCESS) {
 				fprintf(stderr, "[pke_deserialize_ui_box] Failed to parse value for: '%s', err: %i", SRLZTN_UI_BOX_MIN_HEIGHT, res);
 				continue;
 			}
 			continue;
 		}
-		if (strstr(SRLZTN_UI_BOX_MAX_WIDTH, h->read_line)) {
+		if (strstr(SRLZTN_UI_BOX_MAX_WIDTH, kvec->arr[i].key)) {
 			prefix_len = strlen(SRLZTN_UI_BOX_MAX_WIDTH);
-			res = pk_stn(&bx.max_width, h->read_line + prefix_len, &stn_end);
+			res = pk_stn(&bx.max_width, kvec->arr[i].val + prefix_len, &stn_end);
 			if (res != PK_STN_RES_SUCCESS) {
 				fprintf(stderr, "[pke_deserialize_ui_box] Failed to parse value for: '%s', err: %i", SRLZTN_UI_BOX_MAX_WIDTH, res);
 				continue;
 			}
 			continue;
 		}
-		if (strstr(SRLZTN_UI_BOX_MAX_HEIGHT, h->read_line)) {
+		if (strstr(SRLZTN_UI_BOX_MAX_HEIGHT, kvec->arr[i].key)) {
 			prefix_len = strlen(SRLZTN_UI_BOX_MAX_HEIGHT);
-			res = pk_stn(&bx.max_width, h->read_line + prefix_len, &stn_end);
+			res = pk_stn(&bx.max_width, kvec->arr[i].val + prefix_len, &stn_end);
 			if (res != PK_STN_RES_SUCCESS) {
 				fprintf(stderr, "[pke_deserialize_ui_box] Failed to parse value for: '%s', err: %i", SRLZTN_UI_BOX_MAX_HEIGHT, res);
 				continue;
 			}
 			continue;
 		}
-		if (strstr(SRLZTN_UI_BOX_FLEX_WEIGHT, h->read_line)) {
+		if (strstr(SRLZTN_UI_BOX_FLEX_WEIGHT, kvec->arr[i].key)) {
 			prefix_len = strlen(SRLZTN_UI_BOX_FLEX_WEIGHT);
-			res = pk_stn(&bx.flex_weight, h->read_line + prefix_len, &stn_end);
+			res = pk_stn(&bx.flex_weight, kvec->arr[i].val + prefix_len, &stn_end);
 			if (res != PK_STN_RES_SUCCESS) {
 				fprintf(stderr, "[pke_deserialize_ui_box] Failed to parse value for: '%s', err: %i", SRLZTN_UI_BOX_FLEX_WEIGHT, res);
 				continue;
 			}
 			continue;
 		}
-		if (strstr(SRLZTN_UI_BOX_FLEX_DIRECTION, h->read_line)) {
+		if (strstr(SRLZTN_UI_BOX_FLEX_DIRECTION, kvec->arr[i].key)) {
 			prefix_len = strlen(SRLZTN_UI_BOX_FLEX_DIRECTION);
-			res = pk_stn(&bx.flex_direction, h->read_line + prefix_len, &stn_end);
+			res = pk_stn(&bx.flex_direction, kvec->arr[i].val + prefix_len, &stn_end);
 			if (res != PK_STN_RES_SUCCESS) {
 				fprintf(stderr, "[pke_deserialize_ui_box] Failed to parse value for: '%s', err: %i", SRLZTN_UI_BOX_FLEX_DIRECTION, res);
 				continue;
 			}
 			continue;
 		}
-		if (strstr(SRLZTN_UI_BOX_LAYER, h->read_line)) {
+		if (strstr(SRLZTN_UI_BOX_LAYER, kvec->arr[i].key)) {
 			prefix_len = strlen(SRLZTN_UI_BOX_LAYER);
-			res = pk_stn(&bx.layer, h->read_line + prefix_len, &stn_end);
+			res = pk_stn(&bx.layer, kvec->arr[i].val + prefix_len, &stn_end);
 			if (res != PK_STN_RES_SUCCESS) {
 				fprintf(stderr, "[pke_deserialize_ui_box] Failed to parse value for: '%s', err: %i", SRLZTN_UI_BOX_LAYER, res);
 				continue;
 			}
 			continue;
 		}
-		if (strstr(SRLZTN_UI_BOX_TYPE, h->read_line)) {
+		if (strstr(SRLZTN_UI_BOX_TYPE, kvec->arr[i].key)) {
 			prefix_len = strlen(SRLZTN_UI_BOX_TYPE);
-			res = pk_stn(&bx.type, h->read_line + prefix_len, &stn_end);
+			res = pk_stn(&bx.type, kvec->arr[i].val + prefix_len, &stn_end);
 			if (res != PK_STN_RES_SUCCESS) {
 				fprintf(stderr, "[pke_deserialize_ui_box] Failed to parse value for: '%s', err: %i", SRLZTN_UI_BOX_TYPE, res);
 				continue;
@@ -220,26 +327,68 @@ bool pke_deserialize_ui_box(srlztn_deserialize_helper *h) {
 			// TODO specific bucket?
 			switch (bx.type) {
 				case PKE_UI_BOX_TYPE_TEXT:
-					type_data = pk_new<pke_ui_box_type_data_text>();
 					break;
 				default:
-					fprintf(stderr, "[pke_deserialize_ui_box] Parsed unknown ui box data type from: '%s'", h->read_line);
+					fprintf(stderr, "[pke_deserialize_ui_box] Parsed unknown ui box data type from: '%s'", kvec->arr[i].val);
 					continue;
 			}
 			continue;
 		}
-		// TODO something isn't right here, too much room for parsing mistakes
-		if (bx.type != PKE_UI_BOX_TYPE_STANDARD && type_data != nullptr) {
-			switch (bx.type) {
-				case PKE_UI_BOX_TYPE_TEXT:
-					if (pke_deserialize_ui_box_internal(h, reinterpret_cast<pke_ui_box_type_data_text *>(bx.type_data))) {
-						continue;
-					}
-					break;
-				default:
-					continue;
-			}
+	}
+
+	// get ready to deserialize children
+	if (bx.type != PKE_UI_BOX_TYPE_STANDARD) {
+		switch (bx.type) {
+			case PKE_UI_BOX_TYPE_TEXT:
+				bx.type_data = pk_new<pke_ui_box_type_data_text>();
+				break;
+			default:
+				break;
+		}
+	}
+
+	// deserialize children
+	for (i = 0; i < kvec->children.next; ++i) {
+		pke_kve_container *child_kvec = kvec->children[i];
+		if (strcmp(child_kvec->type_code.val, SRLZTN_OBJ_UI_BOX_TYPE_DATA) == 0) {
+			pke_deserialize_ui_box_internal(h, child_kvec, static_cast<pke_ui_box_type_data_text*>(bx.type_data));
+		}
+	}
+
+	pke_ui_box *box;
+	if (parent_box == nullptr) {
+		box = pke_ui_box_new_root(bx.type, bx.uuid);
+	} else {
+		box = pke_ui_box_new_child(parent_box, bx.type, bx.uuid);
+	}
+	box->flags = bx.flags;
+	box->pos_top_left_x = bx.pos_top_left_x;
+	box->pos_top_left_y = bx.pos_top_left_y;
+	box->min_width = bx.min_width;
+	box->min_height = bx.min_height;
+	box->max_width = bx.max_width;
+	box->max_height = bx.max_height;
+	box->flex_weight = bx.flex_weight;
+	box->type = bx.type;
+	box->flex_direction = bx.flex_direction;
+	box->layer = bx.layer;
+
+	// TODO clone functions?
+	// might not be necessary if we refactor deserialization into their own ctors
+	if (bx.type != PKE_UI_BOX_TYPE_STANDARD) {
+		switch (bx.type) {
+			case PKE_UI_BOX_TYPE_TEXT:
+				reinterpret_cast<pke_ui_box_type_data_text*>(box->type_data  )->font_render_uuid
+					= reinterpret_cast<pke_ui_box_type_data_text*>(bx.type_data)->font_render_uuid;
+				reinterpret_cast<pke_ui_box_type_data_text*>(box->type_data  )->font_render_handle
+					= reinterpret_cast<pke_ui_box_type_data_text*>(bx.type_data)->font_render_handle;
+				reinterpret_cast<pke_ui_box_type_data_text*>(box->type_data  )->font_render_settings
+					= reinterpret_cast<pke_ui_box_type_data_text*>(bx.type_data)->font_render_settings;
+				break;
+			default:
+				break;
 		}
 	}
-	return false;
+
+	return;
 }
diff --git a/src/serialization-static-ui.hpp b/src/serialization-static-ui.hpp
index 9026c5d..19a5c6c 100644
--- a/src/serialization-static-ui.hpp
+++ b/src/serialization-static-ui.hpp
@@ -4,7 +4,7 @@
 #include "static-ui.hpp"
 #include "serialization.hpp"
 
-bool pke_serialize_ui_box(srlztn_serialize_helper *h, pke_ui_box *box);
-bool pke_deserialize_ui_box(srlztn_deserialize_helper *h);
+pk_handle pke_serialize_ui_box(srlztn_serialize_helper *h, pke_ui_box *box);
+void pke_deserialize_ui_box(srlztn_deserialize_helper *h, pke_kve_container *kvec);
 
 #endif /* PKE_SERIALIZATION_STATIC_UI_HPP */
diff --git a/src/serialization.cpp b/src/serialization.cpp
index b41c70d..bc5fb44 100644
--- a/src/serialization.cpp
+++ b/src/serialization.cpp
@@ -1,5 +1,6 @@
 
 #include "serialization.hpp"
+#include "pk.h"
 #include "serialization-component.hpp"
 #include "serialization-camera.hpp"
 #include "camera.hpp"
@@ -9,21 +10,27 @@ bool srlztn_mapping_find_first_handle_by_uuid(void *handle, void *mapping) {
 	srlztn_instance_mapping *inst_mapping = reinterpret_cast<srlztn_instance_mapping *>(mapping);
 	return inst_mapping->serialized_uuid == *reinterpret_cast<pk_uuid *>(handle);
 }
+bool srlztn_kvec_find_first_by_handle(void *handle, void *container) {
+	pke_kve_container *kvec = reinterpret_cast<pke_kve_container*>(container);
+	return kvec->srlztn_handle == *reinterpret_cast<pk_handle*>(handle);
+}
 
 srlztn_serialize_helper *pke_serialize_init(pk_membucket *bkt) {
 	srlztn_serialize_helper *helper = pk_new<srlztn_serialize_helper>(bkt);
 	// TODO custom allocator
-	helper->o = {};
+	// helper->o = {};
 	helper->bkt = bkt;
+	helper->kvp_containers.bkt = bkt;
 	return helper;
 }
 
 srlztn_deserialize_helper *pke_deserialize_init(pk_membucket *bkt) {
 	srlztn_deserialize_helper *helper = pk_new<srlztn_deserialize_helper>(bkt);
 	helper->bkt = bkt;
-	helper->read_line = nullptr;
+	// helper->read_line = nullptr;
 	// TODO custom allocator
-	helper->mapping = {bkt};
+	// helper->mapping = {bkt};
+	helper->kvp_containers.bkt = bkt;
 	return helper;
 }
 
@@ -35,19 +42,27 @@ void pke_deserialize_teardown(srlztn_deserialize_helper *helper) {
 	(void)helper;
 }
 
-void pke_serialize_file_project(srlztn_serialize_helper *h) {
+void pke_serialize_project(srlztn_serialize_helper *h) {
 	(void)h;
 }
-
-void pke_deserialize_file_project(srlztn_deserialize_helper *h) {
+void pke_deserialize_project(srlztn_deserialize_helper *h) {
 	(void)h;
 }
+void pke_serialize_project_to_stream(std::ostream &o, srlztn_serialize_helper *helper) {
+	(void)o;
+	(void)helper;
+}
+void pke_deserialize_project_from_stream(std::istream &i, srlztn_deserialize_helper *helper) {
+	(void)i;
+	(void)helper;
+}
 
-void pke_serialize_file_scene(srlztn_serialize_helper *h) {
-	h->o << SRLZTN_FILE_BEGIN << std::endl;
-	h->o << SRLZTN_FILE_VERSION << std::endl;
-	h->o << "" << std::endl;
-
+void pke_serialize_scene(srlztn_serialize_helper *h) {
+	pke_kve_container kvec = {};
+	kvec.bkt = h->bkt;
+	kvec.arr.bkt = h->bkt;
+	kvec.children.bkt = h->bkt;
+	kvec.type_code = cstring_to_pk_cstr(SRLZTN_OBJ_INSTANCE);
 	pk_handle_bucket_index_T instanceBucketCount = ECS_GetInstances_BucketCount();
 	for (pk_handle_bucket_index_T b = 0; b < instanceBucketCount; ++b) {
 		pk_handle_item_index_T count;
@@ -59,12 +74,12 @@ void pke_serialize_file_scene(srlztn_serialize_helper *h) {
 			if (PK_HAS_FLAG(instance.comp_instance_flags, COMPONENT_INSTANCE_FLAG_DO_NOT_SERIALIZE)) {
 				continue;
 			}
-			h->o << SRLZTN_OBJ_INSTANCE << std::endl;
 			pke_serialize_instance(h, &instance);
-			h->o << SRLZTN_OBJ_END << std::endl;
+			pk_arr_append_t(&h->kvp_containers, kvec);
 		}
 	}
 
+	kvec.type_code = cstring_to_pk_cstr(SRLZTN_OBJ_CAMERA);
 	pk_handle_bucket_index_T cameraBucketCount = PkeCamera_GetBucketCount();
 	for (pk_handle_bucket_index_T b = 0; b < cameraBucketCount; ++b) {
 		pk_handle_item_index_T count;
@@ -73,34 +88,202 @@ void pke_serialize_file_scene(srlztn_serialize_helper *h) {
 			const auto &cam = cameras[i];
 			if (cam.handle == CameraHandle_MAX)
 				continue;
-			h->o << SRLZTN_OBJ_CAMERA << std::endl;
 			pke_serialize_camera(h, &cam);
-			h->o << SRLZTN_OBJ_END << std::endl;
+			pk_arr_append_t(&h->kvp_containers, kvec);
+		}
+	}
+}
+void pke_deserialize_scene(srlztn_deserialize_helper *h) {
+	uint32_t i;
+	pke_kve_container *kvec;
+
+	for (i = 0; i < h->kvp_containers.next; ++i) {
+		kvec = &h->kvp_containers[i];
+		if (strcmp(SRLZTN_OBJ_INSTANCE, kvec->type_code.val) == 0) {
+			pke_deserialize_instance(h, kvec);
+			continue;
+		}
+		if (strcmp(SRLZTN_OBJ_CAMERA, kvec->type_code.val) == 0) {
+			pke_deserialize_camera(h, kvec);
+			continue;
 		}
 	}
 
-	h->o << SRLZTN_FILE_END << std::endl;
 }
-void pke_deserialize_file_scene(srlztn_deserialize_helper *h) {
-	h->read_line = pk_new<char>(h->read_line_len, h->bkt);
-	memset(h->read_line, '\0', h->read_line_len);
+void pke_serialize_scene_to_stream(std::ostream &o, srlztn_serialize_helper *h) {
+	uint32_t i, k;
+	pke_kve_container *kvec;
+	pke_kve *kve;
+	o << SRLZTN_FILE_BEGIN << std::endl;
+	o << SRLZTN_FILE_VERSION << std::endl;
+	o << "" << std::endl;
 
-	while (h->i->getline(h->read_line, h->read_line_len)) {
-		if (strcmp(SRLZTN_OBJ_INSTANCE, h->read_line) == 0) {
-			pke_deserialize_instance(h);
+	for (i = 0; i < h->kvp_containers.next; ++i) {
+		kvec = &h->kvp_containers[i];
+		o << kvec->type_code.val;
+		o << std::setw(8) << std::setfill('0') << std::setbase(16) << kvec->srlztn_handle.bucketIndex;
+		o << SRLZTN_HANDLE_SEPARATOR;
+		o << std::setw(8) << std::setfill('0') << std::setbase(16) << kvec->srlztn_handle.itemIndex;
+		o << std::setbase(0) << std::setw(0) << std::endl;
+		for (k = 0; k < kvec->child_handles.next; ++k) {
+			o << SRLZTN_CHILD_ID;
+			o << std::setw(8) << std::setfill('0') << std::setbase(16) << kvec->srlztn_handle.bucketIndex;
+			o << SRLZTN_HANDLE_SEPARATOR;
+			o << std::setw(8) << std::setfill('0') << std::setbase(16) << kvec->srlztn_handle.itemIndex;
+			o << std::setbase(0) << std::setw(0) << std::endl;
+		}
+		for (k = 0; k < kvec->arr.next; ++k) {
+			kve = &kvec->arr[k];
+			o << kve->key << kve->val << kve->end << std::endl;
+		}
+		o << SRLZTN_OBJ_END << std::endl;
+	}
+
+	o << SRLZTN_FILE_END << std::endl;
+}
+void pke_deserialize_scene_from_stream(std::istream &i, srlztn_deserialize_helper *h) {
+	// 0: new object
+	// 1: new kve
+	// 2: multiline kve start
+	// 3: multiline kve in progress
+	uint8_t state = 0;
+	size_t read_line_len = 128;
+	size_t offset = 0;
+	PK_STN_RES res;
+	char *read_line = pk_new<char>(read_line_len, h->bkt);
+	memset(read_line, '\0', read_line_len);
+	char *s, *rl;
+	pk_handle handle;
+	pke_kve_container kvec;
+	pke_kve kve;
+	kvec.bkt = h->bkt;
+	kvec.arr.bkt = h->bkt;
+	kvec.children.bkt = h->bkt;
+
+	i.getline(read_line, read_line_len);
+	assert(strstr(read_line, SRLZTN_FILE_BEGIN) != 0);
+	i.getline(read_line, read_line_len);
+	assert(strstr(read_line, SRLZTN_FILE_VERSION) != 0);
+
+	while (i.getline(read_line, read_line_len)) {
+		if (strlen(read_line) == 0 && state != 1) continue;
+		if (strstr(read_line, SRLZTN_FILE_END) == read_line) continue;
+		// new object
+		if (state == 0) {
+			// obj_type:FFFFFFFF!FFFFFFFF
+			read_line[strchr(read_line, ':') - read_line] = '\0';
+			offset = strlen(read_line) + 1;
+			read_line[strchr(read_line + offset, '!') - read_line] = '\0';
+			kvec.type_code.length = strlen(read_line);
+			kvec.type_code.reserved = kvec.type_code.length + 1;
+			s = pk_new<char>(kvec.type_code.reserved, h->bkt);
+			sprintf(s, "%s", read_line);
+			kvec.type_code.val = s;
+			rl = read_line + strlen(read_line) + 1;
+			res = pk_stn(&handle.bucketIndex, rl, NULL);
+			assert(res == PK_STN_RES_SUCCESS);
+			rl += 9;
+			res = pk_stn(&handle.itemIndex, rl, &s, 16);
+			assert(res == PK_STN_RES_SUCCESS);
+			state = 1;
+			kvec.srlztn_handle = handle;
 			continue;
 		}
-		if (strcmp(SRLZTN_OBJ_CAMERA, h->read_line) == 0) {
-			pke_deserialize_camera(h);
+		if (state == 1 && strstr(read_line, SRLZTN_CHILD_ID)) {
+			rl = read_line + strlen(SRLZTN_CHILD_ID) + 1;
+			res = pk_stn(&handle.bucketIndex, rl, NULL);
+			assert(res == PK_STN_RES_SUCCESS);
+			rl += 9;
+			res = pk_stn(&handle.itemIndex, rl, &s, 16);
+			assert(res == PK_STN_RES_SUCCESS);
+			state = 1;
+			pk_arr_append_t(&kvec.child_handles, handle);
+			continue;
+		} else if (state == 1 && strlen(read_line) > 0) { // kve start
+			offset = strchr(read_line, ':') - read_line;
+			s = pk_new<char>(strlen(read_line) + 1);
+			sprintf(s, "%.*s", (int)offset+1, read_line);
+			kve.key = s;
+			if (strstr(read_line, "::")) {
+				state = 2;
+				continue;
+			}
+			read_line[offset] = '\0';
+			rl = read_line + offset + 1;
+			s = pk_new<char>(strlen(rl) + 1);
+			sprintf(s, "%s", rl);
+			kve.val = s;
+			kve.end = SRLZTN_KVE_END;
+			pk_arr_append_t(&kvec.arr, kve);
+			continue;
+		}
+		// multiline
+		if (state == 2) {
+			s = pk_new<char>(strlen(read_line) + 1, h->bkt);
+			sprintf(s, "%s", read_line);
+			state = 3;
+			continue;
+		}
+		if (state == 3) {
+			rl = pk_new<char>(strlen(s) + strlen(read_line) + 1, h->bkt);
+			sprintf(rl, "%s%s", s, read_line);
+			pk_delete<char>(s, strlen(s) + 1, h->bkt);
+			s = rl;
 			continue;
 		}
+		// multiline end
+		if (strstr(read_line, SRLZTN_MULTILINE_END)) {
+			assert(state >= 2);
+			kve.end = SRLZTN_MULTILINE_END;
+			pk_arr_append_t(&kvec.arr, kve);
+			state = 1;
+			continue;
+		}
+		// end of object
+		if (state != 2) {
+			state = 0;
+			if (kvec.type_code.val != nullptr) {
+				pk_arr_append_t(&h->kvp_containers, kvec);
+			}
+			kvec.type_code.val = nullptr;
+			kvec.type_code.length = 0;
+			kvec.type_code.reserved = 0;
+			pk_arr_reset(&kvec.arr);
+			pk_arr_reset(&kvec.children);
+		}
 	}
+
+	for (uint32_t c = 0; c < h->kvp_containers.next; ++c) {
+		pke_kve_container *parent = &h->kvp_containers[c];
+		if (parent->child_handles.next == 0 || parent->child_handles.next == parent->children.next) {
+			continue;
+		}
+		for (uint32_t cc = 0; cc < c; ++cc) {
+			pke_kve_container *child = &h->kvp_containers[cc];
+			for (uint32_t ch = 0; ch < parent->child_handles.next; ++ch) {
+				if (child->srlztn_handle == parent->child_handles[ch]) {
+					pk_arr_append_t(&parent->children, child);
+					break;
+				}
+			}
+		}
+	}
+
+	pk_delete<char>(read_line, read_line_len, h->bkt);
 }
 
-void pke_serialize_file_level(srlztn_serialize_helper *h) {
+void pke_serialize_level(srlztn_serialize_helper *h) {
 	(void)h;
 }
-void pke_deserialize_file_level(srlztn_deserialize_helper *h) {
+void pke_deserialize_level(srlztn_deserialize_helper *h) {
 	(void)h;
 }
+void pke_serialize_level_to_stream(std::ostream &o, srlztn_serialize_helper *helper) {
+	(void)o;
+	(void)helper;
+}
+void pke_deserialize_level_from_stream(std::istream &i, srlztn_deserialize_helper *helper) {
+	(void)i;
+	(void)helper;
+}
 
diff --git a/src/serialization.hpp b/src/serialization.hpp
index b6d2bfa..3b74428 100644
--- a/src/serialization.hpp
+++ b/src/serialization.hpp
@@ -1,63 +1,74 @@
 #ifndef PKE_SERIALIZATION_HPP
 #define PKE_SERIALIZATION_HPP
 
+#include "kve.hpp"
 #include "pk.h"
 #include "components.hpp"
 #include "scene-types.hpp"
 
-inline const char* const SRLZTN_FILE_BEGIN              = ":PKFB:";
-inline const char* const SRLZTN_FILE_END                = ":PKFE:";
-inline const char* const SRLZTN_FILE_VERSION            = ":0:";
-inline const char* const SRLZTN_FILE_NUM_SEPARATOR      = ";";
-
-inline const char* const SRLZTN_OBJ_END                 = "";
-inline const char* const SRLZTN_OBJ_INSTANCE            = "Instance:";
-inline const char* const SRLZTN_OBJ_CAMERA              = "Camera:";
-inline const char* const SRLZTN_OBJ_UI_BOX              = "Camera:";
-
-inline const char* const SRLZTN_POSROT_POS              = "Position: ";
-inline const char* const SRLZTN_POSROT_ROT              = "Rotation: ";
-inline const char* const SRLZTN_POSROT_SCALE            = "Scale: ";
-
-inline const char* const SRLZTN_INSTANCE_COMPONENT_HANDLE           = "InstanceHandle: ";
-inline const char* const SRLZTN_INSTANCE_COMPONENT_ENTITY_HANDLE    = "EntityHandle: ";
-inline const char* const SRLZTN_INSTANCE_COMPONENT_ENTITY_TYPE_CODE = "EntityTypeCode: ";
-inline const char* const SRLZTN_INSTANCE_COMPONENT_UUID             = "UUID: ";
-inline const char* const SRLZTN_INSTANCE_COMPONENT_MASS             = "Mass: ";
-inline const char* const SRLZTN_INSTANCE_COMPONENT_COLLISION_LAYER  = "CollisionLayer: ";
-inline const char* const SRLZTN_INSTANCE_COMPONENT_COLLISION_MASK   = "CollisionMask: ";
-inline const char* const SRLZTN_INSTANCE_COMPONENT_COLLISION_CB_SIGNATURE = "CollisionCBSignature: ";
-
-inline const char* const SRLZTN_CAMERA_TYPE                   = "Type: ";
-inline const char* const SRLZTN_CAMERA_UUID                   = "UUID: ";
-inline const char* const SRLZTN_CAMERA_ORIENTATION            = "Orientation: ";
-inline const char* const SRLZTN_CAMERA_TARGET_INSTANCE_UUID   = "TargetUUID: ";
-inline const char* const SRLZTN_CAMERA_IS_PRIMARY             = "IsPrimary: ";
-
-inline const char* const SRLZTN_UI_BOX_UUID                   = "UUID: ";
-inline const char* const SRLZTN_UI_BOX_PARENT_UUID            = "ParentUUID: ";
-inline const char* const SRLZTN_UI_BOX_FLAGS                  = "Flags: ";
-inline const char* const SRLZTN_UI_BOX_POS_TOP_LEFT_X         = "PosTopLeftX: ";
-inline const char* const SRLZTN_UI_BOX_POS_TOP_LEFT_Y         = "PosTopLeftY: ";
-inline const char* const SRLZTN_UI_BOX_MIN_WIDTH              = "MinWidthX: ";
-inline const char* const SRLZTN_UI_BOX_MIN_HEIGHT             = "MinWidthY: ";
-inline const char* const SRLZTN_UI_BOX_MAX_WIDTH              = "MaxWidthX: ";
-inline const char* const SRLZTN_UI_BOX_MAX_HEIGHT             = "MaxWidthY: ";
-inline const char* const SRLZTN_UI_BOX_FLEX_WEIGHT            = "FlexWeight: ";
-inline const char* const SRLZTN_UI_BOX_TYPE                   = "Type: ";
-inline const char* const SRLZTN_UI_BOX_FLEX_DIRECTION         = "FlexDirection: ";
-inline const char* const SRLZTN_UI_BOX_LAYER                  = "Layer: ";
-inline const char* const SRLZTN_UI_BOX_DATA_TEXT_FONT_RENDER_UUID = "FontRenderUUID: ";
-
-inline const char* const SRLZTN_UI_FONT_RENDER_UUID                        = "UUID: ";
-inline const char* const SRLZTN_UI_FONT_RENDER_TEXT_BEGIN                  = "TextBegin::";
-inline const char* const SRLZTN_UI_FONT_RENDER_TEXT_END                    = "::TextEnd";
-inline const char* const SRLZTN_UI_FONT_RENDER_SETTINGS_CHAR_SCALE         = "CharScale";
-inline const char* const SRLZTN_UI_FONT_RENDER_SETTINGS_LINE_HEIGHT_SCALE  = "LineHeightScale";
-inline const char* const SRLZTN_UI_FONT_RENDER_SETTINGS_CHAR_SPACING_SCALE = "CharSpacingScale";
-inline const char* const SRLZTN_UI_FONT_RENDER_SETTINGS_SURFACE_AREA_SIZE  = "SurfaceAreaSize";
-inline const char* const SRLZTN_UI_FONT_RENDER_SETTINGS_SURFACE_AREA_POS   = "SurfaceAreaPos";
-inline const char* const SRLZTN_UI_FONT_RENDER_SETTINGS_SURFACE_AREA_FLAGS = "SurfaceAreaFlags";
+#define iccsc inline const char* const
+
+iccsc SRLZTN_FILE_BEGIN                          = ":PKFB:";
+iccsc SRLZTN_FILE_END                            = ":PKFE:";
+iccsc SRLZTN_FILE_VERSION                        = ":0:";
+
+iccsc SRLZTN_NUM_SEPARATOR                       = ";";
+iccsc SRLZTN_HANDLE_SEPARATOR                    = "!";
+iccsc SRLZTN_KVE_END                             = "";
+iccsc SRLZTN_MULTILINE_END                       = ":MULTILINE_END:";
+iccsc SRLZTN_CHILD_ID                            = "ChildId:";
+
+iccsc SRLZTN_OBJ_END                             = "";
+iccsc SRLZTN_OBJ_INSTANCE_POSITION               = "InstPos:";
+iccsc SRLZTN_OBJ_INSTANCE                        = "Instance:";
+iccsc SRLZTN_OBJ_CAMERA                          = "Camera:";
+iccsc SRLZTN_OBJ_UI_BOX                          = "UIBox:";
+iccsc SRLZTN_OBJ_FONT_RENDER                     = "FontRender:";
+iccsc SRLZTN_OBJ_FONT_RENDER_SETTINGS            = "FontRenderSettings:";
+iccsc SRLZTN_OBJ_UI_BOX_TYPE_DATA                = "UIBoxTypeData:";
+
+iccsc SRLZTN_POSROT_POS                          = "Position:";
+iccsc SRLZTN_POSROT_ROT                          = "Rotation:";
+iccsc SRLZTN_POSROT_SCALE                        = "Scale:";
+
+iccsc SRLZTN_INSTANCE_COMPONENT_HANDLE           = "InstanceHandle:";
+iccsc SRLZTN_INSTANCE_COMPONENT_ENTITY_HANDLE    = "EntityHandle:";
+iccsc SRLZTN_INSTANCE_COMPONENT_ENTITY_TYPE_CODE = "EntityTypeCode:";
+iccsc SRLZTN_INSTANCE_COMPONENT_UUID             = "UUID:";
+iccsc SRLZTN_INSTANCE_COMPONENT_MASS             = "Mass:";
+iccsc SRLZTN_INSTANCE_COMPONENT_COLLISION_LAYER  = "CollisionLayer:";
+iccsc SRLZTN_INSTANCE_COMPONENT_COLLISION_MASK   = "CollisionMask:";
+iccsc SRLZTN_INSTANCE_COMPONENT_COLLISION_CB_SIGNATURE = "CollisionCBSignature:";
+
+iccsc SRLZTN_CAMERA_TYPE                         = "Type:";
+iccsc SRLZTN_CAMERA_UUID                         = "UUID:";
+iccsc SRLZTN_CAMERA_ORIENTATION                  = "Orientation:";
+iccsc SRLZTN_CAMERA_TARGET_INSTANCE_UUID         = "TargetUUID:";
+iccsc SRLZTN_CAMERA_IS_PRIMARY                   = "IsPrimary:";
+
+iccsc SRLZTN_UI_BOX_UUID                         = "UUID:";
+iccsc SRLZTN_UI_BOX_PARENT_UUID                  = "ParentUUID:";
+iccsc SRLZTN_UI_BOX_FLAGS                        = "Flags:";
+iccsc SRLZTN_UI_BOX_POS_TOP_LEFT_X               = "PosTopLeftX:";
+iccsc SRLZTN_UI_BOX_POS_TOP_LEFT_Y               = "PosTopLeftY:";
+iccsc SRLZTN_UI_BOX_MIN_WIDTH                    = "MinWidthX:";
+iccsc SRLZTN_UI_BOX_MIN_HEIGHT                   = "MinWidthY:";
+iccsc SRLZTN_UI_BOX_MAX_WIDTH                    = "MaxWidthX:";
+iccsc SRLZTN_UI_BOX_MAX_HEIGHT                   = "MaxWidthY:";
+iccsc SRLZTN_UI_BOX_FLEX_WEIGHT                  = "FlexWeight:";
+iccsc SRLZTN_UI_BOX_TYPE                         = "Type:";
+iccsc SRLZTN_UI_BOX_FLEX_DIRECTION               = "FlexDirection:";
+iccsc SRLZTN_UI_BOX_LAYER                        = "Layer:";
+iccsc SRLZTN_UI_BOX_DATA_TEXT_FONT_RENDER_UUID   = "FontRenderUUID:";
+
+iccsc SRLZTN_UI_FONT_RENDER_UUID                        = "UUID:";
+iccsc SRLZTN_UI_FONT_RENDER_TEXT_BEGIN                  = "TextBegin::";
+iccsc SRLZTN_UI_FONT_RENDER_SETTINGS_CHAR_SCALE         = "CharScale:";
+iccsc SRLZTN_UI_FONT_RENDER_SETTINGS_LINE_HEIGHT_SCALE  = "LineHeightScale:";
+iccsc SRLZTN_UI_FONT_RENDER_SETTINGS_CHAR_SPACING_SCALE = "CharSpacingScale:";
+iccsc SRLZTN_UI_FONT_RENDER_SETTINGS_SURFACE_AREA_SIZE  = "SurfaceAreaSize:";
+iccsc SRLZTN_UI_FONT_RENDER_SETTINGS_SURFACE_AREA_POS   = "SurfaceAreaPos:";
+iccsc SRLZTN_UI_FONT_RENDER_SETTINGS_SURFACE_AREA_FLAGS = "SurfaceAreaFlags:";
 
 struct srlztn_instance_mapping {
 	pk_uuid serialized_uuid = pk_uuid_zed;
@@ -67,32 +78,42 @@ struct srlztn_instance_mapping {
 
 struct srlztn_serialize_helper {
 	pk_membucket *bkt;
-	std::ostringstream o;
+	// std::ostringstream o;
+	pk_arr_t<pke_kve_container> kvp_containers;
+	pk_handle handle_head;
 };
 
 struct srlztn_deserialize_helper {
-	size_t read_line_len = 256;
-	pke_scene *scene;
 	pk_membucket *bkt;
-	char *read_line;
-	std::istream *i;
+	// std::istream *i;
+	// size_t read_line_len = 256;
+	pke_scene *scene;
+	// char *read_line;
 	pk_arr_t<srlztn_instance_mapping> mapping;
+	pk_arr_t<pke_kve_container> kvp_containers;
 };
 
 bool srlztn_mapping_find_first_handle_by_uuid(void *handle, void *mapping);
+bool srlztn_kvec_find_first_by_handle(void *handle, void *container);
 
 srlztn_serialize_helper *pke_serialize_init(pk_membucket *bkt);
 srlztn_deserialize_helper *pke_deserialize_init(pk_membucket *bkt);
 void pke_serialize_teardown(srlztn_serialize_helper *helper);
 void pke_deserialize_teardown(srlztn_deserialize_helper *helper);
 
-void pke_serialize_file_project(srlztn_serialize_helper *helper);
-void pke_deserialize_file_project(srlztn_deserialize_helper *helper);
+void pke_serialize_project(srlztn_serialize_helper *helper);
+void pke_deserialize_project(srlztn_deserialize_helper *helper);
+void pke_serialize_project_to_stream(std::ostream &o, srlztn_serialize_helper *helper);
+void pke_deserialize_project_from_stream(std::istream &i, srlztn_deserialize_helper *helper);
 
-void pke_serialize_file_scene(srlztn_serialize_helper *helper);
-void pke_deserialize_file_scene(srlztn_deserialize_helper *helper);
+void pke_serialize_scene(srlztn_serialize_helper *helper);
+void pke_deserialize_scene(srlztn_deserialize_helper *helper);
+void pke_serialize_scene_to_stream(std::ostream &o, srlztn_serialize_helper *helper);
+void pke_deserialize_scene_from_stream(std::istream &i, srlztn_deserialize_helper *helper);
 
-void pke_serialize_file_level(srlztn_serialize_helper *helper);
-void pke_deserialize_file_level(srlztn_deserialize_helper *helper);
+void pke_serialize_level(srlztn_serialize_helper *helper);
+void pke_deserialize_level(srlztn_deserialize_helper *helper);
+void pke_serialize_level_to_stream(std::ostream &o, srlztn_serialize_helper *helper);
+void pke_deserialize_level_from_stream(std::istream &i, srlztn_deserialize_helper *helper);
 
 #endif /* PKE_SERIALIZATION_HPP */