diff --git a/.clang-tidy b/.clang-tidy
index f9fdf11..2776bd4 100644
--- a/.clang-tidy
+++ b/.clang-tidy
@@ -1,6 +1,9 @@
 Checks: '-*,readability-identifier-naming'
 CheckOptions:
   - { key: readability-identifier-naming.PrivateMemberSuffix,  value: "_" }
+  - { key: readability-identifier-naming.AggressiveDependentMemberLookup,  value: true }
   - { key: readability-identifier-naming.ProtectedMemberSuffix,  value: "_" }
   - { key: readability-identifier-naming.ClassCase,  value: "lower_case" }
   - { key: readability-identifier-naming.StructCase,  value: "lower_case" }
+  - { key: readability-identifier-naming.FunctionCase,  value: "lower_case" }
+  - { key: readability-identifier-naming.MethodCase,  value: "lower_case" }
diff --git a/driver/io_unix.cpp b/driver/io_unix.cpp
index 1a175c8..c0a5630 100644
--- a/driver/io_unix.cpp
+++ b/driver/io_unix.cpp
@@ -129,7 +129,7 @@ unix_datagram::unix_datagram(unix_event_port &event_port, int file_descriptor,
 	: i_fd_owner{event_port, file_descriptor, fd_flags, EPOLLIN | EPOLLOUT} {}
 
 namespace {
-ssize_t unixReadMsg(int fd, void *buffer, size_t length) {
+ssize_t unix_read_msg(int fd, void *buffer, size_t length) {
 	struct ::sockaddr_storage their_addr;
 	socklen_t addr_len = sizeof(sockaddr_storage);
 	return ::recvfrom(fd, buffer, length, 0,
@@ -137,15 +137,15 @@ ssize_t unixReadMsg(int fd, void *buffer, size_t length) {
 					  &addr_len);
 }
 
-ssize_t unixWriteMsg(int fd, const void *buffer, size_t length,
-					 ::sockaddr *dest_addr, socklen_t dest_addr_len) {
+ssize_t unix_write_msg(int fd, const void *buffer, size_t length,
+					   ::sockaddr *dest_addr, socklen_t dest_addr_len) {
 
 	return ::sendto(fd, buffer, length, 0, dest_addr, dest_addr_len);
 }
 } // namespace
 
 error_or<size_t> unix_datagram::read(void *buffer, size_t length) {
-	ssize_t read_bytes = unixReadMsg(fd(), buffer, length);
+	ssize_t read_bytes = unix_read_msg(fd(), buffer, length);
 	if (read_bytes > 0) {
 		return static_cast<size_t>(read_bytes);
 	}
@@ -163,8 +163,8 @@ error_or<size_t> unix_datagram::write(const void *buffer, size_t length,
 	unix_network_address &unix_dest = static_cast<unix_network_address &>(dest);
 	socket_address &sock_addr = unix_dest.unix_address();
 	socklen_t sock_addr_length = sock_addr.get_raw_length();
-	ssize_t write_bytes = unixWriteMsg(fd(), buffer, length,
-									   sock_addr.get_raw(), sock_addr_length);
+	ssize_t write_bytes = unix_write_msg(fd(), buffer, length,
+										 sock_addr.get_raw(), sock_addr_length);
 	if (write_bytes > 0) {
 		return static_cast<size_t>(write_bytes);
 	}
@@ -192,14 +192,14 @@ void unix_datagram::notify(uint32_t mask) {
 }
 
 namespace {
-bool beginsWith(const std::string_view &viewed,
-				const std::string_view &begins) {
+bool begins_with(const std::string_view &viewed,
+				 const std::string_view &begins) {
 	return viewed.size() >= begins.size() &&
 		   viewed.compare(0, begins.size(), begins) == 0;
 }
 
 std::variant<unix_network_address, unix_network_address *>
-translateNetworkAddressToUnixNetworkAddress(network_address &addr) {
+translate_network_address_to_unix_network_address(network_address &addr) {
 	auto addr_variant = addr.representation();
 	std::variant<unix_network_address, unix_network_address *> os_addr =
 		std::visit(
@@ -221,7 +221,7 @@ translateNetworkAddressToUnixNetworkAddress(network_address &addr) {
 	return os_addr;
 }
 
-unix_network_address &translateToUnixAddressRef(
+unix_network_address &translate_to_unix_address_ref(
 	std::variant<unix_network_address, unix_network_address *> &addr_variant) {
 	return std::visit(
 		[](auto &arg) -> unix_network_address & {
@@ -241,9 +241,10 @@ unix_network_address &translateToUnixAddressRef(
 } // namespace
 
 own<server> unix_network::listen(network_address &addr) {
-	auto unix_addr_storage = translateNetworkAddressToUnixNetworkAddress(addr);
+	auto unix_addr_storage =
+		translate_network_address_to_unix_network_address(addr);
 	unix_network_address &address =
-		translateToUnixAddressRef(unix_addr_storage);
+		translate_to_unix_address_ref(unix_addr_storage);
 
 	assert(address.unix_address_size() > 0);
 	if (address.unix_address_size() == 0) {
@@ -274,9 +275,10 @@ own<server> unix_network::listen(network_address &addr) {
 }
 
 conveyor<own<io_stream>> unix_network::connect(network_address &addr) {
-	auto unix_addr_storage = translateNetworkAddressToUnixNetworkAddress(addr);
+	auto unix_addr_storage =
+		translate_network_address_to_unix_network_address(addr);
 	unix_network_address &address =
-		translateToUnixAddressRef(unix_addr_storage);
+		translate_to_unix_address_ref(unix_addr_storage);
 
 	assert(address.unix_address_size() > 0);
 	if (address.unix_address_size() == 0) {
@@ -335,9 +337,10 @@ conveyor<own<io_stream>> unix_network::connect(network_address &addr) {
 }
 
 own<datagram> unix_network::datagram(network_address &addr) {
-	auto unix_addr_storage = translateNetworkAddressToUnixNetworkAddress(addr);
+	auto unix_addr_storage =
+		translate_network_address_to_unix_network_address(addr);
 	unix_network_address &address =
-		translateToUnixAddressRef(unix_addr_storage);
+		translate_to_unix_address_ref(unix_addr_storage);
 
 	SAW_ASSERT(address.unix_address_size() > 0) { return nullptr; }
 
@@ -380,9 +383,9 @@ conveyor<own<network_address>>
 unix_network::resolve_address(const std::string &path, uint16_t port_hint) {
 	std::string_view addr_view{path};
 	{
-		std::string_view begins_with = "unix:";
-		if (beginsWith(addr_view, begins_with)) {
-			addr_view.remove_prefix(begins_with.size());
+		std::string_view str_begins_with = "unix:";
+		if (begins_with(addr_view, str_begins_with)) {
+			addr_view.remove_prefix(str_begins_with.size());
 		}
 	}
 
diff --git a/source/forstio/async.h b/source/forstio/async.h
index 699d971..e0f2dbd 100644
--- a/source/forstio/async.h
+++ b/source/forstio/async.h
@@ -291,7 +291,7 @@ template <typename Func> conveyor_result<Func, void> exec_later(Func &&func);
  */
 template <typename... Args>
 conveyor<std::tuple<Args...>>
-joinConveyors(std::tuple<conveyor<Args>...> &conveyors);
+join_conveyors(std::tuple<conveyor<Args>...> &conveyors);
 
 template <typename T> class conveyor_feeder {
 public:
@@ -460,11 +460,11 @@ public:
 	void poll();
 };
 
-template <typename Func> conveyor_result<Func, void> yieldNext(Func &&func);
+template <typename Func> conveyor_result<Func, void> yield_next(Func &&func);
 
-template <typename Func> conveyor_result<Func, void> yieldLater(Func &&func);
+template <typename Func> conveyor_result<Func, void> yield_later(Func &&func);
 
-template <typename Func> conveyor_result<Func, void> yieldLast(Func &&func);
+template <typename Func> conveyor_result<Func, void> yield_last(Func &&func);
 } // namespace saw
 
 // Secret stuff
diff --git a/source/forstio/error.h b/source/forstio/error.h
index ebe928c..d8a5ae2 100644
--- a/source/forstio/error.h
+++ b/source/forstio/error.h
@@ -106,7 +106,8 @@ template <typename T> class error_or final : public error_or_value {
 private:
 	std::variant<error, fix_void<T>> value_or_error_;
 
-	static_assert(!std::is_same_v<T, void_t>, "Don't use internal private types");
+	static_assert(!std::is_same_v<T, void_t>,
+				  "Don't use internal private types");
 
 public:
 	error_or() = default;
diff --git a/source/forstio/io.cpp b/source/forstio/io.cpp
index c6ef90c..f0705d2 100644
--- a/source/forstio/io.cpp
+++ b/source/forstio/io.cpp
@@ -10,7 +10,7 @@ async_io_stream::async_io_stream(own<io_stream> str)
 					  .then([this]() { read_stepper_.read_step(*stream_); })
 					  .sink()},
 	  write_ready_{stream_->write_ready()
-					   .then([this]() { write_stepper_.writeStep(*stream_); })
+					   .then([this]() { write_stepper_.write_step(*stream_); })
 					   .sink()},
 	  read_disconnected_{stream_->on_read_disconnected()
 							 .then([this]() {
@@ -49,7 +49,7 @@ void async_io_stream::write(const void *buffer, size_t length) {
 
 	write_stepper_.write_task =
 		write_task_and_step_helper::write_io_task{buffer, length, 0};
-	write_stepper_.writeStep(*stream_);
+	write_stepper_.write_step(*stream_);
 }
 
 conveyor<size_t> async_io_stream::write_done() {
diff --git a/source/forstio/io_helpers.cpp b/source/forstio/io_helpers.cpp
index 0b0ebf0..47c5017 100644
--- a/source/forstio/io_helpers.cpp
+++ b/source/forstio/io_helpers.cpp
@@ -1,4 +1,4 @@
-#include "io_helpers.h"
+#include "io_helpers.h"
 
 #include "io.h"
 
@@ -44,7 +44,7 @@ void read_task_and_step_helper::read_step(input_stream &reader) {
 	}
 }
 
-void write_task_and_step_helper::writeStep(output_stream &writer) {
+void write_task_and_step_helper::write_step(output_stream &writer) {
 	while (write_task.has_value()) {
 		write_io_task &task = *write_task;
 
@@ -82,4 +82,4 @@ void write_task_and_step_helper::writeStep(output_stream &writer) {
 	}
 }
 
-} // namespace saw
\ No newline at end of file
+} // namespace saw
diff --git a/source/forstio/io_helpers.h b/source/forstio/io_helpers.h
index 1c2626a..9e9ff20 100644
--- a/source/forstio/io_helpers.h
+++ b/source/forstio/io_helpers.h
@@ -48,6 +48,6 @@ public:
 	own<conveyor_feeder<size_t>> write_done = nullptr;
 
 public:
-	void writeStep(output_stream &writer);
+	void write_step(output_stream &writer);
 };
 } // namespace saw
diff --git a/source/forstio/io_peer.h b/source/forstio/io_peer.h
index 0d55322..5f5b7e6 100644
--- a/source/forstio/io_peer.h
+++ b/source/forstio/io_peer.h
@@ -17,13 +17,13 @@ public:
 	 *
 	 */
 	streaming_io_peer(
-		own<conveyor_feeder<HeapMessageRoot<Incoming, InContainer>>> feed,
+		own<conveyor_feeder<heap_message_root<Incoming, InContainer>>> feed,
 		own<async_io_stream> stream, Codec codec, BufferT in, BufferT out);
 	/**
 	 *
 	 */
 	streaming_io_peer(
-		own<conveyor_feeder<HeapMessageRoot<Incoming, InContainer>>> feed,
+		own<conveyor_feeder<heap_message_root<Incoming, InContainer>>> feed,
 		own<async_io_stream> stream);
 
 	/**
@@ -35,26 +35,26 @@ public:
 	/**
 	 * Send a message to the remote peer
 	 */
-	error send(HeapMessageRoot<Outgoing, OutContainer> builder);
+	error send(heap_message_root<Outgoing, OutContainer> builder);
 
 	/**
 	 * A phantom conveyor feeder. Meant for interfacing with other components
 	 */
-	conveyor_feeder<HeapMessageRoot<Outgoing, OutContainer>> &feeder();
+	conveyor_feeder<heap_message_root<Outgoing, OutContainer>> &feeder();
 
 	conveyor<void> on_read_disconnected();
 
 private:
 	/// @unimplemented
 	class peer_conveyor_feeder final
-		: public conveyor_feeder<HeapMessageRoot<Outgoing, OutContainer>> {
+		: public conveyor_feeder<heap_message_root<Outgoing, OutContainer>> {
 	public:
 		peer_conveyor_feeder(
 			streaming_io_peer<Codec, Incoming, Outgoing, InContainer,
 							  OutContainer, BufferT> &peer_)
 			: peer_{peer_} {}
 
-		void feed(HeapMessageRoot<Outgoing, OutContainer> &&data) override {
+		void feed(heap_message_root<Outgoing, OutContainer> &&data) override {
 			(void)data;
 		}
 
@@ -70,7 +70,7 @@ private:
 	};
 
 private:
-	own<conveyor_feeder<HeapMessageRoot<Incoming, InContainer>>>
+	own<conveyor_feeder<heap_message_root<Incoming, InContainer>>>
 		incoming_feeder_ = nullptr;
 
 	own<async_io_stream> io_stream_;
@@ -96,8 +96,8 @@ template <typename Codec, typename Incoming, typename Outgoing,
 		  typename BufferT = ring_buffer>
 std::pair<own<streaming_io_peer<Codec, Incoming, Outgoing, InContainer,
 								OutContainer, BufferT>>,
-		  conveyor<HeapMessageRoot<Incoming, InContainer>>>
-newStreamingIoPeer(own<async_io_stream> stream);
+		  conveyor<heap_message_root<Incoming, InContainer>>>
+new_streaming_io_peer(own<async_io_stream> stream);
 
 } // namespace saw
 
diff --git a/source/forstio/io_peer.tmpl.h b/source/forstio/io_peer.tmpl.h
index 8af7753..880a58a 100644
--- a/source/forstio/io_peer.tmpl.h
+++ b/source/forstio/io_peer.tmpl.h
@@ -2,58 +2,59 @@ namespace saw {
 
 template <typename Codec, typename Incoming, typename Outgoing,
 		  typename InContainer, typename OutContainer, typename BufferT>
-streaming_io_peer<Codec, Incoming, Outgoing, InContainer, OutContainer, BufferT>::
+streaming_io_peer<Codec, Incoming, Outgoing, InContainer, OutContainer,
+				  BufferT>::
 	streaming_io_peer(
-		own<conveyor_feeder<HeapMessageRoot<Incoming, InContainer>>> feed,
+		own<conveyor_feeder<heap_message_root<Incoming, InContainer>>> feed,
 		own<async_io_stream> str)
 	: streaming_io_peer{std::move(feed), std::move(str), {}, {}, {}} {}
 
 template <typename Codec, typename Incoming, typename Outgoing,
 		  typename InContainer, typename OutContainer, typename BufferT>
-streaming_io_peer<Codec, Incoming, Outgoing, InContainer, OutContainer, BufferT>::
+streaming_io_peer<Codec, Incoming, Outgoing, InContainer, OutContainer,
+				  BufferT>::
 	streaming_io_peer(
-		own<conveyor_feeder<HeapMessageRoot<Incoming, InContainer>>> feed,
+		own<conveyor_feeder<heap_message_root<Incoming, InContainer>>> feed,
 		own<async_io_stream> stream, Codec codec, BufferT in, BufferT out)
 	: incoming_feeder_{std::move(feed)},
 	  io_stream_{std::move(stream)}, codec_{std::move(codec)},
 	  in_buffer_{std::move(in)}, out_buffer_{std::move(out)},
-	  sink_read_{io_stream_->read_done()
-					 .then([this](size_t bytes) -> error_or<void> {
-						 in_buffer_.write_advance(bytes);
+	  sink_read_{
+		  io_stream_->read_done()
+			  .then([this](size_t bytes) -> error_or<void> {
+				  in_buffer_.write_advance(bytes);
 
-						 if (in_buffer_.write_segment_length() == 0) {
-							 return critical_error("Message too long");
-						 }
+				  if (in_buffer_.write_segment_length() == 0) {
+					  return critical_error("Message too long");
+				  }
 
-						 io_stream_->read(&in_buffer_.write(), 1,
-										  in_buffer_.write_segment_length());
+				  io_stream_->read(&in_buffer_.write(), 1,
+								   in_buffer_.write_segment_length());
 
-						 while (true) {
-							 auto root =
-								 heapMessageRoot<Incoming, InContainer>();
-							 auto builder = root.build();
+				  while (true) {
+					  auto root = heap_message_root<Incoming, InContainer>();
+					  auto builder = root.build();
 
-							 error err =
-								 codec_.template decode<Incoming, InContainer>(
-									 builder, in_buffer_);
-							 if (err.is_critical()) {
-								 return err;
-							 }
+					  error err = codec_.template decode<Incoming, InContainer>(
+						  builder, in_buffer_);
+					  if (err.is_critical()) {
+						  return err;
+					  }
 
-							 if (!err.failed()) {
-								 incoming_feeder_->feed(std::move(root));
-							 } else {
-								 break;
-							 }
-						 }
+					  if (!err.failed()) {
+						  incoming_feeder_->feed(std::move(root));
+					  } else {
+						  break;
+					  }
+				  }
 
-						 return void_t{};
-					 })
-					 .sink([this](error err) {
-						 incoming_feeder_->fail(err.copy_error());
+				  return void_t{};
+			  })
+			  .sink([this](error err) {
+				  incoming_feeder_->fail(err.copy_error());
 
-						 return err;
-					 })},
+				  return err;
+			  })},
 	  sink_write_{io_stream_->write_done()
 					  .then([this](size_t bytes) -> error_or<void> {
 						  out_buffer_.read_advance(bytes);
@@ -72,8 +73,8 @@ streaming_io_peer<Codec, Incoming, Outgoing, InContainer, OutContainer, BufferT>
 template <typename Codec, typename Incoming, typename Outgoing,
 		  typename InContainer, typename OutContainer, typename BufferT>
 error streaming_io_peer<Codec, Incoming, Outgoing, InContainer, OutContainer,
-					  BufferT>::send(HeapMessageRoot<Outgoing, OutContainer>
-										 msg) {
+						BufferT>::send(heap_message_root<Outgoing, OutContainer>
+										   msg) {
 	bool restart_write = out_buffer_.read_segment_length() == 0;
 
 	error err =
@@ -83,7 +84,8 @@ error streaming_io_peer<Codec, Incoming, Outgoing, InContainer, OutContainer,
 	}
 
 	if (restart_write) {
-		io_stream_->write(&out_buffer_.read(), out_buffer_.read_segment_length());
+		io_stream_->write(&out_buffer_.read(),
+						  out_buffer_.read_segment_length());
 	}
 
 	return no_error();
@@ -91,22 +93,24 @@ error streaming_io_peer<Codec, Incoming, Outgoing, InContainer, OutContainer,
 
 template <typename Codec, typename Incoming, typename Outgoing,
 		  typename InContainer, typename OutContainer, typename BufferT>
-conveyor<void> streaming_io_peer<Codec, Incoming, Outgoing, InContainer,
-							   OutContainer, BufferT>::on_read_disconnected() {
+conveyor<void>
+streaming_io_peer<Codec, Incoming, Outgoing, InContainer, OutContainer,
+				  BufferT>::on_read_disconnected() {
 	return io_stream_->on_read_disconnected();
 }
 
 template <typename Codec, typename Incoming, typename Outgoing,
 		  typename InContainer, typename OutContainer, typename BufferT>
 std::pair<own<streaming_io_peer<Codec, Incoming, Outgoing, InContainer,
-							  OutContainer, BufferT>>,
-		  conveyor<HeapMessageRoot<Incoming, InContainer>>>
+								OutContainer, BufferT>>,
+		  conveyor<heap_message_root<Incoming, InContainer>>>
 newstreaming_io_peer(own<async_io_stream> stream) {
-	auto caf = newconveyorAndFeeder<HeapMessageRoot<Incoming, InContainer>>();
+	auto caf =
+		new_conveyor_and_feeder<heap_message_root<Incoming, InContainer>>();
 
 	return {heap<streaming_io_peer<Codec, Incoming, Outgoing, InContainer,
-								 OutContainer, BufferT>>(std::move(caf.feeder),
-														 std::move(stream)),
+								   OutContainer, BufferT>>(
+				std::move(caf.feeder), std::move(stream)),
 			std::move(caf.conveyor)};
 }
 
diff --git a/source/forstio/message.h b/source/forstio/message.h
index 5bf3afe..9e04e70 100644
--- a/source/forstio/message.h
+++ b/source/forstio/message.h
@@ -74,8 +74,8 @@ public:
 		 */
 		template <size_t i>
 		typename std::enable_if<
-			!SchemaIsArray<
-				typename MessageParameterPackType<i, V...>::Type>::Value,
+			!schema_is_array<
+				typename message_parameter_pack_type<i, V...>::Type>::Value,
 			typename Container::template ElementType<i>::builder>::type
 		init() {
 			return typename Container::template ElementType<i>::builder{
@@ -88,23 +88,23 @@ public:
 		 */
 		template <string_literal Literal>
 		typename std::enable_if<
-			!SchemaIsArray<typename MessageParameterPackType<
-				MessageParameterKeyPackIndex<Literal, Keys...>::Value,
+			!schema_is_array<typename message_parameter_pack_type<
+				message_parameter_key_pack_index<Literal, Keys...>::Value,
 				V...>::Type>::Value,
 			typename Container::template ElementType<
-				MessageParameterKeyPackIndex<Literal,
-											 Keys...>::Value>::builder>::type
+				message_parameter_key_pack_index<Literal, Keys...>::Value>::
+				builder>::type
 		init() {
 			constexpr size_t i =
-				MessageParameterKeyPackIndex<Literal, Keys...>::Value;
+				message_parameter_key_pack_index<Literal, Keys...>::Value;
 
 			return init<i>();
 		}
 
 		template <size_t i>
 		typename std::enable_if<
-			SchemaIsArray<
-				typename MessageParameterPackType<i, V...>::Type>::Value,
+			schema_is_array<
+				typename message_parameter_pack_type<i, V...>::Type>::Value,
 			typename Container::template ElementType<i>::builder>::type
 		init(size_t size = 0) {
 			auto array_builder =
@@ -118,15 +118,15 @@ public:
 		 */
 		template <string_literal Literal>
 		typename std::enable_if<
-			SchemaIsArray<typename MessageParameterPackType<
-				MessageParameterKeyPackIndex<Literal, Keys...>::Value,
+			schema_is_array<typename message_parameter_pack_type<
+				message_parameter_key_pack_index<Literal, Keys...>::Value,
 				V...>::Type>::Value,
 			typename Container::template ElementType<
-				MessageParameterKeyPackIndex<Literal,
-											 Keys...>::Value>::builder>::type
+				message_parameter_key_pack_index<Literal, Keys...>::Value>::
+				builder>::type
 		init(size_t size) {
 			constexpr size_t i =
-				MessageParameterKeyPackIndex<Literal, Keys...>::Value;
+				message_parameter_key_pack_index<Literal, Keys...>::Value;
 
 			return init<i>(size);
 		}
@@ -156,11 +156,11 @@ public:
 		 */
 		template <string_literal Literal>
 		typename Container::template ElementType<
-			MessageParameterKeyPackIndex<Literal, Keys...>::Value>::reader
+			message_parameter_key_pack_index<Literal, Keys...>::Value>::reader
 		get() {
 			// The index of the first match
 			constexpr size_t i =
-				MessageParameterKeyPackIndex<Literal, Keys...>::Value;
+				message_parameter_key_pack_index<Literal, Keys...>::Value;
 
 			return get<i>();
 		}
@@ -202,8 +202,8 @@ public:
 
 		template <size_t i>
 		typename std::enable_if<
-			!SchemaIsArray<
-				typename MessageParameterPackType<i, V...>::Type>::Value,
+			!schema_is_array<
+				typename message_parameter_pack_type<i, V...>::Type>::Value,
 			typename Container::template ElementType<i>::builder>::type
 
 		init() {
@@ -213,15 +213,15 @@ public:
 
 		template <string_literal Literal>
 		typename std::enable_if<
-			!SchemaIsArray<typename MessageParameterPackType<
-				MessageParameterKeyPackIndex<Literal, Keys...>::Value,
+			!schema_is_array<typename message_parameter_pack_type<
+				message_parameter_key_pack_index<Literal, Keys...>::Value,
 				V...>::Type>::Value,
 			typename Container::template ElementType<
-				MessageParameterKeyPackIndex<Literal,
-											 Keys...>::Value>::builder>::type
+				message_parameter_key_pack_index<Literal, Keys...>::Value>::
+				builder>::type
 		init() {
 			constexpr size_t i =
-				MessageParameterKeyPackIndex<Literal, Keys...>::Value;
+				message_parameter_key_pack_index<Literal, Keys...>::Value;
 
 			return init<i>();
 		}
@@ -231,8 +231,8 @@ public:
 		 */
 		template <size_t i>
 		typename std::enable_if<
-			SchemaIsArray<
-				typename MessageParameterPackType<i, V...>::Type>::Value,
+			schema_is_array<
+				typename message_parameter_pack_type<i, V...>::Type>::Value,
 			typename Container::template ElementType<i>::builder>::type
 		init(size_t size = 0) {
 			return typename Container::template ElementType<i>::builder{
@@ -241,15 +241,15 @@ public:
 
 		template <string_literal Literal>
 		typename std::enable_if<
-			SchemaIsArray<typename MessageParameterPackType<
-				MessageParameterKeyPackIndex<Literal, Keys...>::Value,
+			schema_is_array<typename message_parameter_pack_type<
+				message_parameter_key_pack_index<Literal, Keys...>::Value,
 				V...>::Type>::Value,
 			typename Container::template ElementType<
-				MessageParameterKeyPackIndex<Literal,
-											 Keys...>::Value>::builder>::type
+				message_parameter_key_pack_index<Literal, Keys...>::Value>::
+				builder>::type
 		init(size_t size) {
 			constexpr size_t i =
-				MessageParameterKeyPackIndex<Literal, Keys...>::Value;
+				message_parameter_key_pack_index<Literal, Keys...>::Value;
 
 			return init<i>(size);
 		}
@@ -272,24 +272,24 @@ public:
 
 		template <string_literal Literal>
 		typename Container::template ElementType<
-			MessageParameterKeyPackIndex<Literal, Keys...>::Value>::reader
+			message_parameter_key_pack_index<Literal, Keys...>::Value>::reader
 		get() {
 			// The index of the first match
 			constexpr size_t i =
-				MessageParameterKeyPackIndex<Literal, Keys...>::Value;
+				message_parameter_key_pack_index<Literal, Keys...>::Value;
 
 			return get<i>();
 		}
 
 		template <string_literal Literal>
-		static constexpr size_t toIndex() noexcept {
-			return MessageParameterKeyPackIndex<Literal, Keys...>::Value;
+		static constexpr size_t to_index() noexcept {
+			return message_parameter_key_pack_index<Literal, Keys...>::Value;
 		}
 
 		size_t index() const noexcept { return message_.container_.index(); }
 
-		template <string_literal Literal> bool hasAlternative() const {
-			return index() == toIndex<Literal>();
+		template <string_literal Literal> bool has_alternative() const {
+			return index() == to_index<Literal>();
 		}
 	};
 };
@@ -383,8 +383,8 @@ public:
 
 		template <size_t i>
 		typename std::enable_if<
-			!SchemaIsArray<
-				typename MessageParameterPackType<i, T...>::Type>::Value,
+			!schema_is_array<
+				typename message_parameter_pack_type<i, T...>::Type>::Value,
 			typename Container::template ElementType<i>::builder>::type
 		init() {
 			return typename Container::template ElementType<i>::builder{
@@ -393,8 +393,8 @@ public:
 
 		template <size_t i>
 		typename std::enable_if<
-			SchemaIsArray<
-				typename MessageParameterPackType<i, T...>::Type>::Value,
+			schema_is_array<
+				typename message_parameter_pack_type<i, T...>::Type>::Value,
 			typename Container::template ElementType<i>::builder>::type
 		init(size_t size = 0) {
 			return typename Container::template ElementType<i>::builder{
@@ -511,12 +511,13 @@ public:
 };
 
 template <class Schema, class Container = message_container<Schema>>
-class HeapMessageRoot {
+class heap_message_root {
 private:
 	own<message<Schema, Container>> root_;
 
 public:
-	HeapMessageRoot(own<message<Schema, Container>> r) : root_{std::move(r)} {}
+	heap_message_root(own<message<Schema, Container>> r)
+		: root_{std::move(r)} {}
 
 	typename message<Schema, Container>::builder build() {
 		assert(root_);
@@ -530,7 +531,7 @@ public:
 };
 
 template <class T, class Container>
-class HeapMessageRoot<schema::Array<T>, Container> {
+class heap_message_root<schema::Array<T>, Container> {
 public:
 	using Schema = schema::Array<T>;
 
@@ -538,7 +539,8 @@ private:
 	own<message<Schema, Container>> root_;
 
 public:
-	HeapMessageRoot(own<message<Schema, Container>> r) : root_{std::move(r)} {}
+	heap_message_root(own<message<Schema, Container>> r)
+		: root_{std::move(r)} {}
 
 	typename message<Schema, Container>::builder build(size_t size) {
 		assert(root_);
@@ -555,8 +557,8 @@ public:
  * Minor helper for creating a message root
  */
 template <class Schema, class Container = message_container<Schema>>
-inline HeapMessageRoot<Schema, Container> heapMessageRoot() {
+inline heap_message_root<Schema, Container> new_heap_message_root() {
 	own<message<Schema, Container>> root = heap<message<Schema, Container>>();
-	return HeapMessageRoot<Schema, Container>{std::move(root)};
+	return heap_message_root<Schema, Container>{std::move(root)};
 }
 } // namespace saw
diff --git a/source/forstio/message_container.h b/source/forstio/message_container.h
index b2ea2b5..191052a 100644
--- a/source/forstio/message_container.h
+++ b/source/forstio/message_container.h
@@ -10,16 +10,17 @@ template <class T> class message_container;
 
 template <class T, class Container = message_container<T>> class message;
 
-template <size_t N, class... T> struct MessageParameterPackType;
+template <size_t N, class... T> struct message_parameter_pack_type;
 
-template <class TN, class... T> struct MessageParameterPackType<0, TN, T...> {
+template <class TN, class... T>
+struct message_parameter_pack_type<0, TN, T...> {
 	using Type = TN;
 };
 
 template <size_t N, class TN, class... T>
-struct MessageParameterPackType<N, TN, T...> {
+struct message_parameter_pack_type<N, TN, T...> {
 	static_assert(sizeof...(T) > 0, "Exhausted parameters");
-	using Type = typename MessageParameterPackType<N - 1, T...>::Type;
+	using Type = typename message_parameter_pack_type<N - 1, T...>::Type;
 };
 
 template <class T, class... TL> struct MessageParameterPackIndex;
@@ -40,31 +41,31 @@ struct MessageParameterPackIndex<T, TL0, TL...> {
  * This is the workaround
  */
 template <string_literal V, string_literal Key0, string_literal... Keys>
-struct MessageParameterKeyPackIndexHelper {
+struct message_parameter_key_pack_index_helper {
 	static constexpr size_t Value =
 		(V == Key0)
 			? (0u)
-			: (1u + MessageParameterKeyPackIndexHelper<V, Keys...>::Value);
+			: (1u + message_parameter_key_pack_index_helper<V, Keys...>::Value);
 };
 
 template <string_literal V, string_literal Key0>
-struct MessageParameterKeyPackIndexHelper<V, Key0> {
+struct message_parameter_key_pack_index_helper<V, Key0> {
 	static constexpr size_t Value = (V == Key0) ? (0u) : (1u);
 };
 
 template <string_literal V, string_literal... Keys>
-struct MessageParameterKeyPackIndex {
+struct message_parameter_key_pack_index {
 	static constexpr size_t Value =
-		MessageParameterKeyPackIndexHelper<V, Keys...>::Value;
+		message_parameter_key_pack_index_helper<V, Keys...>::Value;
 	static_assert(Value < sizeof...(Keys),
 				  "Provided StringLiteral doesn't exist in searched list");
 };
 
-template <class T> struct SchemaIsArray {
+template <class T> struct schema_is_array {
 	constexpr static bool Value = false;
 };
 
-template <class T> struct SchemaIsArray<schema::Array<T>> {
+template <class T> struct schema_is_array<schema::Array<T>> {
 	constexpr static bool Value = true;
 };
 
@@ -78,7 +79,7 @@ public:
 	using SchemaType = schema::Struct<schema::NamedMember<V, Keys>...>;
 
 	template <size_t i>
-	using ElementType = typename MessageParameterPackType<
+	using ElementType = typename message_parameter_pack_type<
 		i, message<V, message_container<V>>...>::Type;
 
 	template <size_t i> ElementType<i> &get() { return std::get<i>(values_); }
@@ -97,12 +98,13 @@ public:
 	using SchemaType = schema::Union<schema::NamedMember<V, Keys>...>;
 
 	template <size_t i>
-	using ElementType = typename MessageParameterPackType<
+	using ElementType = typename message_parameter_pack_type<
 		i, message<V, message_container<V>>...>::Type;
 
 	template <size_t i> ElementType<i> &get() {
 		if (i != value_.index()) {
-			using MessageIV = typename MessageParameterPackType<i, V...>::Type;
+			using MessageIV =
+				typename message_parameter_pack_type<i, V...>::Type;
 			value_ = message<MessageIV, message_container<MessageIV>>{};
 		}
 		return std::get<i>(value_);
@@ -146,7 +148,7 @@ public:
 	using SchemaType = schema::Tuple<T...>;
 
 	template <size_t i>
-	using ElementType = typename MessageParameterPackType<
+	using ElementType = typename message_parameter_pack_type<
 		i, message<T, message_container<T>>...>::Type;
 
 	template <size_t i> ElementType<i> &get() { return std::get<i>(values_); }
diff --git a/source/forstio/proto_kel.h b/source/forstio/proto_kel.h
index 83b0aac..511cf91 100644
--- a/source/forstio/proto_kel.h
+++ b/source/forstio/proto_kel.h
@@ -5,37 +5,37 @@
 #include "stream_endian.h"
 
 namespace saw {
-class ProtoKelCodec {
+class proto_kel_codec {
 public:
 	using UnionIdT = uint32_t;
 	using ArrayLengthT = uint64_t;
 	using PacketLengthT = uint64_t;
 
 private:
-	struct ReadContext {
+	struct read_context {
 		buffer &buffer;
 		size_t offset = 0;
 	};
 
-	template <typename T> friend struct ProtoKelEncodeImpl;
+	template <typename T> friend struct proto_kel_encode_impl;
 
-	template <typename T> friend struct ProtoKelDecodeImpl;
+	template <typename T> friend struct proto_kel_decode_impl;
 
 public:
-	struct Limits {
-		ProtoKelCodec::PacketLengthT packet_size;
+	struct limits {
+		proto_kel_codec::PacketLengthT packet_size;
 
-		Limits() : packet_size{4096} {}
-		Limits(ProtoKelCodec::PacketLengthT ps) : packet_size{ps} {}
+		limits() : packet_size{4096} {}
+		limits(proto_kel_codec::PacketLengthT ps) : packet_size{ps} {}
 	};
 
-	struct Version {
+	struct version {
 		size_t major;
 		size_t minor;
 		size_t security;
 	};
 
-	const Version version() const { return Version{0, 0, 0}; }
+	const version get_version() const { return version{0, 0, 0}; }
 
 	template <class Schema, class Container = message_container<Schema>>
 	error encode(typename message<Schema, Container>::reader reader,
@@ -43,13 +43,13 @@ public:
 
 	template <class Schema, class Container = message_container<Schema>>
 	error decode(typename message<Schema, Container>::builder builder,
-				 buffer &buffer, const Limits &limits = Limits{});
+				 buffer &buffer, const limits &lim = limits{});
 };
 
-template <class T> struct ProtoKelEncodeImpl;
+template <class T> struct proto_kel_encode_impl;
 
 template <class T, size_t N, class Container>
-struct ProtoKelEncodeImpl<message<schema::Primitive<T, N>, Container>> {
+struct proto_kel_encode_impl<message<schema::Primitive<T, N>, Container>> {
 	static error
 	encode(typename message<schema::Primitive<T, N>, Container>::reader data,
 		   buffer &buffer) {
@@ -66,7 +66,7 @@ struct ProtoKelEncodeImpl<message<schema::Primitive<T, N>, Container>> {
 };
 
 template <class Container>
-struct ProtoKelEncodeImpl<message<schema::String, Container>> {
+struct proto_kel_encode_impl<message<schema::String, Container>> {
 	static error
 	encode(typename message<schema::String, Container>::reader data,
 		   buffer &buffer) {
@@ -96,166 +96,170 @@ struct ProtoKelEncodeImpl<message<schema::String, Container>> {
 };
 
 template <class... T, class Container>
-struct ProtoKelEncodeImpl<message<schema::Tuple<T...>, Container>> {
+struct proto_kel_encode_impl<message<schema::Tuple<T...>, Container>> {
 	template <size_t i = 0>
 	static typename std::enable_if<i == sizeof...(T), error>::type
-	encodeMembers(typename message<schema::Tuple<T...>, Container>::reader,
-				  buffer &) {
+	encode_members(typename message<schema::Tuple<T...>, Container>::reader,
+				   buffer &) {
 		return no_error();
 	}
 
 	template <size_t i = 0>
 	static typename std::enable_if<(i < sizeof...(T)), error>::type
-	encodeMembers(typename message<schema::Tuple<T...>, Container>::reader data,
-				  buffer &buffer) {
+	encode_members(
+		typename message<schema::Tuple<T...>, Container>::reader data,
+		buffer &buffer) {
 		error err =
-			ProtoKelEncodeImpl<typename Container::template ElementType<i>>::
+			proto_kel_encode_impl<typename Container::template ElementType<i>>::
 				encode(data.template get<i>(), buffer);
 		if (err.failed()) {
 			return err;
 		}
 
-		return encodeMembers<i + 1>(data, buffer);
+		return encode_members<i + 1>(data, buffer);
 	}
 
 	static error
 	encode(typename message<schema::Tuple<T...>, Container>::reader data,
 		   buffer &buffer) {
-		return encodeMembers<0>(data, buffer);
+		return encode_members<0>(data, buffer);
 	}
 
 	template <size_t i = 0>
 	static typename std::enable_if<i == sizeof...(T), size_t>::type
-	sizeMembers(typename message<schema::Tuple<T...>, Container>::reader) {
+	size_members(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(
+		i<sizeof...(T), size_t>::type size_members(
 			typename message<schema::Tuple<T...>, Container>::reader reader) {
-		return ProtoKelEncodeImpl<typename Container::template ElementType<i>>::
-				   size(reader.template get<i>()) +
-			   sizeMembers<i + 1>(reader);
+		return proto_kel_encode_impl<typename Container::template ElementType<
+				   i>>::size(reader.template get<i>()) +
+			   size_members<i + 1>(reader);
 	}
 
 	static size_t
 	size(typename message<schema::Tuple<T...>, Container>::reader reader) {
-		return sizeMembers<0>(reader);
+		return size_members<0>(reader);
 	}
 };
 
 template <typename... V, string_literal... K, class Container>
-struct ProtoKelEncodeImpl<
+struct proto_kel_encode_impl<
 	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 message<schema::Struct<schema::NamedMember<V, K>...>,
-								   Container>::reader,
-				  buffer &) {
+	encode_members(
+		typename message<schema::Struct<schema::NamedMember<V, K>...>,
+						 Container>::reader,
+		buffer &) {
 		return no_error();
 	}
 	template <size_t i = 0>
 		static typename std::enable_if <
-		i<sizeof...(V), error>::type encodeMembers(
+		i<sizeof...(V), error>::type encode_members(
 			typename message<schema::Struct<schema::NamedMember<V, K>...>,
 							 Container>::reader data,
 			buffer &buffer) {
 
 		error err =
-			ProtoKelEncodeImpl<typename Container::template ElementType<i>>::
+			proto_kel_encode_impl<typename Container::template ElementType<i>>::
 				encode(data.template get<i>(), buffer);
 		if (err.failed()) {
 			return err;
 		}
-		return encodeMembers<i + 1>(data, buffer);
+		return encode_members<i + 1>(data, buffer);
 	}
 
 	static error
 	encode(typename message<schema::Struct<schema::NamedMember<V, K>...>,
 							Container>::reader data,
 		   buffer &buffer) {
-		return encodeMembers<0>(data, buffer);
+		return encode_members<0>(data, buffer);
 	}
 
 	template <size_t i = 0>
 	static typename std::enable_if<i == sizeof...(V), size_t>::type
-	sizeMembers(typename message<schema::Struct<schema::NamedMember<V, K>...>,
-								 Container>::reader) {
+	size_members(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(
+		i<sizeof...(V), size_t>::type size_members(
 			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);
+		return proto_kel_encode_impl<typename Container::template ElementType<
+				   i>>::size(reader.template get<i>()) +
+			   size_members<i + 1>(reader);
 	}
 
 	static size_t
 	size(typename message<schema::Struct<schema::NamedMember<V, K>...>,
 						  Container>::reader reader) {
-		return sizeMembers<0>(reader);
+		return size_members<0>(reader);
 	}
 };
 
 template <typename... V, string_literal... K, class Container>
-struct ProtoKelEncodeImpl<
+struct proto_kel_encode_impl<
 	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 &) {
+	encode_members(typename message<schema::Union<schema::NamedMember<V, K>...>,
+									Container>::reader,
+				   buffer &) {
 		return no_error();
 	}
 
 	template <size_t i = 0>
 		static typename std::enable_if <
-		i<sizeof...(V), error>::type encodeMembers(
+		i<sizeof...(V), error>::type encode_members(
 			typename message<schema::Union<schema::NamedMember<V, K>...>,
 							 Container>::reader reader,
 			buffer &buffer) {
 		if (reader.index() == i) {
 			error err =
-				stream_value<ProtoKelCodec::UnionIdT>::encode(i, buffer);
+				stream_value<proto_kel_codec::UnionIdT>::encode(i, buffer);
 			if (err.failed()) {
 				return err;
 			}
-			return ProtoKelEncodeImpl<typename Container::template ElementType<
-				i>>::encode(reader.template get<i>(), buffer);
+			return proto_kel_encode_impl<
+				typename Container::template ElementType<i>>::
+				encode(reader.template get<i>(), buffer);
 		}
-		return encodeMembers<i + 1>(reader, buffer);
+		return encode_members<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);
+		return encode_members<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) {
+	size_members(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(
+		i<sizeof...(V), size_t>::type size_members(
 			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 proto_kel_encode_impl<
+				typename Container::template ElementType<i>>::
+				size(reader.template get<i>());
 		}
-		return sizeMembers<i + 1>(reader);
+		return size_members<i + 1>(reader);
 	}
 
 	/*
@@ -264,18 +268,18 @@ struct ProtoKelEncodeImpl<
 	static size_t
 	size(typename message<schema::Union<schema::NamedMember<V, K>...>,
 						  Container>::reader reader) {
-		return sizeof(ProtoKelCodec::UnionIdT) + sizeMembers<0>(reader);
+		return sizeof(proto_kel_codec::UnionIdT) + size_members<0>(reader);
 	}
 };
 
 template <class T, class Container>
-struct ProtoKelEncodeImpl<message<schema::Array<T>, Container>> {
+struct proto_kel_encode_impl<message<schema::Array<T>, Container>> {
 	static error
 	encode(typename message<schema::Array<T>, Container>::reader data,
 		   buffer &buffer) {
-		ProtoKelCodec::ArrayLengthT array_length = data.size();
+		proto_kel_codec::ArrayLengthT array_length = data.size();
 		{
-			error err = stream_value<ProtoKelCodec::ArrayLengthT>::encode(
+			error err = stream_value<proto_kel_codec::ArrayLengthT>::encode(
 				array_length, buffer);
 			if (err.failed()) {
 				return err;
@@ -284,7 +288,7 @@ struct ProtoKelEncodeImpl<message<schema::Array<T>, Container>> {
 
 		for (size_t i = 0; i < array_length; ++i) {
 			error err =
-				ProtoKelEncodeImpl<typename Container::ElementType>::encode(
+				proto_kel_encode_impl<typename Container::ElementType>::encode(
 					data.get(i), buffer);
 			if (err.failed()) {
 				return err;
@@ -298,10 +302,10 @@ struct ProtoKelEncodeImpl<message<schema::Array<T>, Container>> {
 	 */
 	static size_t
 	size(typename message<schema::Array<T>, Container>::reader data) {
-		size_t members = sizeof(ProtoKelCodec::ArrayLengthT);
+		size_t members = sizeof(proto_kel_codec::ArrayLengthT);
 		for (size_t i = 0; i < data.size(); ++i) {
 			members +=
-				ProtoKelEncodeImpl<typename Container::ElementType>::size(
+				proto_kel_encode_impl<typename Container::ElementType>::size(
 					data.get(i));
 		}
 
@@ -312,10 +316,10 @@ struct ProtoKelEncodeImpl<message<schema::Array<T>, Container>> {
 /*
  * Decode Implementations
  */
-template <typename T> struct ProtoKelDecodeImpl;
+template <typename T> struct proto_kel_decode_impl;
 
 template <class T, size_t N, class Container>
-struct ProtoKelDecodeImpl<message<schema::Primitive<T, N>, Container>> {
+struct proto_kel_decode_impl<message<schema::Primitive<T, N>, Container>> {
 	static error
 	decode(typename message<schema::Primitive<T, N>, Container>::builder data,
 		   buffer &buffer) {
@@ -328,7 +332,7 @@ struct ProtoKelDecodeImpl<message<schema::Primitive<T, N>, Container>> {
 };
 
 template <class Container>
-struct ProtoKelDecodeImpl<message<schema::String, Container>> {
+struct proto_kel_decode_impl<message<schema::String, Container>> {
 	static error
 	decode(typename message<schema::String, Container>::builder data,
 		   buffer &buffer) {
@@ -362,107 +366,108 @@ struct ProtoKelDecodeImpl<message<schema::String, Container>> {
 };
 
 template <class... T, class Container>
-struct ProtoKelDecodeImpl<message<schema::Tuple<T...>, Container>> {
+struct proto_kel_decode_impl<message<schema::Tuple<T...>, Container>> {
 	template <size_t i = 0>
 	static typename std::enable_if<i == sizeof...(T), error>::type
-	decodeMembers(typename message<schema::Tuple<T...>, Container>::builder,
-				  buffer &) {
+	decode_members(typename message<schema::Tuple<T...>, Container>::builder,
+				   buffer &) {
 		return no_error();
 	}
 
 	template <size_t i = 0>
 		static typename std::enable_if <
-		i<sizeof...(T), error>::type decodeMembers(
+		i<sizeof...(T), error>::type decode_members(
 			typename message<schema::Tuple<T...>, Container>::builder builder,
 			buffer &buffer) {
 
 		error err =
-			ProtoKelDecodeImpl<typename Container::template ElementType<i>>::
+			proto_kel_decode_impl<typename Container::template ElementType<i>>::
 				decode(builder.template init<i>(), buffer);
 		if (err.failed()) {
 			return err;
 		}
-		return decodeMembers<i + 1>(builder, buffer);
+		return decode_members<i + 1>(builder, buffer);
 	}
 
 	static error
 	decode(typename message<schema::Tuple<T...>, Container>::builder builder,
 		   buffer &buffer) {
-		return decodeMembers<0>(builder, buffer);
+		return decode_members<0>(builder, buffer);
 	}
 };
 
 template <class... V, string_literal... K, class Container>
-struct ProtoKelDecodeImpl<
+struct proto_kel_decode_impl<
 	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 message<schema::Struct<schema::NamedMember<V, K>...>,
-								   Container>::builder,
-				  buffer &) {
+	decode_members(
+		typename message<schema::Struct<schema::NamedMember<V, K>...>,
+						 Container>::builder,
+		buffer &) {
 		return no_error();
 	}
 
 	template <size_t i = 0>
 		static typename std::enable_if <
-		i<sizeof...(V), error>::type decodeMembers(
+		i<sizeof...(V), error>::type decode_members(
 			typename message<schema::Struct<schema::NamedMember<V, K>...>,
 							 Container>::builder builder,
 			buffer &buffer) {
 
 		error err =
-			ProtoKelDecodeImpl<typename Container::template ElementType<i>>::
+			proto_kel_decode_impl<typename Container::template ElementType<i>>::
 				decode(builder.template init<i>(), buffer);
 		if (err.failed()) {
 			return err;
 		}
-		return decodeMembers<i + 1>(builder, buffer);
+		return decode_members<i + 1>(builder, buffer);
 	}
 
 	static error
 	decode(typename message<schema::Struct<schema::NamedMember<V, K>...>,
 							Container>::builder builder,
 		   buffer &buffer) {
-		return decodeMembers<0>(builder, buffer);
+		return decode_members<0>(builder, buffer);
 	}
 };
 
 template <class... V, string_literal... K, class Container>
-struct ProtoKelDecodeImpl<
+struct proto_kel_decode_impl<
 	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 message<schema::Union<schema::NamedMember<V, K>...>,
-								   Container>::builder,
-				  buffer &, ProtoKelCodec::UnionIdT) {
+	decode_members(typename message<schema::Union<schema::NamedMember<V, K>...>,
+									Container>::builder,
+				   buffer &, proto_kel_codec::UnionIdT) {
 		return no_error();
 	}
 
 	template <size_t i = 0>
 		static typename std::enable_if <
-		i<sizeof...(V), error>::type decodeMembers(
+		i<sizeof...(V), error>::type decode_members(
 			typename message<schema::Union<schema::NamedMember<V, K>...>,
 							 Container>::builder builder,
-			buffer &buffer, ProtoKelCodec::UnionIdT id) {
+			buffer &buffer, proto_kel_codec::UnionIdT id) {
 
 		if (id == i) {
 			error err =
-				ProtoKelDecodeImpl<typename Container::template ElementType<
+				proto_kel_decode_impl<typename Container::template ElementType<
 					i>>::decode(builder.template init<i>(), buffer);
 			if (err.failed()) {
 				return err;
 			}
 		}
-		return decodeMembers<i + 1>(builder, buffer, id);
+		return decode_members<i + 1>(builder, buffer, id);
 	}
 
 	static error
 	decode(typename message<schema::Union<schema::NamedMember<V, K>...>,
 							Container>::builder builder,
 		   buffer &buffer) {
-		ProtoKelCodec::UnionIdT id = 0;
-		error err = stream_value<ProtoKelCodec::UnionIdT>::decode(id, buffer);
+		proto_kel_codec::UnionIdT id = 0;
+		error err = stream_value<proto_kel_codec::UnionIdT>::decode(id, buffer);
 		if (err.failed()) {
 			return err;
 		}
@@ -470,18 +475,18 @@ struct ProtoKelDecodeImpl<
 			return critical_error("Union doesn't have this many id's");
 		}
 
-		return decodeMembers<0>(builder, buffer, id);
+		return decode_members<0>(builder, buffer, id);
 	}
 };
 
 template <class T, class Container>
-struct ProtoKelDecodeImpl<message<schema::Array<T>, Container>> {
+struct proto_kel_decode_impl<message<schema::Array<T>, Container>> {
 	static error
 	decode(typename message<schema::Array<T>, Container>::builder data,
 		   buffer &buffer) {
-		ProtoKelCodec::ArrayLengthT array_length = 0;
+		proto_kel_codec::ArrayLengthT array_length = 0;
 		{
-			error err = stream_value<ProtoKelCodec::ArrayLengthT>::decode(
+			error err = stream_value<proto_kel_codec::ArrayLengthT>::decode(
 				array_length, buffer);
 			if (err.failed()) {
 				return err;
@@ -492,7 +497,7 @@ struct ProtoKelDecodeImpl<message<schema::Array<T>, Container>> {
 
 		for (size_t i = 0; i < array_length; ++i) {
 			error err =
-				ProtoKelDecodeImpl<typename Container::ElementType>::decode(
+				proto_kel_decode_impl<typename Container::ElementType>::decode(
 					data.init(i), buffer);
 			if (err.failed()) {
 				return err;
@@ -503,30 +508,30 @@ struct ProtoKelDecodeImpl<message<schema::Array<T>, Container>> {
 };
 
 template <class Schema, class Container>
-error ProtoKelCodec::encode(typename message<Schema, Container>::reader reader,
-							buffer &buffer) {
+error proto_kel_codec::encode(
+	typename message<Schema, Container>::reader reader, buffer &buffer) {
 	buffer_view view{buffer};
 
-	ProtoKelCodec::PacketLengthT packet_length =
-		ProtoKelEncodeImpl<message<Schema, Container>>::size(reader);
+	proto_kel_codec::PacketLengthT packet_length =
+		proto_kel_encode_impl<message<Schema, Container>>::size(reader);
 	// Check the size of the packet for the first
 	// message length description
 
-	error err = view.write_require_length(packet_length +
-										  sizeof(ProtoKelCodec::PacketLengthT));
+	error err = view.write_require_length(
+		packet_length + sizeof(proto_kel_codec::PacketLengthT));
 	if (err.failed()) {
 		return err;
 	}
 
 	{
-		error err = stream_value<ProtoKelCodec::PacketLengthT>::encode(
+		error err = stream_value<proto_kel_codec::PacketLengthT>::encode(
 			packet_length, view);
 		if (err.failed()) {
 			return err;
 		}
 	}
 	{
-		error err = ProtoKelEncodeImpl<message<Schema, Container>>::encode(
+		error err = proto_kel_encode_impl<message<Schema, Container>>::encode(
 			reader, view);
 		if (err.failed()) {
 			return err;
@@ -538,14 +543,14 @@ error ProtoKelCodec::encode(typename message<Schema, Container>::reader reader,
 }
 
 template <class Schema, class Container>
-error ProtoKelCodec::decode(
+error proto_kel_codec::decode(
 	typename message<Schema, Container>::builder builder, buffer &buffer,
-	const Limits &limits) {
+	const limits &limits) {
 	buffer_view view{buffer};
 
-	ProtoKelCodec::PacketLengthT packet_length = 0;
+	proto_kel_codec::PacketLengthT packet_length = 0;
 	{
-		error err = stream_value<ProtoKelCodec::PacketLengthT>::decode(
+		error err = stream_value<proto_kel_codec::PacketLengthT>::decode(
 			packet_length, view);
 		if (err.failed()) {
 			return err;
@@ -562,14 +567,14 @@ error ProtoKelCodec::decode(
 	}
 
 	{
-		error err = ProtoKelDecodeImpl<message<Schema, Container>>::decode(
+		error err = proto_kel_decode_impl<message<Schema, Container>>::decode(
 			builder, view);
 		if (err.failed()) {
 			return err;
 		}
 	}
 	{
-		if (ProtoKelEncodeImpl<message<Schema, Container>>::size(
+		if (proto_kel_encode_impl<message<Schema, Container>>::size(
 				builder.as_reader()) != packet_length) {
 			return critical_error("Bad packet format");
 		}
diff --git a/source/forstio/schema.h b/source/forstio/schema.h
index f2b3d18..d10092b 100644
--- a/source/forstio/schema.h
+++ b/source/forstio/schema.h
@@ -5,7 +5,7 @@
 
 namespace saw {
 namespace schema {
-
+// NOLINTBEGIN
 template <typename T, string_literal Literal> struct NamedMember {};
 
 template <typename... T> struct Struct {
@@ -72,5 +72,6 @@ template <class... T> struct Interface {
 template <class... Request, class... Response, string_literal... Literal>
 struct Interface<Function<Request, Response, Literal>...> {};
 
+// NOLINTEND
 } // namespace schema
 } // namespace saw
diff --git a/test/message.cpp b/test/message.cpp
index 06192d8..3eb4709 100644
--- a/test/message.cpp
+++ b/test/message.cpp
@@ -16,7 +16,7 @@ using TestTuple = schema::Tuple<schema::UInt32, schema::String>;
 SAW_TEST("Message Tuple"){
 	std::string test_string_1 = "banana";
 	
-	auto root = saw::heapMessageRoot<TestTuple>();
+	auto root = saw::new_heap_message_root<TestTuple>();
 	auto builder = root.build();
 	auto uint = builder.init<0>();
 	uint.set(10);
@@ -36,7 +36,7 @@ SAW_TEST("Message Tuple nested"){
 	std::string test_string_1 = "banana";
 	std::string test_string_2 = "bat";
 	
-	auto root = saw::heapMessageRoot<NestedTestTuple>();
+	auto root = saw::new_heap_message_root<NestedTestTuple>();
 	auto builder = root.build();
 	auto inner_list = builder.init<0>();
 	auto uint = inner_list.init<0>();
@@ -64,7 +64,7 @@ using TestStruct = schema::Struct<
 
 SAW_TEST("Message Struct"){
 	std::string test_string = "foo";
-	auto root = saw::heapMessageRoot<TestStruct>();
+	auto root = saw::new_heap_message_root<TestStruct>();
 	auto builder = root.build();
 	auto uint = builder.init<"test_uint">();
 	uint.set(23);
@@ -103,7 +103,7 @@ void arrayCheck(saw::message<TestArray>::builder builder){
 }
 
 SAW_TEST("Message Array"){
-	auto root = saw::heapMessageRoot<TestArray>();
+	auto root = saw::new_heap_message_root<TestArray>();
 
 	auto builder = root.build(3);
 
@@ -115,7 +115,7 @@ using TestArrayStruct = schema::Struct<
 >;
 
 SAW_TEST("Message Array in Struct"){
-	auto root = saw::heapMessageRoot<TestArrayStruct>();
+	auto root = saw::new_heap_message_root<TestArrayStruct>();
 
 	auto builder = root.build();
 
diff --git a/test/proto_kel.cpp b/test/proto_kel.cpp
index 83dc55f..6eb48c4 100644
--- a/test/proto_kel.cpp
+++ b/test/proto_kel.cpp
@@ -27,26 +27,26 @@ SAW_TEST("Primitive Encoding"){
 	using namespace saw;
 	uint32_t value = 5;
 
-	auto root = heapMessageRoot<TestSize>();
+	auto root = new_heap_message_root<TestSize>();
 	auto builder = root.build();
 
 	builder.set(value);
 
 	ring_buffer temp_buffer;
-	ProtoKelCodec codec;
+	proto_kel_codec codec;
 
 	error err = codec.encode<TestSize>(root.read(), temp_buffer);
 
 	SAW_EXPECT(!err.failed(), err.message());
-	SAW_EXPECT(temp_buffer.read_composite_length() == (sizeof(value)+sizeof(ProtoKelCodec::PacketLengthT)), "Bad Size: " + std::to_string(temp_buffer.read_composite_length()));
-	constexpr size_t pkt_shift = sizeof(ProtoKelCodec::PacketLengthT);
+	SAW_EXPECT(temp_buffer.read_composite_length() == (sizeof(value)+sizeof(proto_kel_codec::PacketLengthT)), "Bad Size: " + std::to_string(temp_buffer.read_composite_length()));
+	constexpr size_t pkt_shift = sizeof(proto_kel_codec::PacketLengthT);
 	SAW_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");
 }
 
 SAW_TEST("List Encoding"){
 	using namespace saw;
 
-	auto root = heapMessageRoot<TestTuple>();
+	auto root = new_heap_message_root<TestTuple>();
 	auto builder = root.build();
 
 	auto first = builder.init<0>();
@@ -55,7 +55,7 @@ SAW_TEST("List Encoding"){
 	second.set(43871);
 
 	ring_buffer buffer;
-	ProtoKelCodec codec;
+	proto_kel_codec codec;
 
 	error err = codec.encode<TestTuple>(root.read(), buffer);
 
@@ -67,7 +67,7 @@ SAW_TEST("List Encoding"){
 SAW_TEST("Struct Encoding"){
 	using namespace saw;
 
-	auto root = heapMessageRoot<TestStruct>();
+	auto root = new_heap_message_root<TestStruct>();
 	auto builder = root.build();
 
 	auto test_uint = builder.init<"test_uint">();
@@ -81,7 +81,7 @@ SAW_TEST("Struct Encoding"){
 	string_name.set("test_name");
 
 	ring_buffer buffer;
-	ProtoKelCodec codec;
+	proto_kel_codec codec;
 
 	error err = codec.encode<TestStruct>(builder.as_reader(), buffer);
 
@@ -94,14 +94,14 @@ SAW_TEST("Struct Encoding"){
 SAW_TEST("Union Encoding"){
 	using namespace saw;
 	{
-		auto root = heapMessageRoot<TestUnion>();
+		auto root = new_heap_message_root<TestUnion>();
 		auto builder = root.build();
 
 		auto test_uint = builder.init<"test_uint">();
 		test_uint.set(23);
 
 		ring_buffer buffer;
-		ProtoKelCodec codec;
+		proto_kel_codec codec;
 
 		error err = codec.encode<TestUnion>(builder.as_reader(), buffer);
 
@@ -111,14 +111,14 @@ SAW_TEST("Union Encoding"){
 			== buffer.to_hex(), "Not equal encoding:\n"+buffer.to_hex());
 	}
 	{
-		auto root = heapMessageRoot<TestUnion>();
+		auto root = new_heap_message_root<TestUnion>();
 		auto builder = root.build();
 
 		auto test_string = builder.init<"test_string">();
 		test_string.set("foo");
 
 		ring_buffer buffer;
-		ProtoKelCodec codec;
+		proto_kel_codec codec;
 
 		error err = codec.encode<TestUnion>(builder.as_reader(), buffer);
 
@@ -136,9 +136,9 @@ SAW_TEST("Tuple Decoding"){
 	ring_buffer buffer;
 	buffer.push(*buffer_raw, sizeof(buffer_raw));
 
-	ProtoKelCodec codec;
+	proto_kel_codec codec;
 
-	auto root = heapMessageRoot<TestTuple>();
+	auto root = new_heap_message_root<TestTuple>();
 	auto builder = root.build();
 
 	error err = codec.decode<TestTuple>(builder, buffer);
@@ -159,9 +159,9 @@ SAW_TEST("Struct Decoding"){
 	ring_buffer buffer;
 	buffer.push(*buffer_raw, sizeof(buffer_raw));
 
-	ProtoKelCodec codec;
+	proto_kel_codec codec;
 
-	auto root = heapMessageRoot<TestStruct>();
+	auto root = new_heap_message_root<TestStruct>();
 	auto builder = root.build();
 
 	error err = codec.decode<TestStruct>(builder, buffer);
@@ -182,16 +182,16 @@ SAW_TEST("Union Decoding"){
 	ring_buffer buffer;
 	buffer.push(*buffer_raw, sizeof(buffer_raw));
 
-	ProtoKelCodec codec;
+	proto_kel_codec codec;
 
-	auto root = heapMessageRoot<TestUnion>();
+	auto root = new_heap_message_root<TestUnion>();
 	auto builder = root.build();
 	auto reader = builder.as_reader();
 
 	error err = codec.decode<TestUnion>(builder, buffer);
 
 	SAW_EXPECT(!err.failed(), err.message());
-	SAW_EXPECT(reader.hasAlternative<"test_string">(), "Wrong union value");
+	SAW_EXPECT(reader.has_alternative<"test_string">(), "Wrong union value");
 	auto str_rd = reader.get<"test_string">();
 	SAW_EXPECT(str_rd.get() == "foo", "Wrong value: " + std::string{str_rd.get()});
 }
@@ -203,8 +203,8 @@ using TestArrayStruct = schema::Array<
 SAW_TEST("Array Encoding"){
 	using namespace saw;
 	
-	ProtoKelCodec codec;
-	auto root = heapMessageRoot<TestArrayStruct>();
+	proto_kel_codec codec;
+	auto root = new_heap_message_root<TestArrayStruct>();
 	auto builder = root.build(2);
 
 	auto one = builder.init(0);