diff --git a/.clang-format b/.clang-format
index 6205f67..710226b 100644
--- a/.clang-format
+++ b/.clang-format
@@ -112,9 +112,6 @@ SpacesInCStyleCastParentheses: false
 SpacesInParentheses: false
 SpacesInSquareBrackets: false
 Standard:        Cpp11
-StatementMacros: 
-  - Q_UNUSED
-  - QT_REQUIRE_VERSION
 TabWidth:        4
 UseTab:          ForContinuationAndIndentation
 ...
diff --git a/SConstruct b/SConstruct
index 706e9dc..eb1f0eb 100644
--- a/SConstruct
+++ b/SConstruct
@@ -29,10 +29,10 @@ def add_kel_source_files(self, sources, filetype, lib_env=None, shared=False, ta
             sources.append( self.StaticObject( target=target_name, source=path ) )
     pass
 
-env=Environment(CPPPATH=['#source/kelgin','#source','#','#driver'],
+env=Environment(ENV=os.environ, CPPPATH=['#source/kelgin','#source','#','#driver'],
     CXX='clang++',
     CPPDEFINES=['GIN_UNIX'],
-    CXXFLAGS=['-std=c++17','-g','-Wall','-Wextra'],
+    CXXFLAGS=['-std=c++20','-g','-Wall','-Wextra'],
     LIBS=['gnutls'])
 env.__class__.add_source_files = add_kel_source_files
 
diff --git a/source/kelgin/json.h b/source/kelgin/json.h
deleted file mode 100644
index 189a491..0000000
--- a/source/kelgin/json.h
+++ /dev/null
@@ -1,1094 +0,0 @@
-#pragma once
-
-#include "buffer.h"
-#include "message.h"
-#include "message_dynamic.h"
-
-#include "error.h"
-
-#include <cassert>
-#include <charconv>
-#include <sstream>
-#include <string_view>
-#include <tuple>
-
-#include <iostream>
-
-namespace gin {
-class JsonCodec {
-public:
-	struct Limits {
-		size_t depth;
-		size_t elements;
-
-		Limits() : depth{16}, elements{1024} {}
-		Limits(size_t d, size_t e) : depth{d}, elements{e} {}
-	};
-
-private:
-	bool isWhitespace(int8_t letter);
-
-	void skipWhitespace(Buffer &buffer);
-
-	Error decodeBool(DynamicMessageBool::Builder message, Buffer &buffer);
-
-	// Not yet clear if double or integer
-	Error decodeNumber(Own<DynamicMessage> &message, Buffer &buffer);
-
-	Error decodeNull(Buffer &buffer);
-
-	Error decodeValue(Own<DynamicMessage> &message, Buffer &buffer,
-					  const Limits &limits, Limits &counter);
-
-	Error decodeRawString(std::string &raw, Buffer &buffer);
-
-	Error decodeList(DynamicMessageList::Builder builder, Buffer &buffer,
-					 const Limits &limits, Limits &counter);
-
-	Error decodeStruct(DynamicMessageStruct::Builder message, Buffer &buffer,
-					   const Limits &limits, Limits &counter);
-
-	ErrorOr<Own<DynamicMessage>> decodeDynamic(Buffer &buffer,
-											   const Limits &limits);
-
-public:
-	template <typename T>
-	Error encode(typename T::Reader reader, Buffer &buffer);
-
-	template <typename T>
-	Error decode(typename T::Builder builder, Buffer &buffer,
-				 const Limits &limits = Limits{});
-};
-
-template <typename T> struct JsonEncodeImpl;
-
-template <typename T> struct JsonEncodeImpl<MessagePrimitive<T>> {
-	static Error encode(typename MessagePrimitive<T>::Reader data,
-						Buffer &buffer) {
-		std::string stringified = std::to_string(data.get());
-		Error error =
-			buffer.push(*reinterpret_cast<const uint8_t *>(stringified.data()),
-						stringified.size());
-		if (error.failed()) {
-			return error;
-		}
-		return noError();
-	}
-};
-
-template <> struct JsonEncodeImpl<MessagePrimitive<std::string>> {
-	static Error encode(typename MessagePrimitive<std::string>::Reader data,
-						Buffer &buffer) {
-		std::string str =
-			std::string{"\""} + std::string{data.get()} + std::string{"\""};
-		Error error = buffer.push(
-			*reinterpret_cast<const uint8_t *>(str.data()), str.size());
-		if (error.failed()) {
-			return error;
-		}
-		return noError();
-	}
-};
-
-template <> struct JsonEncodeImpl<MessagePrimitive<bool>> {
-	static Error encode(typename MessagePrimitive<bool>::Reader data,
-						Buffer &buffer) {
-		std::string str = data.get() ? "true" : "false";
-		Error error = buffer.push(
-			*reinterpret_cast<const uint8_t *>(str.data()), str.size());
-		if (error.failed()) {
-			return error;
-		}
-		return noError();
-	}
-};
-
-template <typename... T> struct JsonEncodeImpl<MessageList<T...>> {
-	template <size_t i = 0>
-	static typename std::enable_if<i == sizeof...(T), Error>::type
-	encodeMembers(typename MessageList<T...>::Reader data, Buffer &buffer) {
-		(void)data;
-		(void)buffer;
-		return noError();
-	}
-	template <size_t i = 0>
-		static typename std::enable_if <
-		i<sizeof...(T), Error>::type
-		encodeMembers(typename MessageList<T...>::Reader data, Buffer &buffer) {
-		if (data.template get<i>().isSetExplicitly()) {
-			{
-				Error error =
-					JsonEncodeImpl<typename ParameterPackType<i, T...>::type>::
-						encode(data.template get<i>(), buffer);
-				if (error.failed()) {
-					return error;
-				}
-			}
-		} else {
-			{
-				std::string_view str = "null";
-				Error error = buffer.push(
-					*reinterpret_cast<const uint8_t *>(str.data()), str.size());
-				if (error.failed()) {
-					return error;
-				}
-			}
-		}
-		if constexpr ((i + 1u) < sizeof...(T)) {
-			Error error = buffer.push(',');
-			if (error.failed()) {
-				return error;
-			}
-		}
-		{
-			Error error =
-				JsonEncodeImpl<MessageList<T...>>::encodeMembers<i + 1>(data,
-																		buffer);
-			if (error.failed()) {
-				return error;
-			}
-		}
-		return noError();
-	}
-
-	static Error encode(typename MessageList<T...>::Reader data,
-						Buffer &buffer) {
-		Error error = buffer.push('[');
-		if (error.failed()) {
-			return error;
-		}
-		error =
-			JsonEncodeImpl<MessageList<T...>>::encodeMembers<0>(data, buffer);
-		if (error.failed()) {
-			return error;
-		}
-		error = buffer.push(']');
-		if (error.failed()) {
-			return error;
-		}
-		return noError();
-	}
-};
-
-template <typename... V, typename... K>
-struct JsonEncodeImpl<MessageStruct<MessageStructMember<V, K>...>> {
-	template <size_t i = 0>
-	static typename std::enable_if<i == sizeof...(V), Error>::type
-	encodeMembers(
-		typename MessageStruct<MessageStructMember<V, K>...>::Reader data,
-		Buffer &buffer) {
-		(void)data;
-		(void)buffer;
-		return Error{};
-	}
-	template <size_t i = 0>
-		static typename std::enable_if <
-		i<sizeof...(V), Error>::type encodeMembers(
-			typename MessageStruct<MessageStructMember<V, K>...>::Reader data,
-			Buffer &buffer) {
-		{
-			Error error = buffer.push('\"');
-			if (error.failed()) {
-				return error;
-			}
-			std::string_view view = ParameterPackType<i, K...>::type::view();
-			error = buffer.push(*reinterpret_cast<const uint8_t *>(view.data()),
-								view.size());
-			if (error.failed()) {
-				return error;
-			}
-			error = buffer.push('\"');
-			if (error.failed()) {
-				return error;
-			}
-			error = buffer.push(':');
-			if (error.failed()) {
-				return error;
-			}
-		}
-		if (data.template get<i>().isSetExplicitly()) {
-			Error error =
-				JsonEncodeImpl<typename ParameterPackType<i, V...>::type>::
-					encode(data.template get<i>(), buffer);
-			if (error.failed()) {
-				return error;
-			}
-		} else {
-			std::string_view str = "null";
-			Error error = buffer.push(
-				*reinterpret_cast<const uint8_t *>(str.data()), str.size());
-			if (error.failed()) {
-				return error;
-			}
-		}
-		if constexpr ((i + 1u) < sizeof...(V)) {
-			Error error = buffer.push(',');
-			if (error.failed()) {
-				return error;
-			}
-		}
-		{
-			Error error =
-				JsonEncodeImpl<MessageStruct<MessageStructMember<V, K>...>>::
-					encodeMembers<i + 1>(data, buffer);
-			if (error.failed()) {
-				return error;
-			}
-		}
-		return noError();
-	}
-
-	static Error
-	encode(typename MessageStruct<MessageStructMember<V, K>...>::Reader data,
-		   Buffer &buffer) {
-		Error error = buffer.push('{');
-		if (error.failed()) {
-			return error;
-		}
-		error = JsonEncodeImpl<MessageStruct<MessageStructMember<V, K>...>>::
-			encodeMembers<0>(data, buffer);
-		if (error.failed()) {
-			return error;
-		}
-		error = buffer.push('}');
-		if (error.failed()) {
-			return error;
-		}
-		return noError();
-	}
-};
-
-template <typename... V, typename... K>
-struct JsonEncodeImpl<MessageUnion<MessageUnionMember<V, K>...>> {
-	template <size_t i = 0>
-	static typename std::enable_if<i == sizeof...(V), Error>::type encodeMember(
-		typename MessageUnion<MessageUnionMember<V, K>...>::Reader data,
-		Buffer &buffer) {
-		(void)data;
-		(void)buffer;
-		return noError();
-	}
-	template <size_t i = 0>
-		static typename std::enable_if <
-		i<sizeof...(V), Error>::type encodeMember(
-			typename MessageUnion<MessageUnionMember<V, K>...>::Reader reader,
-			Buffer &buffer) {
-		/// @todo only encode if alternative is set, skip in other cases
-		/// use holds_alternative
-
-		if (reader.template holdsAlternative<
-				typename ParameterPackType<i, K...>::type>()) {
-			{
-				Error error = buffer.push('{');
-				if (error.failed()) {
-					return error;
-				}
-			}
-			{
-				Error error = buffer.push('\"');
-				if (error.failed()) {
-					return error;
-				}
-				std::string_view view =
-					ParameterPackType<i, K...>::type::view();
-				error =
-					buffer.push(*reinterpret_cast<const uint8_t *>(view.data()),
-								view.size());
-				if (error.failed()) {
-					return error;
-				}
-				error = buffer.push('\"');
-				if (error.failed()) {
-					return error;
-				}
-				error = buffer.push(':');
-				if (error.failed()) {
-					return error;
-				}
-			}
-
-			Error error =
-				JsonEncodeImpl<typename ParameterPackType<i, V...>::type>::
-					encode(reader.template get<i>(), buffer);
-			if (error.failed()) {
-				return error;
-			}
-			{
-				Error error = buffer.push('}');
-				if (error.failed()) {
-					return error;
-				}
-			}
-			return noError();
-		}
-
-		Error error =
-			JsonEncodeImpl<MessageUnion<MessageUnionMember<V, K>...>>::
-				encodeMember<i + 1>(reader, buffer);
-		if (error.failed()) {
-			return error;
-		}
-
-		return noError();
-	}
-
-	static Error
-	encode(typename MessageUnion<MessageUnionMember<V, K>...>::Reader reader,
-		   Buffer &buffer) {
-		return encodeMember<0>(reader, buffer);
-	}
-};
-
-/*
- * For JSON decoding we need a dynamic layer where we can query information from
- */
-template <typename T> struct JsonDecodeImpl;
-
-template <typename T> struct JsonDecodeImpl<MessagePrimitive<T>> {
-	// static void decode(BufferView view, typename
-	// MessagePrimitive<T>::Builder){}
-	static Error decode(typename MessagePrimitive<T>::Builder,
-						DynamicMessage::DynamicReader) {
-
-		// This is also a valid null implementation :)
-		return noError();
-	}
-};
-template <> struct JsonDecodeImpl<MessagePrimitive<bool>> {
-	// static void decode(BufferView view, typename
-	// MessagePrimitive<T>::Builder){}
-	static Error decode(typename MessagePrimitive<bool>::Builder data,
-						DynamicMessage::DynamicReader reader) {
-		if (reader.type() != DynamicMessage::Type::Bool) {
-			return criticalError("Not a boolean");
-		}
-		DynamicMessageBool::Reader b_reader = reader.as<DynamicMessageBool>();
-		data.set(b_reader.get());
-		return noError();
-	}
-};
-template <> struct JsonDecodeImpl<MessagePrimitive<int64_t>> {
-	// static void decode(BufferView view, typename
-	// MessagePrimitive<T>::Builder){}
-	static Error decode(typename MessagePrimitive<int64_t>::Builder data,
-						DynamicMessage::DynamicReader reader) {
-		if (reader.type() != DynamicMessage::Type::Signed) {
-			return criticalError("Not an integer");
-		}
-		DynamicMessageSigned::Reader s_reader =
-			reader.as<DynamicMessageSigned>();
-		data.set(s_reader.get());
-		return noError();
-	}
-};
-template <> struct JsonDecodeImpl<MessagePrimitive<uint32_t>> {
-	// static void decode(BufferView view, typename
-	// MessagePrimitive<T>::Builder){}
-	static Error decode(typename MessagePrimitive<uint32_t>::Builder builder,
-						DynamicMessage::DynamicReader reader) {
-		if (reader.type() != DynamicMessage::Type::Signed) {
-			return criticalError("Not an integer");
-		}
-		DynamicMessageSigned::Reader s_reader =
-			reader.as<DynamicMessageSigned>();
-		int64_t val = s_reader.get();
-		if (val < 0) {
-			return criticalError("Not an unsigned integer");
-		}
-		builder.set(static_cast<uint32_t>(val));
-		return noError();
-	}
-};
-template <> struct JsonDecodeImpl<MessagePrimitive<int32_t>> {
-	// static void decode(BufferView view, typename
-	// MessagePrimitive<T>::Builder){}
-	static Error decode(typename MessagePrimitive<int32_t>::Builder data,
-						DynamicMessage::DynamicReader reader) {
-		if (reader.type() != DynamicMessage::Type::Signed) {
-			return criticalError("Not an integer");
-		}
-		DynamicMessageSigned::Reader s_reader =
-			reader.as<DynamicMessageSigned>();
-		int64_t val = s_reader.get();
-		data.set(static_cast<int32_t>(val));
-		return noError();
-	}
-};
-
-template <> struct JsonDecodeImpl<MessagePrimitive<std::string>> {
-	static Error decode(typename MessagePrimitive<std::string>::Builder builder,
-						DynamicMessage::DynamicReader reader) {
-		if (reader.type() != DynamicMessage::Type::String) {
-			return criticalError("Not a string");
-		}
-		DynamicMessageString::Reader s_reader =
-			reader.as<DynamicMessageString>();
-		builder.set(s_reader.get());
-
-		return noError();
-	}
-};
-
-template <typename... T> struct JsonDecodeImpl<MessageList<T...>> {
-	template <size_t i = 0>
-	static typename std::enable_if<i == sizeof...(T), Error>::type
-	decodeMembers(typename MessageList<T...>::Builder builder,
-				  DynamicMessageList::Reader reader) {
-		(void)builder;
-		(void)reader;
-		return noError();
-	}
-
-	template <size_t i = 0>
-		static typename std::enable_if <
-		i<sizeof...(T), Error>::type
-		decodeMembers(typename MessageList<T...>::Builder builder,
-					  DynamicMessageList::Reader reader) {
-
-		DynamicMessage::DynamicReader member_reader = reader.get(i);
-
-		{
-			Error error =
-				JsonDecodeImpl<typename ParameterPackType<i, T...>::type>::
-					decode(builder.template init<i>(), member_reader);
-
-			if (error.failed()) {
-				return error;
-			}
-		}
-		{
-			Error error =
-				JsonDecodeImpl<MessageList<T...>>::decodeMembers<i + 1>(builder,
-																		reader);
-			if (error.failed()) {
-				return error;
-			}
-		}
-		return noError();
-	}
-
-	static Error decode(typename MessageList<T...>::Builder builder,
-						DynamicMessage::DynamicReader reader) {
-		if (reader.type() != DynamicMessage::Type::List) {
-			return criticalError("Not a list");
-		}
-
-		Error error = JsonDecodeImpl<MessageList<T...>>::decodeMembers<0>(
-			builder, reader.as<DynamicMessageList>());
-		if (error.failed()) {
-			return error;
-		}
-		return noError();
-	}
-};
-
-template <typename... V, typename... K>
-struct JsonDecodeImpl<MessageStruct<MessageStructMember<V, K>...>> {
-	template <size_t i = 0>
-	static typename std::enable_if<i == sizeof...(V), Error>::type
-	decodeMembers(typename MessageStruct<MessageStructMember<V, K>...>::Builder,
-				  DynamicMessageStruct::Reader) {
-		return noError();
-	}
-	template <size_t i = 0>
-		static typename std::enable_if <
-		i<sizeof...(V), Error>::type decodeMembers(
-			typename MessageStruct<MessageStructMember<V, K>...>::Builder
-				builder,
-			DynamicMessageStruct::Reader reader) {
-		DynamicMessage::DynamicReader member_reader =
-			reader.get(ParameterPackType<i, K...>::type::view());
-		{
-			Error error =
-				JsonDecodeImpl<typename ParameterPackType<i, V...>::type>::
-					decode(builder.template init<i>(), member_reader);
-			if (error.failed()) {
-				return error;
-			}
-		}
-		{
-			Error error =
-				JsonDecodeImpl<MessageStruct<MessageStructMember<V, K>...>>::
-					decodeMembers<i + 1>(builder, reader);
-			if (error.failed()) {
-				return error;
-			}
-		}
-		return noError();
-	}
-	static Error decode(
-		typename MessageStruct<MessageStructMember<V, K>...>::Builder builder,
-		DynamicMessage::DynamicReader reader) {
-		if (reader.type() != DynamicMessage::Type::Struct) {
-			return criticalError("Not a struct");
-		}
-		Error error =
-			JsonDecodeImpl<MessageStruct<MessageStructMember<V, K>...>>::
-				decodeMembers<0>(builder, reader.as<DynamicMessageStruct>());
-		if (error.failed()) {
-			return error;
-		}
-		return noError();
-	}
-};
-
-bool JsonCodec::isWhitespace(int8_t letter) {
-	return letter == '\t' || letter == ' ' || letter == '\r' || letter == '\n';
-}
-
-void JsonCodec::skipWhitespace(Buffer &buffer) {
-	while (buffer.readCompositeLength() > 0 && isWhitespace(buffer.read())) {
-		buffer.readAdvance(1);
-	}
-}
-
-struct JsonCodecLimitGuardHelper {
-	JsonCodec::Limits &counter;
-
-	JsonCodecLimitGuardHelper(JsonCodec::Limits &l) : counter{l} {
-		++counter.depth;
-		++counter.elements;
-	}
-
-	~JsonCodecLimitGuardHelper() { --counter.depth; }
-
-	static bool inLimit(const JsonCodec::Limits &counter,
-						const JsonCodec::Limits &top) {
-		return counter.depth < top.depth && counter.elements < top.elements;
-	}
-};
-
-Error JsonCodec::decodeBool(DynamicMessageBool::Builder message,
-							Buffer &buffer) {
-	assert((buffer.read() == 'T') || (buffer.read() == 't') ||
-		   (buffer.read() == 'F') || (buffer.read() == 'f'));
-
-	bool is_true = buffer.read() == 'T' || buffer.read() == 't';
-	buffer.readAdvance(1);
-
-	if (is_true) {
-		std::array<char, 3> check = {'r', 'u', 'e'};
-		for (size_t i = 0; buffer.readCompositeLength() > 0 && i < 3; ++i) {
-			if (buffer.read() != check[i]) {
-				return criticalError("Assumed true value, but it is invalid");
-			}
-			buffer.readAdvance(1);
-		}
-	} else {
-		std::array<char, 4> check = {'a', 'l', 's', 'e'};
-		for (size_t i = 0; buffer.readCompositeLength() > 0 && i < 4; ++i) {
-			if (buffer.read() != check[i]) {
-				return criticalError("Assumed false value, but it is invalid");
-			}
-			buffer.readAdvance(1);
-		}
-	}
-
-	message.set(is_true);
-
-	return noError();
-}
-
-// Not yet clear if double or integer
-Error JsonCodec::decodeNumber(Own<DynamicMessage> &message, Buffer &buffer) {
-	assert((buffer.read() >= '0' && buffer.read() <= '9') ||
-		   buffer.read() == '+' || buffer.read() == '-');
-	size_t offset = 0;
-
-	if (buffer.read() == '-') {
-		++offset;
-	} else if (buffer.read() == '+') {
-		return criticalError("Not a valid number with +");
-	}
-	if (offset >= buffer.readCompositeLength()) {
-		return recoverableError("Buffer too short");
-	}
-	bool integer = true;
-	if (buffer.read(offset) >= '1' && buffer.read(offset) <= '9') {
-		++offset;
-
-		if (offset >= buffer.readCompositeLength()) {
-			return recoverableError("Buffer too short");
-		}
-
-		while (1) {
-			if (buffer.read(offset) >= '0' && buffer.read(offset) <= '9') {
-				++offset;
-
-				if (offset >= buffer.readCompositeLength()) {
-					return recoverableError("Buffer too short");
-				}
-				continue;
-			}
-			break;
-		}
-	} else if (buffer.read(offset) == '0') {
-		++offset;
-	} else {
-		return criticalError("Not a JSON number");
-	}
-	if (offset >= buffer.readCompositeLength()) {
-		return recoverableError("Buffer too short");
-	}
-	if (buffer.read(offset) == '.') {
-		integer = false;
-		++offset;
-
-		if (offset >= buffer.readCompositeLength()) {
-			return recoverableError("Buffer too short");
-		}
-
-		size_t partial_start = offset;
-
-		while (1) {
-			if (buffer.read(offset) >= '0' && buffer.read(offset) <= '9') {
-				++offset;
-
-				if (offset >= buffer.readCompositeLength()) {
-					return recoverableError("Buffer too short");
-				}
-				continue;
-			}
-			break;
-		}
-
-		if (offset == partial_start) {
-			return criticalError("No numbers after '.'");
-		}
-	}
-	if (buffer.read(offset) == 'e' || buffer.read(offset) == 'E') {
-		integer = false;
-		++offset;
-
-		if (offset >= buffer.readCompositeLength()) {
-			return recoverableError("Buffer too short");
-		}
-
-		if (buffer.read(offset) == '+' || buffer.read(offset) == '-') {
-			++offset;
-			if (offset >= buffer.readCompositeLength()) {
-				return recoverableError("Buffer too short");
-			}
-		}
-
-		size_t exp_start = offset;
-
-		while (1) {
-			if (buffer.read(offset) >= '0' && buffer.read(offset) <= '9') {
-				++offset;
-
-				if (offset >= buffer.readCompositeLength()) {
-					return recoverableError("Buffer too short");
-				}
-				continue;
-			}
-			break;
-		}
-		if (offset == exp_start) {
-			return criticalError("No numbers after exponent token");
-		}
-	}
-
-	if (offset >= buffer.readCompositeLength()) {
-		return recoverableError("Buffer too short");
-	}
-
-	std::string_view number_view{reinterpret_cast<char *>(&buffer.read()),
-								 offset};
-	if (integer) {
-		int64_t result;
-		auto fc_result =
-			std::from_chars(number_view.data(),
-							number_view.data() + number_view.size(), result);
-		if (fc_result.ec != std::errc{}) {
-			return criticalError("Not an integer");
-		}
-
-		//
-		auto int_msg = std::make_unique<DynamicMessageSigned>();
-		DynamicMessageSigned::Builder builder{*int_msg};
-		builder.set(result);
-		message = std::move(int_msg);
-	} else {
-		std::string double_hack{number_view};
-		double result;
-		// This is hacky because technically c++17 allows noexcept from_chars
-		// doubles, but clang++ and g++ don't implement it since that is
-		// apparently hard.
-		try {
-			result = std::stod(double_hack);
-		} catch (const std::exception &) {
-			return criticalError("Not a double");
-		}
-
-		/*
-		auto fc_result =
-			std::from_chars(number_view.data(),
-							number_view.data() + number_view.size(), result);
-		if (fc_result.ec != std::errc{}) {
-			return criticalError("Not a double");
-		}
-		*/
-
-		//
-		auto dbl_msg = std::make_unique<DynamicMessageDouble>();
-		DynamicMessageDouble::Builder builder{*dbl_msg};
-		builder.set(result);
-		message = std::move(dbl_msg);
-	}
-
-	buffer.readAdvance(offset);
-	skipWhitespace(buffer);
-	return noError();
-}
-
-Error JsonCodec::decodeNull(Buffer &buffer) {
-	assert(buffer.read() == 'N' || buffer.read() == 'n');
-
-	buffer.readAdvance(1);
-
-	std::array<char, 3> check = {'u', 'l', 'l'};
-	for (size_t i = 0; buffer.readCompositeLength() > 0 && i < 3; ++i) {
-		if (buffer.read() != check[i]) {
-			return criticalError("Assumed null value, but it is invalid");
-		}
-		buffer.readAdvance(1);
-	}
-
-	return noError();
-}
-
-Error JsonCodec::decodeValue(Own<DynamicMessage> &message, Buffer &buffer,
-							 const Limits &limits, Limits &counter) {
-	skipWhitespace(buffer);
-
-	JsonCodecLimitGuardHelper ctr_helper{counter};
-
-	if (!JsonCodecLimitGuardHelper::inLimit(counter, limits)) {
-		return criticalError("Not in limit");
-	}
-
-	if (buffer.readCompositeLength() == 0) {
-		return recoverableError("Buffer too short");
-	}
-
-	switch (buffer.read()) {
-	case '"': {
-		std::string str;
-		Error error = decodeRawString(str, buffer);
-		if (error.failed()) {
-			return error;
-		}
-		Own<DynamicMessageString> msg_string =
-			std::make_unique<DynamicMessageString>();
-		DynamicMessageString::Builder builder{*msg_string};
-		builder.set(std::move(str));
-		message = std::move(msg_string);
-	} break;
-	case '0':
-	case '1':
-	case '2':
-	case '3':
-	case '4':
-	case '5':
-	case '6':
-	case '7':
-	case '8':
-	case '9':
-	case '+':
-	case '-': {
-		Error error = decodeNumber(message, buffer);
-		if (error.failed()) {
-			return error;
-		}
-	} break;
-	case 't':
-	case 'T':
-	case 'f':
-	case 'F': {
-		Own<DynamicMessageBool> msg_bool =
-			std::make_unique<DynamicMessageBool>();
-		decodeBool(DynamicMessageBool::Builder{*msg_bool}, buffer);
-		message = std::move(msg_bool);
-	} break;
-	case '{': {
-		Own<DynamicMessageStruct> msg_struct =
-			std::make_unique<DynamicMessageStruct>();
-		Error error = decodeStruct(DynamicMessageStruct::Builder{*msg_struct},
-								   buffer, limits, counter);
-		if (error.failed()) {
-			return error;
-		}
-		message = std::move(msg_struct);
-	} break;
-	case '[': {
-		Own<DynamicMessageList> msg_list =
-			std::make_unique<DynamicMessageList>();
-		decodeList(DynamicMessageList::Builder{*msg_list}, buffer, limits,
-				   counter);
-		message = std::move(msg_list);
-	} break;
-	case 'n':
-	case 'N': {
-		Own<DynamicMessageNull> msg_null =
-			std::make_unique<DynamicMessageNull>();
-		decodeNull(buffer);
-		message = std::move(msg_null);
-	} break;
-	default: {
-		return criticalError("Cannot identify next JSON value");
-	}
-	}
-
-	skipWhitespace(buffer);
-	return noError();
-}
-
-Error JsonCodec::decodeRawString(std::string &raw, Buffer &buffer) {
-	assert(buffer.read() == '"');
-
-	buffer.readAdvance(1);
-	std::stringstream iss;
-	bool string_done = false;
-	while (!string_done) {
-		if (buffer.readCompositeLength() == 0) {
-			return recoverableError("Buffer too short");
-		}
-		switch (buffer.read()) {
-		case '\\':
-			buffer.readAdvance(1);
-			if (buffer.readCompositeLength() == 0) {
-				return recoverableError("Buffer too short");
-			}
-			switch (buffer.read()) {
-			case '\\':
-			case '/':
-			case '"':
-				iss << buffer.read();
-				break;
-			case 'b':
-				iss << '\b';
-				break;
-			case 'f':
-				iss << '\f';
-				break;
-			case 'n':
-				iss << '\n';
-				break;
-			case 'r':
-				iss << '\r';
-				break;
-			case 't':
-				iss << '\t';
-				break;
-			case 'u': {
-				buffer.readAdvance(1);
-				if (buffer.readCompositeLength() < 4) {
-					return recoverableError("Broken unicode or short buffer");
-				}
-				/// @todo correct unicode handling
-				iss << '?'; // dummy line
-				iss << '?';
-				iss << '?';
-				iss << '?';
-				// There is always a skip at the end so here we skip 3
-				// instead of 4 bytes
-				buffer.readAdvance(3);
-			} break;
-			}
-			break;
-		case '"':
-			string_done = true;
-			break;
-		default:
-			iss << buffer.read();
-			break;
-		}
-		buffer.readAdvance(1);
-	}
-	raw = iss.str();
-	return noError();
-}
-
-Error JsonCodec::decodeList(DynamicMessageList::Builder builder, Buffer &buffer,
-							const Limits &limits, Limits &counter) {
-	assert(buffer.read() == '[');
-	buffer.readAdvance(1);
-	skipWhitespace(buffer);
-	if (buffer.readCompositeLength() == 0) {
-		return recoverableError("Buffer too short");
-	}
-
-	while (buffer.read() != ']') {
-
-		Own<DynamicMessage> message = nullptr;
-		{
-			Error error = decodeValue(message, buffer, limits, counter);
-			if (error.failed()) {
-				return error;
-			}
-		}
-		builder.push(std::move(message));
-		if (buffer.readCompositeLength() == 0) {
-			return recoverableError("Buffer too short");
-		}
-
-		switch (buffer.read()) {
-		case ']':
-			break;
-		case ',':
-			buffer.readAdvance(1);
-			skipWhitespace(buffer);
-			if (buffer.readCompositeLength() == 0) {
-				return recoverableError("Buffer too short");
-			}
-			break;
-		default:
-			return criticalError("Not a JSON Object");
-		}
-	}
-	buffer.readAdvance(1);
-	return noError();
-}
-
-Error JsonCodec::decodeStruct(DynamicMessageStruct::Builder message,
-							  Buffer &buffer, const Limits &limits,
-							  Limits &counter) {
-	assert(buffer.read() == '{');
-	buffer.readAdvance(1);
-	skipWhitespace(buffer);
-	if (buffer.readCompositeLength() == 0) {
-		return recoverableError("Buffer too short");
-	}
-
-	while (buffer.read() != '}') {
-		if (buffer.read() == '"') {
-			std::string key_string;
-			{
-				Error error = decodeRawString(key_string, buffer);
-				if (error.failed()) {
-					return error;
-				}
-			}
-			skipWhitespace(buffer);
-			if (buffer.readCompositeLength() == 0) {
-				return recoverableError("Buffer too short");
-			}
-			if (buffer.read() != ':') {
-				return criticalError("Expecting a ':' token");
-			}
-			buffer.readAdvance(1);
-			Own<DynamicMessage> msg = nullptr;
-			{
-				Error error = decodeValue(msg, buffer, limits, counter);
-				if (error.failed()) {
-					return error;
-				}
-			}
-			message.init(key_string, std::move(msg));
-			if (buffer.readCompositeLength() == 0) {
-				return recoverableError("Buffer too short");
-			}
-
-			switch (buffer.read()) {
-			case '}':
-				break;
-			case ',':
-				buffer.readAdvance(1);
-				skipWhitespace(buffer);
-				if (buffer.readCompositeLength() == 0) {
-					return recoverableError("Buffer too short");
-				}
-				break;
-			default:
-				return criticalError("Not a JSON Object");
-			}
-		} else {
-			return criticalError("Not a JSON Object");
-		}
-	}
-	buffer.readAdvance(1);
-	return noError();
-}
-
-ErrorOr<Own<DynamicMessage>> JsonCodec::decodeDynamic(Buffer &buffer,
-													  const Limits &limits) {
-	Limits counter{0, 0};
-
-	skipWhitespace(buffer);
-	if (buffer.readCompositeLength() == 0) {
-		return recoverableError("Buffer too short");
-	}
-	if (buffer.read() == '{') {
-
-		Own<DynamicMessageStruct> message =
-			std::make_unique<DynamicMessageStruct>();
-		Error error = decodeStruct(DynamicMessageStruct::Builder{*message},
-								   buffer, limits, counter);
-		if (error.failed()) {
-			return error;
-		}
-		skipWhitespace(buffer);
-
-		return Own<DynamicMessage>{std::move(message)};
-	} else if (buffer.read() == '[') {
-
-		Own<DynamicMessageList> message =
-			std::make_unique<DynamicMessageList>();
-		Error error = decodeList(*message, buffer, limits, counter);
-		if (error.failed()) {
-			return error;
-		}
-		skipWhitespace(buffer);
-
-		return Own<DynamicMessage>{std::move(message)};
-	} else {
-		return criticalError("Not a JSON Object");
-	}
-}
-
-template <typename T>
-Error JsonCodec::encode(typename T::Reader reader, Buffer &buffer) {
-	BufferView view{buffer};
-	Error error = JsonEncodeImpl<T>::encode(reader, view);
-	if (error.failed()) {
-		return error;
-	}
-
-	buffer.writeAdvance(view.writeOffset());
-
-	return error;
-}
-
-template <typename T>
-Error JsonCodec::decode(typename T::Builder builder, Buffer &buffer,
-						const Limits &limits) {
-
-	BufferView view{buffer};
-
-	ErrorOr<Own<DynamicMessage>> error_or_message = decodeDynamic(view, limits);
-	if (error_or_message.isError()) {
-		return std::move(error_or_message.error());
-	}
-
-	Own<DynamicMessage> message = std::move(error_or_message.value());
-	if (!message) {
-		return criticalError("No message object created");
-	}
-	if (message->type() == DynamicMessage::Type::Null) {
-		return criticalError("Can't decode to json");
-	}
-
-	DynamicMessage::DynamicReader reader{*message};
-	Error static_error = JsonDecodeImpl<T>::decode(builder, reader);
-
-	if (static_error.failed()) {
-		return static_error;
-	}
-
-	buffer.readAdvance(view.readOffset());
-
-	return static_error;
-}
-
-} // namespace gin
diff --git a/source/kelgin/message.h b/source/kelgin/message.h
index 9ddb58e..0752778 100644
--- a/source/kelgin/message.h
+++ b/source/kelgin/message.h
@@ -2,457 +2,440 @@
 
 #include <cstdint>
 #include <tuple>
+#include <type_traits>
 #include <variant>
 #include <vector>
 
+#include <cassert>
+
 #include "common.h"
 
+#include "message_container.h"
+#include "schema.h"
 #include "string_literal.h"
 
 namespace gin {
-class Message {
+class MessageBase {
 protected:
 	bool set_explicitly = false;
 
 public:
-	template <typename T> T &as() {
-		static_assert(std::is_base_of<Message, T>());
-		return reinterpret_cast<T &>(*this);
+	template <class T> T &as() {
+		static_assert(std::is_base_of<MessageBase, T>());
+		return dynamic_cast<T &>(*this);
 	}
 
-	template <typename T> const T &as() const {
-		static_assert(std::is_base_of<Message, T>());
-		return reinterpret_cast<const T &>(*this);
+	template <class T> const T &as() const {
+		static_assert(std::is_base_of<MessageBase, T>());
+		return dynamic_cast<const T &>(*this);
 	}
 };
 /*
- * Representing all primitive types
+ * Representing all message types
+ * Description which type to use happens through the use of the schema classes
+ * in schema.h The message classes are wrapper classes which store the data
+ * according to the specified container class.
+ *
+ * The reader and builder classe exist to create some clarity while implementing
+ * parsers. Also minor guarantess are provided if the message is used as a
+ * template parameter.
  */
-template <typename T> class MessagePrimitive : public Message {
+
+/*
+ * Struct Message
+ */
+template <class... V, StringLiteral... Keys, class Container>
+class Message<schema::Struct<schema::NamedMember<V, Keys>...>, Container> final
+	: public MessageBase {
 private:
-	T value;
+	using SchemaType = schema::Struct<schema::NamedMember<V, Keys>...>;
+	using MessageType = Message<SchemaType, Container>;
+	Container container;
+
+	static_assert(std::is_same_v<SchemaType, typename Container::SchemaType>,
+				  "Container should have same the schema as Message");
 
 	friend class Builder;
 	friend class Reader;
 
 public:
-	MessagePrimitive() = default;
-
 	class Reader;
 	class Builder {
 	private:
-		MessagePrimitive<T> &message;
+		MessageType &message;
 
 	public:
-		Builder(MessagePrimitive<T> &message) : message{message} {}
-
-		constexpr void set(const T &value) {
-			message.value = value;
-			message.set_explicitly = true;
-		}
+		Builder(MessageType &msg) : message{msg} {}
 
 		Reader asReader() { return Reader{message}; }
-	};
 
-	class Reader {
-	private:
-		MessagePrimitive<T> &message;
-
-	public:
-		Reader(MessagePrimitive<T> &message) : message{message} {}
-
-		const T &get() const { return message.value; }
-
-		bool isSetExplicitly() const { return message.set_explicitly; }
-
-		Builder asBuilder() { return Builder{message}; }
-	};
-};
-
-template <> class MessagePrimitive<std::string> : public Message {
-private:
-	std::string value;
-
-	friend class Builder;
-	friend class Reader;
-
-public:
-	MessagePrimitive() = default;
-
-	class Reader;
-	class Builder {
-	private:
-		MessagePrimitive<std::string> &message;
-
-	public:
-		Builder(MessagePrimitive<std::string> &message) : message{message} {}
-
-		void set(std::string_view value) {
-			message.value = std::string{value};
-			message.set_explicitly = true;
-		}
 		/*
-		void set(std::string &&value) {
-			message.value = std::move(value);
-			message.set_explicitly = true;
-		}
-		*/
-
-		Reader asReader() { return Reader{message}; }
-	};
-
-	class Reader {
-	private:
-		MessagePrimitive<std::string> &message;
-
-	public:
-		Reader(MessagePrimitive<std::string> &message) : message{message} {}
-
-		std::string_view get() const { return std::string_view{message.value}; }
-
-		bool isSetExplicitly() const { return message.set_explicitly; }
-
-		Builder asBuilder() { return Builder{message}; }
-	};
-};
-
-template <typename... Args> class MessageList : public Message {
-private:
-	using tuple_type = std::tuple<Args...>;
-	tuple_type elements;
-	friend class Builder;
-	friend class Reader;
-
-public:
-	class Reader;
-	class Builder {
-	private:
-		MessageList<Args...> &message;
-
-	public:
-		Builder(MessageList<Args...> &message) : message{message} {
-			message.set_explicitly = true;
-		}
-
+		 * Initialize a member by index
+		 */
 		template <size_t i>
-		constexpr typename std::tuple_element_t<i, tuple_type>::Builder init() {
-			std::tuple_element_t<i, tuple_type> &msg_ref =
-				std::get<i>(message.elements);
-			return
-				typename std::tuple_element_t<i, tuple_type>::Builder{msg_ref};
+		typename Container::template ElementType<i>::Builder init() {
+			return typename Container::template ElementType<i>::Builder{
+				message.container.template get<i>()};
 		}
 
-		Reader asReader() { return Reader{message}; }
-	};
-
-	class Reader {
-	private:
-		MessageList<Args...> &message;
-
-	public:
-		Reader(MessageList<Args...> &message) : message{message} {}
-
-		template <size_t i>
-		constexpr typename std::tuple_element_t<i, tuple_type>::Reader get() {
-			return std::get<i>(message.elements);
-		}
-
-		size_t size() const { return std::tuple_size<tuple_type>::value; }
-
-		bool isSetExplicitly() const { return message.set_explicitly; }
-
-		Builder asBuilder() { return Builder{message}; }
-	};
-};
-
-/// @todo how to do initialization?
-template <typename T> class MessageArray : public Message {
-private:
-	using array_type = std::vector<T>;
-	array_type elements;
-	friend class Builder;
-	friend class Reader;
-
-public:
-	class Reader;
-	class Builder {
-	private:
-		MessageArray<T> &message;
-
-	public:
-		Builder(MessageArray<T> &message) : message{message} {
-			message.set_explicitly = true;
-		}
-
-		constexpr typename T::Builder init(size_t i) {
-			T &msg_ref = message.elements.at(i);
-			return typename T::Builder{msg_ref};
-		}
-
-		Reader asReader() { return Reader{message}; }
-	};
-
-	class Reader {
-	private:
-		MessageArray<T> &message;
-
-	public:
-		Reader(MessageArray<T> &message) : message{message} {}
-
-		constexpr typename T::Reader get(size_t i) {
-			return message.elements.at(i);
-		}
-
-		size_t size() const { return message.elements.size(); }
-
-		bool isSetExplicitly() const { return message.set_explicitly; }
-
-		Builder asBuilder() { return Builder{message}; }
-	};
-};
-
-template <typename T, typename K> struct MessageStructMember;
-
-template <typename T, typename C, C... Chars>
-struct MessageStructMember<T, StringLiteral<C, Chars...>> {
-	T value;
-};
-
-/*
- * Helper structs which retrieve
- * the index of a parameter pack based on the index
- * or
- * a type based on the index
- * Pass N as the index for the desired type
- * or
- * a type to get the first occurence of a type index
- */
-template <size_t N, typename... T> struct ParameterPackType;
-
-template <typename T, typename... TL> struct ParameterPackType<0, T, TL...> {
-	using type = T;
-};
-
-template <size_t N, typename T, typename... TL>
-struct ParameterPackType<N, T, TL...> {
-	using type = typename ParameterPackType<N - 1, TL...>::type;
-};
-
-template <typename T, typename... TL> struct ParameterPackIndex;
-
-template <typename T, typename... TL> struct ParameterPackIndex<T, T, TL...> {
-	static constexpr size_t value = 0u;
-};
-
-template <typename T, typename TL0, typename... TL>
-struct ParameterPackIndex<T, TL0, TL...> {
-	static constexpr size_t value = 1u + ParameterPackIndex<T, TL...>::value;
-};
-
-template <typename... T> class MessageStruct;
-
-/*
- * Since no value is retrieved from the keys, I only need a value tuple
- */
-template <typename... V, typename... K>
-class MessageStruct<MessageStructMember<V, K>...> : public Message {
-private:
-	using value_type = std::tuple<V...>;
-	value_type values;
-	friend class Builder;
-	friend class Reader;
-
-public:
-	class Reader;
-	class Builder {
-	private:
-		MessageStruct<MessageStructMember<V, K>...> &message;
-
-	public:
-		Builder(MessageStruct<MessageStructMember<V, K>...> &message)
-			: message{message} {
-			message.set_explicitly = true;
-		}
-
-		template <size_t i>
-		constexpr typename std::tuple_element_t<i, value_type>::Builder init() {
-			std::tuple_element_t<i, value_type> &msg_ref =
-				std::get<i>(message.values);
-			return
-				typename std::tuple_element_t<i, value_type>::Builder{msg_ref};
-		}
-
-		template <typename T>
-		constexpr
-			typename std::tuple_element_t<ParameterPackIndex<T, K...>::value,
-										  value_type>::Builder
-			init() {
-			std::tuple_element_t<ParameterPackIndex<T, K...>::value, value_type>
-				&msg_ref = std::get<ParameterPackIndex<T, K...>::value>(
-					message.values);
-			return typename std::tuple_element_t<
-				ParameterPackIndex<T, K...>::value, value_type>::Builder{
-				msg_ref};
-		}
-
-		Reader asReader() { return Reader{message}; }
-	};
-	class Reader {
-	private:
-		MessageStruct<MessageStructMember<V, K>...> &message;
-
-	public:
-		Reader(MessageStruct<MessageStructMember<V, K>...> &message)
-			: message{message} {}
-
-		template <size_t i>
-		constexpr typename std::tuple_element_t<i, value_type>::Reader get() {
-			std::tuple_element_t<i, value_type> &msg_ref =
-				std::get<i>(message.values);
-			return
-				typename std::tuple_element_t<i, value_type>::Reader{msg_ref};
-		}
-
-		template <typename T>
-		constexpr
-			typename std::tuple_element_t<ParameterPackIndex<T, K...>::value,
-										  value_type>::Reader
-			get() {
-			std::tuple_element_t<ParameterPackIndex<T, K...>::value, value_type>
-				&msg_ref = std::get<ParameterPackIndex<T, K...>::value>(
-					message.values);
-			return typename std::tuple_element_t<
-				ParameterPackIndex<T, K...>::value, value_type>::Reader{
-				msg_ref};
-		}
-
-		constexpr size_t size() { return std::tuple_size<value_type>::value; }
-
-		bool isSetExplicitly() const { return message.set_explicitly; }
-
-		Builder asBuilder() { return Builder{message}; }
-	};
-};
-
-template <typename T, typename K> struct MessageUnionMember;
-
-template <typename T, typename C, C... Chars>
-struct MessageUnionMember<T, StringLiteral<C, Chars...>> {
-	T value;
-};
-
-template <typename... T> class MessageUnion;
-
-/// @todo copied from MessageStruct, but the acces is different, since
-///	 only one value can be set at the same time.
-template <typename... V, typename... K>
-class MessageUnion<MessageUnionMember<V, K>...> : public Message {
-private:
-	using value_type = std::variant<MessageUnionMember<V, K>...>;
-	value_type values;
-	friend class Builder;
-	friend class Reader;
-
-public:
-	class Reader;
-	class Builder {
-	private:
-		MessageUnion<MessageUnionMember<V, K>...> &message;
-
-	public:
-		Builder(MessageUnion<MessageUnionMember<V, K>...> &message)
-			: message{message} {
-			message.set_explicitly = true;
-		}
-
-		template <size_t i>
-		constexpr typename ParameterPackType<i, V...>::type::Builder init() {
-			message.values =
-				typename std::variant_alternative_t<i, value_type>{};
-			typename ParameterPackType<i, V...>::type &msg_ref =
-				std::get<i>(message.values).value;
-			return typename ParameterPackType<i, V...>::type::Builder{msg_ref};
-		}
-
-		template <typename T>
-		constexpr typename ParameterPackType<ParameterPackIndex<T, K...>::value,
-											 V...>::type::Builder
+		/*
+		 * Initialize a member by their name
+		 * This is the preferred method for schema::Struct messages
+		 */
+		template <StringLiteral Literal>
+		typename Container::template ElementType<
+			MessageParameterKeyPackIndex<Literal, Keys...>::Value>::Builder
 		init() {
-			message.values = typename std::variant_alternative_t<
-				ParameterPackIndex<T, K...>::value, value_type>{};
-			typename ParameterPackType<ParameterPackIndex<T, K...>::value,
-									   V...>::type &msg_ref =
-				std::get<ParameterPackIndex<T, K...>::value>(message.values)
-					.value;
-			return
-				typename ParameterPackType<ParameterPackIndex<T, K...>::value,
-										   V...>::type::Builder{msg_ref};
+			constexpr size_t i =
+				MessageParameterKeyPackIndex<Literal, Keys...>::Value;
+
+			return init<i>();
+		}
+	};
+
+	class Reader {
+	private:
+		MessageType &message;
+
+	public:
+		Reader(MessageType &msg) : message{msg} {}
+
+		Builder asBuilder() { return Builder{message}; }
+
+		/*
+		 * Get member by index
+		 */
+		template <size_t i>
+		typename Container::template ElementType<i>::Reader get() {
+			return typename Container::template ElementType<i>::Reader{
+				message.container.template get<i>()};
 		}
 
+		/*
+		 * Get member by name
+		 * This is the preferred method for schema::Struct messages
+		 */
+		template <StringLiteral Literal>
+		typename Container::template ElementType<
+			MessageParameterKeyPackIndex<Literal, Keys...>::Value>::Reader
+		get() {
+			// The index of the first match
+			constexpr size_t i =
+				MessageParameterKeyPackIndex<Literal, Keys...>::Value;
+
+			return get<i>();
+		}
+	};
+
+	Builder build() { return Builder{*this}; }
+
+	Reader read() { return Reader{*this}; }
+};
+
+/*
+ * Union message class. Wrapper object
+ */
+template <class... V, StringLiteral... Keys, class Container>
+class Message<schema::Union<schema::NamedMember<V, Keys>...>, Container> final
+	: public MessageBase {
+private:
+	using SchemaType = schema::Union<schema::NamedMember<V, Keys>...>;
+	using MessageType = Message<SchemaType, Container>;
+
+	Container container;
+
+	static_assert(std::is_same_v<SchemaType, typename Container::SchemaType>,
+				  "Container should have same the schema as Message");
+
+	friend class Builder;
+	friend class Reader;
+
+public:
+	class Reader;
+	class Builder {
+	private:
+		MessageType &message;
+
+	public:
+		Builder(MessageType &msg) : message{msg} {}
+
 		Reader asReader() { return Reader{message}; }
+
+		template <size_t i>
+		typename Container::template ElementType<i>::Builder init() {
+			return typename Container::template ElementType<i>::Builder{
+				message.container.template get<i>()};
+		}
+
+		template <StringLiteral Literal>
+		typename Container::template ElementType<
+			MessageParameterKeyPackIndex<Literal, Keys...>::Value>::Builder
+		init() {
+			constexpr size_t i =
+				MessageParameterKeyPackIndex<Literal, Keys...>::Value;
+
+			return init<i>();
+		}
+	};
+
+	class Reader {
+	private:
+		MessageType &message;
+
+	public:
+		Reader(MessageType &msg) : message{msg} {}
+
+		Builder asBuilder() { return Builder{message}; }
+
+		template <size_t i>
+		typename Container::template ElementType<i>::Reader get() {
+			return typename Container::template ElementType<i>::Reader{
+				message.container.template get<i>()};
+		}
+
+		template <StringLiteral Literal>
+		typename Container::template ElementType<
+			MessageParameterKeyPackIndex<Literal, Keys...>::Value>::Reader
+		get() {
+			// The index of the first match
+			constexpr size_t i =
+				MessageParameterKeyPackIndex<Literal, Keys...>::Value;
+
+			return get<i>();
+		}
+
+		template <StringLiteral Literal>
+		constexpr size_t toIndex() const noexcept {
+			return MessageParameterKeyPackIndex<Literal, Keys...>::Value;
+		}
+
+		size_t index() const noexcept { return message.container.index(); }
+
+		template <StringLiteral Literal> bool hasAlternative() const {
+			return index() == toIndex<Literal>();
+		}
+	};
+};
+
+/*
+ * Array message class. Wrapper around an array schema element
+ * @todo Array class needs either a resize function or each message class has an
+ * individual call for Array children
+ */
+/*
+template<class T, class Container>
+class Message<schema::Array<T>, Container> final : public MessageBase {
+private:
+	using SchemaType = schema::Array<T>;
+	using MessageType = Message<SchemaType, Container>;
+
+	Container container;
+
+	static_assert(std::is_same_v<SchemaType, typename Container::SchemaType>,
+				  "Container should have same Schema as Message");
+
+	friend class Builder;
+	friend class Reader;
+
+public:
+	class Reader;
+	class Builder {
+	private:
+		MessageType & message;
+	public:
+		Builder(MessageType& msg):message{msg}{}
+
+		Reader asReader(){return Reader{message};}
+
+		template<size_t i>
+		typename Container::MessageType::Builder init(){
+			return typename
+Container::MessageType::Builder{message.container.get<i>()};
+		}
+	};
+
+	class Reader {
+	private:
+		MessageType& message;
+	public:
+		Reader(MessageType& msg):message{msg}{}
+
+		Builder asBuilder(){return Builder{message};}
+
+		template<size_t i>
+		typename Container::MessageType::Reader get(){
+			return typename
+Container::MessageType::Reader{message.container.get<i>()};
+		}
+	};
+};
+*/
+
+/*
+ * Tuple message class. Wrapper around a tuple schema
+ */
+template <class... T, class Container>
+class Message<schema::Tuple<T...>, Container> final : public MessageBase {
+private:
+	using SchemaType = schema::Tuple<T...>;
+	using MessageType = Message<SchemaType, Container>;
+
+	Container container;
+
+	static_assert(std::is_same_v<SchemaType, typename Container::SchemaType>,
+				  "Container should have same the schema as Message");
+
+	friend class Builder;
+	friend class Reader;
+
+public:
+	class Reader;
+	class Builder {
+		MessageType &message;
+
+	public:
+		Builder(MessageType &msg) : message{msg} {}
+
+		Reader asReader() { return Reader{message}; }
+
+		template <size_t i>
+		typename Container::template ElementType<i>::Builder init() {
+			return typename Container::template ElementType<i>::Builder{
+				message.container.template get<i>()};
+		}
 	};
 	class Reader {
 	private:
-		MessageUnion<MessageUnionMember<V, K>...> &message;
+		MessageType &message;
 
 	public:
-		Reader(MessageUnion<MessageUnionMember<V, K>...> &message)
-			: message{message} {}
-
-		template <size_t i>
-		constexpr typename ParameterPackType<i, V...>::type::Reader get() {
-			typename ParameterPackType<i, V...>::type &msg_ref =
-				std::get<i>(message.values).value;
-			return typename ParameterPackType<i, V...>::type::Reader{msg_ref};
-		}
-
-		template <typename T>
-		constexpr typename ParameterPackType<ParameterPackIndex<T, K...>::value,
-											 V...>::type::Reader
-		get() {
-			typename ParameterPackType<ParameterPackIndex<T, K...>::value,
-									   V...>::type &msg_ref =
-				std::get<ParameterPackIndex<T, K...>::value>(message.values)
-					.value;
-			return
-				typename ParameterPackType<ParameterPackIndex<T, K...>::value,
-										   V...>::type::Reader{msg_ref};
-		}
-
-		template <typename T> constexpr bool holdsAlternative() {
-			return std::holds_alternative<std::variant_alternative_t<
-				ParameterPackIndex<T, K...>::value, value_type>>(
-				message.values);
-		}
-
-		size_t index() const { return message.values.index(); }
-
-		bool isSetExplicitly() const { return message.set_explicitly; }
-
-		constexpr size_t size() { return std::variant_size<value_type>::value; }
+		Reader(MessageType &msg) : message{msg} {}
 
 		Builder asBuilder() { return Builder{message}; }
+
+		template <size_t i>
+		typename Container::template ElementType<i>::Reader get() {
+			return typename Container::template ElementType<i>::Reader{
+				message.container.template get<i>()};
+		}
 	};
 };
 
-class MessageReader {
+/*
+ * Primitive type (float, double, uint8_t, uint16_t, uint32_t, uint64_t, int8_t,
+ * int16_t, int32_t, int64_t) message class
+ */
+template <class T, size_t N, class Container>
+class Message<schema::Primitive<T, N>, Container> final : public MessageBase {
+private:
+	using SchemaType = schema::Primitive<T, N>;
+	using MessageType = Message<SchemaType, Container>;
+
+	Container container;
+
+	static_assert(std::is_same_v<SchemaType, typename Container::SchemaType>,
+				  "Container should have same the schema as Message");
+
+	friend class Builder;
+	friend class Reader;
+
 public:
-	virtual ~MessageReader() = default;
+	class Reader;
+	class Builder {
+	private:
+		MessageType &message;
+
+	public:
+		Builder(MessageType &msg) : message{msg} {}
+
+		Reader asReader() { return Reader{message}; }
+
+		void set(const typename Container::ValueType &value) {
+			message.container.set(value);
+		}
+	};
+
+	class Reader {
+	private:
+		MessageType &message;
+
+	public:
+		Reader(Message &msg) : message{msg} {}
+
+		Builder asBuilder() { return Builder{message}; }
+
+		const typename Container::ValueType &get() const {
+			return message.container.get();
+		}
+	};
 };
 
-class MessageBuilder {
+template <class Container>
+class Message<schema::String, Container> final : public MessageBase {
 private:
-	Own<Message> root_message = nullptr;
+	using SchemaType = schema::String;
+	using MessageType = Message<SchemaType, Container>;
+
+	Container container;
+
+	static_assert(std::is_same_v<SchemaType, typename Container::SchemaType>,
+				  "Container should have same the schema as Message");
+
+	friend class Builder;
+	friend class Reader;
 
 public:
-	virtual ~MessageBuilder() = default;
+	class Reader;
+	class Builder {
+	private:
+		MessageType &message;
 
-	template <typename MessageRoot> typename MessageRoot::Builder initRoot() {
-		root_message = std::make_unique<MessageRoot>();
-		MessageRoot &msg_ref = root_message->as<MessageRoot>();
-		return typename MessageRoot::Builder{msg_ref};
+	public:
+		Builder(MessageType &msg) : message{msg} {}
+
+		Reader asReader() { return Reader{message}; }
+
+		void set(const std::string &str) { message.container.set(str); }
+	};
+
+	class Reader {
+	private:
+		MessageType &message;
+
+	public:
+		Reader(MessageType &msg) : message{msg} {}
+
+		Builder asBuilder() { return Builder{message}; }
+
+		std::string_view get() { return message.container.get(); }
+	};
+};
+
+template <class Schema, class Container = MessageContainer<Schema>>
+class HeapMessageRoot {
+private:
+	Own<Message<Schema, Container>> root;
+
+public:
+	HeapMessageRoot(Own<Message<Schema, Container>> r) : root{std::move(r)} {}
+
+	typename Message<Schema, Container>::Builder build() {
+		assert(root);
+		return typename Message<Schema, Container>::Builder{*root};
+	}
+
+	typename Message<Schema, Container>::Reader read() {
+		assert(root);
+		return typename Message<Schema, Container>::Reader{*root};
 	}
 };
 
-inline MessageBuilder heapMessageBuilder() { return MessageBuilder{}; }
+/*
+ * Minor helper for creating a message root
+ */
+template <class Schema, class Container = MessageContainer<Schema>>
+inline HeapMessageRoot<Schema, Container> heapMessageRoot() {
+	Own<Message<Schema, Container>> root = heap<Message<Schema, Container>>();
+	return HeapMessageRoot<Schema, Container>{std::move(root)};
+}
 } // namespace gin
diff --git a/source/kelgin/message_container.h b/source/kelgin/message_container.h
new file mode 100644
index 0000000..15930cd
--- /dev/null
+++ b/source/kelgin/message_container.h
@@ -0,0 +1,226 @@
+#pragma once
+
+#include "schema.h"
+
+namespace gin {
+template <class T> class MessageContainer;
+
+template <class T, class Container> class Message;
+
+template <size_t N, class... T> struct MessageParameterPackType;
+
+template <class TN, class... T> struct MessageParameterPackType<0, TN, T...> {
+	using Type = TN;
+};
+
+template <size_t N, class TN, class... T>
+struct MessageParameterPackType<N, TN, T...> {
+	static_assert(sizeof...(T) > 0, "Exhausted parameters");
+	using Type = typename MessageParameterPackType<N - 1, T...>::Type;
+};
+
+template <class T, class... TL> struct MessageParameterPackIndex;
+
+template <class T, class... TL> struct MessageParameterPackIndex<T, T, TL...> {
+	static constexpr size_t Value = 0u;
+};
+
+template <class T, class TL0, class... TL>
+struct MessageParameterPackIndex<T, TL0, TL...> {
+	static constexpr size_t Value =
+		1u + MessageParameterPackIndex<T, TL...>::Value;
+};
+
+/*
+ * Nightmare inducing compiler problems found here. Somehow non-type
+ * StringLiterals cannot be resolved as non-type primitive template values can.
+ * This is the workaround
+ */
+template <StringLiteral V, StringLiteral Key0, StringLiteral... Keys>
+struct MessageParameterKeyPackIndexHelper {
+	static constexpr size_t Value =
+		(V == Key0)
+			? (0u)
+			: (1u + MessageParameterKeyPackIndexHelper<V, Keys...>::Value);
+};
+
+template <StringLiteral V, StringLiteral Key0>
+struct MessageParameterKeyPackIndexHelper<V, Key0> {
+	static constexpr size_t Value = (V == Key0) ? (0u) : (1u);
+};
+
+template <StringLiteral V, StringLiteral... Keys>
+struct MessageParameterKeyPackIndex {
+	static constexpr size_t Value =
+		MessageParameterKeyPackIndexHelper<V, Keys...>::Value;
+	static_assert(Value < sizeof...(Keys),
+				  "Provided StringLiteral doesn't exist in searched list");
+};
+
+template <class... V, StringLiteral... Keys>
+class MessageContainer<schema::Struct<schema::NamedMember<V, Keys>...>> {
+private:
+	using ValueType = std::tuple<Message<V, MessageContainer<V>>...>;
+	ValueType values;
+
+public:
+	using SchemaType = schema::Struct<schema::NamedMember<V, Keys>...>;
+
+	template <size_t i>
+	using ElementType = typename MessageParameterPackType<
+		i, Message<V, MessageContainer<V>>...>::Type;
+
+	template <size_t i> ElementType<i> &get() { return std::get<i>(values); }
+};
+
+/*
+ * Union storage
+ */
+template <class... V, StringLiteral... Keys>
+class MessageContainer<schema::Union<schema::NamedMember<V, Keys>...>> {
+private:
+	using ValueType = std::variant<Message<V, MessageContainer<V>>...>;
+	ValueType value;
+
+public:
+	using SchemaType = schema::Union<schema::NamedMember<V, Keys>...>;
+
+	template <size_t i>
+	using ElementType = typename MessageParameterPackType<
+		i, Message<V, MessageContainer<V>>...>::Type;
+
+	template <size_t i> ElementType<i> &get() {
+		if (i != value.index()) {
+			using MessageIV = typename MessageParameterPackType<i, V...>::Type;
+			value = Message<MessageIV, MessageContainer<MessageIV>>{};
+		}
+		return std::get<i>(value);
+	}
+
+	size_t index() const noexcept { return value.index(); }
+};
+
+/*
+ * Array storage
+ */
+
+/*
+template<class T>
+class MessageContainer<schema::Array> {
+private:
+	using ValueType = std::vector<Message<T,MessageContainer<T>>>;
+	ValueType values;
+public:
+	using SchemaType = schema::Array<T>;
+
+	template<size_t i> Message<T,MessageContainer<T>>& get(){
+		return values.at(i);
+	}
+};
+*/
+
+/*
+ * Tuple storage
+ */
+template <class... T> class MessageContainer<schema::Tuple<T...>> {
+private:
+	using ValueType = std::tuple<Message<T, MessageContainer<T>>...>;
+	ValueType values;
+
+public:
+	using SchemaType = schema::Tuple<T...>;
+
+	template <size_t i>
+	using ElementType = typename MessageParameterPackType<
+		i, Message<T, MessageContainer<T>>...>::Type;
+
+	template <size_t i> ElementType<i> &get() { return std::get<i>(values); }
+};
+
+/*
+ * Helper for the basic message container, so the class doesn't have to be
+ * specialized 10 times.
+ */
+template <class T> struct PrimitiveTypeHelper;
+
+template <>
+struct PrimitiveTypeHelper<schema::Primitive<schema::SignedInteger, 1>> {
+	using Type = int8_t;
+};
+
+template <>
+struct PrimitiveTypeHelper<schema::Primitive<schema::SignedInteger, 2>> {
+	using Type = int16_t;
+};
+
+template <>
+struct PrimitiveTypeHelper<schema::Primitive<schema::SignedInteger, 4>> {
+	using Type = int32_t;
+};
+
+template <>
+struct PrimitiveTypeHelper<schema::Primitive<schema::SignedInteger, 8>> {
+	using Type = int64_t;
+};
+
+template <>
+struct PrimitiveTypeHelper<schema::Primitive<schema::UnsignedInteger, 1>> {
+	using Type = uint8_t;
+};
+
+template <>
+struct PrimitiveTypeHelper<schema::Primitive<schema::UnsignedInteger, 2>> {
+	using Type = uint16_t;
+};
+
+template <>
+struct PrimitiveTypeHelper<schema::Primitive<schema::UnsignedInteger, 4>> {
+	using Type = uint32_t;
+};
+
+template <>
+struct PrimitiveTypeHelper<schema::Primitive<schema::UnsignedInteger, 8>> {
+	using Type = uint64_t;
+};
+
+template <>
+struct PrimitiveTypeHelper<schema::Primitive<schema::FloatingPoint, 4>> {
+	using Type = float;
+};
+
+template <>
+struct PrimitiveTypeHelper<schema::Primitive<schema::FloatingPoint, 8>> {
+	using Type = double;
+};
+
+template <class T, size_t N> class MessageContainer<schema::Primitive<T, N>> {
+public:
+	using SchemaType = schema::Primitive<T, N>;
+	using ValueType =
+		typename PrimitiveTypeHelper<schema::Primitive<T, N>>::Type;
+
+private:
+	ValueType value;
+
+public:
+	MessageContainer() : value{0} {}
+
+	void set(const ValueType &v) { value = v; }
+
+	const ValueType &get() const { return value; }
+};
+
+template <> class MessageContainer<schema::String> {
+public:
+	using SchemaType = schema::String;
+	using ValueType = std::string;
+
+private:
+	ValueType value;
+
+public:
+	void set(const ValueType &v) { value = v; }
+
+	const ValueType &get() const { return value; }
+};
+} // namespace gin
diff --git a/source/kelgin/message_dynamic.cpp b/source/kelgin/message_dynamic.cpp
deleted file mode 100644
index 9ad430a..0000000
--- a/source/kelgin/message_dynamic.cpp
+++ /dev/null
@@ -1,22 +0,0 @@
-#include "message_dynamic.h"
-
-namespace gin {
-template <>
-DynamicMessage::Type DynamicMessagePrimitive<uint64_t>::type() const {
-	return DynamicMessage::Type::Unsigned;
-};
-template <>
-DynamicMessage::Type DynamicMessagePrimitive<int64_t>::type() const {
-	return DynamicMessage::Type::Signed;
-};
-template <>
-DynamicMessage::Type DynamicMessagePrimitive<std::string>::type() const {
-	return DynamicMessage::Type::String;
-};
-template <> DynamicMessage::Type DynamicMessagePrimitive<bool>::type() const {
-	return DynamicMessage::Type::Bool;
-};
-template <> DynamicMessage::Type DynamicMessagePrimitive<double>::type() const {
-	return DynamicMessage::Type::Double;
-};
-} // namespace gin
\ No newline at end of file
diff --git a/source/kelgin/message_dynamic.h b/source/kelgin/message_dynamic.h
deleted file mode 100644
index a0c6065..0000000
--- a/source/kelgin/message_dynamic.h
+++ /dev/null
@@ -1,274 +0,0 @@
-#pragma once
-
-#include <cstdint>
-#include <deque>
-#include <map>
-#include <string>
-
-#include "common.h"
-
-/// @todo Move implementation to cpp file
-
-namespace gin {
-/*
- * Base class for each message data structure
- */
-class DynamicMessage {
-protected:
-	/*
-	 * The encoder and decoders use this as a hint if this was set by a default
-	 * value or not
-	 */
-	bool set_explicitly = false;
-
-public:
-	/*
-	 * Later use for dynamic access
-	 */
-	enum class Type : uint16_t {
-		Null,
-		Struct,
-		List,
-		Array,
-		Union,
-		String,
-		Signed,
-		Unsigned,
-		Bool,
-		Double
-	};
-
-	virtual ~DynamicMessage() = default;
-
-	virtual Type type() const = 0;
-
-	template <typename T> T &as() {
-		static_assert(std::is_base_of<DynamicMessage, T>());
-		return reinterpret_cast<T &>(*this);
-	}
-
-	template <typename T> const T &as() const {
-		static_assert(std::is_base_of<DynamicMessage, T>());
-		return reinterpret_cast<const T &>(*this);
-	}
-
-	class DynamicReader;
-	class DynamicBuilder {
-	private:
-		DynamicMessage &message;
-
-	public:
-		DynamicBuilder(DynamicMessage &message) : message{message} {}
-
-		DynamicReader asReader() const { return DynamicReader{message}; }
-
-		DynamicMessage::Type type() const { return message.type(); }
-
-		template <typename T> typename T::Builder as() {
-			static_assert(std::is_base_of<DynamicMessage, T>());
-			return typename T::Builder{reinterpret_cast<T &>(message)};
-		}
-	};
-
-	class DynamicReader {
-	private:
-		DynamicMessage &message;
-
-	public:
-		DynamicReader(DynamicMessage &message) : message{message} {}
-
-		DynamicBuilder asBuilder() const { return DynamicBuilder{message}; }
-
-		DynamicMessage::Type type() const { return message.type(); }
-
-		template <typename T> typename T::Reader as() {
-			static_assert(std::is_base_of<DynamicMessage, T>());
-			return typename T::Reader{reinterpret_cast<T &>(message)};
-		}
-	};
-};
-
-class DynamicMessageNull : public DynamicMessage {
-public:
-	DynamicMessage::Type type() const override {
-		return DynamicMessage::Type::Null;
-	}
-};
-static DynamicMessageNull dynamicNullMessage;
-
-template <typename T> class DynamicMessagePrimitive : public DynamicMessage {
-private:
-	T value;
-	friend class Builder;
-	friend class Reader;
-
-public:
-	DynamicMessagePrimitive() = default;
-
-	DynamicMessage::Type type() const override;
-
-	class Reader;
-	class Builder {
-	private:
-		DynamicMessagePrimitive<T> &message;
-
-	public:
-		Builder(DynamicMessagePrimitive<T> &message) : message{message} {}
-
-		constexpr void set(const T &value) {
-			message.value = value;
-			message.set_explicitly = true;
-		}
-
-		constexpr void set(T &&value) {
-			message.value = std::move(value);
-			message.set_explicitly = true;
-		}
-
-		Reader asReader() const { return Reader{message}; }
-	};
-
-	class Reader {
-	private:
-		DynamicMessagePrimitive<T> &message;
-
-	public:
-		Reader(DynamicMessagePrimitive<T> &message) : message{message} {}
-
-		constexpr const T &get() { return message.value; }
-
-		bool isSetExplicitly() const { return message.set_explicitly; }
-
-		Builder asBuilder() const { return Builder{message}; }
-	};
-};
-
-using DynamicMessageString = DynamicMessagePrimitive<std::string>;
-using DynamicMessageSigned = DynamicMessagePrimitive<int64_t>;
-using DynamicMessageUnsigned = DynamicMessagePrimitive<uint64_t>;
-using DynamicMessageBool = DynamicMessagePrimitive<bool>;
-using DynamicMessageDouble = DynamicMessagePrimitive<double>;
-
-class DynamicMessageStruct : public DynamicMessage {
-private:
-	std::map<std::string, Own<DynamicMessage>, std::less<>> messages;
-	friend class Builder;
-	friend class Reader;
-
-public:
-	DynamicMessage::Type type() const override {
-		return DynamicMessage::Type::Struct;
-	}
-	class Reader;
-	class Builder {
-	private:
-		DynamicMessageStruct &message;
-
-	public:
-		Builder(DynamicMessageStruct &message) : message{message} {
-			message.set_explicitly = true;
-		}
-
-		template <typename T> typename T::Builder init(const std::string &key) {
-			Own<T> msg = std::make_unique<T>();
-			typename T::Builder builder{*msg};
-			/*auto insert = */ message.messages.insert(
-				std::make_pair(key, std::move(msg)));
-			return builder;
-		}
-
-		DynamicMessage::DynamicBuilder init(const std::string &key,
-											Own<DynamicMessage> &&msg) {
-			DynamicMessage::DynamicBuilder builder{*msg};
-			message.messages.insert(std::make_pair(key, std::move(msg)));
-			return builder;
-		}
-
-		Reader asReader() const { return Reader{message}; }
-	};
-
-	class Reader {
-	private:
-		DynamicMessageStruct &message;
-
-	public:
-		Reader(DynamicMessageStruct &message) : message{message} {}
-
-		DynamicMessage::DynamicReader get(std::string_view key) {
-			auto find = message.messages.find(key);
-			if (find != message.messages.end()) {
-				return DynamicMessage::DynamicReader{*(find->second)};
-			} else {
-				return DynamicMessage::DynamicReader{dynamicNullMessage};
-			}
-		}
-
-		size_t size() const { return message.messages.size(); }
-
-		bool isSetExplicitly() const { return message.set_explicitly; }
-
-		Builder asBuilder() const { return Builder{message}; }
-	};
-};
-
-class DynamicMessageList : public DynamicMessage {
-private:
-	std::deque<Own<DynamicMessage>> messages;
-	friend class Builder;
-	friend class Reader;
-
-public:
-	DynamicMessage::Type type() const override {
-		return DynamicMessage::Type::List;
-	}
-	class Reader;
-	class Builder {
-	private:
-		DynamicMessageList &message;
-
-	public:
-		Builder(DynamicMessageList &message) : message{message} {
-			message.set_explicitly = true;
-		}
-
-		template <typename T> typename T::Builder push() {
-			static_assert(std::is_base_of<DynamicMessage, T>());
-			Own<T> msg = std::make_unique<T>();
-			typename T::Builder builder{*msg};
-			message.messages.push_back(std::move(msg));
-			return builder;
-		}
-
-		DynamicMessage::DynamicBuilder push(Own<DynamicMessage> &&msg) {
-			DynamicMessage::DynamicBuilder builder{*msg};
-			message.messages.push_back(std::move(msg));
-			return builder;
-		}
-
-		Reader asReader() const { return Reader{message}; }
-	};
-
-	class Reader {
-	private:
-		DynamicMessageList &message;
-
-	public:
-		Reader(DynamicMessageList &message) : message{message} {}
-
-		DynamicMessage::DynamicReader get(size_t element) {
-			if (element < message.messages.size()) {
-				return DynamicMessage::DynamicReader{
-					*(message.messages[element])};
-			} else {
-				return DynamicMessage::DynamicReader{dynamicNullMessage};
-			}
-		}
-
-		size_t size() const { return message.messages.size(); }
-
-		bool isSetExplicitly() const { return message.set_explicitly; }
-
-		Builder asBuilder() const { return Builder{message}; }
-	};
-};
-} // namespace gin
\ No newline at end of file
diff --git a/source/kelgin/proto_kel.h b/source/kelgin/proto_kel.h
index e940a02..c379753 100644
--- a/source/kelgin/proto_kel.h
+++ b/source/kelgin/proto_kel.h
@@ -42,31 +42,39 @@ public:
 
 	const Version version() const { return Version{0, 0, 0}; }
 
-	template <typename T>
-	Error encode(typename T::Reader reader, Buffer &buffer);
+	template <class Schema, class Container = MessageContainer<Schema>>
+	Error encode(typename Message<Schema, Container>::Reader reader,
+				 Buffer &buffer);
 
-	template <typename T>
-	Error decode(typename T::Builder builder, Buffer &buffer,
-				 const Limits &limits = Limits{});
+	template <class Schema, class Container = MessageContainer<Schema>>
+	Error decode(typename Message<Schema, Container>::Builder builder,
+				 Buffer &buffer, const Limits &limits = Limits{});
 };
 
-template <typename T> struct ProtoKelEncodeImpl;
+template <class T> struct ProtoKelEncodeImpl;
 
-template <typename T> struct ProtoKelEncodeImpl<MessagePrimitive<T>> {
-	static Error encode(typename MessagePrimitive<T>::Reader data,
-						Buffer &buffer) {
-		Error error = StreamValue<T>::encode(data.get(), buffer);
+template <class T, size_t N, class Container>
+struct ProtoKelEncodeImpl<Message<schema::Primitive<T, N>, Container>> {
+	static Error
+	encode(typename Message<schema::Primitive<T, N>, Container>::Reader data,
+		   Buffer &buffer) {
+		Error error = StreamValue<typename PrimitiveTypeHelper<
+			schema::Primitive<T, N>>::Type>::encode(data.get(), buffer);
 		return error;
 	}
 
-	static size_t size(typename MessagePrimitive<T>::Reader) {
-		return StreamValue<T>::size();
+	static size_t
+	size(typename Message<schema::Primitive<T, N>, Container>::Reader) {
+		return StreamValue<typename PrimitiveTypeHelper<
+			schema::Primitive<T, N>>::Type>::size();
 	}
 };
 
-template <> struct ProtoKelEncodeImpl<MessagePrimitive<std::string>> {
-	static Error encode(typename MessagePrimitive<std::string>::Reader data,
-						Buffer &buffer) {
+template <class Container>
+struct ProtoKelEncodeImpl<Message<schema::String, Container>> {
+	static Error
+	encode(typename Message<schema::String, Container>::Reader data,
+		   Buffer &buffer) {
 		std::string_view view = data.get();
 		size_t size = view.size();
 
@@ -86,24 +94,27 @@ template <> struct ProtoKelEncodeImpl<MessagePrimitive<std::string>> {
 		return noError();
 	}
 
-	static size_t size(typename MessagePrimitive<std::string>::Reader reader) {
+	static size_t
+	size(typename Message<schema::String, Container>::Reader reader) {
 		return sizeof(size_t) + reader.get().size();
 	}
 };
 
-template <typename... T> struct ProtoKelEncodeImpl<MessageList<T...>> {
+template <class... T, class Container>
+struct ProtoKelEncodeImpl<Message<schema::Tuple<T...>, Container>> {
 	template <size_t i = 0>
 	static typename std::enable_if<i == sizeof...(T), Error>::type
-	encodeMembers(typename MessageList<T...>::Reader, Buffer &) {
+	encodeMembers(typename Message<schema::Tuple<T...>, Container>::Reader,
+				  Buffer &) {
 		return noError();
 	}
 
 	template <size_t i = 0>
-		static typename std::enable_if <
-		i<sizeof...(T), Error>::type
-		encodeMembers(typename MessageList<T...>::Reader data, Buffer &buffer) {
+	static typename std::enable_if<(i < sizeof...(T)), Error>::type
+	encodeMembers(typename Message<schema::Tuple<T...>, Container>::Reader data,
+				  Buffer &buffer) {
 		Error error =
-			ProtoKelEncodeImpl<typename ParameterPackType<i, T...>::type>::
+			ProtoKelEncodeImpl<typename Container::template ElementType<i>>::
 				encode(data.template get<i>(), buffer);
 		if (error.failed()) {
 			return error;
@@ -112,47 +123,52 @@ template <typename... T> struct ProtoKelEncodeImpl<MessageList<T...>> {
 		return encodeMembers<i + 1>(data, buffer);
 	}
 
-	static Error encode(typename MessageList<T...>::Reader data,
-						Buffer &buffer) {
+	static Error
+	encode(typename Message<schema::Tuple<T...>, Container>::Reader data,
+		   Buffer &buffer) {
 		return encodeMembers<0>(data, buffer);
 	}
 
 	template <size_t i = 0>
 	static typename std::enable_if<i == sizeof...(T), size_t>::type
-	sizeMembers(typename MessageList<T...>::Reader) {
+	sizeMembers(typename Message<schema::Tuple<T...>, Container>::Reader) {
 		return 0;
 	}
 
 	template <size_t i = 0>
 		static typename std::enable_if <
-		i<sizeof...(T), size_t>::type
-		sizeMembers(typename MessageList<T...>::Reader reader) {
-		return ProtoKelEncodeImpl<typename ParameterPackType<i, T...>::type>::
+		i<sizeof...(T), size_t>::type sizeMembers(
+			typename Message<schema::Tuple<T...>, Container>::Reader reader) {
+		return ProtoKelEncodeImpl<typename Container::template ElementType<i>>::
 				   size(reader.template get<i>()) +
 			   sizeMembers<i + 1>(reader);
 	}
 
-	static size_t size(typename MessageList<T...>::Reader reader) {
+	static size_t
+	size(typename Message<schema::Tuple<T...>, Container>::Reader reader) {
 		return sizeMembers<0>(reader);
 	}
 };
 
-template <typename... V, typename... K>
-struct ProtoKelEncodeImpl<MessageStruct<MessageStructMember<V, K>...>> {
+template <typename... V, StringLiteral... K, class Container>
+struct ProtoKelEncodeImpl<
+	Message<schema::Struct<schema::NamedMember<V, K>...>, Container>> {
 	template <size_t i = 0>
 	static typename std::enable_if<i == sizeof...(V), Error>::type
-	encodeMembers(typename MessageStruct<MessageStructMember<V, K>...>::Reader,
+	encodeMembers(typename Message<schema::Struct<schema::NamedMember<V, K>...>,
+								   Container>::Reader,
 				  Buffer &) {
 		return noError();
 	}
 	template <size_t i = 0>
 		static typename std::enable_if <
 		i<sizeof...(V), Error>::type encodeMembers(
-			typename MessageStruct<MessageStructMember<V, K>...>::Reader data,
+			typename Message<schema::Struct<schema::NamedMember<V, K>...>,
+							 Container>::Reader data,
 			Buffer &buffer) {
 
 		Error error =
-			ProtoKelEncodeImpl<typename ParameterPackType<i, V...>::type>::
+			ProtoKelEncodeImpl<typename Container::template ElementType<i>>::
 				encode(data.template get<i>(), buffer);
 		if (error.failed()) {
 			return error;
@@ -161,79 +177,87 @@ struct ProtoKelEncodeImpl<MessageStruct<MessageStructMember<V, K>...>> {
 	}
 
 	static Error
-	encode(typename MessageStruct<MessageStructMember<V, K>...>::Reader data,
+	encode(typename Message<schema::Struct<schema::NamedMember<V, K>...>,
+							Container>::Reader data,
 		   Buffer &buffer) {
 		return encodeMembers<0>(data, buffer);
 	}
 
 	template <size_t i = 0>
 	static typename std::enable_if<i == sizeof...(V), size_t>::type
-	sizeMembers(typename MessageStruct<MessageStructMember<V, K>...>::Reader) {
-		return 0;
-	}
-
-	template <size_t i = 0>
-		static typename std::enable_if <
-		i<sizeof...(V), size_t>::type
-		sizeMembers(typename MessageStruct<MessageStructMember<V, K>...>::Reader
-						reader) {
-		return ProtoKelEncodeImpl<typename ParameterPackType<i, V...>::type>::
-				   size(reader.template get<i>()) +
-			   sizeMembers<i + 1>(reader);
-	}
-
-	static size_t
-	size(typename MessageStruct<MessageStructMember<V, K>...>::Reader reader) {
-		return sizeMembers<0>(reader);
-	}
-};
-
-template <typename... V, typename... K>
-struct ProtoKelEncodeImpl<MessageUnion<MessageUnionMember<V, K>...>> {
-	template <size_t i = 0>
-	static typename std::enable_if<i == sizeof...(V), Error>::type
-	encodeMembers(typename MessageUnion<MessageUnionMember<V, K>...>::Reader,
-				  Buffer &) {
-		return noError();
-	}
-
-	template <size_t i = 0>
-		static typename std::enable_if <
-		i<sizeof...(V), Error>::type encodeMembers(
-			typename MessageUnion<MessageUnionMember<V, K>...>::Reader reader,
-			Buffer &buffer) {
-		if (reader.template holdsAlternative<
-				typename ParameterPackType<i, K...>::type>()) {
-			Error error = StreamValue<msg_union_id_t>::encode(i, buffer);
-			if (error.failed()) {
-				return error;
-			}
-			return ProtoKelEncodeImpl<typename ParameterPackType<
-				i, V...>::type>::encode(reader.template get<i>(), buffer);
-		}
-		return encodeMembers<i + 1>(reader, buffer);
-	}
-
-	static Error
-	encode(typename MessageUnion<MessageUnionMember<V, K>...>::Reader reader,
-		   Buffer &buffer) {
-		return encodeMembers<0>(reader, buffer);
-	}
-
-	template <size_t i = 0>
-	static typename std::enable_if<i == sizeof...(V), size_t>::type
-	sizeMembers(typename MessageUnion<MessageUnionMember<V, K>...>::Reader) {
+	sizeMembers(typename Message<schema::Struct<schema::NamedMember<V, K>...>,
+								 Container>::Reader) {
 		return 0;
 	}
 
 	template <size_t i = 0>
 		static typename std::enable_if <
 		i<sizeof...(V), size_t>::type sizeMembers(
-			typename MessageUnion<MessageUnionMember<V, K>...>::Reader reader) {
-		if (reader.template holdsAlternative<
-				typename ParameterPackType<i, K...>::type>()) {
-			return ProtoKelEncodeImpl<typename ParameterPackType<
-				i, V...>::type>::size(reader.template get<i>());
+			typename Message<schema::Struct<schema::NamedMember<V, K>...>,
+							 Container>::Reader reader) {
+		return ProtoKelEncodeImpl<typename Container::template ElementType<i>>::
+				   size(reader.template get<i>()) +
+			   sizeMembers<i + 1>(reader);
+	}
+
+	static size_t
+	size(typename Message<schema::Struct<schema::NamedMember<V, K>...>,
+						  Container>::Reader reader) {
+		return sizeMembers<0>(reader);
+	}
+};
+
+template <typename... V, StringLiteral... K, class Container>
+struct ProtoKelEncodeImpl<
+	Message<schema::Union<schema::NamedMember<V, K>...>, Container>> {
+
+	template <size_t i = 0>
+	static typename std::enable_if<i == sizeof...(V), Error>::type
+	encodeMembers(typename Message<schema::Union<schema::NamedMember<V, K>...>,
+								   Container>::Reader,
+				  Buffer &) {
+		return noError();
+	}
+
+	template <size_t i = 0>
+		static typename std::enable_if <
+		i<sizeof...(V), Error>::type encodeMembers(
+			typename Message<schema::Union<schema::NamedMember<V, K>...>,
+							 Container>::Reader reader,
+			Buffer &buffer) {
+		if (reader.index() == i) {
+			Error error = StreamValue<msg_union_id_t>::encode(i, buffer);
+			if (error.failed()) {
+				return error;
+			}
+			return ProtoKelEncodeImpl<typename Container::template ElementType<
+				i>>::encode(reader.template get<i>(), buffer);
+		}
+		return encodeMembers<i + 1>(reader, buffer);
+	}
+
+	static Error
+	encode(typename Message<schema::Union<schema::NamedMember<V, K>...>,
+							Container>::Reader reader,
+		   Buffer &buffer) {
+		return encodeMembers<0>(reader, buffer);
+	}
+
+	template <size_t i = 0>
+	static typename std::enable_if<i == sizeof...(V), size_t>::type
+	sizeMembers(typename Message<schema::Union<schema::NamedMember<V, K>...>,
+								 Container>::Reader) {
+		return 0;
+	}
+
+	template <size_t i = 0>
+		static typename std::enable_if <
+		i<sizeof...(V), size_t>::type sizeMembers(
+			typename Message<schema::Union<schema::NamedMember<V, K>...>,
+							 Container>::Reader reader) {
+		if (reader.index() == i) {
+			return ProtoKelEncodeImpl<typename Container::template ElementType<
+				i>>::size(reader.template get<i>());
 		}
 		return sizeMembers<i + 1>(reader);
 	}
@@ -242,8 +266,9 @@ struct ProtoKelEncodeImpl<MessageUnion<MessageUnionMember<V, K>...>> {
 	 * Size of union id + member size
 	 */
 	static size_t
-	size(typename MessageUnion<MessageUnionMember<V, K>...>::Reader reader) {
-		return sizeof(uint32_t) + sizeMembers<0>(reader);
+	size(typename Message<schema::Union<schema::NamedMember<V, K>...>,
+						  Container>::Reader reader) {
+		return sizeof(msg_union_id_t) + sizeMembers<0>(reader);
 	}
 };
 /*
@@ -251,19 +276,24 @@ struct ProtoKelEncodeImpl<MessageUnion<MessageUnionMember<V, K>...>> {
  */
 template <typename T> struct ProtoKelDecodeImpl;
 
-template <typename T> struct ProtoKelDecodeImpl<MessagePrimitive<T>> {
-	static Error decode(typename MessagePrimitive<T>::Builder data,
-						Buffer &buffer) {
-		T val = 0;
-		Error error = StreamValue<T>::decode(val, buffer);
+template <class T, size_t N, class Container>
+struct ProtoKelDecodeImpl<Message<schema::Primitive<T, N>, Container>> {
+	static Error
+	decode(typename Message<schema::Primitive<T, N>, Container>::Builder data,
+		   Buffer &buffer) {
+		typename PrimitiveTypeHelper<schema::Primitive<T, N>>::Type val = 0;
+		Error error = StreamValue<typename PrimitiveTypeHelper<
+			schema::Primitive<T, N>>::Type>::decode(val, buffer);
 		data.set(val);
 		return error;
 	}
 };
 
-template <> struct ProtoKelDecodeImpl<MessagePrimitive<std::string>> {
-	static Error decode(typename MessagePrimitive<std::string>::Builder data,
-						Buffer &buffer) {
+template <class Container>
+struct ProtoKelDecodeImpl<Message<schema::String, Container>> {
+	static Error
+	decode(typename Message<schema::String, Container>::Builder data,
+		   Buffer &buffer) {
 		size_t size = 0;
 		if (sizeof(size) > buffer.readCompositeLength()) {
 			return recoverableError("Buffer too small");
@@ -293,21 +323,23 @@ template <> struct ProtoKelDecodeImpl<MessagePrimitive<std::string>> {
 	}
 };
 
-template <typename... T> struct ProtoKelDecodeImpl<MessageList<T...>> {
+template <class... T, class Container>
+struct ProtoKelDecodeImpl<Message<schema::Tuple<T...>, Container>> {
 	template <size_t i = 0>
 	static typename std::enable_if<i == sizeof...(T), Error>::type
-	decodeMembers(typename MessageList<T...>::Builder, Buffer &) {
+	decodeMembers(typename Message<schema::Tuple<T...>, Container>::Builder,
+				  Buffer &) {
 		return noError();
 	}
 
 	template <size_t i = 0>
 		static typename std::enable_if <
-		i<sizeof...(T), Error>::type
-		decodeMembers(typename MessageList<T...>::Builder builder,
-					  Buffer &buffer) {
+		i<sizeof...(T), Error>::type decodeMembers(
+			typename Message<schema::Tuple<T...>, Container>::Builder builder,
+			Buffer &buffer) {
 
 		Error error =
-			ProtoKelDecodeImpl<typename ParameterPackType<i, T...>::type>::
+			ProtoKelDecodeImpl<typename Container::template ElementType<i>>::
 				decode(builder.template init<i>(), buffer);
 		if (error.failed()) {
 			return error;
@@ -315,17 +347,21 @@ template <typename... T> struct ProtoKelDecodeImpl<MessageList<T...>> {
 		return decodeMembers<i + 1>(builder, buffer);
 	}
 
-	static Error decode(typename MessageList<T...>::Builder builder,
-						Buffer &buffer) {
+	static Error
+	decode(typename Message<schema::Tuple<T...>, Container>::Builder builder,
+		   Buffer &buffer) {
 		return decodeMembers<0>(builder, buffer);
 	}
 };
 
-template <typename... V, typename... K>
-struct ProtoKelDecodeImpl<MessageStruct<MessageStructMember<V, K>...>> {
+template <class... V, StringLiteral... K, class Container>
+struct ProtoKelDecodeImpl<
+	Message<schema::Struct<schema::NamedMember<V, K>...>, Container>> {
+
 	template <size_t i = 0>
 	static typename std::enable_if<i == sizeof...(V), Error>::type
-	decodeMembers(typename MessageStruct<MessageStructMember<V, K>...>::Builder,
+	decodeMembers(typename Message<schema::Struct<schema::NamedMember<V, K>...>,
+								   Container>::Builder,
 				  Buffer &) {
 		return noError();
 	}
@@ -333,12 +369,12 @@ struct ProtoKelDecodeImpl<MessageStruct<MessageStructMember<V, K>...>> {
 	template <size_t i = 0>
 		static typename std::enable_if <
 		i<sizeof...(V), Error>::type decodeMembers(
-			typename MessageStruct<MessageStructMember<V, K>...>::Builder
-				builder,
+			typename Message<schema::Struct<schema::NamedMember<V, K>...>,
+							 Container>::Builder builder,
 			Buffer &buffer) {
 
 		Error error =
-			ProtoKelDecodeImpl<typename ParameterPackType<i, V...>::type>::
+			ProtoKelDecodeImpl<typename Container::template ElementType<i>>::
 				decode(builder.template init<i>(), buffer);
 		if (error.failed()) {
 			return error;
@@ -346,18 +382,21 @@ struct ProtoKelDecodeImpl<MessageStruct<MessageStructMember<V, K>...>> {
 		return decodeMembers<i + 1>(builder, buffer);
 	}
 
-	static Error decode(
-		typename MessageStruct<MessageStructMember<V, K>...>::Builder builder,
-		Buffer &buffer) {
+	static Error
+	decode(typename Message<schema::Struct<schema::NamedMember<V, K>...>,
+							Container>::Builder builder,
+		   Buffer &buffer) {
 		return decodeMembers<0>(builder, buffer);
 	}
 };
 
-template <typename... V, typename... K>
-struct ProtoKelDecodeImpl<MessageUnion<MessageUnionMember<V, K>...>> {
+template <class... V, StringLiteral... K, class Container>
+struct ProtoKelDecodeImpl<
+	Message<schema::Union<schema::NamedMember<V, K>...>, Container>> {
 	template <size_t i = 0>
 	static typename std::enable_if<i == sizeof...(V), Error>::type
-	decodeMembers(typename MessageUnion<MessageUnionMember<V, K>...>::Builder,
+	decodeMembers(typename Message<schema::Union<schema::NamedMember<V, K>...>,
+								   Container>::Builder,
 				  Buffer &, msg_union_id_t) {
 		return noError();
 	}
@@ -365,13 +404,14 @@ struct ProtoKelDecodeImpl<MessageUnion<MessageUnionMember<V, K>...>> {
 	template <size_t i = 0>
 		static typename std::enable_if <
 		i<sizeof...(V), Error>::type decodeMembers(
-			typename MessageUnion<MessageUnionMember<V, K>...>::Builder builder,
+			typename Message<schema::Union<schema::NamedMember<V, K>...>,
+							 Container>::Builder builder,
 			Buffer &buffer, msg_union_id_t id) {
 
 		if (id == i) {
 			Error error =
-				ProtoKelDecodeImpl<typename ParameterPackType<i, V...>::type>::
-					decode(builder.template init<i>(), buffer);
+				ProtoKelDecodeImpl<typename Container::template ElementType<
+					i>>::decode(builder.template init<i>(), buffer);
 			if (error.failed()) {
 				return error;
 			}
@@ -380,7 +420,8 @@ struct ProtoKelDecodeImpl<MessageUnion<MessageUnionMember<V, K>...>> {
 	}
 
 	static Error
-	decode(typename MessageUnion<MessageUnionMember<V, K>...>::Builder builder,
+	decode(typename Message<schema::Union<schema::NamedMember<V, K>...>,
+							Container>::Builder builder,
 		   Buffer &buffer) {
 		msg_union_id_t id = 0;
 		Error error = StreamValue<msg_union_id_t>::decode(id, buffer);
@@ -395,11 +436,13 @@ struct ProtoKelDecodeImpl<MessageUnion<MessageUnionMember<V, K>...>> {
 	}
 };
 
-template <typename T>
-Error ProtoKelCodec::encode(typename T::Reader reader, Buffer &buffer) {
+template <class Schema, class Container>
+Error ProtoKelCodec::encode(typename Message<Schema, Container>::Reader reader,
+							Buffer &buffer) {
 	BufferView view{buffer};
 
-	msg_packet_length_t packet_length = ProtoKelEncodeImpl<T>::size(reader);
+	msg_packet_length_t packet_length =
+		ProtoKelEncodeImpl<Message<Schema, Container>>::size(reader);
 	// Check the size of the packet for the first
 	// message length description
 
@@ -417,7 +460,8 @@ Error ProtoKelCodec::encode(typename T::Reader reader, Buffer &buffer) {
 		}
 	}
 	{
-		Error error = ProtoKelEncodeImpl<T>::encode(reader, view);
+		Error error = ProtoKelEncodeImpl<Message<Schema, Container>>::encode(
+			reader, view);
 		if (error.failed()) {
 			return error;
 		}
@@ -427,9 +471,10 @@ Error ProtoKelCodec::encode(typename T::Reader reader, Buffer &buffer) {
 	return noError();
 }
 
-template <typename T>
-Error ProtoKelCodec::decode(typename T::Builder builder, Buffer &buffer,
-							const Limits &limits) {
+template <class Schema, class Container>
+Error ProtoKelCodec::decode(
+	typename Message<Schema, Container>::Builder builder, Buffer &buffer,
+	const Limits &limits) {
 	BufferView view{buffer};
 
 	msg_packet_length_t packet_length = 0;
@@ -446,13 +491,15 @@ Error ProtoKelCodec::decode(typename T::Builder builder, Buffer &buffer,
 	}
 
 	{
-		Error error = ProtoKelDecodeImpl<T>::decode(builder, view);
+		Error error = ProtoKelDecodeImpl<Message<Schema, Container>>::decode(
+			builder, view);
 		if (error.failed()) {
 			return error;
 		}
 	}
 	{
-		if (ProtoKelEncodeImpl<T>::size(builder.asReader()) != packet_length) {
+		if (ProtoKelEncodeImpl<Message<Schema, Container>>::size(
+				builder.asReader()) != packet_length) {
 			return criticalError("Bad packet format");
 		}
 	}
@@ -461,4 +508,4 @@ Error ProtoKelCodec::decode(typename T::Builder builder, Buffer &buffer,
 	return noError();
 }
 
-} // namespace gin
\ No newline at end of file
+} // namespace gin
diff --git a/source/kelgin/schema.h b/source/kelgin/schema.h
new file mode 100644
index 0000000..40bdb3e
--- /dev/null
+++ b/source/kelgin/schema.h
@@ -0,0 +1,51 @@
+#pragma once
+
+#include "string_literal.h"
+
+namespace gin {
+namespace schema {
+
+template <class T, StringLiteral Literal> struct NamedMember {};
+
+template <class... T> struct Struct;
+
+template <class... V, StringLiteral... K>
+struct Struct<NamedMember<V, K>...> {};
+
+template <class... T> struct Union;
+
+template <class... V, StringLiteral... K> struct Union<NamedMember<V, K>...> {};
+
+template <class T> struct Array {};
+
+template <class... T> struct Tuple {};
+
+struct String {};
+
+struct SignedInteger {};
+struct UnsignedInteger {};
+struct FloatingPoint {};
+
+template <class T, size_t N> struct Primitive {
+	static_assert(((std::is_same_v<T, SignedInteger> ||
+					std::is_same_v<T, UnsignedInteger>)&&(N == 1 || N == 2 ||
+														  N == 4 || N == 8)) ||
+					  (std::is_same_v<T, FloatingPoint> && (N == 4 || N == 8)),
+				  "Primitive Type is not supported");
+};
+
+using Int8 = Primitive<SignedInteger, 1>;
+using Int16 = Primitive<SignedInteger, 2>;
+using Int32 = Primitive<SignedInteger, 4>;
+using Int64 = Primitive<SignedInteger, 8>;
+
+using UInt8 = Primitive<UnsignedInteger, 1>;
+using UInt16 = Primitive<UnsignedInteger, 2>;
+using UInt32 = Primitive<UnsignedInteger, 4>;
+using UInt64 = Primitive<UnsignedInteger, 8>;
+
+using Float32 = Primitive<FloatingPoint, 4>;
+using Float64 = Primitive<FloatingPoint, 8>;
+
+} // namespace schema
+} // namespace gin
diff --git a/source/kelgin/string_literal.h b/source/kelgin/string_literal.h
index b19cb54..40d4101 100644
--- a/source/kelgin/string_literal.h
+++ b/source/kelgin/string_literal.h
@@ -9,17 +9,32 @@ namespace gin {
  * literal. It guarantees compile time uniqueness and thus allows using strings
  * in template parameters.
  */
-template <typename T, T... Chars> class StringLiteral {
+template <class CharT, size_t N> class StringLiteral {
 public:
-	static constexpr std::array<T, sizeof...(Chars) + 1u> data = {Chars...,
-																  '\0'};
-	static constexpr std::string_view view() {
+	constexpr StringLiteral(const CharT (&input)[N]) noexcept {
+		for (size_t i = 0; i < N; ++i) {
+			data[i] = input[i];
+		}
+	}
+
+	std::array<CharT, N> data{};
+
+	constexpr std::string_view view() const noexcept {
 		return std::string_view{data.data()};
 	}
+
+	constexpr bool
+	operator==(const StringLiteral<CharT, N> &) const noexcept = default;
+
+	template <class CharTR, size_t NR>
+	constexpr bool
+	operator==(const StringLiteral<CharTR, NR> &) const noexcept {
+		return false;
+	}
 };
-} // namespace gin
 
 template <typename T, T... Chars>
-constexpr gin::StringLiteral<T, Chars...> operator""_t() {
-	return {};
-}
\ No newline at end of file
+constexpr gin::StringLiteral<T, sizeof...(Chars)> operator""_key() {
+	return gin::StringLiteral<T, sizeof...(Chars) + 1u>{Chars..., '\0'};
+}
+} // namespace gin
diff --git a/test/data/json.h b/test/data/json.h
deleted file mode 100644
index 998c811..0000000
--- a/test/data/json.h
+++ /dev/null
@@ -1,31 +0,0 @@
-#pragma once
-
-#include <string_view>
-
-#include "message.h"
-
-namespace gin {
-const std::string_view json_org_example = 
-R"({
-    "glossary": {
-        "title": "example glossary",
-		"GlossDiv": {
-            "title": "S",
-			"GlossList": {
-                "GlossEntry": {
-                    "ID": "SGML",
-					"SortAs": "SGML",
-					"GlossTerm": "Standard Generalized Markup Language",
-					"Acronym": "SGML",
-					"Abbrev": "ISO 8879:1986",
-					"GlossDef": {
-                        "para": "A meta-markup language, used to create markup languages such as DocBook.",
-						"GlossSeeAlso": ["GML", "XML"]
-                    },
-					"GlossSee": "markup"
-                }
-            }
-        }
-    }
-})";
-}
\ No newline at end of file
diff --git a/test/json.cpp b/test/json.cpp
deleted file mode 100644
index adccd5b..0000000
--- a/test/json.cpp
+++ /dev/null
@@ -1,289 +0,0 @@
-#include "suite/suite.h"
-
-#include <cstdint>
-#include <string>
-
-#include "buffer.h"
-#include "source/kelgin/message.h"
-#include "source/kelgin/json.h"
-
-#include "./data/json.h"
-
-using gin::MessageList;
-using gin::MessageStruct;
-using gin::MessageStructMember;
-using gin::MessagePrimitive;
-using gin::heapMessageBuilder;
-
-using gin::JsonCodec;
-using gin::Error;
-
-using gin::RingBuffer;
-
-namespace {
-typedef MessageList<MessagePrimitive<uint32_t>, MessagePrimitive<std::string> > TestList;
-
-GIN_TEST("JSON List Encoding"){
-	auto builder = heapMessageBuilder();
-	auto root = builder.initRoot<TestList>();
-	auto uint = root.init<0>();
-	uint.set(12);
-	auto string = root.init<1>();
-	string.set("free");
-
-	RingBuffer temp_buffer;
-	JsonCodec codec;
-	codec.encode<TestList>(root.asReader(), temp_buffer);
-
-	std::string tmp_string = temp_buffer.toString();
-	GIN_EXPECT(tmp_string == "[12,\"free\"]", std::string{"Bad encoding:\n"} + tmp_string);
-}
-
-typedef MessageStruct<
-	MessageStructMember<MessagePrimitive<uint32_t>, decltype("test_uint"_t)>,
-	MessageStructMember<MessagePrimitive<std::string>, decltype("test_string"_t)>,
-	MessageStructMember<MessagePrimitive<std::string>, decltype("test_name"_t)>,
-	MessageStructMember<MessagePrimitive<bool>, decltype("test_bool"_t)>
-> TestStruct;
-
-GIN_TEST("JSON Struct Encoding"){
-	auto builder = heapMessageBuilder();
-	auto root = builder.initRoot<TestStruct>();
-	
-	auto uint = root.init<decltype("test_uint"_t)>();
-	uint.set(23);
-
-	std::string test_string = "foo";
-	auto string = root.init<decltype("test_string"_t)>();
-	string.set(test_string);
-	
-	auto string_name = root.init<decltype("test_name"_t)>();
-	string_name.set("test_name"_t.view());
-
-	root.init<decltype("test_bool"_t)>().set(false);
-
-	JsonCodec codec;
-	RingBuffer temp_buffer;
-	codec.encode<TestStruct>(root.asReader(), temp_buffer);
-
-	std::string expected_result{"{\"test_uint\":23,\"test_string\":\"foo\",\"test_name\":\"test_name\",\"test_bool\":false}"};
-	
-	std::string tmp_string = temp_buffer.toString();
-	GIN_EXPECT(tmp_string == expected_result, std::string{"Bad encoding:\n"} + tmp_string);
-}
-
-typedef gin::MessageUnion<
-	gin::MessageUnionMember<gin::MessagePrimitive<uint32_t>, decltype("test_uint"_t)>,
-	gin::MessageUnionMember<gin::MessagePrimitive<std::string>, decltype("test_string"_t)>
-> TestUnion;
-
-GIN_TEST("JSON Union Encoding"){
-	using namespace gin;
-	{
-		auto builder = heapMessageBuilder();
-		auto root = builder.initRoot<TestUnion>();
-
-		auto test_uint = root.init<decltype("test_uint"_t)>();
-		test_uint.set(23);
-
-		RingBuffer buffer;
-		JsonCodec codec;
-
-		Error error = codec.encode<TestUnion>(root.asReader(), buffer);
-
-		GIN_EXPECT(!error.failed(), error.message());
-		
-		std::string expected_result{"{\"test_uint\":23}"};
-			
-		std::string tmp_string = buffer.toString();
-		GIN_EXPECT(tmp_string == expected_result, std::string{"Bad encoding:\n"} + tmp_string);
-	}
-	{
-		auto builder = heapMessageBuilder();
-		auto root = builder.initRoot<TestUnion>();
-
-		auto test_string = root.init<decltype("test_string"_t)>();
-		test_string.set("foo");
-
-		RingBuffer buffer;
-		JsonCodec codec;
-
-		Error error = codec.encode<TestUnion>(root.asReader(), buffer);
-
-		GIN_EXPECT(!error.failed(), error.message());
-
-		std::string expected_result{"{\"test_string\":\"foo\"}"};
-			
-		std::string tmp_string = buffer.toString();
-		GIN_EXPECT(tmp_string == expected_result, std::string{"Bad encoding:\n"} + tmp_string);
-	}
-}
-
-GIN_TEST("JSON Struct Decoding"){
-	std::string json_string = R"(
-	{
-		"test_string" :"banana" ,
-		"test_uint" : 5,
-		"test_name" : "keldu",
-		"test_bool" : true
-	})";
-
-	auto builder = heapMessageBuilder();
-	TestStruct::Builder root = builder.initRoot<TestStruct>();
-
-	JsonCodec codec;
-	RingBuffer temp_buffer;
-	temp_buffer.push(*reinterpret_cast<const uint8_t*>(json_string.data()), json_string.size());
-	Error error = codec.decode<TestStruct>(root, temp_buffer);
-	GIN_EXPECT( !error.failed(), error.message() );
-
-	auto reader = root.asReader();
-	GIN_EXPECT( reader.get<decltype("test_string"_t)>().get() == "banana", "Test String has wrong value" );
-	GIN_EXPECT( reader.get<decltype("test_uint"_t)>().get() == 5, "Test Unsigned has wrong value" );
-	GIN_EXPECT( reader.get<decltype("test_name"_t)>().get() == "keldu", "Test Name has wrong value" );
-	GIN_EXPECT( reader.get<decltype("test_bool"_t)>().get() == true, "Test Bool has wrong value" );
-}
-
-GIN_TEST("JSON List Decoding"){
-	std::string json_string = R"(
-	[
-		12, 
-			"free"
-	])";
-
-	auto builder = heapMessageBuilder();
-	TestList::Builder root = builder.initRoot<TestList>();
-
-	JsonCodec codec;
-	RingBuffer temp_buffer;
-	temp_buffer.push(*reinterpret_cast<const uint8_t*>(json_string.data()), json_string.size());
-	Error error = codec.decode<TestList>(root, temp_buffer);
-	GIN_EXPECT( !error.failed(), error.message() );
-
-	auto reader = root.asReader();
-	GIN_EXPECT( reader.get<0>().get() == 12, "Test Unsigned has wrong value" );
-	GIN_EXPECT( reader.get<1>().get() == "free", "Test String has wrong value" );
-}
-
-typedef MessageStruct<
-	MessageStructMember<MessagePrimitive<uint32_t>, decltype("test_uint"_t)>,
-	MessageStructMember<TestStruct, decltype("test_struct"_t)>,
-	MessageStructMember<MessagePrimitive<std::string>, decltype("test_name"_t)>
-> TestStructDepth;
-
-GIN_TEST("JSON Struct Decoding Two layer"){
-	std::string json_string = R"(
-	{
-		"test_struct" :{
-			"test_string" : 	"banana",
-			"test_uint": 40,
-			"test_name":"HaDiKo",
-			"test_bool" :false
-		},
-		"test_uint": 5,
-		"test_name" : "keldu"
-	})";
-
-	auto builder = heapMessageBuilder();
-	TestStructDepth::Builder root = builder.initRoot<TestStructDepth>();
-
-	JsonCodec codec;
-	RingBuffer temp_buffer;
-	temp_buffer.push(*reinterpret_cast<const uint8_t*>(json_string.data()), json_string.size());
-	Error error = codec.decode<TestStructDepth>(root, temp_buffer);
-	GIN_EXPECT( !error.failed(), error.message() );
-
-	auto reader = root.asReader();
-
-	auto inner_reader = reader.get<decltype("test_struct"_t)>();
-	
-	GIN_EXPECT( inner_reader.get<decltype("test_string"_t)>().get() == "banana", "Test String has wrong value" );
-	GIN_EXPECT( inner_reader.get<decltype("test_uint"_t)>().get() == 40, "Test Unsigned has wrong value" );
-	GIN_EXPECT( inner_reader.get<decltype("test_name"_t)>().get() == "HaDiKo", "Test Name has wrong value" );
-	GIN_EXPECT( inner_reader.get<decltype("test_bool"_t)>().get() == false, "Test Bool has wrong value" );
-	GIN_EXPECT( reader.get<decltype("test_uint"_t)>().get() == 5, "Test Unsigned has wrong value" );
-	GIN_EXPECT( reader.get<decltype("test_name"_t)>().get() == "keldu", "Test Name has wrong value" );
-}
-
-typedef MessageStruct<
-	MessageStructMember<
-		MessageStruct<
-			MessageStructMember< MessagePrimitive<std::string>, decltype("title"_t)>,
-			MessageStructMember<
-				MessageStruct<
-					MessageStructMember<MessagePrimitive<std::string>,decltype("title"_t)>,
-					MessageStructMember<
-						MessageStruct<
-							MessageStructMember<
-								MessageStruct<
-									MessageStructMember<MessagePrimitive<std::string>,decltype("ID"_t)>,
-									MessageStructMember<MessagePrimitive<std::string>,decltype("SortAs"_t)>,
-									MessageStructMember<MessagePrimitive<std::string>,decltype("GlossTerm"_t)>,
-									MessageStructMember<MessagePrimitive<std::string>,decltype("Acronym"_t)>,
-									MessageStructMember<MessagePrimitive<std::string>,decltype("Abbrev"_t)>,
-									MessageStructMember<
-										MessageStruct<
-											MessageStructMember<MessagePrimitive<std::string>, decltype("para"_t)>,
-											MessageStructMember<
-												MessageList<
-													MessagePrimitive<std::string>,
-													MessagePrimitive<std::string>
-												>
-											, decltype("GlossSeeAlso"_t)>
-										>
-									, decltype("GlossDef"_t)>,
-									MessageStructMember<MessagePrimitive<std::string>, decltype("GlossSee"_t)>
-								>
-							, decltype("GlossEntry"_t)>
-						>
-					, decltype("GlossList"_t)>
-				>
-			, decltype("GlossDiv"_t)>
-		>
-	, decltype("glossary"_t)>
-> TestJsonOrgExample;
-
-GIN_TEST ("JSON.org Decoding Example"){
-	auto builder = heapMessageBuilder();
-	TestJsonOrgExample::Builder root = builder.initRoot<TestJsonOrgExample>();
-
-	JsonCodec codec;
-	RingBuffer temp_buffer;
-	temp_buffer.push(*reinterpret_cast<const uint8_t*>(gin::json_org_example.data()), gin::json_org_example.size());
-
-	Error error = codec.decode<TestJsonOrgExample>(root, temp_buffer);
-	GIN_EXPECT(!error.failed(), error.message());
-
-	auto reader = root.asReader();
-
-	auto glossary_reader = reader.get<decltype("glossary"_t)>();
-
-	GIN_EXPECT(glossary_reader.get<decltype("title"_t)>().get() == "example glossary", "Bad glossary title");
-
-	auto gloss_div_reader = glossary_reader.get<decltype("GlossDiv"_t)>();
-
-	GIN_EXPECT(gloss_div_reader.get<decltype("title"_t)>().get() == "S", "bad gloss div value" );
-
-	auto gloss_list_reader = gloss_div_reader.get<decltype("GlossList"_t)>();
-
-	auto gloss_entry_reader = gloss_list_reader.get<decltype("GlossEntry"_t)>();
-
-	GIN_EXPECT(gloss_entry_reader.get<decltype("ID"_t)>().get() == "SGML", "bad ID value" );
-	GIN_EXPECT(gloss_entry_reader.get<decltype("SortAs"_t)>().get() == "SGML", "bad SortAs value" );
-	GIN_EXPECT(gloss_entry_reader.get<decltype("GlossTerm"_t)>().get() == "Standard Generalized Markup Language", "bad GlossTerm value" );
-	GIN_EXPECT(gloss_entry_reader.get<decltype("Acronym"_t)>().get() == "SGML", "bad Acronym value" );
-	GIN_EXPECT(gloss_entry_reader.get<decltype("Abbrev"_t)>().get() == "ISO 8879:1986", "bad Abbrev value" );
-	GIN_EXPECT(gloss_entry_reader.get<decltype("GlossSee"_t)>().get() == "markup", "bad GlossSee value" );
-
-	auto gloss_def_reader = gloss_entry_reader.get<decltype("GlossDef"_t)>();
-
-	GIN_EXPECT(gloss_def_reader.get<decltype("para"_t)>().get() == "A meta-markup language, used to create markup languages such as DocBook.", "para value wrong");
-
-	auto gloss_see_also_reader = gloss_def_reader.get<decltype("GlossSeeAlso"_t)>();
-
-	GIN_EXPECT(gloss_see_also_reader.get<0>().get() == "GML", "List 0 value wrong");
-	GIN_EXPECT(gloss_see_also_reader.get<1>().get() == "XML", "List 1 value wrong");
-
-	// (void) gloss_div_reader;
-}
-}
diff --git a/test/message.cpp b/test/message.cpp
index 7cd6042..182b457 100644
--- a/test/message.cpp
+++ b/test/message.cpp
@@ -4,50 +4,50 @@
 #include <string>
 
 #include "source/kelgin/message.h"
-using gin::MessageList;
-using gin::MessageStruct;
-using gin::MessageStructMember;
-using gin::MessagePrimitive;
-using gin::heapMessageBuilder;
+#include "source/kelgin/schema.h"
 
 namespace {
-typedef MessageList<MessagePrimitive<uint32_t>, MessagePrimitive<std::string> > TestList;
+namespace schema {
+	using namespace gin::schema;
+}
+
+using TestTuple = schema::Tuple<schema::UInt32, schema::String>;
 
 GIN_TEST("MessageList"){
 	std::string test_string_1 = "banana";
 	
-	auto builder = heapMessageBuilder();
-	auto root = builder.initRoot<TestList>();
-	auto uint = root.init<0>();
+	auto root = gin::heapMessageRoot<TestTuple>();
+	auto builder = root.build();
+	auto uint = builder.init<0>();
 	uint.set(10);
-	auto string = root.init<1>();
+	auto string = builder.init<1>();
 	string.set(test_string_1);
 
-	auto root_reader = root.asReader();
-	auto uint_reader = root_reader.get<0>();
-	auto string_reader = root_reader.get<1>();
+	auto reader = root.read();
+	auto uint_reader = reader.get<0>();
+	auto string_reader = reader.get<1>();
 	
 	GIN_EXPECT( uint_reader.get() == 10 && string_reader.get() == test_string_1, "wrong values");
 }
 
-typedef MessageList<MessageList<MessagePrimitive<uint32_t>, MessagePrimitive<std::string>>, MessagePrimitive<std::string> > NestedTestList;
+using NestedTestTuple = schema::Tuple<schema::Tuple<schema::UInt32, schema::String>, schema::String>;
 
 GIN_TEST("MessageList nested"){
 	std::string test_string_1 = "banana";
 	std::string test_string_2 = "bat";
 	
-	auto builder = heapMessageBuilder();
-	auto root = builder.initRoot<NestedTestList>();
-	auto inner_list = root.init<0>();
+	auto root = gin::heapMessageRoot<NestedTestTuple>();
+	auto builder = root.build();
+	auto inner_list = builder.init<0>();
 	auto uint = inner_list.init<0>();
 	uint.set(20);
 	auto inner_string = inner_list.init<1>();
 	inner_string.set(test_string_2);
 	
-	auto string = root.init<1>();
+	auto string = builder.init<1>();
 	string.set(test_string_1);
 
-	auto root_reader = root.asReader();
+	auto root_reader = root.read();
 	auto inner_reader = root_reader.get<0>();
 	auto uint_reader = inner_reader.get<0>();
 	auto inner_string_reader = inner_reader.get<1>();
@@ -56,30 +56,33 @@ GIN_TEST("MessageList nested"){
 	GIN_EXPECT(uint_reader.get() == 20 && inner_string_reader.get() == test_string_2 && string_reader.get() == test_string_1, "wrong values");
 }
 
-typedef MessageStruct<
-	MessageStructMember<MessagePrimitive<uint32_t>, decltype("test_uint"_t)>,
-	MessageStructMember<MessagePrimitive<std::string>, decltype("test_string"_t)>,
-	MessageStructMember<MessagePrimitive<std::string>, decltype("test_name"_t)>
-> TestStruct;
+using TestStruct = schema::Struct<
+	schema::NamedMember<schema::UInt32, "test_uint">,
+	schema::NamedMember<schema::String, "test_string">,
+	schema::NamedMember<schema::String, "test_name">
+>;
 
 GIN_TEST("MessageStruct"){
 	std::string test_string = "foo";
-	auto builder = heapMessageBuilder();
-	auto root = builder.initRoot<TestStruct>();
-	auto uint = root.init<decltype("test_uint"_t)>();
+	auto root = gin::heapMessageRoot<TestStruct>();
+	auto builder = root.build();
+	auto uint = builder.init<"test_uint">();
 	uint.set(23);
-	auto string = root.init<decltype("test_string"_t)>();
+	auto string = builder.init<"test_string">();
 	string.set(test_string);
-	auto string_name = root.init<decltype("test_name"_t)>();
-	string_name.set(&"test_name"_t.data[0]);
+	auto string_name = builder.init<"test_name">();
+	string_name.set("test_name");
 
-	auto reader = root.asReader();
-	auto uint_reader = reader.get<decltype("test_uint"_t)>();
-	auto string_reader = reader.get<decltype("test_string"_t)>();
-	auto name_reader = reader.get<decltype("test_name"_t)>();
+	auto reader = root.read();
+	auto uint_reader = reader.get<"test_uint">();
+	auto string_reader = reader.get<"test_string">();
+	auto name_reader = reader.get<"test_name">();
 
+	/*
+	 * Set string to another value to guarantee no changes
+	 */
 	test_string = "foo2";
 
 	GIN_EXPECT(uint_reader.get() == 23 && string_reader.get() != test_string && string_reader.get() == "foo" && name_reader.get() == "test_name", "wrong values");
 }
-}
\ No newline at end of file
+}
diff --git a/test/proto_kel.cpp b/test/proto_kel.cpp
index cd0a029..074ad3e 100644
--- a/test/proto_kel.cpp
+++ b/test/proto_kel.cpp
@@ -5,54 +5,59 @@
 #include <iostream>
 
 namespace {
-typedef gin::MessagePrimitive<uint32_t> TestSize;
+namespace schema {
+	using namespace gin::schema;
+}
+using TestSize = schema::UInt32;
 
-typedef gin::MessageList<gin::MessagePrimitive<uint32_t>, gin::MessagePrimitive<uint16_t>> TestList;
+using TestTuple = schema::Tuple<schema::UInt32, schema::UInt16>;
 
-typedef gin::MessageStruct<
-	gin::MessageStructMember<gin::MessagePrimitive<uint32_t>, decltype("test_uint"_t)>,
-	gin::MessageStructMember<gin::MessagePrimitive<std::string>, decltype("test_string"_t)>,
-	gin::MessageStructMember<gin::MessagePrimitive<std::string>, decltype("test_name"_t)>
-> TestStruct;
+using TestStruct = schema::Struct<
+	schema::NamedMember<schema::UInt32, "test_uint">,
+	schema::NamedMember<schema::String, "test_string">,
+	schema::NamedMember<schema::String, "test_name">
+>;
 
-typedef gin::MessageUnion<
-	gin::MessageUnionMember<gin::MessagePrimitive<uint32_t>, decltype("test_uint"_t)>,
-	gin::MessageUnionMember<gin::MessagePrimitive<std::string>, decltype("test_string"_t)>
-> TestUnion;
+using TestUnion = schema::Union<
+	schema::NamedMember<schema::UInt32, "test_uint">,
+	schema::NamedMember<schema::String, "test_string">
+>;
 
 GIN_TEST("Primitive Encoding"){
 	using namespace gin;
 	uint32_t value = 5;
 
-	auto builder = heapMessageBuilder();
-	auto root = builder.initRoot<TestSize>();
+	auto root = heapMessageRoot<TestSize>();
+	auto builder = root.build();
 
-	root.set(value);
+	builder.set(value);
 
 	RingBuffer temp_buffer;
+	ProtoKelCodec codec;
 
-	Error error = ProtoKelEncodeImpl<TestSize>::encode(root.asReader(), temp_buffer);
+	Error error = codec.encode<TestSize>(root.read(), temp_buffer);
 
 	GIN_EXPECT(!error.failed(), error.message());
-	GIN_EXPECT(temp_buffer.readCompositeLength() == sizeof(value), "Bad Size: " + std::to_string(temp_buffer.readCompositeLength()));
-	GIN_EXPECT(temp_buffer[0] == 5 && temp_buffer[1] == 0 && temp_buffer[2] == 0 && temp_buffer[3] == 0, "Wrong encoded values");
+	GIN_EXPECT(temp_buffer.readCompositeLength() == (sizeof(value)+sizeof(msg_packet_length_t)), "Bad Size: " + std::to_string(temp_buffer.readCompositeLength()));
+	constexpr size_t pkt_shift = sizeof(msg_packet_length_t);
+	GIN_EXPECT(temp_buffer[pkt_shift] == 5 && temp_buffer[pkt_shift+1] == 0 && temp_buffer[pkt_shift+2] == 0 && temp_buffer[pkt_shift+3] == 0, "Wrong encoded values");
 }
 
 GIN_TEST("List Encoding"){
 	using namespace gin;
 
-	auto builder = heapMessageBuilder();
-	auto root = builder.initRoot<TestList>();
+	auto root = heapMessageRoot<TestTuple>();
+	auto builder = root.build();
 
-	auto first = root.init<0>();
+	auto first = builder.init<0>();
 	first.set(2135231);
-	auto second = root.init<1>();
+	auto second = builder.init<1>();
 	second.set(43871);
 
 	RingBuffer buffer;
 	ProtoKelCodec codec;
 
-	Error error = codec.encode<TestList>(root.asReader(), buffer);
+	Error error = codec.encode<TestTuple>(root.read(), buffer);
 
 	GIN_EXPECT(!error.failed(), error.message());
 	GIN_EXPECT(buffer.readCompositeLength() == 14, "Bad Size: " + std::to_string(buffer.readCompositeLength()));
@@ -62,23 +67,23 @@ GIN_TEST("List Encoding"){
 GIN_TEST("Struct Encoding"){
 	using namespace gin;
 
-	auto builder = heapMessageBuilder();
-	auto root = builder.initRoot<TestStruct>();
+	auto root = heapMessageRoot<TestStruct>();
+	auto builder = root.build();
 
-	auto test_uint = root.init<decltype("test_uint"_t)>();
+	auto test_uint = builder.init<"test_uint">();
 	test_uint.set(23);
 
 	std::string test_string = "foo";
-	auto string = root.init<decltype("test_string"_t)>();
+	auto string = builder.init<"test_string">();
 	string.set(test_string);
 	
-	auto string_name = root.init<decltype("test_name"_t)>();
-	string_name.set("test_name"_t.view());
+	auto string_name = builder.init<"test_name">();
+	string_name.set("test_name");
 
 	RingBuffer buffer;
 	ProtoKelCodec codec;
 
-	Error error = codec.encode<TestStruct>(root.asReader(), buffer);
+	Error error = codec.encode<TestStruct>(builder.asReader(), buffer);
 
 	GIN_EXPECT(!error.failed(), error.message());
 	GIN_EXPECT(buffer.readCompositeLength() == 40, "Bad Size: " + std::to_string(buffer.readCompositeLength()));
@@ -89,16 +94,16 @@ GIN_TEST("Struct Encoding"){
 GIN_TEST("Union Encoding"){
 	using namespace gin;
 	{
-		auto builder = heapMessageBuilder();
-		auto root = builder.initRoot<TestUnion>();
+		auto root = heapMessageRoot<TestUnion>();
+		auto builder = root.build();
 
-		auto test_uint = root.init<decltype("test_uint"_t)>();
+		auto test_uint = builder.init<"test_uint">();
 		test_uint.set(23);
 
 		RingBuffer buffer;
 		ProtoKelCodec codec;
 
-		Error error = codec.encode<TestUnion>(root.asReader(), buffer);
+		Error error = codec.encode<TestUnion>(builder.asReader(), buffer);
 
 		GIN_EXPECT(!error.failed(), error.message());
 		GIN_EXPECT(buffer.readCompositeLength() == 16, "Bad Size: " + std::to_string(buffer.readCompositeLength()));
@@ -106,16 +111,16 @@ GIN_TEST("Union Encoding"){
 			== buffer.toHex(), "Not equal encoding:\n"+buffer.toHex());
 	}
 	{
-		auto builder = heapMessageBuilder();
-		auto root = builder.initRoot<TestUnion>();
+		auto root = heapMessageRoot<TestUnion>();
+		auto builder = root.build();
 
-		auto test_string = root.init<decltype("test_string"_t)>();
+		auto test_string = builder.init<"test_string">();
 		test_string.set("foo");
 
 		RingBuffer buffer;
 		ProtoKelCodec codec;
 
-		Error error = codec.encode<TestUnion>(root.asReader(), buffer);
+		Error error = codec.encode<TestUnion>(builder.asReader(), buffer);
 
 		GIN_EXPECT(!error.failed(), error.message());
 		GIN_EXPECT(buffer.readCompositeLength() == 23, "Bad Size: " + std::to_string(buffer.readCompositeLength()));
@@ -124,7 +129,7 @@ GIN_TEST("Union Encoding"){
 	}
 }
 
-GIN_TEST("List Decoding"){
+GIN_TEST("Tuple Decoding"){
 	using namespace gin;
 	const uint8_t buffer_raw[] = {0x06, 0, 0, 0, 0, 0, 0, 0, 0xbf, 0x94, 0x20, 0x00, 0x5f, 0xab};
 
@@ -133,13 +138,13 @@ GIN_TEST("List Decoding"){
 
 	ProtoKelCodec codec;
 
-	auto builder = heapMessageBuilder();
-	auto root = builder.initRoot<TestList>();
+	auto root = heapMessageRoot<TestTuple>();
+	auto builder = root.build();
 
-	Error error = codec.decode<TestList>(root, buffer);
+	Error error = codec.decode<TestTuple>(builder, buffer);
 	GIN_EXPECT(!error.failed(), error.message());
 	
-	auto reader = root.asReader();
+	auto reader = builder.asReader();
 
 	auto first = reader.get<0>();
 	auto second = reader.get<1>();
@@ -156,15 +161,15 @@ GIN_TEST("Struct Decoding"){
 
 	ProtoKelCodec codec;
 
-	auto builder = heapMessageBuilder();
-	auto root = builder.initRoot<TestStruct>();
+	auto root = heapMessageRoot<TestStruct>();
+	auto builder = root.build();
 
-	Error error = codec.decode<TestStruct>(root, buffer);
-	auto reader = root.asReader();
+	Error error = codec.decode<TestStruct>(builder, buffer);
+	auto reader = builder.asReader();
 
-	auto foo_string = reader.get<decltype("test_string"_t)>();
-	auto test_uint = reader.get<decltype("test_uint"_t)>();
-	auto test_name = reader.get<decltype("test_name"_t)>();
+	auto foo_string = reader.get<"test_string">();
+	auto test_uint = reader.get<"test_uint">();
+	auto test_name = reader.get<"test_name">();
 
 	GIN_EXPECT(!error.failed(), error.message());
 	GIN_EXPECT(foo_string.get() == "foo" && test_uint.get() == 23 && test_name.get() == "test_name", "Values not correctly decoded");
@@ -179,15 +184,15 @@ GIN_TEST("Union Decoding"){
 
 	ProtoKelCodec codec;
 
-	auto builder = heapMessageBuilder();
-	auto root = builder.initRoot<TestUnion>();
-	auto reader = root.asReader();
+	auto root = heapMessageRoot<TestUnion>();
+	auto builder = root.build();
+	auto reader = builder.asReader();
 
-	Error error = codec.decode<TestUnion>(root, buffer);
+	Error error = codec.decode<TestUnion>(builder, buffer);
 
 	GIN_EXPECT(!error.failed(), error.message());
-	GIN_EXPECT(reader.holdsAlternative<decltype("test_string"_t)>(), "Wrong union value");
-	auto str_rd = reader.get<decltype("test_string"_t)>();
+	GIN_EXPECT(reader.hasAlternative<"test_string">(), "Wrong union value");
+	auto str_rd = reader.get<"test_string">();
 	GIN_EXPECT(str_rd.get() == "foo", "Wrong value: " + std::string{str_rd.get()});
 }
 }