diff --git a/driver/io-unix.cpp b/driver/io-unix.cpp
deleted file mode 100644
index 580d5e7..0000000
--- a/driver/io-unix.cpp
+++ /dev/null
@@ -1,422 +0,0 @@
-#include "io-unix.h"
-
-#include <sstream>
-
-namespace saw {
-namespace unix {
-IFdOwner::IFdOwner(UnixEventPort &event_port, int file_descriptor, int fd_flags,
-				   uint32_t event_mask)
-	: event_port_{event_port}, file_descriptor_{file_descriptor},
-	  fd_flags_{fd_flags}, event_mask_{event_mask} {
-	event_port_.subscribe(*this, file_descriptor, event_mask);
-}
-
-IFdOwner::~IFdOwner() {
-	if (file_descriptor_ >= 0) {
-		event_port_.unsubscribe(file_descriptor_);
-		::close(file_descriptor_);
-	}
-}
-
-ssize_t unixRead(int fd, void *buffer, size_t length) {
-	return ::recv(fd, buffer, length, 0);
-}
-
-ssize_t unixWrite(int fd, const void *buffer, size_t length) {
-	return ::send(fd, buffer, length, 0);
-}
-
-UnixIoStream::UnixIoStream(UnixEventPort &event_port, int file_descriptor,
-						   int fd_flags, uint32_t event_mask)
-	: IFdOwner{event_port, file_descriptor, fd_flags, event_mask | EPOLLRDHUP} {
-}
-
-ErrorOr<size_t> UnixIoStream::read(void *buffer, size_t length) {
-	ssize_t read_bytes = unixRead(fd(), buffer, length);
-	if (read_bytes > 0) {
-		return static_cast<size_t>(read_bytes);
-	} else if (read_bytes == 0) {
-		return criticalError("Disconnected", Error::Code::Disconnected);
-	}
-
-	return recoverableError("Currently busy");
-}
-
-Conveyor<void> UnixIoStream::readReady() {
-	auto caf = newConveyorAndFeeder<void>();
-	read_ready_ = std::move(caf.feeder);
-	return std::move(caf.conveyor);
-}
-
-Conveyor<void> UnixIoStream::onReadDisconnected() {
-	auto caf = newConveyorAndFeeder<void>();
-	on_read_disconnect_ = std::move(caf.feeder);
-	return std::move(caf.conveyor);
-}
-
-ErrorOr<size_t> UnixIoStream::write(const void *buffer, size_t length) {
-	ssize_t write_bytes = unixWrite(fd(), buffer, length);
-	if (write_bytes > 0) {
-		return static_cast<size_t>(write_bytes);
-	}
-
-	int error = errno;
-
-	if (error == EAGAIN || error == EWOULDBLOCK) {
-		return recoverableError("Currently busy");
-	}
-
-	return criticalError("Disconnected", Error::Code::Disconnected);
-}
-
-Conveyor<void> UnixIoStream::writeReady() {
-	auto caf = newConveyorAndFeeder<void>();
-	write_ready_ = std::move(caf.feeder);
-	return std::move(caf.conveyor);
-}
-
-void UnixIoStream::notify(uint32_t mask) {
-	if (mask & EPOLLOUT) {
-		if (write_ready_) {
-			write_ready_->feed();
-		}
-	}
-
-	if (mask & EPOLLIN) {
-		if (read_ready_) {
-			read_ready_->feed();
-		}
-	}
-
-	if (mask & EPOLLRDHUP) {
-		if (on_read_disconnect_) {
-			on_read_disconnect_->feed();
-		}
-	}
-}
-
-UnixServer::UnixServer(UnixEventPort &event_port, int file_descriptor,
-					   int fd_flags)
-	: IFdOwner{event_port, file_descriptor, fd_flags, EPOLLIN} {}
-
-Conveyor<Own<IoStream>> UnixServer::accept() {
-	auto caf = newConveyorAndFeeder<Own<IoStream>>();
-	accept_feeder_ = std::move(caf.feeder);
-	return std::move(caf.conveyor);
-}
-
-void UnixServer::notify(uint32_t mask) {
-	if (mask & EPOLLIN) {
-		if (accept_feeder_) {
-			struct ::sockaddr_storage address;
-			socklen_t address_length = sizeof(address);
-
-			int accept_fd =
-				::accept4(fd(), reinterpret_cast<struct ::sockaddr *>(&address),
-						  &address_length, SOCK_NONBLOCK | SOCK_CLOEXEC);
-			if (accept_fd < 0) {
-				return;
-			}
-			auto fd_stream = heap<UnixIoStream>(event_port_, accept_fd, 0,
-												EPOLLIN | EPOLLOUT);
-			accept_feeder_->feed(std::move(fd_stream));
-		}
-	}
-}
-
-UnixDatagram::UnixDatagram(UnixEventPort &event_port, int file_descriptor,
-						   int fd_flags)
-	: IFdOwner{event_port, file_descriptor, fd_flags, EPOLLIN | EPOLLOUT} {}
-
-namespace {
-ssize_t unixReadMsg(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,
-					  reinterpret_cast<struct ::sockaddr *>(&their_addr),
-					  &addr_len);
-}
-
-ssize_t unixWriteMsg(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
-
-ErrorOr<size_t> UnixDatagram::read(void *buffer, size_t length) {
-	ssize_t read_bytes = unixReadMsg(fd(), buffer, length);
-	if (read_bytes > 0) {
-		return static_cast<size_t>(read_bytes);
-	}
-	return recoverableError("Currently busy");
-}
-
-Conveyor<void> UnixDatagram::readReady() {
-	auto caf = newConveyorAndFeeder<void>();
-	read_ready_ = std::move(caf.feeder);
-	return std::move(caf.conveyor);
-}
-
-ErrorOr<size_t> UnixDatagram::write(const void *buffer, size_t length,
-									NetworkAddress &dest) {
-	UnixNetworkAddress &unix_dest = static_cast<UnixNetworkAddress &>(dest);
-	SocketAddress &sock_addr = unix_dest.unixAddress();
-	socklen_t sock_addr_length = sock_addr.getRawLength();
-	ssize_t write_bytes = unixWriteMsg(fd(), buffer, length, sock_addr.getRaw(),
-									   sock_addr_length);
-	if (write_bytes > 0) {
-		return static_cast<size_t>(write_bytes);
-	}
-	return recoverableError("Currently busy");
-}
-
-Conveyor<void> UnixDatagram::writeReady() {
-	auto caf = newConveyorAndFeeder<void>();
-	write_ready_ = std::move(caf.feeder);
-	return std::move(caf.conveyor);
-}
-
-void UnixDatagram::notify(uint32_t mask) {
-	if (mask & EPOLLOUT) {
-		if (write_ready_) {
-			write_ready_->feed();
-		}
-	}
-
-	if (mask & EPOLLIN) {
-		if (read_ready_) {
-			read_ready_->feed();
-		}
-	}
-}
-
-namespace {
-bool beginsWith(const std::string_view &viewed,
-				const std::string_view &begins) {
-	return viewed.size() >= begins.size() &&
-		   viewed.compare(0, begins.size(), begins) == 0;
-}
-
-std::variant<UnixNetworkAddress, UnixNetworkAddress *>
-translateNetworkAddressToUnixNetworkAddress(NetworkAddress &addr) {
-	auto addr_variant = addr.representation();
-	std::variant<UnixNetworkAddress, UnixNetworkAddress *> os_addr = std::visit(
-		[](auto &arg)
-			-> std::variant<UnixNetworkAddress, UnixNetworkAddress *> {
-			using T = std::decay_t<decltype(arg)>;
-
-			if constexpr (std::is_same_v<T, OsNetworkAddress *>) {
-				return static_cast<UnixNetworkAddress *>(arg);
-			}
-
-			auto sock_addrs = SocketAddress::resolve(
-				std::string_view{arg->address()}, arg->port());
-
-			return UnixNetworkAddress{arg->address(), arg->port(),
-									  std::move(sock_addrs)};
-		},
-		addr_variant);
-	return os_addr;
-}
-
-UnixNetworkAddress &translateToUnixAddressRef(
-	std::variant<UnixNetworkAddress, UnixNetworkAddress *> &addr_variant) {
-	return std::visit(
-		[](auto &arg) -> UnixNetworkAddress & {
-			using T = std::decay_t<decltype(arg)>;
-
-			if constexpr (std::is_same_v<T, UnixNetworkAddress>) {
-				return arg;
-			} else if constexpr (std::is_same_v<T, UnixNetworkAddress *>) {
-				return *arg;
-			} else {
-				static_assert(true, "Cases exhausted");
-			}
-		},
-		addr_variant);
-}
-
-} // namespace
-
-Own<Server> UnixNetwork::listen(NetworkAddress &addr) {
-	auto unix_addr_storage = translateNetworkAddressToUnixNetworkAddress(addr);
-	UnixNetworkAddress &address = translateToUnixAddressRef(unix_addr_storage);
-
-	assert(address.unixAddressSize() > 0);
-	if (address.unixAddressSize() == 0) {
-		return nullptr;
-	}
-
-	int fd = address.unixAddress(0).socket(SOCK_STREAM);
-	if (fd < 0) {
-		return nullptr;
-	}
-
-	int val = 1;
-	int rc = ::setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(val));
-	if (rc < 0) {
-		::close(fd);
-		return nullptr;
-	}
-
-	bool failed = address.unixAddress(0).bind(fd);
-	if (failed) {
-		::close(fd);
-		return nullptr;
-	}
-
-	::listen(fd, SOMAXCONN);
-
-	return heap<UnixServer>(event_port_, fd, 0);
-}
-
-Conveyor<Own<IoStream>> UnixNetwork::connect(NetworkAddress &addr) {
-	auto unix_addr_storage = translateNetworkAddressToUnixNetworkAddress(addr);
-	UnixNetworkAddress &address = translateToUnixAddressRef(unix_addr_storage);
-
-	assert(address.unixAddressSize() > 0);
-	if (address.unixAddressSize() == 0) {
-		return Conveyor<Own<IoStream>>{criticalError("No address found")};
-	}
-
-	int fd = address.unixAddress(0).socket(SOCK_STREAM);
-	if (fd < 0) {
-		return Conveyor<Own<IoStream>>{criticalError("Couldn't open socket")};
-	}
-
-	Own<UnixIoStream> io_stream =
-		heap<UnixIoStream>(event_port_, fd, 0, EPOLLIN | EPOLLOUT);
-
-	bool success = false;
-	for (size_t i = 0; i < address.unixAddressSize(); ++i) {
-		SocketAddress &addr_iter = address.unixAddress(i);
-		int status =
-			::connect(fd, addr_iter.getRaw(), addr_iter.getRawLength());
-		if (status < 0) {
-			int error = errno;
-			/*
-			 * It's not connected yet...
-			 * But edge triggered epolling means that it'll
-			 * be ready when the signal is triggered
-			 */
-
-			/// @todo Add limit node when implemented
-			if (error == EINPROGRESS) {
-				/*
-				Conveyor<void> write_ready = io_stream->writeReady();
-				return write_ready.then(
-					[ios{std::move(io_stream)}]() mutable {
-						ios->write_ready = nullptr;
-						return std::move(ios);
-					});
-				*/
-				success = true;
-				break;
-			} else if (error != EINTR) {
-				/// @todo Push error message from
-				return Conveyor<Own<IoStream>>{
-					criticalError("Couldn't connect")};
-			}
-		} else {
-			success = true;
-			break;
-		}
-	}
-
-	if (!success) {
-		return criticalError("Couldn't connect");
-	}
-
-	return Conveyor<Own<IoStream>>{std::move(io_stream)};
-}
-
-Own<Datagram> UnixNetwork::datagram(NetworkAddress &addr) {
-	auto unix_addr_storage = translateNetworkAddressToUnixNetworkAddress(addr);
-	UnixNetworkAddress &address = translateToUnixAddressRef(unix_addr_storage);
-
-	SAW_ASSERT(address.unixAddressSize() > 0) { return nullptr; }
-
-	int fd = address.unixAddress(0).socket(SOCK_DGRAM);
-
-	int optval = 1;
-	int rc =
-		::setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval));
-	if (rc < 0) {
-		::close(fd);
-		return nullptr;
-	}
-
-	bool failed = address.unixAddress(0).bind(fd);
-	if (failed) {
-		::close(fd);
-		return nullptr;
-	}
-	/// @todo
-	return heap<UnixDatagram>(event_port_, fd, 0);
-}
-
-const std::string &UnixNetworkAddress::address() const { return path_; }
-
-uint16_t UnixNetworkAddress::port() const { return port_hint_; }
-
-SocketAddress &UnixNetworkAddress::unixAddress(size_t i) {
-	assert(i < addresses_.size());
-	/// @todo change from list to vector?
-	return addresses_.at(i);
-}
-
-size_t UnixNetworkAddress::unixAddressSize() const { return addresses_.size(); }
-
-UnixNetwork::UnixNetwork(UnixEventPort &event) : event_port_{event} {}
-
-Conveyor<Own<NetworkAddress>>
-UnixNetwork::resolveAddress(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::vector<SocketAddress> addresses =
-		SocketAddress::resolve(addr_view, port_hint);
-
-	return Conveyor<Own<NetworkAddress>>{
-		heap<UnixNetworkAddress>(path, port_hint, std::move(addresses))};
-}
-
-UnixIoProvider::UnixIoProvider(UnixEventPort &port_ref, Own<EventPort> port)
-	: event_port_{port_ref}, event_loop_{std::move(port)}, unix_network_{
-															   port_ref} {}
-
-Own<InputStream> UnixIoProvider::wrapInputFd(int fd) {
-	return heap<UnixIoStream>(event_port_, fd, 0, EPOLLIN);
-}
-
-Network &UnixIoProvider::network() {
-	return static_cast<Network &>(unix_network_);
-}
-
-EventLoop &UnixIoProvider::eventLoop() { return event_loop_; }
-
-} // namespace unix
-
-ErrorOr<AsyncIoContext> setupAsyncIo() {
-	using namespace unix;
-	try {
-		Own<UnixEventPort> prt = heap<UnixEventPort>();
-		UnixEventPort &prt_ref = *prt;
-
-		Own<UnixIoProvider> io_provider =
-			heap<UnixIoProvider>(prt_ref, std::move(prt));
-
-		EventLoop &loop_ref = io_provider->eventLoop();
-
-		return {{std::move(io_provider), loop_ref, prt_ref}};
-	} catch (std::bad_alloc &) {
-		return criticalError("Out of memory");
-	}
-}
-} // namespace saw
diff --git a/driver/io_unix.cpp b/driver/io_unix.cpp
new file mode 100644
index 0000000..1a175c8
--- /dev/null
+++ b/driver/io_unix.cpp
@@ -0,0 +1,431 @@
+#include "io_unix.h"
+
+#include <sstream>
+
+namespace saw {
+namespace unix {
+i_fd_owner::i_fd_owner(unix_event_port &event_port, int file_descriptor,
+					   int fd_flags, uint32_t event_mask)
+	: event_port_{event_port}, file_descriptor_{file_descriptor},
+	  fd_flags_{fd_flags}, event_mask_{event_mask} {
+	event_port_.subscribe(*this, file_descriptor, event_mask);
+}
+
+i_fd_owner::~i_fd_owner() {
+	if (file_descriptor_ >= 0) {
+		event_port_.unsubscribe(file_descriptor_);
+		::close(file_descriptor_);
+	}
+}
+
+ssize_t unix_read(int fd, void *buffer, size_t length) {
+	return ::recv(fd, buffer, length, 0);
+}
+
+ssize_t unix_write(int fd, const void *buffer, size_t length) {
+	return ::send(fd, buffer, length, 0);
+}
+
+unix_io_stream::unix_io_stream(unix_event_port &event_port, int file_descriptor,
+							   int fd_flags, uint32_t event_mask)
+	: i_fd_owner{event_port, file_descriptor, fd_flags,
+				 event_mask | EPOLLRDHUP} {}
+
+error_or<size_t> unix_io_stream::read(void *buffer, size_t length) {
+	ssize_t read_bytes = unix_read(fd(), buffer, length);
+	if (read_bytes > 0) {
+		return static_cast<size_t>(read_bytes);
+	} else if (read_bytes == 0) {
+		return critical_error("Disconnected", error::code::Disconnected);
+	}
+
+	return recoverable_error("Currently busy");
+}
+
+conveyor<void> unix_io_stream::read_ready() {
+	auto caf = new_conveyor_and_feeder<void>();
+	read_ready_ = std::move(caf.feeder);
+	return std::move(caf.conveyor);
+}
+
+conveyor<void> unix_io_stream::on_read_disconnected() {
+	auto caf = new_conveyor_and_feeder<void>();
+	on_read_disconnect_ = std::move(caf.feeder);
+	return std::move(caf.conveyor);
+}
+
+error_or<size_t> unix_io_stream::write(const void *buffer, size_t length) {
+	ssize_t write_bytes = unix_write(fd(), buffer, length);
+	if (write_bytes > 0) {
+		return static_cast<size_t>(write_bytes);
+	}
+
+	int error = errno;
+
+	if (error == EAGAIN || error == EWOULDBLOCK) {
+		return recoverable_error("Currently busy");
+	}
+
+	return critical_error("Disconnected", error::code::Disconnected);
+}
+
+conveyor<void> unix_io_stream::write_ready() {
+	auto caf = new_conveyor_and_feeder<void>();
+	write_ready_ = std::move(caf.feeder);
+	return std::move(caf.conveyor);
+}
+
+void unix_io_stream::notify(uint32_t mask) {
+	if (mask & EPOLLOUT) {
+		if (write_ready_) {
+			write_ready_->feed();
+		}
+	}
+
+	if (mask & EPOLLIN) {
+		if (read_ready_) {
+			read_ready_->feed();
+		}
+	}
+
+	if (mask & EPOLLRDHUP) {
+		if (on_read_disconnect_) {
+			on_read_disconnect_->feed();
+		}
+	}
+}
+
+unix_server::unix_server(unix_event_port &event_port, int file_descriptor,
+						 int fd_flags)
+	: i_fd_owner{event_port, file_descriptor, fd_flags, EPOLLIN} {}
+
+conveyor<own<io_stream>> unix_server::accept() {
+	auto caf = new_conveyor_and_feeder<own<io_stream>>();
+	accept_feeder_ = std::move(caf.feeder);
+	return std::move(caf.conveyor);
+}
+
+void unix_server::notify(uint32_t mask) {
+	if (mask & EPOLLIN) {
+		if (accept_feeder_) {
+			struct ::sockaddr_storage address;
+			socklen_t address_length = sizeof(address);
+
+			int accept_fd =
+				::accept4(fd(), reinterpret_cast<struct ::sockaddr *>(&address),
+						  &address_length, SOCK_NONBLOCK | SOCK_CLOEXEC);
+			if (accept_fd < 0) {
+				return;
+			}
+			auto fd_stream = heap<unix_io_stream>(event_port_, accept_fd, 0,
+												  EPOLLIN | EPOLLOUT);
+			accept_feeder_->feed(std::move(fd_stream));
+		}
+	}
+}
+
+unix_datagram::unix_datagram(unix_event_port &event_port, int file_descriptor,
+							 int fd_flags)
+	: i_fd_owner{event_port, file_descriptor, fd_flags, EPOLLIN | EPOLLOUT} {}
+
+namespace {
+ssize_t unixReadMsg(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,
+					  reinterpret_cast<struct ::sockaddr *>(&their_addr),
+					  &addr_len);
+}
+
+ssize_t unixWriteMsg(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);
+	if (read_bytes > 0) {
+		return static_cast<size_t>(read_bytes);
+	}
+	return recoverable_error("Currently busy");
+}
+
+conveyor<void> unix_datagram::read_ready() {
+	auto caf = new_conveyor_and_feeder<void>();
+	read_ready_ = std::move(caf.feeder);
+	return std::move(caf.conveyor);
+}
+
+error_or<size_t> unix_datagram::write(const void *buffer, size_t length,
+									  network_address &dest) {
+	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);
+	if (write_bytes > 0) {
+		return static_cast<size_t>(write_bytes);
+	}
+	return recoverable_error("Currently busy");
+}
+
+conveyor<void> unix_datagram::write_ready() {
+	auto caf = new_conveyor_and_feeder<void>();
+	write_ready_ = std::move(caf.feeder);
+	return std::move(caf.conveyor);
+}
+
+void unix_datagram::notify(uint32_t mask) {
+	if (mask & EPOLLOUT) {
+		if (write_ready_) {
+			write_ready_->feed();
+		}
+	}
+
+	if (mask & EPOLLIN) {
+		if (read_ready_) {
+			read_ready_->feed();
+		}
+	}
+}
+
+namespace {
+bool beginsWith(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) {
+	auto addr_variant = addr.representation();
+	std::variant<unix_network_address, unix_network_address *> os_addr =
+		std::visit(
+			[](auto &arg)
+				-> std::variant<unix_network_address, unix_network_address *> {
+				using T = std::decay_t<decltype(arg)>;
+
+				if constexpr (std::is_same_v<T, os_network_address *>) {
+					return static_cast<unix_network_address *>(arg);
+				}
+
+				auto sock_addrs = socket_address::resolve(
+					std::string_view{arg->address()}, arg->port());
+
+				return unix_network_address{arg->address(), arg->port(),
+											std::move(sock_addrs)};
+			},
+			addr_variant);
+	return os_addr;
+}
+
+unix_network_address &translateToUnixAddressRef(
+	std::variant<unix_network_address, unix_network_address *> &addr_variant) {
+	return std::visit(
+		[](auto &arg) -> unix_network_address & {
+			using T = std::decay_t<decltype(arg)>;
+
+			if constexpr (std::is_same_v<T, unix_network_address>) {
+				return arg;
+			} else if constexpr (std::is_same_v<T, unix_network_address *>) {
+				return *arg;
+			} else {
+				static_assert(true, "Cases exhausted");
+			}
+		},
+		addr_variant);
+}
+
+} // namespace
+
+own<server> unix_network::listen(network_address &addr) {
+	auto unix_addr_storage = translateNetworkAddressToUnixNetworkAddress(addr);
+	unix_network_address &address =
+		translateToUnixAddressRef(unix_addr_storage);
+
+	assert(address.unix_address_size() > 0);
+	if (address.unix_address_size() == 0) {
+		return nullptr;
+	}
+
+	int fd = address.unix_address(0).socket(SOCK_STREAM);
+	if (fd < 0) {
+		return nullptr;
+	}
+
+	int val = 1;
+	int rc = ::setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(val));
+	if (rc < 0) {
+		::close(fd);
+		return nullptr;
+	}
+
+	bool failed = address.unix_address(0).bind(fd);
+	if (failed) {
+		::close(fd);
+		return nullptr;
+	}
+
+	::listen(fd, SOMAXCONN);
+
+	return heap<unix_server>(event_port_, fd, 0);
+}
+
+conveyor<own<io_stream>> unix_network::connect(network_address &addr) {
+	auto unix_addr_storage = translateNetworkAddressToUnixNetworkAddress(addr);
+	unix_network_address &address =
+		translateToUnixAddressRef(unix_addr_storage);
+
+	assert(address.unix_address_size() > 0);
+	if (address.unix_address_size() == 0) {
+		return conveyor<own<io_stream>>{critical_error("No address found")};
+	}
+
+	int fd = address.unix_address(0).socket(SOCK_STREAM);
+	if (fd < 0) {
+		return conveyor<own<io_stream>>{critical_error("Couldn't open socket")};
+	}
+
+	own<unix_io_stream> io_str =
+		heap<unix_io_stream>(event_port_, fd, 0, EPOLLIN | EPOLLOUT);
+
+	bool success = false;
+	for (size_t i = 0; i < address.unix_address_size(); ++i) {
+		socket_address &addr_iter = address.unix_address(i);
+		int status =
+			::connect(fd, addr_iter.get_raw(), addr_iter.get_raw_length());
+		if (status < 0) {
+			int error = errno;
+			/*
+			 * It's not connected yet...
+			 * But edge triggered epolling means that it'll
+			 * be ready when the signal is triggered
+			 */
+
+			/// @todo Add limit node when implemented
+			if (error == EINPROGRESS) {
+				/*
+				Conveyor<void> write_ready = io_stream->writeReady();
+				return write_ready.then(
+					[ios{std::move(io_stream)}]() mutable {
+						ios->write_ready = nullptr;
+						return std::move(ios);
+					});
+				*/
+				success = true;
+				break;
+			} else if (error != EINTR) {
+				/// @todo Push error message from
+				return conveyor<own<io_stream>>{
+					critical_error("Couldn't connect")};
+			}
+		} else {
+			success = true;
+			break;
+		}
+	}
+
+	if (!success) {
+		return critical_error("Couldn't connect");
+	}
+
+	return conveyor<own<io_stream>>{std::move(io_str)};
+}
+
+own<datagram> unix_network::datagram(network_address &addr) {
+	auto unix_addr_storage = translateNetworkAddressToUnixNetworkAddress(addr);
+	unix_network_address &address =
+		translateToUnixAddressRef(unix_addr_storage);
+
+	SAW_ASSERT(address.unix_address_size() > 0) { return nullptr; }
+
+	int fd = address.unix_address(0).socket(SOCK_DGRAM);
+
+	int optval = 1;
+	int rc =
+		::setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval));
+	if (rc < 0) {
+		::close(fd);
+		return nullptr;
+	}
+
+	bool failed = address.unix_address(0).bind(fd);
+	if (failed) {
+		::close(fd);
+		return nullptr;
+	}
+	/// @todo
+	return heap<unix_datagram>(event_port_, fd, 0);
+}
+
+const std::string &unix_network_address::address() const { return path_; }
+
+uint16_t unix_network_address::port() const { return port_hint_; }
+
+socket_address &unix_network_address::unix_address(size_t i) {
+	assert(i < addresses_.size());
+	/// @todo change from list to vector?
+	return addresses_.at(i);
+}
+
+size_t unix_network_address::unix_address_size() const {
+	return addresses_.size();
+}
+
+unix_network::unix_network(unix_event_port &event) : event_port_{event} {}
+
+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::vector<socket_address> addresses =
+		socket_address::resolve(addr_view, port_hint);
+
+	return conveyor<own<network_address>>{
+		heap<unix_network_address>(path, port_hint, std::move(addresses))};
+}
+
+unix_io_provider::unix_io_provider(unix_event_port &port_ref,
+								   own<event_port> port)
+	: event_port_{port_ref}, event_loop_{std::move(port)}, unix_network_{
+															   port_ref} {}
+
+own<input_stream> unix_io_provider::wrap_input_fd(int fd) {
+	return heap<unix_io_stream>(event_port_, fd, 0, EPOLLIN);
+}
+
+class network &unix_io_provider::network() {
+	return static_cast<class network &>(unix_network_);
+}
+
+class event_loop &unix_io_provider::event_loop() {
+	return event_loop_;
+}
+
+} // namespace unix
+
+error_or<async_io_context> setup_async_io() {
+	using namespace unix;
+	try {
+		own<unix_event_port> prt = heap<unix_event_port>();
+		unix_event_port &prt_ref = *prt;
+
+		own<unix_io_provider> io_provider =
+			heap<unix_io_provider>(prt_ref, std::move(prt));
+
+		event_loop &loop_ref = io_provider->event_loop();
+
+		return {{std::move(io_provider), loop_ref, prt_ref}};
+	} catch (std::bad_alloc &) {
+		return critical_error("Out of memory");
+	}
+}
+} // namespace saw
diff --git a/driver/io-unix.h b/driver/io_unix.h
similarity index 60%
rename from driver/io-unix.h
rename to driver/io_unix.h
index 715b3cc..1979411 100644
--- a/driver/io-unix.h
+++ b/driver/io_unix.h
@@ -26,16 +26,16 @@
 #include <unordered_map>
 #include <vector>
 
-#include "forstio/io.h"
+#include "io.h"
 
 namespace saw {
 namespace unix {
 constexpr int MAX_EPOLL_EVENTS = 256;
 
-class UnixEventPort;
-class IFdOwner {
+class unix_event_port;
+class i_fd_owner {
 protected:
-	UnixEventPort &event_port_;
+	unix_event_port &event_port_;
 
 private:
 	int file_descriptor_;
@@ -43,29 +43,29 @@ private:
 	uint32_t event_mask_;
 
 public:
-	IFdOwner(UnixEventPort &event_port, int file_descriptor, int fd_flags,
-			 uint32_t event_mask);
+	i_fd_owner(unix_event_port &event_port, int file_descriptor, int fd_flags,
+			   uint32_t event_mask);
 
-	virtual ~IFdOwner();
+	virtual ~i_fd_owner();
 
 	virtual void notify(uint32_t mask) = 0;
 
 	int fd() const { return file_descriptor_; }
 };
 
-class UnixEventPort final : public EventPort {
+class unix_event_port final : public event_port {
 private:
 	int epoll_fd_;
 	int signal_fd_;
 
 	sigset_t signal_fd_set_;
 
-	std::unordered_multimap<Signal, Own<ConveyorFeeder<void>>>
+	std::unordered_multimap<Signal, own<conveyor_feeder<void>>>
 		signal_conveyors_;
 
 	int pipefds_[2];
 
-	std::vector<int> toUnixSignal(Signal signal) const {
+	std::vector<int> to_unix_signal(Signal signal) const {
 		switch (signal) {
 		case Signal::User1:
 			return {SIGUSR1};
@@ -75,7 +75,7 @@ private:
 		}
 	}
 
-	Signal fromUnixSignal(int signal) const {
+	Signal from_unix_signal(int signal) const {
 		switch (signal) {
 		case SIGUSR1:
 			return Signal::User1;
@@ -87,8 +87,8 @@ private:
 		}
 	}
 
-	void notifySignalListener(int sig) {
-		Signal signal = fromUnixSignal(sig);
+	void notify_signal_listener(int sig) {
+		Signal signal = from_unix_signal(sig);
 
 		auto equal_range = signal_conveyors_.equal_range(signal);
 		for (auto iter = equal_range.first; iter != equal_range.second;
@@ -102,7 +102,7 @@ private:
 		}
 	}
 
-	bool pollImpl(int time) {
+	bool poll_impl(int time) {
 		epoll_event events[MAX_EPOLL_EVENTS];
 		int nfds = 0;
 		do {
@@ -124,7 +124,7 @@ private:
 						}
 						assert(n == sizeof(siginfo));
 
-						notifySignalListener(siginfo.ssi_signo);
+						notify_signal_listener(siginfo.ssi_signo);
 					}
 				} else if (events[i].data.u64 == 1) {
 					uint8_t i;
@@ -138,8 +138,8 @@ private:
 						}
 					}
 				} else {
-					IFdOwner *owner =
-						reinterpret_cast<IFdOwner *>(events[i].data.ptr);
+					i_fd_owner *owner =
+						reinterpret_cast<i_fd_owner *>(events[i].data.ptr);
 					if (owner) {
 						owner->notify(events[i].events);
 					}
@@ -151,7 +151,7 @@ private:
 	}
 
 public:
-	UnixEventPort() : epoll_fd_{-1}, signal_fd_{-1} {
+	unix_event_port() : epoll_fd_{-1}, signal_fd_{-1} {
 		::signal(SIGPIPE, SIG_IGN);
 
 		epoll_fd_ = ::epoll_create1(EPOLL_CLOEXEC);
@@ -182,19 +182,19 @@ public:
 		::epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, pipefds_[0], &event);
 	}
 
-	~UnixEventPort() {
+	~unix_event_port() {
 		::close(epoll_fd_);
 		::close(signal_fd_);
 		::close(pipefds_[0]);
 		::close(pipefds_[1]);
 	}
 
-	Conveyor<void> onSignal(Signal signal) override {
-		auto caf = newConveyorAndFeeder<void>();
+	conveyor<void> on_signal(Signal signal) override {
+		auto caf = new_conveyor_and_feeder<void>();
 
 		signal_conveyors_.insert(std::make_pair(signal, std::move(caf.feeder)));
 
-		std::vector<int> sig = toUnixSignal(signal);
+		std::vector<int> sig = to_unix_signal(signal);
 
 		for (auto iter = sig.begin(); iter != sig.end(); ++iter) {
 			::sigaddset(&signal_fd_set_, *iter);
@@ -202,17 +202,18 @@ public:
 		::sigprocmask(SIG_BLOCK, &signal_fd_set_, nullptr);
 		::signalfd(signal_fd_, &signal_fd_set_, SFD_NONBLOCK | SFD_CLOEXEC);
 
-		auto node = Conveyor<void>::fromConveyor(std::move(caf.conveyor));
-		return Conveyor<void>::toConveyor(std::move(node));
+		auto node = conveyor<void>::from_conveyor(std::move(caf.conveyor));
+		return conveyor<void>::to_conveyor(std::move(node));
 	}
 
-	void poll() override { pollImpl(0); }
+	void poll() override { poll_impl(0); }
 
-	void wait() override { pollImpl(-1); }
+	void wait() override { poll_impl(-1); }
 
 	void wait(const std::chrono::steady_clock::duration &duration) override {
-		pollImpl(std::chrono::duration_cast<std::chrono::milliseconds>(duration)
-					 .count());
+		poll_impl(
+			std::chrono::duration_cast<std::chrono::milliseconds>(duration)
+				.count());
 	}
 	void
 	wait(const std::chrono::steady_clock::time_point &time_point) override {
@@ -220,9 +221,9 @@ public:
 		if (time_point <= now) {
 			poll();
 		} else {
-			pollImpl(std::chrono::duration_cast<std::chrono::milliseconds>(
-						 time_point - now)
-						 .count());
+			poll_impl(std::chrono::duration_cast<std::chrono::milliseconds>(
+						  time_point - now)
+						  .count());
 		}
 	}
 
@@ -236,7 +237,7 @@ public:
 		::send(pipefds_[1], &i, sizeof(i), MSG_DONTWAIT);
 	}
 
-	void subscribe(IFdOwner &owner, int fd, uint32_t event_mask) {
+	void subscribe(i_fd_owner &owner, int fd, uint32_t event_mask) {
 		if (epoll_fd_ < 0 || fd < 0) {
 			return;
 		}
@@ -262,28 +263,28 @@ public:
 	}
 };
 
-ssize_t unixRead(int fd, void *buffer, size_t length);
-ssize_t unixWrite(int fd, const void *buffer, size_t length);
+ssize_t unix_read(int fd, void *buffer, size_t length);
+ssize_t unix_write(int fd, const void *buffer, size_t length);
 
-class UnixIoStream final : public IoStream, public IFdOwner {
+class unix_io_stream final : public io_stream, public i_fd_owner {
 private:
-	Own<ConveyorFeeder<void>> read_ready_ = nullptr;
-	Own<ConveyorFeeder<void>> on_read_disconnect_ = nullptr;
-	Own<ConveyorFeeder<void>> write_ready_ = nullptr;
+	own<conveyor_feeder<void>> read_ready_ = nullptr;
+	own<conveyor_feeder<void>> on_read_disconnect_ = nullptr;
+	own<conveyor_feeder<void>> write_ready_ = nullptr;
 
 public:
-	UnixIoStream(UnixEventPort &event_port, int file_descriptor, int fd_flags,
-				 uint32_t event_mask);
+	unix_io_stream(unix_event_port &event_port, int file_descriptor,
+				   int fd_flags, uint32_t event_mask);
 
-	ErrorOr<size_t> read(void *buffer, size_t length) override;
+	error_or<size_t> read(void *buffer, size_t length) override;
 
-	Conveyor<void> readReady() override;
+	conveyor<void> read_ready() override;
 
-	Conveyor<void> onReadDisconnected() override;
+	conveyor<void> on_read_disconnected() override;
 
-	ErrorOr<size_t> write(const void *buffer, size_t length) override;
+	error_or<size_t> write(const void *buffer, size_t length) override;
 
-	Conveyor<void> writeReady() override;
+	conveyor<void> write_ready() override;
 
 	/*
 		void read(void *buffer, size_t min_length, size_t max_length) override;
@@ -300,32 +301,33 @@ public:
 	void notify(uint32_t mask) override;
 };
 
-class UnixServer final : public Server, public IFdOwner {
+class unix_server final : public server, public i_fd_owner {
 private:
-	Own<ConveyorFeeder<Own<IoStream>>> accept_feeder_ = nullptr;
+	own<conveyor_feeder<own<io_stream>>> accept_feeder_ = nullptr;
 
 public:
-	UnixServer(UnixEventPort &event_port, int file_descriptor, int fd_flags);
+	unix_server(unix_event_port &event_port, int file_descriptor, int fd_flags);
 
-	Conveyor<Own<IoStream>> accept() override;
+	conveyor<own<io_stream>> accept() override;
 
 	void notify(uint32_t mask) override;
 };
 
-class UnixDatagram final : public Datagram, public IFdOwner {
+class unix_datagram final : public datagram, public i_fd_owner {
 private:
-	Own<ConveyorFeeder<void>> read_ready_ = nullptr;
-	Own<ConveyorFeeder<void>> write_ready_ = nullptr;
+	own<conveyor_feeder<void>> read_ready_ = nullptr;
+	own<conveyor_feeder<void>> write_ready_ = nullptr;
 
 public:
-	UnixDatagram(UnixEventPort &event_port, int file_descriptor, int fd_flags);
+	unix_datagram(unix_event_port &event_port, int file_descriptor,
+				  int fd_flags);
 
-	ErrorOr<size_t> read(void *buffer, size_t length) override;
-	Conveyor<void> readReady() override;
+	error_or<size_t> read(void *buffer, size_t length) override;
+	conveyor<void> read_ready() override;
 
-	ErrorOr<size_t> write(const void *buffer, size_t length,
-						  NetworkAddress &dest) override;
-	Conveyor<void> writeReady() override;
+	error_or<size_t> write(const void *buffer, size_t length,
+						   network_address &dest) override;
+	conveyor<void> write_ready() override;
 
 	void notify(uint32_t mask) override;
 };
@@ -333,7 +335,7 @@ public:
 /**
  * Helper class which provides potential addresses to NetworkAddress
  */
-class SocketAddress {
+class socket_address {
 private:
 	union {
 		struct sockaddr generic;
@@ -346,10 +348,10 @@ private:
 	socklen_t address_length_;
 	bool wildcard_;
 
-	SocketAddress() : wildcard_{false} {}
+	socket_address() : wildcard_{false} {}
 
 public:
-	SocketAddress(const void *sockaddr, socklen_t len, bool wildcard)
+	socket_address(const void *sockaddr, socklen_t len, bool wildcard)
 		: address_length_{len}, wildcard_{wildcard} {
 		assert(len <= sizeof(address_));
 		memcpy(&address_.generic, sockaddr, len);
@@ -371,17 +373,17 @@ public:
 		return error < 0;
 	}
 
-	struct ::sockaddr *getRaw() {
+	struct ::sockaddr *get_raw() {
 		return &address_.generic;
 	}
 
-	const struct ::sockaddr *getRaw() const { return &address_.generic; }
+	const struct ::sockaddr *get_raw() const { return &address_.generic; }
 
-	socklen_t getRawLength() const { return address_length_; }
+	socklen_t get_raw_length() const { return address_length_; }
 
-	static std::vector<SocketAddress> resolve(std::string_view str,
-											  uint16_t port_hint) {
-		std::vector<SocketAddress> results;
+	static std::vector<socket_address> resolve(std::string_view str,
+											   uint16_t port_hint) {
+		std::vector<socket_address> results;
 
 		struct ::addrinfo *head;
 		struct ::addrinfo hints;
@@ -400,7 +402,7 @@ public:
 		}
 
 		for (struct ::addrinfo *it = head; it != nullptr; it = it->ai_next) {
-			if (it->ai_addrlen > sizeof(SocketAddress::address_)) {
+			if (it->ai_addrlen > sizeof(socket_address::address_)) {
 				continue;
 			}
 			results.push_back({it->ai_addr, it->ai_addrlen, wildcard});
@@ -410,15 +412,15 @@ public:
 	}
 };
 
-class UnixNetworkAddress final : public OsNetworkAddress {
+class unix_network_address final : public os_network_address {
 private:
 	const std::string path_;
 	uint16_t port_hint_;
-	std::vector<SocketAddress> addresses_;
+	std::vector<socket_address> addresses_;
 
 public:
-	UnixNetworkAddress(const std::string &path, uint16_t port_hint,
-					   std::vector<SocketAddress> &&addr)
+	unix_network_address(const std::string &path, uint16_t port_hint,
+						 std::vector<socket_address> &&addr)
 		: path_{path}, port_hint_{port_hint}, addresses_{std::move(addr)} {}
 
 	const std::string &address() const override;
@@ -426,42 +428,43 @@ public:
 	uint16_t port() const override;
 
 	// Custom address info
-	SocketAddress &unixAddress(size_t i = 0);
-	size_t unixAddressSize() const;
+	socket_address &unix_address(size_t i = 0);
+	size_t unix_address_size() const;
 };
 
-class UnixNetwork final : public Network {
+class unix_network final : public network {
 private:
-	UnixEventPort &event_port_;
+	unix_event_port &event_port_;
 
 public:
-	UnixNetwork(UnixEventPort &event_port);
+	unix_network(unix_event_port &event_port);
 
-	Conveyor<Own<NetworkAddress>>
-	resolveAddress(const std::string &address, uint16_t port_hint = 0) override;
+	conveyor<own<network_address>>
+	resolve_address(const std::string &address,
+					uint16_t port_hint = 0) override;
 
-	Own<Server> listen(NetworkAddress &addr) override;
+	own<server> listen(network_address &addr) override;
 
-	Conveyor<Own<IoStream>> connect(NetworkAddress &addr) override;
+	conveyor<own<io_stream>> connect(network_address &addr) override;
 
-	Own<Datagram> datagram(NetworkAddress &addr) override;
+	own<class datagram> datagram(network_address &addr) override;
 };
 
-class UnixIoProvider final : public IoProvider {
+class unix_io_provider final : public io_provider {
 private:
-	UnixEventPort &event_port_;
-	EventLoop event_loop_;
+	unix_event_port &event_port_;
+	class event_loop event_loop_;
 
-	UnixNetwork unix_network_;
+	unix_network unix_network_;
 
 public:
-	UnixIoProvider(UnixEventPort &port_ref, Own<EventPort> port);
+	unix_io_provider(unix_event_port &port_ref, own<event_port> port);
 
-	Network &network() override;
+	class network &network() override;
 
-	Own<InputStream> wrapInputFd(int fd) override;
+	own<input_stream> wrap_input_fd(int fd) override;
 
-	EventLoop &eventLoop();
+	class event_loop &event_loop();
 };
 } // namespace unix
 } // namespace saw
diff --git a/source/forstio/async.cpp b/source/forstio/async.cpp
index 08d718d..5af7267 100644
--- a/source/forstio/async.cpp
+++ b/source/forstio/async.cpp
@@ -7,38 +7,38 @@
 
 namespace saw {
 namespace {
-thread_local EventLoop *local_loop = nullptr;
+thread_local event_loop *local_loop = nullptr;
 
-EventLoop &currentEventLoop() {
-	EventLoop *loop = local_loop;
+event_loop &current_event_loop() {
+	event_loop *loop = local_loop;
 	assert(loop);
 	return *loop;
 }
 } // namespace
 
-ConveyorNode::ConveyorNode() {}
+conveyor_node::conveyor_node() {}
 
-ConveyorNodeWithChildMixin::ConveyorNodeWithChildMixin(
-	Own<ConveyorNode> &&child_, ConveyorNode &owner)
+conveyor_node_with_child_mixin::conveyor_node_with_child_mixin(
+	own<conveyor_node> &&child_, conveyor_node &owner)
 	: child{std::move(child_)} {
 	assert(child);
 
-	child->notifyParentAttached(owner);
+	child->notify_parent_attached(owner);
 }
 
-ErrorOr<Own<ConveyorNode>>
-ConveyorNodeWithChildMixin::swapChild(Own<ConveyorNode> &&swapee) {
+error_or<own<conveyor_node>>
+conveyor_node_with_child_mixin::swap_child(own<conveyor_node> &&swapee) {
 	SAW_ASSERT(child) {
-		return criticalError("Child should exist if this function is called");
+		return critical_error("Child should exist if this function is called");
 	}
-	Own<ConveyorNode> old_child = std::move(child);
+	own<conveyor_node> old_child = std::move(child);
 
 	/**
 	 * We need the parent of the old_child's next storage
 	 */
-	ConveyorStorage *old_storage = old_child->nextStorage();
-	ConveyorStorage *old_storage_parent = old_storage ? old_storage->getParent()
-													  : nullptr;
+	conveyor_storage *old_storage = old_child->next_storage();
+	conveyor_storage *old_storage_parent =
+		old_storage ? old_storage->get_parent() : nullptr;
 
 	/**
 	 * Swap in the new child
@@ -51,56 +51,56 @@ ConveyorNodeWithChildMixin::swapChild(Own<ConveyorNode> &&swapee) {
 		 * storage has a nullptr set And if the old_storage_parent is a nullptr,
 		 * then it doesn't matter. So we don't check for it
 		 */
-		ConveyorStorage *swapee_storage = child->nextStorage();
+		conveyor_storage *swapee_storage = child->next_storage();
 		if (swapee_storage) {
-			swapee_storage->setParent(old_storage_parent);
+			swapee_storage->set_parent(old_storage_parent);
 		}
 	}
 
 	return old_child;
 }
 
-ConveyorStorage::ConveyorStorage() {}
+conveyor_storage::conveyor_storage() {}
 
-ConveyorStorage::~ConveyorStorage() {}
+conveyor_storage::~conveyor_storage() {}
 
-ConveyorStorage *ConveyorStorage::getParent() const { return parent_; }
+conveyor_storage *conveyor_storage::get_parent() const { return parent_; }
 
-void ConveyorEventStorage::setParent(ConveyorStorage *p) {
+void conveyor_event_storage::set_parent(conveyor_storage *p) {
 	/*
 	 * parent check isn't needed, but is used
 	 * for the assert, because the storage should
 	 * be armed if there was an element present
 	 * and a valid parent
 	 */
-	if (/*!parent && */ p && !isArmed() && queued() > 0) {
+	if (/*!parent && */ p && !is_armed() && queued() > 0) {
 		assert(!parent_);
 		if (p->space() > 0) {
-			armLater();
+			arm_later();
 		}
 	}
 
 	parent_ = p;
 }
 
-ConveyorEventStorage::ConveyorEventStorage() : ConveyorStorage{} {}
+conveyor_event_storage::conveyor_event_storage() : conveyor_storage{} {}
 
-ConveyorBase::ConveyorBase(Own<ConveyorNode> &&node_p)
+conveyor_base::conveyor_base(own<conveyor_node> &&node_p)
 	: node_{std::move(node_p)} {}
 
-Error PropagateError::operator()(const Error &error) const {
-	return error.copyError();
+error propagate_error::operator()(const error &error) const {
+	return error.copy_error();
 }
 
-Error PropagateError::operator()(Error &&error) { return std::move(error); }
+error propagate_error::operator()(error &&err) { return std::move(err); }
 
-Event::Event() : Event(currentEventLoop()) {}
+event::event() : event(current_event_loop()) {}
 
-Event::Event(EventLoop &loop) : loop_{loop} {}
+event::event(event_loop &loop) : loop_{loop} {}
 
-Event::~Event() { disarm(); }
+event::~event() { disarm(); }
 
-void Event::armNext() {
+void event::arm_next() {
 	assert(&loop_ == local_loop);
 	if (prev_ == nullptr) {
 		// Push the next_insert_point back by one
@@ -129,11 +129,11 @@ void Event::armNext() {
 			loop_.tail_ = &next_;
 		}
 
-		loop_.setRunnable(true);
+		loop_.set_runnable(true);
 	}
 }
 
-void Event::armLater() {
+void event::arm_later() {
 	assert(&loop_ == local_loop);
 
 	if (prev_ == nullptr) {
@@ -149,11 +149,11 @@ void Event::armLater() {
 			loop_.tail_ = &next_;
 		}
 
-		loop_.setRunnable(true);
+		loop_.set_runnable(true);
 	}
 }
 
-void Event::armLast() {
+void event::arm_last() {
 	assert(&loop_ == local_loop);
 
 	if (prev_ == nullptr) {
@@ -168,11 +168,11 @@ void Event::armLast() {
 			loop_.tail_ = &next_;
 		}
 
-		loop_.setRunnable(true);
+		loop_.set_runnable(true);
 	}
 }
 
-void Event::disarm() {
+void event::disarm() {
 	if (prev_ != nullptr) {
 		if (loop_.tail_ == &next_) {
 			loop_.tail_ = prev_;
@@ -192,33 +192,33 @@ void Event::disarm() {
 	}
 }
 
-bool Event::isArmed() const { return prev_ != nullptr; }
+bool event::is_armed() const { return prev_ != nullptr; }
 
-ConveyorSink::ConveyorSink() : node_{nullptr} {}
+conveyor_sink::conveyor_sink() : node_{nullptr} {}
 
-ConveyorSink::ConveyorSink(Own<ConveyorNode> &&node_p)
+conveyor_sink::conveyor_sink(own<conveyor_node> &&node_p)
 	: node_{std::move(node_p)} {}
 
-void EventLoop::setRunnable(bool runnable) { is_runnable_ = runnable; }
+void event_loop::set_runnable(bool runnable) { is_runnable_ = runnable; }
 
-EventLoop::EventLoop() {}
+event_loop::event_loop() {}
 
-EventLoop::EventLoop(Own<EventPort> &&event_port)
-	: event_port_{std::move(event_port)} {}
+event_loop::event_loop(own<class event_port> &&ep)
+	: event_port_{std::move(ep)} {}
 
-EventLoop::~EventLoop() { assert(local_loop != this); }
+event_loop::~event_loop() { assert(local_loop != this); }
 
-void EventLoop::enterScope() {
+void event_loop::enter_scope() {
 	assert(!local_loop);
 	local_loop = this;
 }
 
-void EventLoop::leaveScope() {
+void event_loop::leave_scope() {
 	assert(local_loop == this);
 	local_loop = nullptr;
 }
 
-bool EventLoop::turnLoop() {
+bool event_loop::turn_loop() {
 	size_t turn_step = 0;
 	while (head_ && turn_step < 65536) {
 		if (!turn()) {
@@ -229,8 +229,8 @@ bool EventLoop::turnLoop() {
 	return true;
 }
 
-bool EventLoop::turn() {
-	Event *event = head_;
+bool event_loop::turn() {
+	event *event = head_;
 
 	if (!event) {
 		return false;
@@ -259,158 +259,161 @@ bool EventLoop::turn() {
 	return true;
 }
 
-bool EventLoop::wait(const std::chrono::steady_clock::duration &duration) {
+bool event_loop::wait(const std::chrono::steady_clock::duration &duration) {
 	if (event_port_) {
 		event_port_->wait(duration);
 	}
 
-	return turnLoop();
+	return turn_loop();
 }
 
-bool EventLoop::wait(const std::chrono::steady_clock::time_point &time_point) {
+bool event_loop::wait(const std::chrono::steady_clock::time_point &time_point) {
 	if (event_port_) {
 		event_port_->wait(time_point);
 	}
 
-	return turnLoop();
+	return turn_loop();
 }
 
-bool EventLoop::wait() {
+bool event_loop::wait() {
 	if (event_port_) {
 		event_port_->wait();
 	}
 
-	return turnLoop();
+	return turn_loop();
 }
 
-bool EventLoop::poll() {
+bool event_loop::poll() {
 	if (event_port_) {
 		event_port_->poll();
 	}
 
-	return turnLoop();
+	return turn_loop();
 }
 
-EventPort *EventLoop::eventPort() { return event_port_.get(); }
+event_port *event_loop::event_port() { return event_port_.get(); }
 
-ConveyorSinkSet &EventLoop::daemon() {
+conveyor_sink_set &event_loop::daemon() {
 	if (!daemon_sink_) {
-		daemon_sink_ = heap<ConveyorSinkSet>();
+		daemon_sink_ = heap<conveyor_sink_set>();
 	}
 	return *daemon_sink_;
 }
 
-WaitScope::WaitScope(EventLoop &loop) : loop_{loop} { loop_.enterScope(); }
+wait_scope::wait_scope(event_loop &loop) : loop_{loop} { loop_.enter_scope(); }
 
-WaitScope::~WaitScope() { loop_.leaveScope(); }
+wait_scope::~wait_scope() { loop_.leave_scope(); }
 
-void WaitScope::wait() { loop_.wait(); }
+void wait_scope::wait() { loop_.wait(); }
 
-void WaitScope::wait(const std::chrono::steady_clock::duration &duration) {
+void wait_scope::wait(const std::chrono::steady_clock::duration &duration) {
 	loop_.wait(duration);
 }
 
-void WaitScope::wait(const std::chrono::steady_clock::time_point &time_point) {
+void wait_scope::wait(const std::chrono::steady_clock::time_point &time_point) {
 	loop_.wait(time_point);
 }
 
-void WaitScope::poll() { loop_.poll(); }
+void wait_scope::poll() { loop_.poll(); }
 
-ErrorOr<Own<ConveyorNode>>
-ConvertConveyorNodeBase::swapChild(Own<ConveyorNode> &&swapee) noexcept {
-	return child_mixin_.swapChild(std::move(swapee));
+error_or<own<conveyor_node>>
+convert_conveyor_node_base::swap_child(own<conveyor_node> &&swapee) noexcept {
+	return child_mixin_.swap_child(std::move(swapee));
 }
 
-ConveyorStorage *ConvertConveyorNodeBase::nextStorage() noexcept {
+conveyor_storage *convert_conveyor_node_base::next_storage() noexcept {
 	if (!child_mixin_.child) {
 		return nullptr;
 	}
-	return child_mixin_.child->nextStorage();
+	return child_mixin_.child->next_storage();
 }
 
-ImmediateConveyorNodeBase::ImmediateConveyorNodeBase()
-	: ConveyorEventStorage{} {}
+immediate_conveyor_node_base::immediate_conveyor_node_base()
+	: conveyor_event_storage{} {}
 
-MergeConveyorNodeBase::MergeConveyorNodeBase() : ConveyorEventStorage{} {}
+merge_conveyor_node_base::merge_conveyor_node_base()
+	: conveyor_event_storage{} {}
 
-ErrorOr<Own<ConveyorNode>>
-QueueBufferConveyorNodeBase::swapChild(Own<ConveyorNode> &&swapee_) noexcept {
-	return child_mixin_.swapChild(std::move(swapee_));
+error_or<own<conveyor_node>> queue_buffer_conveyor_node_base::swap_child(
+	own<conveyor_node> &&swapee_) noexcept {
+	return child_mixin_.swap_child(std::move(swapee_));
 }
 
-void ConveyorSinkSet::destroySinkConveyorNode(ConveyorNode &node) {
-	if (!isArmed()) {
-		armLast();
+void conveyor_sink_set::destroy_sink_conveyor_node(conveyor_node &node) {
+	if (!is_armed()) {
+		arm_last();
 	}
 
 	delete_nodes_.push(&node);
 }
 
-void ConveyorSinkSet::fail(Error &&error) {
+void conveyor_sink_set::fail(error &&error) {
 	/// @todo call error_handler
 }
 
-ConveyorSinkSet::ConveyorSinkSet(EventLoop &event_loop) : Event{event_loop} {}
+conveyor_sink_set::conveyor_sink_set(event_loop &event_loop)
+	: event{event_loop} {}
 
-void ConveyorSinkSet::add(Conveyor<void> &&sink) {
-	auto nas = Conveyor<void>::fromConveyor(std::move(sink));
+void conveyor_sink_set::add(conveyor<void> &&sink) {
+	auto nas = conveyor<void>::from_conveyor(std::move(sink));
 	SAW_ASSERT(nas) { return; }
-	ConveyorStorage *storage = nas->nextStorage();
+	conveyor_storage *storage = nas->next_storage();
 
-	Own<SinkConveyorNode> sink_node = nullptr;
+	own<sink_conveyor_node> sink_node = nullptr;
 	try {
-		sink_node = heap<SinkConveyorNode>(std::move(nas), *this);
+		sink_node = heap<sink_conveyor_node>(std::move(nas), *this);
 	} catch (std::bad_alloc &) {
 		return;
 	}
 	if (storage) {
-		storage->setParent(sink_node.get());
+		storage->set_parent(sink_node.get());
 	}
 
 	sink_nodes_.emplace_back(std::move(sink_node));
 }
 
-void ConveyorSinkSet::fire() {
+void conveyor_sink_set::fire() {
 	while (!delete_nodes_.empty()) {
-		ConveyorNode *node = delete_nodes_.front();
+		conveyor_node *node = delete_nodes_.front();
 		/*auto erased = */ std::remove_if(sink_nodes_.begin(),
 										  sink_nodes_.end(),
-										  [node](Own<ConveyorNode> &element) {
+										  [node](own<conveyor_node> &element) {
 											  return node == element.get();
 										  });
 		delete_nodes_.pop();
 	}
 }
 
-ConvertConveyorNodeBase::ConvertConveyorNodeBase(Own<ConveyorNode> &&dep)
+convert_conveyor_node_base::convert_conveyor_node_base(own<conveyor_node> &&dep)
 	: child_mixin_{std::move(dep), *this} {}
 
-void ConvertConveyorNodeBase::getResult(ErrorOrValue &err_or_val) {
-	getImpl(err_or_val);
+void convert_conveyor_node_base::get_result(error_or_value &err_or_val) {
+	get_impl(err_or_val);
 }
 
-void AttachConveyorNodeBase::getResult(ErrorOrValue &err_or_val) noexcept {
+void attach_conveyor_node_base::get_result(
+	error_or_value &err_or_val) noexcept {
 	if (child_mixin_.child) {
-		child_mixin_.child->getResult(err_or_val);
+		child_mixin_.child->get_result(err_or_val);
 	}
 }
 
-ErrorOr<Own<ConveyorNode>>
-AttachConveyorNodeBase::swapChild(Own<ConveyorNode> &&swapee_) noexcept {
-	return child_mixin_.swapChild(std::move(swapee_));
+error_or<own<conveyor_node>>
+attach_conveyor_node_base::swap_child(own<conveyor_node> &&swapee_) noexcept {
+	return child_mixin_.swap_child(std::move(swapee_));
 }
 
-ConveyorStorage *AttachConveyorNodeBase::nextStorage() noexcept {
+conveyor_storage *attach_conveyor_node_base::next_storage() noexcept {
 	if (!child_mixin_.child) {
 		return nullptr;
 	}
 
-	return child_mixin_.child->nextStorage();
+	return child_mixin_.child->next_storage();
 }
 
-void detachConveyor(Conveyor<void> &&conveyor) {
-	EventLoop &loop = currentEventLoop();
-	ConveyorSinkSet &sink = loop.daemon();
+void detach_conveyor(conveyor<void> &&conveyor) {
+	event_loop &loop = current_event_loop();
+	conveyor_sink_set &sink = loop.daemon();
 	sink.add(std::move(conveyor));
 }
 } // namespace saw
diff --git a/source/forstio/async.h b/source/forstio/async.h
index 4a25385..366b14e 100644
--- a/source/forstio/async.h
+++ b/source/forstio/async.h
@@ -11,220 +11,222 @@
 #include <type_traits>
 
 namespace saw {
-class ConveyorStorage;
-class ConveyorNode {
+class conveyor_storage;
+class conveyor_node {
 public:
-	ConveyorNode();
-	virtual ~ConveyorNode() = default;
+	conveyor_node();
+	virtual ~conveyor_node() = default;
 
 	/**
 	 * Internal method to retrieve results from children
 	 */
-	virtual void getResult(ErrorOrValue &err_or_val) = 0;
+	virtual void get_result(error_or_value &err_or_val) = 0;
 
 	/**
 	 * Swap out child with another one
 	 */
-	virtual ErrorOr<Own<ConveyorNode>>
-	swapChild(Own<ConveyorNode> &&swapee_) = 0;
+	virtual error_or<own<conveyor_node>>
+	swap_child(own<conveyor_node> &&swapee_) = 0;
 
 	/**
 	 * Retrieve the next storage node
 	 */
-	virtual ConveyorStorage *nextStorage() = 0;
+	virtual conveyor_storage *next_storage() = 0;
 
 	/**
 	 * Notify that a new parent was attached
 	 * Only relevant for the feeding nodes
 	 */
-	virtual void notifyParentAttached(ConveyorNode &){};
+	virtual void notify_parent_attached(conveyor_node &){};
 };
 
-class ConveyorNodeWithChildMixin final {
+class conveyor_node_with_child_mixin final {
 public:
-	Own<ConveyorNode> child = nullptr;
+	own<conveyor_node> child = nullptr;
 
-	ConveyorNodeWithChildMixin(Own<ConveyorNode> &&child_,
-							   ConveyorNode &owner_);
-	~ConveyorNodeWithChildMixin() = default;
+	conveyor_node_with_child_mixin(own<conveyor_node> &&child_,
+								   conveyor_node &owner_);
+	~conveyor_node_with_child_mixin() = default;
 
 	/**
 	 * Swap out children and return the child ptr, since the caller is the child
 	 * itself. Stack needs to be cleared before the child is destroyed, so the
 	 * swapped out node is returned as well.
 	 */
-	ErrorOr<Own<ConveyorNode>> swapChild(Own<ConveyorNode> &&swapee);
+	error_or<own<conveyor_node>> swap_child(own<conveyor_node> &&swapee);
 };
 
-class ConveyorNodeWithParentMixin final {
+class conveyor_node_with_parent_mixin final {
 public:
-	ConveyorNode *parent = nullptr;
+	conveyor_node *parent = nullptr;
 
-	ErrorOr<Own<ConveyorNode>> swapChildOfParent(Own<ConveyorNode> &&swapee) {
+	error_or<own<conveyor_node>>
+	swap_child_of_parent(own<conveyor_node> &&swapee) {
 		SAW_ASSERT(parent) {
-			return criticalError(
+			return critical_error(
 				"Can't swap child, because parent doesn't exist");
 		}
 
-		return parent->swapChild(std::move(swapee));
+		return parent->swap_child(std::move(swapee));
 	}
-	void changeParent(ConveyorNode *p) { parent = p; }
+	void change_parent(conveyor_node *p) { parent = p; }
 };
 
-class EventLoop;
-class WaitScope;
+class event_loop;
+class wait_scope;
 /*
  * Event class similar to capn'proto.
  * https://github.com/capnproto/capnproto
  */
-class Event {
+class event {
 private:
-	EventLoop &loop_;
-	Event **prev_ = nullptr;
-	Event *next_ = nullptr;
+	event_loop &loop_;
+	event **prev_ = nullptr;
+	event *next_ = nullptr;
 
-	friend class EventLoop;
+	friend class event_loop;
 
 public:
-	Event();
-	Event(EventLoop &loop);
-	virtual ~Event();
+	event();
+	event(event_loop &loop);
+	virtual ~event();
 
 	virtual void fire() = 0;
 
-	void armNext();
-	void armLater();
-	void armLast();
+	void arm_next();
+	void arm_later();
+	void arm_last();
 	void disarm();
 
-	bool isArmed() const;
+	bool is_armed() const;
 };
 
-class ConveyorStorage {
+class conveyor_storage {
 protected:
-	ConveyorStorage *parent_ = nullptr;
+	conveyor_storage *parent_ = nullptr;
 
 public:
-	ConveyorStorage();
-	virtual ~ConveyorStorage();
+	conveyor_storage();
+	virtual ~conveyor_storage();
 
 	virtual size_t space() const = 0;
 	virtual size_t queued() const = 0;
-	virtual void childHasFired() = 0;
-	virtual void parentHasFired() = 0;
+	virtual void child_has_fired() = 0;
+	virtual void parent_has_fired() = 0;
 
-	virtual void setParent(ConveyorStorage *parent) = 0;
-	ConveyorStorage *getParent() const;
+	virtual void set_parent(conveyor_storage *parent) = 0;
+	conveyor_storage *get_parent() const;
 };
 
-class ConveyorEventStorage : public ConveyorStorage, public Event {
+class conveyor_event_storage : public conveyor_storage, public event {
 public:
-	ConveyorEventStorage();
-	virtual ~ConveyorEventStorage() = default;
+	conveyor_event_storage();
+	virtual ~conveyor_event_storage() = default;
 
-	void setParent(ConveyorStorage *parent) override;
+	void set_parent(conveyor_storage *parent) override;
 };
 
-class ConveyorBase {
+class conveyor_base {
 protected:
-	Own<ConveyorNode> node_;
+	own<conveyor_node> node_;
 
 public:
-	ConveyorBase(Own<ConveyorNode> &&node_p);
-	virtual ~ConveyorBase() = default;
+	conveyor_base(own<conveyor_node> &&node_p);
+	virtual ~conveyor_base() = default;
 
-	ConveyorBase(ConveyorBase &&) = default;
-	ConveyorBase &operator=(ConveyorBase &&) = default;
+	conveyor_base(conveyor_base &&) = default;
+	conveyor_base &operator=(conveyor_base &&) = default;
 
-	void get(ErrorOrValue &err_or_val);
+	void get(error_or_value &err_or_val);
 };
 
-template <typename T> class Conveyor;
+template <typename T> class conveyor;
 
-template <typename T> Conveyor<T> chainedConveyorType(T *);
+template <typename T> conveyor<T> chained_conveyor_type(T *);
 
 // template <typename T> Conveyor<T> chainedConveyorType(Conveyor<T> *);
 
-template <typename T> T removeErrorOrType(T *);
+template <typename T> T remove_error_or_type(T *);
 
-template <typename T> T removeErrorOrType(ErrorOr<T> *);
+template <typename T> T remove_error_or_type(error_or<T> *);
 
 template <typename T>
-using RemoveErrorOr = decltype(removeErrorOrType((T *)nullptr));
+using remove_error_or = decltype(remove_error_or_type((T *)nullptr));
 
 template <typename T>
-using ChainedConveyors = decltype(chainedConveyorType((T *)nullptr));
+using chained_conveyors = decltype(chained_conveyor_type((T *)nullptr));
 
 template <typename Func, typename T>
-using ConveyorResult = ChainedConveyors<RemoveErrorOr<ReturnType<Func, T>>>;
+using conveyor_result =
+	chained_conveyors<remove_error_or<return_type<Func, T>>>;
 
-struct PropagateError {
+struct propagate_error {
 public:
-	Error operator()(const Error &error) const;
-	Error operator()(Error &&error);
+	error operator()(const error &err) const;
+	error operator()(error &&err);
 };
 
-class ConveyorSink {
+class conveyor_sink {
 private:
-	Own<ConveyorNode> node_;
+	own<conveyor_node> node_;
 
 public:
-	ConveyorSink();
-	ConveyorSink(Own<ConveyorNode> &&node);
+	conveyor_sink();
+	conveyor_sink(own<conveyor_node> &&node);
 
-	ConveyorSink(ConveyorSink &&) = default;
-	ConveyorSink &operator=(ConveyorSink &&) = default;
+	conveyor_sink(conveyor_sink &&) = default;
+	conveyor_sink &operator=(conveyor_sink &&) = default;
 };
 
-template <typename T> class MergeConveyorNodeData;
+template <typename T> class merge_conveyor_node_data;
 
-template <typename T> class MergeConveyor {
+template <typename T> class merge_conveyor {
 private:
-	Lent<MergeConveyorNodeData<T>> data_;
+	lent<merge_conveyor_node_data<T>> data_;
 
 public:
-	MergeConveyor() = default;
-	MergeConveyor(Lent<MergeConveyorNodeData<T>> d);
-	~MergeConveyor();
+	merge_conveyor() = default;
+	merge_conveyor(lent<merge_conveyor_node_data<T>> d);
+	~merge_conveyor();
 
-	void attach(Conveyor<T> conveyor);
+	void attach(conveyor<T> conv);
 };
 
 /**
  * Main interface for async operations.
  */
-template <typename T> class Conveyor final : public ConveyorBase {
+template <typename T> class conveyor final : public conveyor_base {
 public:
 	/**
 	 * Construct an immediately fulfilled node
 	 */
-	Conveyor(FixVoid<T> value);
+	conveyor(fix_void<T> value);
 
 	/**
 	 * Construct an immediately failed node
 	 */
-	Conveyor(Error &&error);
+	conveyor(error &&err);
 
 	/**
 	 * Construct a conveyor with a child node
 	 */
-	Conveyor(Own<ConveyorNode> node_p);
+	conveyor(own<conveyor_node> node_p);
 
-	Conveyor(Conveyor<T> &&) = default;
-	Conveyor<T> &operator=(Conveyor<T> &&) = default;
+	conveyor(conveyor<T> &&) = default;
+	conveyor<T> &operator=(conveyor<T> &&) = default;
 
 	/**
 	 * This method converts values or errors from children
 	 */
-	template <typename Func, typename ErrorFunc = PropagateError>
-	[[nodiscard]] ConveyorResult<Func, T>
-	then(Func &&func, ErrorFunc &&error_func = PropagateError());
+	template <typename Func, typename ErrorFunc = propagate_error>
+	[[nodiscard]] conveyor_result<Func, T>
+	then(Func &&func, ErrorFunc &&error_func = propagate_error());
 
 	/**
 	 * This method adds a buffer node in the conveyor chains which acts as a
 	 * scheduler interrupt point and collects elements up to the supplied limit.
 	 */
-	[[nodiscard]] Conveyor<T>
+	[[nodiscard]] conveyor<T>
 	buffer(size_t limit = std::numeric_limits<size_t>::max());
 
 	/**
@@ -233,7 +235,7 @@ public:
 	 * Useful for resource lifetime control.
 	 */
 	template <typename... Args>
-	[[nodiscard]] Conveyor<T> attach(Args &&...args);
+	[[nodiscard]] conveyor<T> attach(Args &&...args);
 
 	/** @todo implement
 	 * This method limits the total amount of passed elements
@@ -241,89 +243,90 @@ public:
 	 * If you meant to fork it and destroy paths you shouldn't place
 	 * an interrupt point between the fork and this limiter
 	 */
-	[[nodiscard]] Conveyor<T> limit(size_t val = 1);
+	[[nodiscard]] conveyor<T> limit(size_t val = 1);
 
 	/**
 	 *
 	 */
-	[[nodiscard]] std::pair<Conveyor<T>, MergeConveyor<T>> merge();
+	[[nodiscard]] std::pair<conveyor<T>, merge_conveyor<T>> merge();
 
 	/**
 	 * Moves the conveyor chain into a thread local storage point which drops
 	 * every element. Use sink() if you want to control the lifetime of a
 	 * conveyor chain
 	 */
-	template <typename ErrorFunc = PropagateError>
-	void detach(ErrorFunc &&err_func = PropagateError());
+	template <typename ErrorFunc = propagate_error>
+	void detach(ErrorFunc &&err_func = propagate_error());
 	/**
 	 * Creates a local sink which drops elements, but lifetime control remains
 	 * in your hand.
 	 */
-	template <typename ErrorFunc = PropagateError>
-	[[nodiscard]] ConveyorSink sink(ErrorFunc &&error_func = PropagateError());
+	template <typename ErrorFunc = propagate_error>
+	[[nodiscard]] conveyor_sink
+	sink(ErrorFunc &&error_func = propagate_error());
 
 	/**
 	 * If no sink() or detach() is used you have to take elements out of the
 	 * chain yourself.
 	 */
-	ErrorOr<FixVoid<T>> take();
+	error_or<fix_void<T>> take();
 
 	/** @todo implement
 	 * Specifically pump elements through this chain with the provided
 	 * wait_scope
 	 */
-	void poll(WaitScope &wait_scope);
+	void poll(wait_scope &wait_scope);
 
 	// helper
-	static Conveyor<T> toConveyor(Own<ConveyorNode> node);
+	static conveyor<T> to_conveyor(own<conveyor_node> node);
 
 	// helper
-	static Own<ConveyorNode> fromConveyor(Conveyor<T> conveyor);
+	static own<conveyor_node> from_conveyor(conveyor<T> conveyor);
 };
 
-template <typename Func> ConveyorResult<Func, void> execLater(Func &&func);
+template <typename Func> conveyor_result<Func, void> exec_later(Func &&func);
 
 /*
  * Join Conveyors into a single one
  */
 template <typename... Args>
-Conveyor<std::tuple<Args...>>
-joinConveyors(std::tuple<Conveyor<Args>...> &conveyors);
+conveyor<std::tuple<Args...>>
+joinConveyors(std::tuple<conveyor<Args>...> &conveyors);
 
-template <typename T> class ConveyorFeeder {
+template <typename T> class conveyor_feeder {
 public:
-	virtual ~ConveyorFeeder() = default;
+	virtual ~conveyor_feeder() = default;
 
 	virtual void feed(T &&data) = 0;
-	virtual void fail(Error &&error) = 0;
+	virtual void fail(error &&error) = 0;
 
 	virtual size_t space() const = 0;
 	virtual size_t queued() const = 0;
 
-	virtual Error swap(Conveyor<T> &&conveyor) noexcept = 0;
+	virtual error swap(conveyor<T> &&conveyor) noexcept = 0;
 };
 
-template <> class ConveyorFeeder<void> {
+template <> class conveyor_feeder<void> {
 public:
-	virtual ~ConveyorFeeder() = default;
+	virtual ~conveyor_feeder() = default;
 
 	virtual void feed(Void &&value = Void{}) = 0;
-	virtual void fail(Error &&error) = 0;
+	virtual void fail(error &&error) = 0;
 
 	virtual size_t space() const = 0;
 	virtual size_t queued() const = 0;
 
-	virtual Error swap(Conveyor<Void> &&conveyor) noexcept = 0;
+	virtual error swap(conveyor<Void> &&conveyor) noexcept = 0;
 };
 
-template <typename T> struct ConveyorAndFeeder {
-	Own<ConveyorFeeder<T>> feeder;
-	Conveyor<T> conveyor;
+template <typename T> struct conveyor_and_feeder {
+	own<conveyor_feeder<T>> feeder;
+	conveyor<T> conveyor;
 };
 
-template <typename T> ConveyorAndFeeder<T> newConveyorAndFeeder();
+template <typename T> conveyor_and_feeder<T> new_conveyor_and_feeder();
 
-template <typename T> ConveyorAndFeeder<T> oneTimeConveyorAndFeeder();
+template <typename T> conveyor_and_feeder<T> one_time_conveyor_and_feeder();
 
 enum class Signal : uint8_t { Terminate, User1 };
 
@@ -332,11 +335,11 @@ enum class Signal : uint8_t { Terminate, User1 };
  * events which may be signals from the operating system or just other threads.
  * Default EventPorts are supplied by setupAsyncIo() in io.h
  */
-class EventPort {
+class event_port {
 public:
-	virtual ~EventPort() = default;
+	virtual ~event_port() = default;
 
-	virtual Conveyor<void> onSignal(Signal signal) = 0;
+	virtual conveyor<void> on_signal(Signal signal) = 0;
 
 	virtual void poll() = 0;
 	virtual void wait() = 0;
@@ -346,9 +349,9 @@ public:
 	virtual void wake() = 0;
 };
 
-class SinkConveyorNode;
+class sink_conveyor_node;
 
-class ConveyorSinkSet final : public Event {
+class conveyor_sink_set final : public event {
 private:
 	/*
 		class Helper final : public Event {
@@ -371,24 +374,24 @@ private:
 
 		gin::Own<Helper> helper;
 	*/
-	friend class SinkConveyorNode;
+	friend class sink_conveyor_node;
 
-	void destroySinkConveyorNode(ConveyorNode &sink_node);
-	void fail(Error &&error);
+	void destroy_sink_conveyor_node(conveyor_node &sink_node);
+	void fail(error &&err);
 
-	std::list<Own<ConveyorNode>> sink_nodes_;
+	std::list<own<conveyor_node>> sink_nodes_;
 
-	std::queue<ConveyorNode *> delete_nodes_;
+	std::queue<conveyor_node *> delete_nodes_;
 
-	std::function<void(Error &&error)> error_handler_;
+	std::function<void(error &&)> error_handler_;
 
 public:
 	// ConveyorSinks();
 	// ConveyorSinks(EventLoop& event_loop);
-	ConveyorSinkSet() = default;
-	ConveyorSinkSet(EventLoop &event_loop);
+	conveyor_sink_set() = default;
+	conveyor_sink_set(event_loop &event_loop);
 
-	void add(Conveyor<void> &&node);
+	void add(conveyor<void> &&node);
 
 	void fire() override;
 };
@@ -397,59 +400,59 @@ public:
  * EventLoop class similar to capn'proto.
  * https://github.com/capnproto/capnproto
  */
-class EventLoop {
+class event_loop {
 private:
-	friend class Event;
-	Event *head_ = nullptr;
-	Event **tail_ = &head_;
-	Event **next_insert_point_ = &head_;
-	Event **later_insert_point_ = &head_;
+	friend class event;
+	event *head_ = nullptr;
+	event **tail_ = &head_;
+	event **next_insert_point_ = &head_;
+	event **later_insert_point_ = &head_;
 
 	bool is_runnable_ = false;
 
-	Own<EventPort> event_port_ = nullptr;
+	own<event_port> event_port_ = nullptr;
 
-	Own<ConveyorSinkSet> daemon_sink_ = nullptr;
+	own<conveyor_sink_set> daemon_sink_ = nullptr;
 
 	// functions
-	void setRunnable(bool runnable);
+	void set_runnable(bool runnable);
 
-	friend class WaitScope;
-	void enterScope();
-	void leaveScope();
+	friend class wait_scope;
+	void enter_scope();
+	void leave_scope();
 
-	bool turnLoop();
+	bool turn_loop();
 	bool turn();
 
 public:
-	EventLoop();
-	EventLoop(Own<EventPort> &&port);
-	~EventLoop();
+	event_loop();
+	event_loop(own<event_port> &&port);
+	~event_loop();
 
-	EventLoop(EventLoop &&) = default;
-	EventLoop &operator=(EventLoop &&) = default;
+	event_loop(event_loop &&) = default;
+	event_loop &operator=(event_loop &&) = default;
 
 	bool wait();
 	bool wait(const std::chrono::steady_clock::duration &);
 	bool wait(const std::chrono::steady_clock::time_point &);
 	bool poll();
 
-	EventPort *eventPort();
+	event_port *event_port();
 
-	ConveyorSinkSet &daemon();
+	conveyor_sink_set &daemon();
 };
 
 /*
  * WaitScope class similar to capn'proto.
  * https://github.com/capnproto/capnproto
  */
-class WaitScope {
+class wait_scope {
 private:
-	EventLoop &loop_;
+	event_loop &loop_;
 
 public:
-	WaitScope(EventLoop &loop);
-	~WaitScope();
+	wait_scope(event_loop &loop);
+	~wait_scope();
 
 	void wait();
 	void wait(const std::chrono::steady_clock::duration &);
@@ -457,38 +460,38 @@ public:
 	void poll();
 };
 
-template <typename Func> ConveyorResult<Func, void> yieldNext(Func &&func);
+template <typename Func> conveyor_result<Func, void> yieldNext(Func &&func);
 
-template <typename Func> ConveyorResult<Func, void> yieldLater(Func &&func);
+template <typename Func> conveyor_result<Func, void> yieldLater(Func &&func);
 
-template <typename Func> ConveyorResult<Func, void> yieldLast(Func &&func);
+template <typename Func> conveyor_result<Func, void> yieldLast(Func &&func);
 } // namespace saw
 
 // Secret stuff
 // Aka private semi hidden classes
 namespace saw {
 
-template <typename Out, typename In> struct FixVoidCaller {
+template <typename Out, typename In> struct fix_void_caller {
 	template <typename Func> static Out apply(Func &func, In &&in) {
 		return func(std::move(in));
 	}
 };
 
-template <typename Out> struct FixVoidCaller<Out, Void> {
+template <typename Out> struct fix_void_caller<Out, Void> {
 	template <typename Func> static Out apply(Func &func, Void &&in) {
 		(void)in;
 		return func();
 	}
 };
 
-template <typename In> struct FixVoidCaller<Void, In> {
+template <typename In> struct fix_void_caller<Void, In> {
 	template <typename Func> static Void apply(Func &func, In &&in) {
 		func(std::move(in));
 		return Void{};
 	}
 };
 
-template <> struct FixVoidCaller<Void, Void> {
+template <> struct fix_void_caller<Void, Void> {
 	template <typename Func> static Void apply(Func &func, Void &&in) {
 		(void)in;
 		func();
@@ -496,114 +499,115 @@ template <> struct FixVoidCaller<Void, Void> {
 	}
 };
 
-template <typename T> class AdaptConveyorNode;
+template <typename T> class adapt_conveyor_node;
 
 template <typename T>
-class AdaptConveyorFeeder final : public ConveyorFeeder<UnfixVoid<T>> {
+class adapt_conveyor_feeder final : public conveyor_feeder<unfix_void<T>> {
 private:
-	AdaptConveyorNode<T> *feedee_ = nullptr;
+	adapt_conveyor_node<T> *feedee_ = nullptr;
 
 public:
-	~AdaptConveyorFeeder();
+	~adapt_conveyor_feeder();
 
-	void setFeedee(AdaptConveyorNode<T> *feedee);
+	void set_feedee(adapt_conveyor_node<T> *feedee);
 
 	void feed(T &&value) override;
-	void fail(Error &&error) override;
+	void fail(error &&error) override;
 
 	size_t space() const override;
 	size_t queued() const override;
 
-	Error swap(Conveyor<T> &&conv) noexcept override;
+	error swap(conveyor<T> &&conv) noexcept override;
 };
 
 template <typename T>
-class AdaptConveyorNode final : public ConveyorNode,
-								public ConveyorEventStorage {
+class adapt_conveyor_node final : public conveyor_node,
+								  public conveyor_event_storage {
 private:
-	AdaptConveyorFeeder<T> *feeder_ = nullptr;
+	adapt_conveyor_feeder<T> *feeder_ = nullptr;
 
-	std::queue<ErrorOr<UnfixVoid<T>>> storage_;
+	std::queue<error_or<unfix_void<T>>> storage_;
 
-	ConveyorNodeWithParentMixin parent_node_;
+	conveyor_node_with_parent_mixin parent_node_;
 
 public:
-	AdaptConveyorNode();
-	~AdaptConveyorNode();
+	adapt_conveyor_node();
+	~adapt_conveyor_node();
 
-	void setFeeder(AdaptConveyorFeeder<T> *feeder);
+	void set_feeder(adapt_conveyor_feeder<T> *feeder);
 
 	void feed(T &&value);
-	void fail(Error &&error);
+	void fail(error &&error);
 
 	// ConveyorNode
-	void getResult(ErrorOrValue &err_or_val) override;
+	void get_result(error_or_value &err_or_val) override;
 
-	ErrorOr<Own<ConveyorNode>>
-	swapChild(Own<ConveyorNode> &&swapee) noexcept override;
+	error_or<own<conveyor_node>>
+	swap_child(own<conveyor_node> &&swapee) noexcept override;
 
-	ConveyorStorage *nextStorage() noexcept override;
-	void notifyParentAttached(ConveyorNode &) noexcept override;
+	conveyor_storage *next_storage() noexcept override;
+	void notify_parent_attached(conveyor_node &) noexcept override;
 
 	// ConveyorStorage
 	size_t space() const override;
 	size_t queued() const override;
 
-	void childHasFired() override;
-	void parentHasFired() override;
+	void child_has_fired() override;
+	void parent_has_fired() override;
 
 	// Event
 	void fire() override;
 };
 
-template <typename T> class OneTimeConveyorNode;
+template <typename T> class one_time_conveyor_node;
 
 template <typename T>
-class OneTimeConveyorFeeder final : public ConveyorFeeder<UnfixVoid<T>> {
+class one_time_conveyor_feeder final : public conveyor_feeder<unfix_void<T>> {
 private:
-	OneTimeConveyorNode<T> *feedee_ = nullptr;
+	one_time_conveyor_node<T> *feedee_ = nullptr;
 
 public:
-	~OneTimeConveyorFeeder();
+	~one_time_conveyor_feeder();
 
-	void setFeedee(OneTimeConveyorNode<T> *feedee);
+	void set_feedee(one_time_conveyor_node<T> *feedee);
 
 	void feed(T &&value) override;
-	void fail(Error &&error) override;
+	void fail(error &&error) override;
 
 	size_t space() const override;
 	size_t queued() const override;
 };
 
 template <typename T>
-class OneTimeConveyorNode final : public ConveyorNode,
-								  public ConveyorStorage,
-								  public Event {
+class one_time_conveyor_node final : public conveyor_node,
+									 public conveyor_storage,
+									 public event {
 private:
-	OneTimeConveyorFeeder<T> *feeder_ = nullptr;
+	one_time_conveyor_feeder<T> *feeder_ = nullptr;
 
 	bool passed_ = false;
-	Maybe<ErrorOr<T>> storage_ = std::nullopt;
+	maybe<error_or<T>> storage_ = std::nullopt;
 
 public:
-	~OneTimeConveyorNode();
+	~one_time_conveyor_node();
 
-	void setFeeder(OneTimeConveyorFeeder<T> *feeder);
+	void set_feeder(one_time_conveyor_feeder<T> *feeder);
 
 	void feed(T &&value);
-	void fail(Error &&error);
+	void fail(error &&error);
 
 	// ConveyorNode
-	void getResult(ErrorOrValue &err_or_val) override;
+	void get_result(error_or_value &err_or_val) override;
 
-	ErrorOr<Own<ConveyorNode>> swapChild(Own<ConveyorNode> &&swapee) override;
+	error_or<own<conveyor_node>>
+	swap_child(own<conveyor_node> &&swapee) override;
 
 	// ConveyorStorage
 	size_t space() const override;
 	size_t queued() const override;
 
-	void childHasFired() override {}
-	void parentHasFired() override;
+	void child_has_fired() override {}
+	void parent_has_fired() override;
 
 	// Event
 	void fire() override;
@@ -613,156 +617,158 @@ public:
  * This class buffers and saves incoming elements and acts as an interrupt node
  * for processing calls
  */
-class QueueBufferConveyorNodeBase : public ConveyorNode,
-									public ConveyorEventStorage {
+class queue_buffer_conveyor_node_base : public conveyor_node,
+										public conveyor_event_storage {
 protected:
-	ConveyorNodeWithChildMixin child_mixin_;
+	conveyor_node_with_child_mixin child_mixin_;
 
 public:
-	QueueBufferConveyorNodeBase(Own<ConveyorNode> child_)
-		: ConveyorEventStorage{}, child_mixin_{std::move(child_), *this} {}
-	virtual ~QueueBufferConveyorNodeBase() = default;
+	queue_buffer_conveyor_node_base(own<conveyor_node> child_)
+		: conveyor_event_storage{}, child_mixin_{std::move(child_), *this} {}
+	virtual ~queue_buffer_conveyor_node_base() = default;
 
 	/**
 	 * Use mixin
 	 */
-	ErrorOr<Own<ConveyorNode>>
-	swapChild(Own<ConveyorNode> &&swapee_) noexcept override;
+	error_or<own<conveyor_node>>
+	swap_child(own<conveyor_node> &&swapee_) noexcept override;
 
-	ConveyorStorage *nextStorage() noexcept override {
-		return static_cast<ConveyorStorage *>(this);
+	conveyor_storage *next_storage() noexcept override {
+		return static_cast<conveyor_storage *>(this);
 	}
 };
 
 template <typename T>
-class QueueBufferConveyorNode final : public QueueBufferConveyorNodeBase {
+class queue_buffer_conveyor_node final
+	: public queue_buffer_conveyor_node_base {
 private:
-	std::queue<ErrorOr<T>> storage_;
+	std::queue<error_or<T>> storage_;
 	size_t max_store_;
 
 public:
-	QueueBufferConveyorNode(Own<ConveyorNode> dep, size_t max_size)
-		: QueueBufferConveyorNodeBase{std::move(dep)}, max_store_{max_size} {}
+	queue_buffer_conveyor_node(own<conveyor_node> dep, size_t max_size)
+		: queue_buffer_conveyor_node_base{std::move(dep)}, max_store_{
+															   max_size} {}
 	// Event
 	void fire() override;
 	// ConveyorNode
-	void getResult(ErrorOrValue &eov) noexcept override;
+	void get_result(error_or_value &eov) noexcept override;
 
 	// ConveyorStorage
 	size_t space() const override;
 	size_t queued() const override;
 
-	void childHasFired() override;
-	void parentHasFired() override;
+	void child_has_fired() override;
+	void parent_has_fired() override;
 };
 
-class AttachConveyorNodeBase : public ConveyorNode {
+class attach_conveyor_node_base : public conveyor_node {
 protected:
-	ConveyorNodeWithChildMixin child_mixin_;
+	conveyor_node_with_child_mixin child_mixin_;
 
 public:
-	AttachConveyorNodeBase(Own<ConveyorNode> &&child_)
+	attach_conveyor_node_base(own<conveyor_node> &&child_)
 		: child_mixin_{std::move(child_), *this} {}
 
-	virtual ~AttachConveyorNodeBase() = default;
+	virtual ~attach_conveyor_node_base() = default;
 
-	void getResult(ErrorOrValue &err_or_val) noexcept override;
+	void get_result(error_or_value &err_or_val) noexcept override;
 
 	/**
 	 * Use mixin
 	 */
-	ErrorOr<Own<ConveyorNode>>
-	swapChild(Own<ConveyorNode> &&swapee_) noexcept override;
+	error_or<own<conveyor_node>>
+	swap_child(own<conveyor_node> &&swapee_) noexcept override;
 
-	ConveyorStorage *nextStorage() noexcept override;
+	conveyor_storage *next_storage() noexcept override;
 };
 
 template <typename... Args>
-class AttachConveyorNode final : public AttachConveyorNodeBase {
+class attach_conveyor_node final : public attach_conveyor_node_base {
 public:
-	AttachConveyorNode(Own<ConveyorNode> &&dep, Args &&...args)
-		: AttachConveyorNodeBase(std::move(dep)), attached_data_{
-													  std::move(args...)} {}
+	attach_conveyor_node(own<conveyor_node> &&dep, Args &&...args)
+		: attach_conveyor_node_base(std::move(dep)), attached_data_{
+														 std::move(args...)} {}
 
 private:
 	std::tuple<Args...> attached_data_;
 };
 
-class ConvertConveyorNodeBase : public ConveyorNode {
+class convert_conveyor_node_base : public conveyor_node {
 public:
-	ConvertConveyorNodeBase(Own<ConveyorNode> &&dep);
-	virtual ~ConvertConveyorNodeBase() = default;
+	convert_conveyor_node_base(own<conveyor_node> &&dep);
+	virtual ~convert_conveyor_node_base() = default;
 
-	void getResult(ErrorOrValue &err_or_val) override;
+	void get_result(error_or_value &err_or_val) override;
 
-	virtual void getImpl(ErrorOrValue &err_or_val) = 0;
+	virtual void get_impl(error_or_value &err_or_val) = 0;
 
-	ErrorOr<Own<ConveyorNode>>
-	swapChild(Own<ConveyorNode> &&swapee) noexcept override;
+	error_or<own<conveyor_node>>
+	swap_child(own<conveyor_node> &&swapee) noexcept override;
 
-	ConveyorStorage *nextStorage() noexcept override;
+	conveyor_storage *next_storage() noexcept override;
 
 protected:
-	ConveyorNodeWithChildMixin child_mixin_;
+	conveyor_node_with_child_mixin child_mixin_;
 };
 
 template <typename T, typename DepT, typename Func, typename ErrorFunc>
-class ConvertConveyorNode final : public ConvertConveyorNodeBase {
+class convert_conveyor_node final : public convert_conveyor_node_base {
 private:
 	Func func_;
 	ErrorFunc error_func_;
 
-	static_assert(std::is_same<DepT, RemoveErrorOr<DepT>>::value,
+	static_assert(std::is_same<DepT, remove_error_or<DepT>>::value,
 				  "Should never be of type ErrorOr");
 
 public:
-	ConvertConveyorNode(Own<ConveyorNode> &&dep, Func &&func,
-						ErrorFunc &&error_func)
-		: ConvertConveyorNodeBase(std::move(dep)), func_{std::move(func)},
+	convert_conveyor_node(own<conveyor_node> &&dep, Func &&func,
+						  ErrorFunc &&error_func)
+		: convert_conveyor_node_base(std::move(dep)), func_{std::move(func)},
 		  error_func_{std::move(error_func)} {}
 
-	void getImpl(ErrorOrValue &err_or_val) noexcept override {
-		ErrorOr<UnfixVoid<DepT>> dep_eov;
-		ErrorOr<UnfixVoid<RemoveErrorOr<T>>> &eov =
-			err_or_val.as<UnfixVoid<RemoveErrorOr<T>>>();
+	void get_impl(error_or_value &err_or_val) noexcept override {
+		error_or<unfix_void<DepT>> dep_eov;
+		error_or<unfix_void<remove_error_or<T>>> &eov =
+			err_or_val.as<unfix_void<remove_error_or<T>>>();
 		if (child_mixin_.child) {
-			child_mixin_.child->getResult(dep_eov);
-			if (dep_eov.isValue()) {
+			child_mixin_.child->get_result(dep_eov);
+			if (dep_eov.is_value()) {
 				try {
 
-					eov = FixVoidCaller<T, DepT>::apply(
+					eov = fix_void_caller<T, DepT>::apply(
 						func_, std::move(dep_eov.value()));
 				} catch (const std::bad_alloc &) {
-					eov = criticalError("Out of memory");
+					eov = critical_error("Out of memory");
 				} catch (const std::exception &) {
-					eov = criticalError(
+					eov = critical_error(
 						"Exception in chain occured. Return ErrorOr<T> if you "
 						"want to handle errors which are recoverable");
 				}
-			} else if (dep_eov.isError()) {
+			} else if (dep_eov.is_error()) {
 				eov = error_func_(std::move(dep_eov.error()));
 			} else {
-				eov = criticalError("No value set in dependency");
+				eov = critical_error("No value set in dependency");
 			}
 		} else {
-			eov = criticalError("Conveyor doesn't have child");
+			eov = critical_error("Conveyor doesn't have child");
 		}
 	}
 };
 
-class SinkConveyorNode final : public ConveyorNode,
-							   public ConveyorEventStorage {
+class sink_conveyor_node final : public conveyor_node,
+								 public conveyor_event_storage {
 private:
-	ConveyorNodeWithChildMixin child_mixin_;
-	ConveyorSinkSet *conveyor_sink_;
+	conveyor_node_with_child_mixin child_mixin_;
+	conveyor_sink_set *conveyor_sink_;
 
 public:
-	SinkConveyorNode(Own<ConveyorNode> node, ConveyorSinkSet &conv_sink)
-		: ConveyorEventStorage{}, child_mixin_{std::move(node), *this},
+	sink_conveyor_node(own<conveyor_node> node, conveyor_sink_set &conv_sink)
+		: conveyor_event_storage{}, child_mixin_{std::move(node), *this},
 		  conveyor_sink_{&conv_sink} {}
 
-	SinkConveyorNode(Own<ConveyorNode> node)
-		: ConveyorEventStorage{}, child_mixin_{std::move(node), *this},
+	sink_conveyor_node(own<conveyor_node> node)
+		: conveyor_event_storage{}, child_mixin_{std::move(node), *this},
 		  conveyor_sink_{nullptr} {}
 
 	// Event only queued if a critical error occured
@@ -772,7 +778,7 @@ public:
 		child_mixin_.child = nullptr;
 
 		if (conveyor_sink_) {
-			conveyor_sink_->destroySinkConveyorNode(*this);
+			conveyor_sink_->destroy_sink_conveyor_node(*this);
 			conveyor_sink_ = nullptr;
 		}
 	}
@@ -782,25 +788,25 @@ public:
 	size_t queued() const override { return 0; }
 
 	// ConveyorNode
-	void getResult(ErrorOrValue &err_or_val) noexcept override {
+	void get_result(error_or_value &err_or_val) noexcept override {
 		err_or_val.as<Void>() =
-			criticalError("In a sink node no result can be returned");
+			critical_error("In a sink node no result can be returned");
 	}
 
-	ErrorOr<Own<ConveyorNode>>
-	swapChild(Own<ConveyorNode> &&swapee) noexcept override {
-		return child_mixin_.swapChild(std::move(swapee));
+	error_or<own<conveyor_node>>
+	swap_child(own<conveyor_node> &&swapee) noexcept override {
+		return child_mixin_.swap_child(std::move(swapee));
 	}
 
 	// ConveyorStorage
-	void childHasFired() override {
+	void child_has_fired() override {
 		if (child_mixin_.child) {
-			ErrorOr<void> dep_eov;
-			child_mixin_.child->getResult(dep_eov);
-			if (dep_eov.isError()) {
-				if (dep_eov.error().isCritical()) {
-					if (!isArmed()) {
-						armLast();
+			error_or<void> dep_eov;
+			child_mixin_.child->get_result(dep_eov);
+			if (dep_eov.is_error()) {
+				if (dep_eov.error().is_critical()) {
+					if (!is_armed()) {
+						arm_last();
 					}
 				}
 				if (conveyor_sink_) {
@@ -813,9 +819,9 @@ public:
 	/*
 	 * No parent needs to be fired since we always have space
 	 */
-	void parentHasFired() override {}
+	void parent_has_fired() override {}
 
-	ConveyorStorage *nextStorage() override {
+	conveyor_storage *next_storage() override {
 		// Should never happen though
 		assert(false);
 		return nullptr;
@@ -823,49 +829,49 @@ public:
 	}
 };
 
-class ImmediateConveyorNodeBase : public ConveyorNode,
-								  public ConveyorEventStorage {
+class immediate_conveyor_node_base : public conveyor_node,
+									 public conveyor_event_storage {
 private:
 public:
-	ImmediateConveyorNodeBase();
+	immediate_conveyor_node_base();
 
-	virtual ~ImmediateConveyorNodeBase() = default;
+	virtual ~immediate_conveyor_node_base() = default;
 
-	ErrorOr<Own<ConveyorNode>>
-	swapChild(Own<ConveyorNode> &&swapee) noexcept override {
+	error_or<own<conveyor_node>>
+	swap_child(own<conveyor_node> &&swapee) noexcept override {
 		(void)swapee;
-		return recoverableError("Node doesn't support swapping");
+		return recoverable_error("Node doesn't support swapping");
 	}
 
-	ConveyorStorage *nextStorage() noexcept override {
-		return static_cast<ConveyorStorage *>(this);
+	conveyor_storage *next_storage() noexcept override {
+		return static_cast<conveyor_storage *>(this);
 	}
 };
 
 template <typename T>
-class ImmediateConveyorNode final : public ImmediateConveyorNodeBase {
+class immediate_conveyor_node final : public immediate_conveyor_node_base {
 private:
-	ErrorOr<FixVoid<T>> value_;
+	error_or<fix_void<T>> value_;
 	uint8_t retrieved_;
 
 public:
-	ImmediateConveyorNode(FixVoid<T> &&val);
-	ImmediateConveyorNode(Error &&error);
+	immediate_conveyor_node(fix_void<T> &&val);
+	immediate_conveyor_node(error &&error);
 
 	// ConveyorStorage
 	size_t space() const override;
 	size_t queued() const override;
 
-	void childHasFired() override;
-	void parentHasFired() override;
+	void child_has_fired() override;
+	void parent_has_fired() override;
 
 	// ConveyorNode
-	void getResult(ErrorOrValue &err_or_val) noexcept override {
+	void get_result(error_or_value &err_or_val) noexcept override {
 		if (retrieved_ > 0) {
-			err_or_val.as<FixVoid<T>>() =
-				makeError("Already taken value", Error::Code::Exhausted);
+			err_or_val.as<fix_void<T>>() =
+				make_error("Already taken value", error::code::Exhausted);
 		} else {
-			err_or_val.as<FixVoid<T>>() = std::move(value_);
+			err_or_val.as<fix_void<T>>() = std::move(value_);
 		}
 		if (queued() > 0) {
 			++retrieved_;
@@ -879,55 +885,57 @@ public:
 /*
  * Collects every incoming value and throws it in one lane
  */
-class MergeConveyorNodeBase : public ConveyorNode, public ConveyorEventStorage {
+class merge_conveyor_node_base : public conveyor_node,
+								 public conveyor_event_storage {
 public:
-	MergeConveyorNodeBase();
+	merge_conveyor_node_base();
 
-	virtual ~MergeConveyorNodeBase() = default;
+	virtual ~merge_conveyor_node_base() = default;
 
-	ConveyorStorage *nextStorage() noexcept override {
-		return static_cast<ConveyorStorage *>(this);
+	conveyor_storage *next_storage() noexcept override {
+		return static_cast<conveyor_storage *>(this);
 	}
 };
 
-template <typename T> class MergeConveyorNode : public MergeConveyorNodeBase {
+template <typename T>
+class merge_conveyor_node : public merge_conveyor_node_base {
 private:
-	class Appendage final : public ConveyorNode, public ConveyorStorage {
+	class appendage final : public conveyor_node, public conveyor_storage {
 	public:
-		Own<ConveyorNode> child;
-		MergeConveyorNode *merger;
+		own<conveyor_node> child;
+		merge_conveyor_node *merger;
 
-		Maybe<ErrorOr<FixVoid<T>>> error_or_value;
+		maybe<error_or<fix_void<T>>> error_or_value_;
 
 	public:
-		Appendage(Own<ConveyorNode> n, MergeConveyorNode &m)
-			: ConveyorStorage{}, child{std::move(n)}, merger{&m},
-			  error_or_value{std::nullopt} {}
+		appendage(own<conveyor_node> n, merge_conveyor_node &m)
+			: conveyor_storage{}, child{std::move(n)}, merger{&m},
+			  error_or_value_{std::nullopt} {}
 
-		bool childStorageHasElementQueued() const {
+		bool child_storage_has_element_queued() const {
 			if (!child) {
 				return false;
 			}
-			ConveyorStorage *storage = child->nextStorage();
+			conveyor_storage *storage = child->next_storage();
 			if (storage) {
 				return storage->queued() > 0;
 			}
 			return false;
 		}
 
-		void getAppendageResult(ErrorOrValue &eov);
+		void get_appendage_result(error_or_value &eov);
 
 		/**
 		 * ConveyorNode
 		 */
-		ErrorOr<Own<ConveyorNode>>
-		swapChild(Own<ConveyorNode> &&swapee_) override;
+		error_or<own<conveyor_node>>
+		swap_child(own<conveyor_node> &&swapee_) override;
 
-		ConveyorStorage *nextStorage() noexcept override {
-			return static_cast<ConveyorStorage *>(this);
+		conveyor_storage *next_storage() noexcept override {
+			return static_cast<conveyor_storage *>(this);
 		}
 
-		void getResult(ErrorOrValue &err_or_val) override;
+		void get_result(error_or_value &err_or_val) override;
 
 		/**
 		 * ConveyorStorage
@@ -936,48 +944,48 @@ private:
 
 		size_t queued() const override;
 
-		void childHasFired() override;
+		void child_has_fired() override;
 
-		void parentHasFired() override;
+		void parent_has_fired() override;
 
-		void setParent(ConveyorStorage *par) override;
+		void set_parent(conveyor_storage *par) override;
 	};
 
-	friend class MergeConveyorNodeData<T>;
-	friend class Appendage;
+	friend class merge_conveyor_node_data<T>;
+	friend class appendage;
 
-	Our<MergeConveyorNodeData<T>> data_;
+	our<merge_conveyor_node_data<T>> data_;
 	size_t next_appendage_ = 0;
 
 public:
-	MergeConveyorNode(Our<MergeConveyorNodeData<T>> data);
-	~MergeConveyorNode();
+	merge_conveyor_node(our<merge_conveyor_node_data<T>> data);
+	~merge_conveyor_node();
 	// ConveyorNode
-	ErrorOr<Own<ConveyorNode>>
-	swapChild(Own<ConveyorNode> &&c) noexcept override;
+	error_or<own<conveyor_node>>
+	swap_child(own<conveyor_node> &&c) noexcept override;
 
 	// Event
-	void getResult(ErrorOrValue &err_or_val) noexcept override;
+	void get_result(error_or_value &err_or_val) noexcept override;
 
 	void fire() override;
 
 	// ConveyorStorage
 	size_t space() const override;
 	size_t queued() const override;
-	void childHasFired() override;
-	void parentHasFired() override;
+	void child_has_fired() override;
+	void parent_has_fired() override;
 };
 
-template <typename T> class MergeConveyorNodeData {
+template <typename T> class merge_conveyor_node_data {
 public:
-	std::vector<Own<typename MergeConveyorNode<T>::Appendage>> appendages;
+	std::vector<own<typename merge_conveyor_node<T>::appendage>> appendages;
 
-	MergeConveyorNode<T> *merger = nullptr;
+	merge_conveyor_node<T> *merger = nullptr;
 
 public:
-	void attach(Conveyor<T> conv);
+	void attach(conveyor<T> conv);
 
-	void governingNodeDestroyed();
+	void governing_node_destroyed();
 };
 
 /*
@@ -1000,7 +1008,7 @@ private:
 		size_t queued() const override;
 
 		void fire() override;
-		void getResult(ErrorOrValue& eov) override;
+		void get_result(ErrorOrValue& eov) override;
 	};
 
 	std::tuple<Appendage<Args>...> appendages;
diff --git a/source/forstio/async.tmpl.h b/source/forstio/async.tmpl.h
index ca36f06..df9a37c 100644
--- a/source/forstio/async.tmpl.h
+++ b/source/forstio/async.tmpl.h
@@ -10,18 +10,18 @@
 
 namespace saw {
 
-template <typename Func> ConveyorResult<Func, void> execLater(Func &&func) {
-	Conveyor<void> conveyor{FixVoid<void>{}};
+template <typename Func> conveyor_result<Func, void> execLater(Func &&func) {
+	conveyor<void> conveyor{fix_void<void>{}};
 	return conveyor.then(std::move(func));
 }
 
 template <typename T>
-Conveyor<T>::Conveyor(FixVoid<T> value) : ConveyorBase(nullptr) {
+conveyor<T>::conveyor(fix_void<T> value) : conveyor_base(nullptr) {
 	// Is there any way to do  this?
-	// @todo new ConveyorBase constructor for Immediate values
+	// @todo new conveyor_base constructor for Immediate values
 
-	Own<ImmediateConveyorNode<FixVoid<T>>> immediate =
-		heap<ImmediateConveyorNode<FixVoid<T>>>(std::move(value));
+	own<immediate_conveyor_node<fix_void<T>>> immediate =
+		heap<immediate_conveyor_node<fix_void<T>>>(std::move(value));
 
 	if (!immediate) {
 		return;
@@ -31,9 +31,9 @@ Conveyor<T>::Conveyor(FixVoid<T> value) : ConveyorBase(nullptr) {
 }
 
 template <typename T>
-Conveyor<T>::Conveyor(Error &&error) : ConveyorBase(nullptr) {
-	Own<ImmediateConveyorNode<FixVoid<T>>> immediate =
-		heap<ImmediateConveyorNode<FixVoid<T>>>(std::move(error));
+conveyor<T>::conveyor(error &&err) : conveyor_base(nullptr) {
+	own<immediate_conveyor_node<fix_void<T>>> immediate =
+		heap<immediate_conveyor_node<fix_void<T>>>(std::move(err));
 
 	if (!immediate) {
 		return;
@@ -43,146 +43,151 @@ Conveyor<T>::Conveyor(Error &&error) : ConveyorBase(nullptr) {
 }
 
 template <typename T>
-Conveyor<T>::Conveyor(Own<ConveyorNode> node_p)
-	: ConveyorBase{std::move(node_p)} {}
+conveyor<T>::conveyor(own<conveyor_node> node_p)
+	: conveyor_base{std::move(node_p)} {}
 
 template <typename T>
 template <typename Func, typename ErrorFunc>
-ConveyorResult<Func, T> Conveyor<T>::then(Func &&func, ErrorFunc &&error_func) {
-	Own<ConveyorNode> conversion_node =
-		heap<ConvertConveyorNode<FixVoid<ReturnType<Func, T>>, FixVoid<T>, Func,
-								 ErrorFunc>>(std::move(node_), std::move(func),
-											 std::move(error_func));
+conveyor_result<Func, T> conveyor<T>::then(Func &&func,
+										   ErrorFunc &&error_func) {
+	own<conveyor_node> conversion_node =
+		heap<convert_conveyor_node<fix_void<return_type<Func, T>>, fix_void<T>,
+								   Func, ErrorFunc>>(
+			std::move(node_), std::move(func), std::move(error_func));
 
-	return Conveyor<RemoveErrorOr<ReturnType<Func, T>>>::toConveyor(
+	return conveyor<remove_error_or<return_type<Func, T>>>::to_conveyor(
 		std::move(conversion_node));
 }
 
-template <typename T> Conveyor<T> Conveyor<T>::buffer(size_t size) {
-	SAW_ASSERT(node_) { return Conveyor<T>{Own<ConveyorNode>{nullptr}}; }
-	ConveyorStorage *storage = node_->nextStorage();
-	SAW_ASSERT(storage) { return Conveyor<T>{Own<ConveyorNode>{nullptr}}; }
+template <typename T> conveyor<T> conveyor<T>::buffer(size_t size) {
+	SAW_ASSERT(node_) { return conveyor<T>{own<conveyor_node>{nullptr}}; }
+	conveyor_storage *storage = node_->next_storage();
+	SAW_ASSERT(storage) { return conveyor<T>{own<conveyor_node>{nullptr}}; }
 
-	Own<QueueBufferConveyorNode<FixVoid<T>>> storage_node =
-		heap<QueueBufferConveyorNode<FixVoid<T>>>(std::move(node_), size);
+	own<queue_buffer_conveyor_node<fix_void<T>>> storage_node =
+		heap<queue_buffer_conveyor_node<fix_void<T>>>(std::move(node_), size);
 
-	ConveyorStorage *storage_ptr =
-		static_cast<ConveyorStorage *>(storage_node.get());
+	conveyor_storage *storage_ptr =
+		static_cast<conveyor_storage *>(storage_node.get());
 
-	storage->setParent(storage_ptr);
-	return Conveyor<T>{std::move(storage_node)};
+	storage->set_parent(storage_ptr);
+	return conveyor<T>{std::move(storage_node)};
 }
 
 template <typename T>
 template <typename... Args>
-Conveyor<T> Conveyor<T>::attach(Args &&...args) {
-	Own<AttachConveyorNode<Args...>> attach_node =
-		heap<AttachConveyorNode<Args...>>(std::move(node_), std::move(args...));
-	return Conveyor<T>{std::move(attach_node)};
+conveyor<T> conveyor<T>::attach(Args &&...args) {
+	own<attach_conveyor_node<Args...>> attach_node =
+		heap<attach_conveyor_node<Args...>>(std::move(node_),
+											std::move(args...));
+	return conveyor<T>{std::move(attach_node)};
 }
 
 template <typename T>
-std::pair<Conveyor<T>, MergeConveyor<T>> Conveyor<T>::merge() {
-	Our<MergeConveyorNodeData<T>> data = share<MergeConveyorNodeData<T>>();
+std::pair<conveyor<T>, merge_conveyor<T>> conveyor<T>::merge() {
+	our<merge_conveyor_node_data<T>> data =
+		share<merge_conveyor_node_data<T>>();
 
-	Own<MergeConveyorNode<T>> merge_node = heap<MergeConveyorNode<T>>(data);
+	own<merge_conveyor_node<T>> merge_node = heap<merge_conveyor_node<T>>(data);
 
 	SAW_ASSERT(node_) {
-		return std::make_pair(Conveyor<T>{Own<ConveyorNode>{nullptr}},
-							  MergeConveyor<T>{});
+		return std::make_pair(conveyor<T>{own<conveyor_node>{nullptr}},
+							  merge_conveyor<T>{});
 	}
-	ConveyorStorage *storage = node_->nextStorage();
+	conveyor_storage *storage = node_->next_storage();
 	SAW_ASSERT(storage) {
-		return std::make_pair(Conveyor<T>{Own<ConveyorNode>{nullptr}},
-							  MergeConveyor<T>{});
+		return std::make_pair(conveyor<T>{own<conveyor_node>{nullptr}},
+							  merge_conveyor<T>{});
 	}
 
-	data->attach(Conveyor<T>::toConveyor(std::move(node_)));
+	data->attach(conveyor<T>::to_conveyor(std::move(node_)));
 
-	MergeConveyor<T> node_ref{data};
+	merge_conveyor<T> node_ref{data};
 
-	return std::make_pair(Conveyor<T>{std::move(merge_node)},
+	return std::make_pair(conveyor<T>{std::move(merge_node)},
 						  std::move(node_ref));
 }
 
 template <>
 template <typename ErrorFunc>
-ConveyorSink Conveyor<void>::sink(ErrorFunc &&error_func) {
-	ConveyorStorage *storage = node_->nextStorage();
-	SAW_ASSERT(storage) { return ConveyorSink{}; }
+conveyor_sink conveyor<void>::sink(ErrorFunc &&error_func) {
+	conveyor_storage *storage = node_->next_storage();
+	SAW_ASSERT(storage) { return conveyor_sink{}; }
 
-	Own<SinkConveyorNode> sink_node = heap<SinkConveyorNode>(std::move(node_));
-	ConveyorStorage *storage_ptr =
-		static_cast<ConveyorStorage *>(sink_node.get());
+	own<sink_conveyor_node> sink_node =
+		heap<sink_conveyor_node>(std::move(node_));
+	conveyor_storage *storage_ptr =
+		static_cast<conveyor_storage *>(sink_node.get());
 
-	storage->setParent(storage_ptr);
+	storage->set_parent(storage_ptr);
 
-	return ConveyorSink{std::move(sink_node)};
+	return conveyor_sink{std::move(sink_node)};
 }
 
-void detachConveyor(Conveyor<void> &&conveyor);
+void detach_conveyor(conveyor<void> &&conveyor);
 
 template <typename T>
 template <typename ErrorFunc>
-void Conveyor<T>::detach(ErrorFunc &&func) {
-	detachConveyor(std::move(then([](T &&) {}, std::move(func))));
+void conveyor<T>::detach(ErrorFunc &&func) {
+	detach_conveyor(std::move(then([](T &&) {}, std::move(func))));
 }
 
 template <>
 template <typename ErrorFunc>
-void Conveyor<void>::detach(ErrorFunc &&func) {
-	detachConveyor(std::move(then([]() {}, std::move(func))));
+void conveyor<void>::detach(ErrorFunc &&func) {
+	detach_conveyor(std::move(then([]() {}, std::move(func))));
 }
 
 template <typename T>
-Conveyor<T> Conveyor<T>::toConveyor(Own<ConveyorNode> node) {
-	return Conveyor<T>{std::move(node)};
+conveyor<T> conveyor<T>::to_conveyor(own<conveyor_node> node) {
+	return conveyor<T>{std::move(node)};
 }
 
 template <typename T>
-Own<ConveyorNode> Conveyor<T>::fromConveyor(Conveyor<T> conveyor) {
+own<conveyor_node> conveyor<T>::from_conveyor(conveyor<T> conveyor) {
 	return std::move(conveyor.node_);
 }
 
-template <typename T> ErrorOr<FixVoid<T>> Conveyor<T>::take() {
+template <typename T> error_or<fix_void<T>> conveyor<T>::take() {
 	SAW_ASSERT(node_) {
-		return ErrorOr<FixVoid<T>>{criticalError("Conveyor in invalid state")};
+		return error_or<fix_void<T>>{
+			critical_error("conveyor in invalid state")};
 	}
-	ConveyorStorage *storage = node_->nextStorage();
+	conveyor_storage *storage = node_->next_storage();
 	if (storage) {
 		if (storage->queued() > 0) {
-			ErrorOr<FixVoid<T>> result;
-			node_->getResult(result);
+			error_or<fix_void<T>> result;
+			node_->get_result(result);
 			return result;
 		} else {
-			return ErrorOr<FixVoid<T>>{
-				recoverableError("Conveyor buffer has no elements")};
+			return error_or<fix_void<T>>{
+				recoverable_error("conveyor buffer has no elements")};
 		}
 	} else {
-		return ErrorOr<FixVoid<T>>{
-			criticalError("Conveyor node has no child storage")};
+		return error_or<fix_void<T>>{
+			critical_error("conveyor node has no child storage")};
 	}
 }
 
-template <typename T> ConveyorAndFeeder<T> newConveyorAndFeeder() {
-	Own<AdaptConveyorFeeder<FixVoid<T>>> feeder =
-		heap<AdaptConveyorFeeder<FixVoid<T>>>();
-	Own<AdaptConveyorNode<FixVoid<T>>> node =
-		heap<AdaptConveyorNode<FixVoid<T>>>();
+template <typename T> conveyor_and_feeder<T> new_conveyor_and_feeder() {
+	own<adapt_conveyor_feeder<fix_void<T>>> feeder =
+		heap<adapt_conveyor_feeder<fix_void<T>>>();
+	own<adapt_conveyor_node<fix_void<T>>> node =
+		heap<adapt_conveyor_node<fix_void<T>>>();
 
-	feeder->setFeedee(node.get());
-	node->setFeeder(feeder.get());
+	feeder->set_feedee(node.get());
+	node->set_feeder(feeder.get());
 
-	return ConveyorAndFeeder<T>{std::move(feeder),
-								Conveyor<T>::toConveyor(std::move(node))};
+	return conveyor_and_feeder<T>{std::move(feeder),
+								  conveyor<T>::to_conveyor(std::move(node))};
 }
 
 // QueueBuffer
-template <typename T> void QueueBufferConveyorNode<T>::fire() {
+template <typename T> void queue_buffer_conveyor_node<T>::fire() {
 	if (child_mixin_.child) {
 		if (!storage_.empty()) {
-			if (storage_.front().isError()) {
-				if (storage_.front().error().isCritical()) {
+			if (storage_.front().is_error()) {
+				if (storage_.front().error().is_critical()) {
 					child_mixin_.child = nullptr;
 				}
 			}
@@ -192,9 +197,9 @@ template <typename T> void QueueBufferConveyorNode<T>::fire() {
 	bool has_space_before_fire = space() > 0;
 
 	if (parent_) {
-		parent_->childHasFired();
+		parent_->child_has_fired();
 		if (!storage_.empty() && parent_->space() > 0) {
-			armLater();
+			arm_later();
 		}
 	}
 
@@ -205,45 +210,45 @@ template <typename T> void QueueBufferConveyorNode<T>::fire() {
 		return;
 	}
 
-	ConveyorStorage *ch_storage = child_mixin_.child->nextStorage();
+	conveyor_storage *ch_storage = child_mixin_.child->next_storage();
 	if (ch_storage && !has_space_before_fire) {
-		ch_storage->parentHasFired();
+		ch_storage->parent_has_fired();
 	}
 }
 
 template <typename T>
-void QueueBufferConveyorNode<T>::getResult(ErrorOrValue &eov) noexcept {
-	ErrorOr<T> &err_or_val = eov.as<T>();
+void queue_buffer_conveyor_node<T>::get_result(error_or_value &eov) noexcept {
+	error_or<T> &err_or_val = eov.as<T>();
 	err_or_val = std::move(storage_.front());
 	storage_.pop();
 }
 
-template <typename T> size_t QueueBufferConveyorNode<T>::space() const {
+template <typename T> size_t queue_buffer_conveyor_node<T>::space() const {
 	return max_store_ - storage_.size();
 }
 
-template <typename T> size_t QueueBufferConveyorNode<T>::queued() const {
+template <typename T> size_t queue_buffer_conveyor_node<T>::queued() const {
 	return storage_.size();
 }
 
-template <typename T> void QueueBufferConveyorNode<T>::childHasFired() {
+template <typename T> void queue_buffer_conveyor_node<T>::child_has_fired() {
 	if (child_mixin_.child && storage_.size() < max_store_) {
-		ErrorOr<T> eov;
-		child_mixin_.child->getResult(eov);
+		error_or<T> eov;
+		child_mixin_.child->get_result(eov);
 
-		if (eov.isError()) {
-			if (eov.error().isCritical()) {
+		if (eov.is_error()) {
+			if (eov.error().is_critical()) {
 			}
 		}
 
 		storage_.push(std::move(eov));
-		if (!isArmed()) {
-			armLater();
+		if (!is_armed()) {
+			arm_later();
 		}
 	}
 }
 
-template <typename T> void QueueBufferConveyorNode<T>::parentHasFired() {
+template <typename T> void queue_buffer_conveyor_node<T>::parent_has_fired() {
 	SAW_ASSERT(parent_) { return; }
 
 	if (parent_->space() == 0) {
@@ -251,57 +256,57 @@ template <typename T> void QueueBufferConveyorNode<T>::parentHasFired() {
 	}
 
 	if (queued() > 0) {
-		armLater();
+		arm_later();
 	}
 }
 
 template <typename T>
-ImmediateConveyorNode<T>::ImmediateConveyorNode(FixVoid<T> &&val)
+immediate_conveyor_node<T>::immediate_conveyor_node(fix_void<T> &&val)
 	: value_{std::move(val)}, retrieved_{0} {}
 
 template <typename T>
-ImmediateConveyorNode<T>::ImmediateConveyorNode(Error &&error)
+immediate_conveyor_node<T>::immediate_conveyor_node(error &&error)
 	: value_{std::move(error)}, retrieved_{0} {}
 
-template <typename T> size_t ImmediateConveyorNode<T>::space() const {
+template <typename T> size_t immediate_conveyor_node<T>::space() const {
 	return 0;
 }
 
-template <typename T> size_t ImmediateConveyorNode<T>::queued() const {
+template <typename T> size_t immediate_conveyor_node<T>::queued() const {
 	return retrieved_ > 1 ? 0 : 1;
 }
 
-template <typename T> void ImmediateConveyorNode<T>::childHasFired() {
+template <typename T> void immediate_conveyor_node<T>::child_has_fired() {
 	// Impossible case
 	assert(false);
 }
 
-template <typename T> void ImmediateConveyorNode<T>::parentHasFired() {
+template <typename T> void immediate_conveyor_node<T>::parent_has_fired() {
 	SAW_ASSERT(parent_) { return; }
 	assert(parent_->space() > 0);
 
 	if (queued() > 0) {
-		armNext();
+		arm_next();
 	}
 }
 
-template <typename T> void ImmediateConveyorNode<T>::fire() {
+template <typename T> void immediate_conveyor_node<T>::fire() {
 
 	if (parent_) {
-		parent_->childHasFired();
+		parent_->child_has_fired();
 		if (queued() > 0 && parent_->space() > 0) {
-			armLast();
+			arm_last();
 		}
 	}
 }
 
 template <typename T>
-MergeConveyor<T>::MergeConveyor(Lent<MergeConveyorNodeData<T>> d)
+merge_conveyor<T>::merge_conveyor(lent<merge_conveyor_node_data<T>> d)
 	: data_{std::move(d)} {}
 
-template <typename T> MergeConveyor<T>::~MergeConveyor() {}
+template <typename T> merge_conveyor<T>::~merge_conveyor() {}
 
-template <typename T> void MergeConveyor<T>::attach(Conveyor<T> conveyor) {
+template <typename T> void merge_conveyor<T>::attach(conveyor<T> conveyor) {
 	auto sp = data_.lock();
 	SAW_ASSERT(sp) { return; }
 
@@ -309,26 +314,26 @@ template <typename T> void MergeConveyor<T>::attach(Conveyor<T> conveyor) {
 }
 
 template <typename T>
-MergeConveyorNode<T>::MergeConveyorNode(Our<MergeConveyorNodeData<T>> d)
+merge_conveyor_node<T>::merge_conveyor_node(our<merge_conveyor_node_data<T>> d)
 	: data_{d} {
 	SAW_ASSERT(data_) { return; }
 
 	data_->merger = this;
 }
 
-template <typename T> MergeConveyorNode<T>::~MergeConveyorNode() {}
+template <typename T> merge_conveyor_node<T>::~merge_conveyor_node() {}
 
 template <typename T>
-ErrorOr<Own<ConveyorNode>>
-MergeConveyorNode<T>::swapChild(Own<ConveyorNode> &&swapee_) noexcept {
+error_or<own<conveyor_node>>
+merge_conveyor_node<T>::swap_child(own<conveyor_node> &&swapee_) noexcept {
 	(void)swapee_;
-	return criticalError(
-		"MergeConveyorNode<T>::Appendage should block calls to this class");
+	return critical_error(
+		"merge_conveyor_node<T>::appendage should block calls to this class");
 }
 
 template <typename T>
-void MergeConveyorNode<T>::getResult(ErrorOrValue &eov) noexcept {
-	ErrorOr<FixVoid<T>> &err_or_val = eov.as<FixVoid<T>>();
+void merge_conveyor_node<T>::get_result(error_or_value &eov) noexcept {
+	error_or<fix_void<T>> &err_or_val = eov.as<fix_void<T>>();
 
 	SAW_ASSERT(data_) { return; }
 
@@ -339,39 +344,39 @@ void MergeConveyorNode<T>::getResult(ErrorOrValue &eov) noexcept {
 
 	for (size_t i = next_appendage_; i < appendages.size(); ++i) {
 		if (appendages[i]->queued() > 0) {
-			err_or_val = std::move(appendages[i]->error_or_value.value());
-			appendages[i]->error_or_value = std::nullopt;
+			err_or_val = std::move(appendages[i]->error_or_value_.value());
+			appendages[i]->error_or_value_ = std::nullopt;
 			next_appendage_ = i + 1;
 			return;
 		}
 	}
 	for (size_t i = 0; i < next_appendage_; ++i) {
 		if (appendages[i]->queued() > 0) {
-			err_or_val = std::move(appendages[i]->error_or_value.value());
-			appendages[i]->error_or_value = std::nullopt;
+			err_or_val = std::move(appendages[i]->error_or_value_.value());
+			appendages[i]->error_or_value_ = std::nullopt;
 			next_appendage_ = i + 1;
 			return;
 		}
 	}
 
-	err_or_val = criticalError("No value in Merge Appendages");
+	err_or_val = critical_error("No value in Merge appendages");
 }
 
-template <typename T> void MergeConveyorNode<T>::fire() {
+template <typename T> void merge_conveyor_node<T>::fire() {
 	SAW_ASSERT(queued() > 0) { return; }
 
 	if (parent_) {
-		parent_->childHasFired();
+		parent_->child_has_fired();
 
 		if (queued() > 0 && parent_->space() > 0) {
-			armLater();
+			arm_later();
 		}
 	}
 }
 
-template <typename T> size_t MergeConveyorNode<T>::space() const { return 0; }
+template <typename T> size_t merge_conveyor_node<T>::space() const { return 0; }
 
-template <typename T> size_t MergeConveyorNode<T>::queued() const {
+template <typename T> size_t merge_conveyor_node<T>::queued() const {
 	SAW_ASSERT(data_) { return 0; }
 
 	size_t queue_count = 0;
@@ -383,105 +388,110 @@ template <typename T> size_t MergeConveyorNode<T>::queued() const {
 	return queue_count;
 }
 
-template <typename T> void MergeConveyorNode<T>::childHasFired() {
+template <typename T> void merge_conveyor_node<T>::child_has_fired() {
 	/// This can never happen
 	assert(false);
 }
 
-template <typename T> void MergeConveyorNode<T>::parentHasFired() {
+template <typename T> void merge_conveyor_node<T>::parent_has_fired() {
 	SAW_ASSERT(parent_) { return; }
 	if (queued() > 0) {
 		if (parent_->space() > 0) {
-			armLater();
+			arm_later();
 		}
 	}
 }
 
 /**
- * MergeConveyorNode<T>::Apendage
+ * merge_conveyor_node<T>::Apendage
  */
 
 template <typename T>
-ErrorOr<Own<ConveyorNode>>
-MergeConveyorNode<T>::Appendage::swapChild(Own<ConveyorNode> &&swapee_) {
-	Own<ConveyorNode> old_child = std::move(child);
+error_or<own<conveyor_node>>
+merge_conveyor_node<T>::appendage::swap_child(own<conveyor_node> &&swapee_) {
+	own<conveyor_node> old_child = std::move(child);
 
 	child = std::move(swapee_);
 
 	// This case should never happen
-	SAW_ASSERT(old_child) { return criticalError("No child exists"); }
+	SAW_ASSERT(old_child) { return critical_error("No child exists"); }
 
 	return old_child;
 }
 
 template <typename T>
-void MergeConveyorNode<T>::Appendage::getResult(ErrorOrValue &eov) {
-	ErrorOr<FixVoid<T>> &err_or_val = eov.as<FixVoid<T>>();
+void merge_conveyor_node<T>::appendage::get_result(error_or_value &eov) {
+	error_or<fix_void<T>> &err_or_val = eov.as<fix_void<T>>();
 
 	SAW_ASSERT(queued() > 0) {
-		err_or_val = criticalError("No element queued in Merge Appendage Node");
+		err_or_val =
+			critical_error("No element queued in Merge appendage Node");
 		return;
 	}
 
-	err_or_val = std::move(error_or_value.value());
-	error_or_value = std::nullopt;
+	err_or_val = std::move(error_or_value_.value());
+	error_or_value_ = std::nullopt;
 }
 
-template <typename T> size_t MergeConveyorNode<T>::Appendage::space() const {
+template <typename T> size_t merge_conveyor_node<T>::appendage::space() const {
 	SAW_ASSERT(merger) { return 0; }
 
-	if (error_or_value.has_value()) {
+	if (error_or_value_.has_value()) {
 		return 0;
 	}
 
 	return 1;
 }
 
-template <typename T> size_t MergeConveyorNode<T>::Appendage::queued() const {
+template <typename T> size_t merge_conveyor_node<T>::appendage::queued() const {
 	SAW_ASSERT(merger) { return 0; }
 
-	if (error_or_value.has_value()) {
+	if (error_or_value_.has_value()) {
 		return 1;
 	}
 
 	return 0;
 }
 
-/// @todo delete this function. Replaced by the regular getResult
+/// @todo delete this function. Replaced by the regular get_result
 template <typename T>
-void MergeConveyorNode<T>::Appendage::getAppendageResult(ErrorOrValue &eov) {
-	ErrorOr<FixVoid<T>> &err_or_val = eov.as<FixVoid<T>>();
+void merge_conveyor_node<T>::appendage::get_appendage_result(
+	error_or_value &eov) {
+	error_or<fix_void<T>> &err_or_val = eov.as<fix_void<T>>();
 
 	SAW_ASSERT(queued() > 0) {
-		err_or_val = criticalError("No element queued in Merge Appendage Node");
+		err_or_val =
+			critical_error("No element queued in Merge appendage Node");
 		return;
 	}
 
-	err_or_val = std::move(error_or_value.value());
-	error_or_value = std::nullopt;
+	err_or_val = std::move(error_or_value_.value());
+	error_or_value_ = std::nullopt;
 }
 
-template <typename T> void MergeConveyorNode<T>::Appendage::childHasFired() {
-	SAW_ASSERT(!error_or_value.has_value()) { return; }
-	ErrorOr<FixVoid<T>> eov;
-	child->getResult(eov);
+template <typename T>
+void merge_conveyor_node<T>::appendage::child_has_fired() {
+	SAW_ASSERT(!error_or_value_.has_value()) { return; }
+	error_or<fix_void<T>> eov;
+	child->get_result(eov);
 
-	error_or_value = std::move(eov);
+	error_or_value_ = std::move(eov);
 
-	if (!merger->isArmed()) {
-		merger->armLater();
-	}
-}
-
-template <typename T> void MergeConveyorNode<T>::Appendage::parentHasFired() {
-	ConveyorStorage *child_storage = child->nextStorage();
-	if (child_storage) {
-		child_storage->parentHasFired();
+	if (!merger->is_armed()) {
+		merger->arm_later();
 	}
 }
 
 template <typename T>
-void MergeConveyorNode<T>::Appendage::setParent(ConveyorStorage *par) {
+void merge_conveyor_node<T>::appendage::parent_has_fired() {
+	conveyor_storage *child_storage = child->next_storage();
+	if (child_storage) {
+		child_storage->parent_has_fired();
+	}
+}
+
+template <typename T>
+void merge_conveyor_node<T>::appendage::set_parent(conveyor_storage *par) {
 	SAW_ASSERT(merger) { return; }
 
 	SAW_ASSERT(child) { return; }
@@ -490,24 +500,25 @@ void MergeConveyorNode<T>::Appendage::setParent(ConveyorStorage *par) {
 }
 
 template <typename T>
-void MergeConveyorNodeData<T>::attach(Conveyor<T> conveyor) {
-	auto nas = Conveyor<T>::fromConveyor(std::move(conveyor));
+void merge_conveyor_node_data<T>::attach(conveyor<T> conv) {
+	auto nas = conveyor<T>::from_conveyor(std::move(conv));
 	SAW_ASSERT(nas) { return; }
-	ConveyorStorage *storage = nas->nextStorage();
+	conveyor_storage *storage = nas->next_storage();
 	SAW_ASSERT(storage) { return; }
 
 	auto merge_node_appendage =
-		heap<typename MergeConveyorNode<T>::Appendage>(std::move(nas), *merger);
+		heap<typename merge_conveyor_node<T>::appendage>(std::move(nas),
+														 *merger);
 	auto merge_node_appendage_ptr = merge_node_appendage.get();
 
-	storage->setParent(merge_node_appendage.get());
+	storage->set_parent(merge_node_appendage.get());
 
 	SAW_ASSERT(merger) { return; }
 
-	ConveyorStorage *mrg_storage = merger->nextStorage();
+	conveyor_storage *mrg_storage = merger->next_storage();
 	SAW_ASSERT(mrg_storage) { return; }
 
-	merge_node_appendage->setParent(mrg_storage);
+	merge_node_appendage->set_parent(mrg_storage);
 
 	appendages.push_back(std::move(merge_node_appendage));
 
@@ -516,43 +527,44 @@ void MergeConveyorNodeData<T>::attach(Conveyor<T> conveyor) {
 	// return merge_node_appendage_ptr;
 }
 
-template <typename T> void MergeConveyorNodeData<T>::governingNodeDestroyed() {
+template <typename T>
+void merge_conveyor_node_data<T>::governing_node_destroyed() {
 	appendages.clear();
 	merger = nullptr;
 }
 
-template <typename T> AdaptConveyorFeeder<T>::~AdaptConveyorFeeder() {
+template <typename T> adapt_conveyor_feeder<T>::~adapt_conveyor_feeder() {
 	if (feedee_) {
-		feedee_->setFeeder(nullptr);
+		feedee_->set_feeder(nullptr);
 		feedee_ = nullptr;
 	}
 }
 
 template <typename T>
-void AdaptConveyorFeeder<T>::setFeedee(AdaptConveyorNode<T> *feedee_p) {
+void adapt_conveyor_feeder<T>::set_feedee(adapt_conveyor_node<T> *feedee_p) {
 	feedee_ = feedee_p;
 }
 
-template <typename T> void AdaptConveyorFeeder<T>::feed(T &&value) {
+template <typename T> void adapt_conveyor_feeder<T>::feed(T &&value) {
 	if (feedee_) {
 		feedee_->feed(std::move(value));
 	}
 }
 
-template <typename T> void AdaptConveyorFeeder<T>::fail(Error &&error) {
+template <typename T> void adapt_conveyor_feeder<T>::fail(error &&error) {
 	if (feedee_) {
 		feedee_->fail(std::move(error));
 	}
 }
 
-template <typename T> size_t AdaptConveyorFeeder<T>::queued() const {
+template <typename T> size_t adapt_conveyor_feeder<T>::queued() const {
 	if (feedee_) {
 		return feedee_->queued();
 	}
 	return 0;
 }
 
-template <typename T> size_t AdaptConveyorFeeder<T>::space() const {
+template <typename T> size_t adapt_conveyor_feeder<T>::space() const {
 	if (feedee_) {
 		return feedee_->space();
 	}
@@ -560,33 +572,33 @@ template <typename T> size_t AdaptConveyorFeeder<T>::space() const {
 }
 
 template <typename T>
-Error AdaptConveyorFeeder<T>::swap(Conveyor<T> &&conveyor) noexcept {
-	SAW_ASSERT(feedee_) { return criticalError("No feedee connected"); }
+error adapt_conveyor_feeder<T>::swap(conveyor<T> &&conv) noexcept {
+	SAW_ASSERT(feedee_) { return critical_error("No feedee connected"); }
 
-	auto node = Conveyor<T>::fromConveyor(std::move(conveyor));
+	auto node = conveyor<T>::from_conveyor(std::move(conv));
 
-	feedee_->swapChild(std::move(node));
+	feedee_->swap_child(std::move(node));
 
-	return noError();
+	return no_error();
 }
 
 template <typename T>
-AdaptConveyorNode<T>::AdaptConveyorNode() : ConveyorEventStorage{} {}
+adapt_conveyor_node<T>::adapt_conveyor_node() : conveyor_event_storage{} {}
 
-template <typename T> AdaptConveyorNode<T>::~AdaptConveyorNode() {
+template <typename T> adapt_conveyor_node<T>::~adapt_conveyor_node() {
 	if (feeder_) {
-		feeder_->setFeedee(nullptr);
+		feeder_->set_feedee(nullptr);
 		feeder_ = nullptr;
 	}
 }
 
 template <typename T>
-ErrorOr<Own<ConveyorNode>>
-AdaptConveyorNode<T>::swapChild(Own<ConveyorNode> &&swapee) noexcept {
+error_or<own<conveyor_node>>
+adapt_conveyor_node<T>::swap_child(own<conveyor_node> &&swapee) noexcept {
 	// This should return the owning pointer of this instance
-	auto myself_err = parent_node_.swapChildOfParent(std::move(swapee));
+	auto myself_err = parent_node_.swap_child_of_parent(std::move(swapee));
 
-	if (myself_err.isError()) {
+	if (myself_err.is_error()) {
 		return myself_err;
 	}
 
@@ -598,56 +610,57 @@ AdaptConveyorNode<T>::swapChild(Own<ConveyorNode> &&swapee) noexcept {
 }
 
 template <typename T>
-ConveyorStorage *AdaptConveyorNode<T>::nextStorage() noexcept {
-	return static_cast<ConveyorStorage *>(this);
+conveyor_storage *adapt_conveyor_node<T>::next_storage() noexcept {
+	return static_cast<conveyor_storage *>(this);
 }
 
 template <typename T>
-void AdaptConveyorNode<T>::notifyParentAttached(ConveyorNode &par) noexcept {
-	parent_node_.changeParent(&par);
+void adapt_conveyor_node<T>::notify_parent_attached(
+	conveyor_node &par) noexcept {
+	parent_node_.change_parent(&par);
 }
 
 template <typename T>
-void AdaptConveyorNode<T>::setFeeder(AdaptConveyorFeeder<T> *feeder_p) {
+void adapt_conveyor_node<T>::set_feeder(adapt_conveyor_feeder<T> *feeder_p) {
 	feeder_ = feeder_p;
 }
 
-template <typename T> void AdaptConveyorNode<T>::feed(T &&value) {
+template <typename T> void adapt_conveyor_node<T>::feed(T &&value) {
 	storage_.push(std::move(value));
-	armNext();
+	arm_next();
 }
 
-template <typename T> void AdaptConveyorNode<T>::fail(Error &&error) {
+template <typename T> void adapt_conveyor_node<T>::fail(error &&error) {
 	storage_.push(std::move(error));
-	armNext();
+	arm_next();
 }
 
-template <typename T> size_t AdaptConveyorNode<T>::queued() const {
+template <typename T> size_t adapt_conveyor_node<T>::queued() const {
 	return storage_.size();
 }
 
-template <typename T> size_t AdaptConveyorNode<T>::space() const {
+template <typename T> size_t adapt_conveyor_node<T>::space() const {
 	return std::numeric_limits<size_t>::max() - storage_.size();
 }
 
 template <typename T>
-void AdaptConveyorNode<T>::getResult(ErrorOrValue &err_or_val) {
+void adapt_conveyor_node<T>::get_result(error_or_value &err_or_val) {
 	if (!storage_.empty()) {
 		err_or_val.as<T>() = std::move(storage_.front());
 		storage_.pop();
 	} else {
-		err_or_val.as<T>() =
-			criticalError("Signal for retrieval of storage sent even though no "
-						  "data is present");
+		err_or_val.as<T>() = critical_error(
+			"Signal for retrieval of storage sent even though no "
+			"data is present");
 	}
 }
 
-template <typename T> void AdaptConveyorNode<T>::childHasFired() {
+template <typename T> void adapt_conveyor_node<T>::child_has_fired() {
 	// Adapt node has no children
 	assert(false);
 }
 
-template <typename T> void AdaptConveyorNode<T>::parentHasFired() {
+template <typename T> void adapt_conveyor_node<T>::parent_has_fired() {
 	SAW_ASSERT(parent_) { return; }
 
 	if (parent_->space() == 0) {
@@ -655,99 +668,101 @@ template <typename T> void AdaptConveyorNode<T>::parentHasFired() {
 	}
 }
 
-template <typename T> void AdaptConveyorNode<T>::fire() {
+template <typename T> void adapt_conveyor_node<T>::fire() {
 	if (parent_) {
-		parent_->childHasFired();
+		parent_->child_has_fired();
 
 		if (storage_.size() > 0) {
-			armLater();
+			arm_later();
 		}
 	}
 }
 
-template <typename T> OneTimeConveyorFeeder<T>::~OneTimeConveyorFeeder() {
+template <typename T> one_time_conveyor_feeder<T>::~one_time_conveyor_feeder() {
 	if (feedee_) {
-		feedee_->setFeeder(nullptr);
+		feedee_->set_feeder(nullptr);
 		feedee_ = nullptr;
 	}
 }
 
 template <typename T>
-void OneTimeConveyorFeeder<T>::setFeedee(OneTimeConveyorNode<T> *feedee_p) {
+void one_time_conveyor_feeder<T>::set_feedee(
+	one_time_conveyor_node<T> *feedee_p) {
 	feedee_ = feedee_p;
 }
 
-template <typename T> void OneTimeConveyorFeeder<T>::feed(T &&value) {
+template <typename T> void one_time_conveyor_feeder<T>::feed(T &&value) {
 	if (feedee_) {
 		feedee_->feed(std::move(value));
 	}
 }
 
-template <typename T> void OneTimeConveyorFeeder<T>::fail(Error &&error) {
+template <typename T> void one_time_conveyor_feeder<T>::fail(error &&error) {
 	if (feedee_) {
 		feedee_->fail(std::move(error));
 	}
 }
 
-template <typename T> size_t OneTimeConveyorFeeder<T>::queued() const {
+template <typename T> size_t one_time_conveyor_feeder<T>::queued() const {
 	if (feedee_) {
 		return feedee_->queued();
 	}
 	return 0;
 }
 
-template <typename T> size_t OneTimeConveyorFeeder<T>::space() const {
+template <typename T> size_t one_time_conveyor_feeder<T>::space() const {
 	if (feedee_) {
 		return feedee_->space();
 	}
 	return 0;
 }
 
-template <typename T> OneTimeConveyorNode<T>::~OneTimeConveyorNode() {
+template <typename T> one_time_conveyor_node<T>::~one_time_conveyor_node() {
 	if (feeder_) {
-		feeder_->setFeedee(nullptr);
+		feeder_->set_feedee(nullptr);
 		feeder_ = nullptr;
 	}
 }
 
 template <typename T>
-void OneTimeConveyorNode<T>::setFeeder(OneTimeConveyorFeeder<T> *feeder_p) {
+void one_time_conveyor_node<T>::set_feeder(
+	one_time_conveyor_feeder<T> *feeder_p) {
 	feeder_ = feeder_p;
 }
 
-template <typename T> void OneTimeConveyorNode<T>::feed(T &&value) {
+template <typename T> void one_time_conveyor_node<T>::feed(T &&value) {
 	storage_ = std::move(value);
-	armNext();
+	arm_next();
 }
 
-template <typename T> void OneTimeConveyorNode<T>::fail(Error &&error) {
+template <typename T> void one_time_conveyor_node<T>::fail(error &&error) {
 	storage_ = std::move(error);
-	armNext();
+	arm_next();
 }
 
-template <typename T> size_t OneTimeConveyorNode<T>::queued() const {
+template <typename T> size_t one_time_conveyor_node<T>::queued() const {
 	return storage_.has_value() ? 1 : 0;
 }
 
-template <typename T> size_t OneTimeConveyorNode<T>::space() const {
+template <typename T> size_t one_time_conveyor_node<T>::space() const {
 	return passed_ ? 0 : 1;
 }
 
 template <typename T>
-void OneTimeConveyorNode<T>::getResult(ErrorOrValue &err_or_val) {
+void one_time_conveyor_node<T>::get_result(error_or_value &err_or_val) {
 	if (storage_.has_value()) {
 		err_or_val.as<T>() = std::move(storage_.value());
 		storage_ = std::nullopt;
 	} else {
-		err_or_val.as<T>() =
-			criticalError("Signal for retrieval of storage sent even though no "
-						  "data is present");
+		err_or_val.as<T>() = critical_error(
+			"Signal for retrieval of storage sent even though no "
+			"data is present");
 	}
 }
 
-template <typename T> void OneTimeConveyorNode<T>::fire() {
+template <typename T> void one_time_conveyor_node<T>::fire() {
 	if (parent_) {
-		parent_->childHasFired();
+		parent_->child_has_fired();
 	}
 }
 
diff --git a/source/forstio/buffer.cpp b/source/forstio/buffer.cpp
index 637a383..2f1a6b5 100644
--- a/source/forstio/buffer.cpp
+++ b/source/forstio/buffer.cpp
@@ -7,223 +7,223 @@
 #include <sstream>
 
 namespace saw {
-Error Buffer::push(const uint8_t &value) {
-	size_t write_remain = writeCompositeLength();
+error buffer::push(const uint8_t &value) {
+	size_t write_remain = write_composite_length();
 	if (write_remain > 0) {
 		write() = value;
-		writeAdvance(1);
+		write_advance(1);
 	} else {
-		return recoverableError("Buffer too small");
+		return recoverable_error("Buffer too small");
 	}
-	return noError();
+	return no_error();
 }
 
-Error Buffer::push(const uint8_t &buffer, size_t size) {
-	Error error = writeRequireLength(size);
+error buffer::push(const uint8_t &buffer, size_t size) {
+	error error = write_require_length(size);
 	if (error.failed()) {
 		return error;
 	}
 	const uint8_t *buffer_ptr = &buffer;
 	while (size > 0) {
-		size_t segment = std::min(writeSegmentLength(), size);
+		size_t segment = std::min(write_segment_length(), size);
 		memcpy(&write(), buffer_ptr, segment);
-		writeAdvance(segment);
+		write_advance(segment);
 		size -= segment;
 		buffer_ptr += segment;
 	}
-	return noError();
+	return no_error();
 }
 
-Error Buffer::pop(uint8_t &value) {
-	if (readCompositeLength() > 0) {
+error buffer::pop(uint8_t &value) {
+	if (read_composite_length() > 0) {
 		value = read();
-		readAdvance(1);
+		read_advance(1);
 	} else {
-		return recoverableError("Buffer too small");
+		return recoverable_error("Buffer too small");
 	}
-	return noError();
+	return no_error();
 }
 
-Error Buffer::pop(uint8_t &buffer, size_t size) {
-	if (readCompositeLength() >= size) {
+error buffer::pop(uint8_t &buffer, size_t size) {
+	if (read_composite_length() >= size) {
 		uint8_t *buffer_ptr = &buffer;
 		while (size > 0) {
-			size_t segment = std::min(readSegmentLength(), size);
+			size_t segment = std::min(read_segment_length(), size);
 			memcpy(buffer_ptr, &read(), segment);
-			readAdvance(segment);
+			read_advance(segment);
 			size -= segment;
 			buffer_ptr += segment;
 		}
 	} else {
-		return recoverableError("Buffer too small");
+		return recoverable_error("Buffer too small");
 	}
-	return noError();
+	return no_error();
 }
 
-std::string Buffer::toString() const {
+std::string buffer::to_string() const {
 	std::ostringstream oss;
-	for (size_t i = 0; i < readCompositeLength(); ++i) {
+	for (size_t i = 0; i < read_composite_length(); ++i) {
 		oss << read(i);
 	}
 	return oss.str();
 }
 
-std::string Buffer::toHex() const {
+std::string buffer::to_hex() const {
 	std::ostringstream oss;
 	oss << std::hex << std::setfill('0');
-	for (size_t i = 0; i < readCompositeLength(); ++i) {
+	for (size_t i = 0; i < read_composite_length(); ++i) {
 		oss << std::setw(2) << (uint16_t)read(i);
-		if ((i + 1) < readCompositeLength()) {
+		if ((i + 1) < read_composite_length()) {
 			oss << ((i % 4 == 3) ? '\n' : ' ');
 		}
 	}
 	return oss.str();
 }
 
-BufferView::BufferView(Buffer &buffer)
+buffer_view::buffer_view(buffer &buffer)
 	: buffer_{buffer}, read_offset_{0}, write_offset_{0} {}
 
-size_t BufferView::readPosition() const {
-	return read_offset_ + buffer_.readPosition();
+size_t buffer_view::read_position() const {
+	return read_offset_ + buffer_.read_position();
 }
 
-size_t BufferView::readCompositeLength() const {
-	assert(read_offset_ <= buffer_.readCompositeLength());
-	if (read_offset_ > buffer_.readCompositeLength()) {
+size_t buffer_view::read_composite_length() const {
+	assert(read_offset_ <= buffer_.read_composite_length());
+	if (read_offset_ > buffer_.read_composite_length()) {
 		return 0;
 	}
 
-	return buffer_.readCompositeLength() - read_offset_;
+	return buffer_.read_composite_length() - read_offset_;
 }
 
-size_t BufferView::readSegmentLength(size_t offset) const {
+size_t buffer_view::read_segment_length(size_t offset) const {
 	size_t off = offset + read_offset_;
-	assert(off <= buffer_.readCompositeLength());
-	if (off > buffer_.readCompositeLength()) {
+	assert(off <= buffer_.read_composite_length());
+	if (off > buffer_.read_composite_length()) {
 		return 0;
 	}
 
-	return buffer_.readSegmentLength(off);
+	return buffer_.read_segment_length(off);
 }
 
-void BufferView::readAdvance(size_t bytes) {
+void buffer_view::read_advance(size_t bytes) {
 	size_t offset = bytes + read_offset_;
-	assert(offset <= buffer_.readCompositeLength());
-	if (offset > buffer_.readCompositeLength()) {
-		read_offset_ += buffer_.readCompositeLength();
+	assert(offset <= buffer_.read_composite_length());
+	if (offset > buffer_.read_composite_length()) {
+		read_offset_ += buffer_.read_composite_length();
 		return;
 	}
 
 	read_offset_ += bytes;
 }
 
-uint8_t &BufferView::read(size_t i) {
+uint8_t &buffer_view::read(size_t i) {
 	size_t pos = i + read_offset_;
 
-	assert(pos < buffer_.readCompositeLength());
+	assert(pos < buffer_.read_composite_length());
 
 	return buffer_.read(pos);
 }
 
-const uint8_t &BufferView::read(size_t i) const {
+const uint8_t &buffer_view::read(size_t i) const {
 	size_t pos = i + read_offset_;
 
-	assert(pos < buffer_.readCompositeLength());
+	assert(pos < buffer_.read_composite_length());
 
 	return buffer_.read(pos);
 }
 
-size_t BufferView::writePosition() const {
-	return write_offset_ + buffer_.writePosition();
+size_t buffer_view::write_position() const {
+	return write_offset_ + buffer_.write_position();
 }
 
-size_t BufferView::writeCompositeLength() const {
-	assert(write_offset_ <= buffer_.writeCompositeLength());
-	if (write_offset_ > buffer_.writeCompositeLength()) {
+size_t buffer_view::write_composite_length() const {
+	assert(write_offset_ <= buffer_.write_composite_length());
+	if (write_offset_ > buffer_.write_composite_length()) {
 		return 0;
 	}
 
-	return buffer_.writeCompositeLength() - write_offset_;
+	return buffer_.write_composite_length() - write_offset_;
 }
 
-size_t BufferView::writeSegmentLength(size_t offset) const {
+size_t buffer_view::write_segment_length(size_t offset) const {
 	size_t off = offset + write_offset_;
-	assert(off <= buffer_.writeCompositeLength());
-	if (off > buffer_.writeCompositeLength()) {
+	assert(off <= buffer_.write_composite_length());
+	if (off > buffer_.write_composite_length()) {
 		return 0;
 	}
 
-	return buffer_.writeSegmentLength(off);
+	return buffer_.write_segment_length(off);
 }
 
-void BufferView::writeAdvance(size_t bytes) {
+void buffer_view::write_advance(size_t bytes) {
 	size_t offset = bytes + write_offset_;
-	assert(offset <= buffer_.writeCompositeLength());
-	if (offset > buffer_.writeCompositeLength()) {
-		write_offset_ += buffer_.writeCompositeLength();
+	assert(offset <= buffer_.write_composite_length());
+	if (offset > buffer_.write_composite_length()) {
+		write_offset_ += buffer_.write_composite_length();
 		return;
 	}
 
 	write_offset_ += bytes;
 }
 
-uint8_t &BufferView::write(size_t i) {
+uint8_t &buffer_view::write(size_t i) {
 	size_t pos = i + write_offset_;
 
-	assert(pos < buffer_.writeCompositeLength());
+	assert(pos < buffer_.write_composite_length());
 
 	return buffer_.write(pos);
 }
 
-const uint8_t &BufferView::write(size_t i) const {
+const uint8_t &buffer_view::write(size_t i) const {
 	size_t pos = i + write_offset_;
 
-	assert(pos < buffer_.writeCompositeLength());
+	assert(pos < buffer_.write_composite_length());
 
 	return buffer_.write(pos);
 }
 
-Error BufferView::writeRequireLength(size_t bytes) {
-	return buffer_.writeRequireLength(bytes + write_offset_);
+error buffer_view::write_require_length(size_t bytes) {
+	return buffer_.write_require_length(bytes + write_offset_);
 }
 
-size_t BufferView::readOffset() const { return read_offset_; }
+size_t buffer_view::read_offset() const { return read_offset_; }
 
-size_t BufferView::writeOffset() const { return write_offset_; }
+size_t buffer_view::write_offset() const { return write_offset_; }
 
-RingBuffer::RingBuffer() : read_position_{0}, write_position_{0} {
+ring_buffer::ring_buffer() : read_position_{0}, write_position_{0} {
 	buffer_.resize(RING_BUFFER_MAX_SIZE);
 }
 
-RingBuffer::RingBuffer(size_t size) : read_position_{0}, write_position_{0} {
+ring_buffer::ring_buffer(size_t size) : read_position_{0}, write_position_{0} {
 	buffer_.resize(size);
 }
 
-size_t RingBuffer::readPosition() const { return read_position_; }
+size_t ring_buffer::read_position() const { return read_position_; }
 
 /*
  * If write is ahead of read it is a simple distance, but if read ist ahead of
  * write then there are two segments
  *
  */
-size_t RingBuffer::readCompositeLength() const {
-	return writePosition() < readPosition()
-			   ? buffer_.size() - (readPosition() - writePosition())
+size_t ring_buffer::read_composite_length() const {
+	return write_position() < read_position()
+			   ? buffer_.size() - (read_position() - write_position())
 			   : (write_reached_read_ ? buffer_.size()
-									  : writePosition() - readPosition());
+									  : write_position() - read_position());
 }
 
 /*
  * If write is ahead then it's the simple distance again. If read is ahead it's
  * until the end of the buffer/segment
  */
-size_t RingBuffer::readSegmentLength(size_t offset) const {
-	size_t read_composite = readCompositeLength();
+size_t ring_buffer::read_segment_length(size_t offset) const {
+	size_t read_composite = read_composite_length();
 	assert(offset <= read_composite);
 	offset = std::min(offset, read_composite);
 	size_t remaining = read_composite - offset;
 
-	size_t read_offset = readPosition() + offset;
+	size_t read_offset = read_position() + offset;
 	read_offset = read_offset >= buffer_.size() ? read_offset - buffer_.size()
 												: read_offset;
 
@@ -233,11 +233,11 @@ size_t RingBuffer::readSegmentLength(size_t offset) const {
 	// then it is set to zero by readCompositeLength()
 	// case 3 write is located after read
 	// since std::min you can use simple subtraction
-	if (writePosition() < read_offset) {
+	if (write_position() < read_offset) {
 		return buffer_.size() - read_offset;
 	}
 
-	if (writePosition() == read_offset) {
+	if (write_position() == read_offset) {
 		if (remaining > 0) {
 			return buffer_.size() - read_offset;
 		} else {
@@ -245,11 +245,11 @@ size_t RingBuffer::readSegmentLength(size_t offset) const {
 		}
 	}
 
-	return writePosition() - read_offset;
+	return write_position() - read_offset;
 }
 
-void RingBuffer::readAdvance(size_t bytes) {
-	size_t read_composite = readCompositeLength();
+void ring_buffer::read_advance(size_t bytes) {
+	size_t read_composite = read_composite_length();
 
 	assert(bytes <= read_composite);
 	bytes = std::min(bytes, read_composite);
@@ -259,36 +259,36 @@ void RingBuffer::readAdvance(size_t bytes) {
 	write_reached_read_ = bytes > 0 ? false : write_reached_read_;
 }
 
-uint8_t &RingBuffer::read(size_t i) {
-	assert(i < readCompositeLength());
+uint8_t &ring_buffer::read(size_t i) {
+	assert(i < read_composite_length());
 	size_t pos = read_position_ + i;
 	pos = pos >= buffer_.size() ? pos - buffer_.size() : pos;
 	return buffer_[pos];
 }
 
-const uint8_t &RingBuffer::read(size_t i) const {
-	assert(i < readCompositeLength());
+const uint8_t &ring_buffer::read(size_t i) const {
+	assert(i < read_composite_length());
 	size_t pos = read_position_ + i;
 	pos = pos >= buffer_.size() ? pos - buffer_.size() : pos;
 	return buffer_[pos];
 }
 
-size_t RingBuffer::writePosition() const { return write_position_; }
+size_t ring_buffer::write_position() const { return write_position_; }
 
-size_t RingBuffer::writeCompositeLength() const {
-	return readPosition() > writePosition()
-			   ? (readPosition() - writePosition())
+size_t ring_buffer::write_composite_length() const {
+	return read_position() > write_position()
+			   ? (read_position() - write_position())
 			   : (write_reached_read_
 					  ? 0
-					  : buffer_.size() - (writePosition() - readPosition()));
+					  : buffer_.size() - (write_position() - read_position()));
 }
 
-size_t RingBuffer::writeSegmentLength(size_t offset) const {
-	size_t write_composite = writeCompositeLength();
+size_t ring_buffer::write_segment_length(size_t offset) const {
+	size_t write_composite = write_composite_length();
 	assert(offset <= write_composite);
 	offset = std::min(offset, write_composite);
 
-	size_t write_offset = writePosition() + offset;
+	size_t write_offset = write_position() + offset;
 	write_offset = write_offset >= buffer_.size()
 					   ? write_offset - buffer_.size()
 					   : write_offset;
@@ -304,8 +304,8 @@ size_t RingBuffer::writeSegmentLength(size_t offset) const {
 	return buffer_.size() - write_offset;
 }
 
-void RingBuffer::writeAdvance(size_t bytes) {
-	assert(bytes <= writeCompositeLength());
+void ring_buffer::write_advance(size_t bytes) {
+	assert(bytes <= write_composite_length());
 	size_t advanced = write_position_ + bytes;
 	write_position_ = advanced >= buffer_.size() ? advanced - buffer_.size()
 												 : advanced;
@@ -314,15 +314,15 @@ void RingBuffer::writeAdvance(size_t bytes) {
 		(write_position_ == read_position_ && bytes > 0 ? true : false);
 }
 
-uint8_t &RingBuffer::write(size_t i) {
-	assert(i < writeCompositeLength());
+uint8_t &ring_buffer::write(size_t i) {
+	assert(i < write_composite_length());
 	size_t pos = write_position_ + i;
 	pos = pos >= buffer_.size() ? pos - buffer_.size() : pos;
 	return buffer_[pos];
 }
 
-const uint8_t &RingBuffer::write(size_t i) const {
-	assert(i < writeCompositeLength());
+const uint8_t &ring_buffer::write(size_t i) const {
+	assert(i < write_composite_length());
 	size_t pos = write_position_ + i;
 	pos = pos >= buffer_.size() ? pos - buffer_.size() : pos;
 	return buffer_[pos];
@@ -345,26 +345,27 @@ const uint8_t &RingBuffer::write(size_t i) const {
 		return noError();
 	}
 */
-Error RingBuffer::writeRequireLength(size_t bytes) {
-	size_t write_remain = writeCompositeLength();
+error ring_buffer::write_require_length(size_t bytes) {
+	size_t write_remain = write_composite_length();
 	if (bytes > write_remain) {
-		return recoverableError("Buffer too small");
+		return recoverable_error("Buffer too small");
 	}
-	return noError();
+	return no_error();
 }
 
-ArrayBuffer::ArrayBuffer(size_t size) : read_position_{0}, write_position_{0} {
+array_buffer::array_buffer(size_t size)
+	: read_position_{0}, write_position_{0} {
 	buffer_.resize(size);
 }
 
-size_t ArrayBuffer::readPosition() const { return read_position_; }
+size_t array_buffer::read_position() const { return read_position_; }
 
-size_t ArrayBuffer::readCompositeLength() const {
+size_t array_buffer::read_composite_length() const {
 	return write_position_ - read_position_;
 }
 
-size_t ArrayBuffer::readSegmentLength(size_t offset) const {
-	size_t read_composite = readCompositeLength();
+size_t array_buffer::read_segment_length(size_t offset) const {
+	size_t read_composite = read_composite_length();
 	assert(offset <= read_composite);
 
 	offset = std::min(read_composite, offset);
@@ -373,33 +374,33 @@ size_t ArrayBuffer::readSegmentLength(size_t offset) const {
 	return write_position_ - read_offset;
 }
 
-void ArrayBuffer::readAdvance(size_t bytes) {
-	assert(bytes <= readCompositeLength());
+void array_buffer::read_advance(size_t bytes) {
+	assert(bytes <= read_composite_length());
 	read_position_ += bytes;
 }
 
-uint8_t &ArrayBuffer::read(size_t i) {
-	assert(i < readCompositeLength());
+uint8_t &array_buffer::read(size_t i) {
+	assert(i < read_composite_length());
 
 	return buffer_[i + read_position_];
 }
 
-const uint8_t &ArrayBuffer::read(size_t i) const {
+const uint8_t &array_buffer::read(size_t i) const {
 	assert(i + read_position_ < buffer_.size());
 
 	return buffer_[i + read_position_];
 }
 
-size_t ArrayBuffer::writePosition() const { return write_position_; }
+size_t array_buffer::write_position() const { return write_position_; }
 
-size_t ArrayBuffer::writeCompositeLength() const {
+size_t array_buffer::write_composite_length() const {
 	assert(write_position_ <= buffer_.size());
 	return buffer_.size() - write_position_;
 }
 
-size_t ArrayBuffer::writeSegmentLength(size_t offset) const {
+size_t array_buffer::write_segment_length(size_t offset) const {
 	assert(write_position_ <= buffer_.size());
-	size_t write_composite = writeCompositeLength();
+	size_t write_composite = write_composite_length();
 
 	assert(offset <= write_composite);
 	offset = std::min(write_composite, offset);
@@ -408,26 +409,26 @@ size_t ArrayBuffer::writeSegmentLength(size_t offset) const {
 	return buffer_.size() - write_offset;
 }
 
-void ArrayBuffer::writeAdvance(size_t bytes) {
-	assert(bytes <= writeCompositeLength());
+void array_buffer::write_advance(size_t bytes) {
+	assert(bytes <= write_composite_length());
 	write_position_ += bytes;
 }
 
-uint8_t &ArrayBuffer::write(size_t i) {
-	assert(i < writeCompositeLength());
+uint8_t &array_buffer::write(size_t i) {
+	assert(i < write_composite_length());
 	return buffer_[i + write_position_];
 }
 
-const uint8_t &ArrayBuffer::write(size_t i) const {
-	assert(i < writeCompositeLength());
+const uint8_t &array_buffer::write(size_t i) const {
+	assert(i < write_composite_length());
 	return buffer_[i + write_position_];
 }
-Error ArrayBuffer::writeRequireLength(size_t bytes) {
-	size_t write_remain = writeCompositeLength();
+error array_buffer::write_require_length(size_t bytes) {
+	size_t write_remain = write_composite_length();
 	if (bytes > write_remain) {
-		return recoverableError("Buffer too small");
+		return recoverable_error("Buffer too small");
 	}
-	return noError();
+	return no_error();
 }
 
 } // namespace saw
diff --git a/source/forstio/buffer.h b/source/forstio/buffer.h
index e2ebeab..4485ff1 100644
--- a/source/forstio/buffer.h
+++ b/source/forstio/buffer.h
@@ -13,23 +13,23 @@ namespace saw {
 /*
  * Access class to reduce templated BufferSegments bloat
  */
-class Buffer {
+class buffer {
 protected:
-	~Buffer() = default;
+	~buffer() = default;
 
 public:
-	virtual size_t readPosition() const = 0;
-	virtual size_t readCompositeLength() const = 0;
-	virtual size_t readSegmentLength(size_t offset = 0) const = 0;
-	virtual void readAdvance(size_t bytes) = 0;
+	virtual size_t read_position() const = 0;
+	virtual size_t read_composite_length() const = 0;
+	virtual size_t read_segment_length(size_t offset = 0) const = 0;
+	virtual void read_advance(size_t bytes) = 0;
 
 	virtual uint8_t &read(size_t i = 0) = 0;
 	virtual const uint8_t &read(size_t i = 0) const = 0;
 
-	virtual size_t writePosition() const = 0;
-	virtual size_t writeCompositeLength() const = 0;
-	virtual size_t writeSegmentLength(size_t offset = 0) const = 0;
-	virtual void writeAdvance(size_t bytes) = 0;
+	virtual size_t write_position() const = 0;
+	virtual size_t write_composite_length() const = 0;
+	virtual size_t write_segment_length(size_t offset = 0) const = 0;
+	virtual void write_advance(size_t bytes) = 0;
 
 	virtual uint8_t &write(size_t i = 0) = 0;
 	virtual const uint8_t &write(size_t i = 0) const = 0;
@@ -40,50 +40,53 @@ public:
 	 * There is nothing you can do if read hasn't been filled, but at
 	 * least write can be increased if it is demanded.
 	 */
-	virtual Error writeRequireLength(size_t bytes) = 0;
+	virtual error write_require_length(size_t bytes) = 0;
 
-	Error push(const uint8_t &value);
-	Error push(const uint8_t &buffer, size_t size);
-	Error pop(uint8_t &value);
-	Error pop(uint8_t &buffer, size_t size);
+	error push(const uint8_t &value);
+	error push(const uint8_t &buffer, size_t size);
+	error pop(uint8_t &value);
+	error pop(uint8_t &buffer, size_t size);
 
-	std::string toString() const;
-	std::string toHex() const;
+	/*
+	 * Subject to change
+	 */
+	std::string to_string() const;
+	std::string to_hex() const;
 };
 
 /*
  *	A viewer class for buffers.
  *	Working on the reference buffer invalidates the buffer view
  */
-class BufferView : public Buffer {
+class buffer_view : public buffer {
 private:
-	Buffer &buffer_;
+	buffer &buffer_;
 	size_t read_offset_;
 	size_t write_offset_;
 
 public:
-	BufferView(Buffer &);
+	buffer_view(buffer &);
 
-	size_t readPosition() const override;
-	size_t readCompositeLength() const override;
-	size_t readSegmentLength(size_t offset = 0) const override;
-	void readAdvance(size_t bytes) override;
+	size_t read_position() const override;
+	size_t read_composite_length() const override;
+	size_t read_segment_length(size_t offset = 0) const override;
+	void read_advance(size_t bytes) override;
 
 	uint8_t &read(size_t i = 0) override;
 	const uint8_t &read(size_t i = 0) const override;
 
-	size_t writePosition() const override;
-	size_t writeCompositeLength() const override;
-	size_t writeSegmentLength(size_t offset = 0) const override;
-	void writeAdvance(size_t bytes) override;
+	size_t write_position() const override;
+	size_t write_composite_length() const override;
+	size_t write_segment_length(size_t offset = 0) const override;
+	void write_advance(size_t bytes) override;
 
 	uint8_t &write(size_t i = 0) override;
 	const uint8_t &write(size_t i = 0) const override;
 
-	Error writeRequireLength(size_t bytes) override;
+	error write_require_length(size_t bytes) override;
 
-	size_t readOffset() const;
-	size_t writeOffset() const;
+	size_t read_offset() const;
+	size_t write_offset() const;
 };
 
 /*
@@ -94,7 +97,7 @@ constexpr size_t RING_BUFFER_MAX_SIZE = 4096;
 /*
  * Buffer wrapping around if read caught up
  */
-class RingBuffer final : public Buffer {
+class ring_buffer final : public buffer {
 private:
 	std::vector<uint8_t> buffer_;
 	size_t read_position_;
@@ -102,37 +105,37 @@ private:
 	bool write_reached_read_ = false;
 
 public:
-	RingBuffer();
-	RingBuffer(size_t size);
+	ring_buffer();
+	ring_buffer(size_t size);
 
 	inline size_t size() const { return buffer_.size(); }
 
 	inline uint8_t &operator[](size_t i) { return buffer_[i]; }
 	inline const uint8_t &operator[](size_t i) const { return buffer_[i]; }
 
-	size_t readPosition() const override;
-	size_t readCompositeLength() const override;
-	size_t readSegmentLength(size_t offset = 0) const override;
-	void readAdvance(size_t bytes) override;
+	size_t read_position() const override;
+	size_t read_composite_length() const override;
+	size_t read_segment_length(size_t offset = 0) const override;
+	void read_advance(size_t bytes) override;
 
 	uint8_t &read(size_t i = 0) override;
 	const uint8_t &read(size_t i = 0) const override;
 
-	size_t writePosition() const override;
-	size_t writeCompositeLength() const override;
-	size_t writeSegmentLength(size_t offset = 0) const override;
-	void writeAdvance(size_t bytes) override;
+	size_t write_position() const override;
+	size_t write_composite_length() const override;
+	size_t write_segment_length(size_t offset = 0) const override;
+	void write_advance(size_t bytes) override;
 
 	uint8_t &write(size_t i = 0) override;
 	const uint8_t &write(size_t i = 0) const override;
 
-	Error writeRequireLength(size_t bytes) override;
+	error write_require_length(size_t bytes) override;
 };
 
 /*
  * One time buffer
  */
-class ArrayBuffer : public Buffer {
+class array_buffer : public buffer {
 private:
 	std::vector<uint8_t> buffer_;
 
@@ -140,53 +143,53 @@ private:
 	size_t write_position_;
 
 public:
-	ArrayBuffer(size_t size);
+	array_buffer(size_t size);
 
-	size_t readPosition() const override;
-	size_t readCompositeLength() const override;
-	size_t readSegmentLength(size_t offset = 0) const override;
-	void readAdvance(size_t bytes) override;
+	size_t read_position() const override;
+	size_t read_composite_length() const override;
+	size_t read_segment_length(size_t offset = 0) const override;
+	void read_advance(size_t bytes) override;
 
 	uint8_t &read(size_t i = 0) override;
 	const uint8_t &read(size_t i = 0) const override;
 
-	size_t writePosition() const override;
-	size_t writeCompositeLength() const override;
-	size_t writeSegmentLength(size_t offset = 0) const override;
-	void writeAdvance(size_t bytes) override;
+	size_t write_position() const override;
+	size_t write_composite_length() const override;
+	size_t write_segment_length(size_t offset = 0) const override;
+	void write_advance(size_t bytes) override;
 
 	uint8_t &write(size_t i = 0) override;
 	const uint8_t &write(size_t i = 0) const override;
 
-	Error writeRequireLength(size_t bytes) override;
+	error write_require_length(size_t bytes) override;
 };
 
-class ChainArrayBuffer : public Buffer {
+class chain_array_buffer : public buffer {
 private:
-	std::deque<ArrayBuffer> buffer_;
+	std::deque<array_buffer> buffer_;
 
 	size_t read_position_;
 	size_t write_position_;
 
 public:
-	ChainArrayBuffer();
+	chain_array_buffer();
 
-	size_t readPosition() const override;
-	size_t readCompositeLength() const override;
-	size_t readSegmentLength(size_t offset = 0) const override;
-	void readAdvance(size_t bytes) override;
+	size_t read_position() const override;
+	size_t read_composite_length() const override;
+	size_t read_segment_length(size_t offset = 0) const override;
+	void read_advance(size_t bytes) override;
 
 	uint8_t &read(size_t i = 0) override;
 	const uint8_t &read(size_t i = 0) const override;
 
-	size_t writePosition() const override;
-	size_t writeCompositeLength() const override;
-	size_t writeSegmentLength(size_t offset = 0) const override;
-	void writeAdvance(size_t bytes) override;
+	size_t write_position() const override;
+	size_t write_composite_length() const override;
+	size_t write_segment_length(size_t offset = 0) const override;
+	void write_advance(size_t bytes) override;
 
 	uint8_t &write(size_t i = 0) override;
 	const uint8_t &write(size_t i = 0) const override;
 
-	Error writeRequireLength(size_t bytes) override;
+	error write_require_length(size_t bytes) override;
 };
 } // namespace saw
diff --git a/source/forstio/common.h b/source/forstio/common.h
index b5239aa..3b4bd04 100644
--- a/source/forstio/common.h
+++ b/source/forstio/common.h
@@ -32,43 +32,43 @@ namespace saw {
 	assert(expression);                                                        \
 	if (!(expression)) [[unlikely]]
 
-template <typename T> using Maybe = std::optional<T>;
+template <typename T> using maybe = std::optional<T>;
 
-template <typename T> using Own = std::unique_ptr<T>;
+template <typename T> using own = std::unique_ptr<T>;
 
-template <typename T> using Our = std::shared_ptr<T>;
+template <typename T> using our = std::shared_ptr<T>;
 
-template <typename T> using Lent = std::weak_ptr<T>;
+template <typename T> using lent = std::weak_ptr<T>;
 
-template <typename T, class... Args> Own<T> heap(Args &&...args) {
-	return Own<T>(new T(std::forward<Args>(args)...));
+template <typename T, class... Args> own<T> heap(Args &&...args) {
+	return own<T>(new T(std::forward<Args>(args)...));
 }
 
-template <typename T, class... Args> Our<T> share(Args &&...args) {
+template <typename T, class... Args> our<T> share(Args &&...args) {
 	return std::make_shared<T>(std::forward<Args>(args)...);
 }
 
 template <typename T> T instance() noexcept;
 
-template <typename Func, typename T> struct ReturnTypeHelper {
+template <typename Func, typename T> struct return_type_helper {
 	typedef decltype(instance<Func>()(instance<T>())) Type;
 };
-template <typename Func> struct ReturnTypeHelper<Func, void> {
+template <typename Func> struct return_type_helper<Func, void> {
 	typedef decltype(instance<Func>()()) Type;
 };
 
 template <typename Func, typename T>
-using ReturnType = typename ReturnTypeHelper<Func, T>::Type;
+using return_type = typename return_type_helper<Func, T>::Type;
 
 struct Void {};
 
-template <typename T> struct VoidFix { typedef T Type; };
-template <> struct VoidFix<void> { typedef Void Type; };
-template <typename T> using FixVoid = typename VoidFix<T>::Type;
+template <typename T> struct void_fix { typedef T Type; };
+template <> struct void_fix<void> { typedef Void Type; };
+template <typename T> using fix_void = typename void_fix<T>::Type;
 
-template <typename T> struct VoidUnfix { typedef T Type; };
-template <> struct VoidUnfix<Void> { typedef void Type; };
-template <typename T> using UnfixVoid = typename VoidUnfix<T>::Type;
+template <typename T> struct void_unfix { typedef T Type; };
+template <> struct void_unfix<Void> { typedef void Type; };
+template <typename T> using unfix_void = typename void_unfix<T>::Type;
 
 template <typename... T> constexpr bool always_false = false;
 
diff --git a/source/forstio/error.cpp b/source/forstio/error.cpp
index 685e92d..757e6a8 100644
--- a/source/forstio/error.cpp
+++ b/source/forstio/error.cpp
@@ -1,19 +1,19 @@
 #include "error.h"
 
 namespace saw {
-Error::Error() : error_{static_cast<Error::Code>(0)} {}
+error::error() : error_{static_cast<error::code>(0)} {}
 
-Error::Error(const std::string_view &msg, Error::Code code)
-	: error_message_{msg}, error_{static_cast<Error::Code>(code)} {}
+error::error(const std::string_view &msg, error::code code)
+	: error_message_{msg}, error_{static_cast<error::code>(code)} {}
 
-Error::Error(std::string &&msg, Error::Code code)
-	: error_message_{std::move(msg)}, error_{static_cast<Error::Code>(code)} {}
+error::error(std::string &&msg, error::code code)
+	: error_message_{std::move(msg)}, error_{static_cast<error::code>(code)} {}
 
-Error::Error(Error &&error)
+error::error(error &&error)
 	: error_message_{std::move(error.error_message_)}, error_{std::move(
 														   error.error_)} {}
 
-const std::string_view Error::message() const {
+const std::string_view error::message() const {
 
 	return std::visit(
 		[this](auto &&arg) -> const std::string_view {
@@ -30,20 +30,20 @@ const std::string_view Error::message() const {
 		error_message_);
 }
 
-bool Error::failed() const {
-	return static_cast<std::underlying_type_t<Error::Code>>(error_) != 0;
+bool error::failed() const {
+	return static_cast<std::underlying_type_t<error::code>>(error_) != 0;
 }
 
-bool Error::isCritical() const {
-	return static_cast<std::underlying_type_t<Error::Code>>(error_) < 0;
+bool error::is_critical() const {
+	return static_cast<std::underlying_type_t<error::code>>(error_) < 0;
 }
 
-bool Error::isRecoverable() const {
-	return static_cast<std::underlying_type_t<Error::Code>>(error_) > 0;
+bool error::is_recoverable() const {
+	return static_cast<std::underlying_type_t<error::code>>(error_) > 0;
 }
 
-Error Error::copyError() const {
-	Error error;
+error error::copy_error() const {
+	error error;
 	error.error_ = error_;
 	try {
 		error.error_message_ = error_message_;
@@ -54,20 +54,20 @@ Error Error::copyError() const {
 	return error;
 }
 
-Error::Code Error::code() const { return static_cast<Error::Code>(error_); }
+error::code error::id() const { return static_cast<error::code>(error_); }
 
-Error makeError(const std::string_view &generic, Error::Code code) {
-	return Error{generic, code};
+error make_error(const std::string_view &generic, error::code code) {
+	return error{generic, code};
 }
 
-Error criticalError(const std::string_view &generic, Error::Code c) {
-	return makeError(generic, c);
+error critical_error(const std::string_view &generic, error::code c) {
+	return make_error(generic, c);
 }
 
-Error recoverableError(const std::string_view &generic, Error::Code c) {
-	return makeError(generic, c);
+error recoverable_error(const std::string_view &generic, error::code c) {
+	return make_error(generic, c);
 }
 
-Error noError() { return Error{}; }
+error no_error() { return error{}; }
 
 } // namespace saw
diff --git a/source/forstio/error.h b/source/forstio/error.h
index 7e951b1..63aacaf 100644
--- a/source/forstio/error.h
+++ b/source/forstio/error.h
@@ -14,9 +14,9 @@ namespace saw {
  * critical and recoverable errors. Additional code ids can be provided to the
  * constructor if additional distinctions are necessary.
  */
-class Error {
+class error {
 public:
-	enum class Code : int16_t {
+	enum class code : int16_t {
 		GenericCritical = -1,
 		GenericRecoverable = 1,
 		Disconnected = -99,
@@ -25,119 +25,124 @@ public:
 
 private:
 	std::variant<std::string_view, std::string> error_message_;
-	Code error_;
+	code error_;
 
 public:
-	Error();
-	Error(const std::string_view &msg, Error::Code code);
-	Error(std::string &&msg, Error::Code code);
-	Error(Error &&error);
+	error();
+	error(const std::string_view &msg, error::code id);
+	error(std::string &&msg, error::code id);
+	error(error &&error);
 
-	SAW_FORBID_COPY(Error);
+	SAW_FORBID_COPY(error);
 
-	Error &operator=(Error &&) = default;
+	error &operator=(error &&) = default;
 
 	const std::string_view message() const;
 	bool failed() const;
 
-	bool isCritical() const;
-	bool isRecoverable() const;
+	bool is_critical() const;
+	bool is_recoverable() const;
 
-	Error copyError() const;
+	error copy_error() const;
 
-	Code code() const;
+	code id() const;
 };
 
-Error makeError(const std::string_view &generic, Error::Code c);
+error make_error(const std::string_view &generic, error::code c);
 
 template <typename Formatter>
-Error makeError(const Formatter &formatter, Error::Code code,
-				const std::string_view &generic) {
+error make_error(const Formatter &formatter, error::code code,
+				 const std::string_view &generic) {
 	try {
 		std::string error_msg = formatter();
-		return Error{std::move(error_msg), code};
+		return error{std::move(error_msg), code};
 	} catch (std::bad_alloc &) {
-		return Error{generic, code};
+		return error{generic, code};
 	}
 }
 
-Error criticalError(const std::string_view &generic,
-					Error::Code c = Error::Code::GenericCritical);
+error critical_error(const std::string_view &generic,
+					 error::code c = error::code::GenericCritical);
 
 template <typename Formatter>
-Error criticalError(const Formatter &formatter, const std::string_view &generic,
-					Error::Code c = Error::Code::GenericCritical) {
-	return makeError(formatter, c, generic);
+error critical_error(const Formatter &formatter,
+					 const std::string_view &generic,
+					 error::code c = error::code::GenericCritical) {
+	return make_error(formatter, c, generic);
 }
 
-Error recoverableError(const std::string_view &generic,
-					   Error::Code c = Error::Code::GenericRecoverable);
+error recoverable_error(const std::string_view &generic,
+						error::code c = error::code::GenericRecoverable);
 
 template <typename Formatter>
-Error recoverableError(const Formatter &formatter,
-					   const std::string_view &generic,
-					   Error::Code c = Error::Code::GenericRecoverable) {
-	return makeError(formatter, c, generic);
+error recoverable_error(const Formatter &formatter,
+						const std::string_view &generic,
+						error::code c = error::code::GenericRecoverable) {
+	return make_error(formatter, c, generic);
 }
 
-Error noError();
+error no_error();
 
 /**
  * Exception alternative. Since I code without exceptions this class is
  * essentially a kind of exception replacement.
  */
-template <typename T> class ErrorOr;
+template <typename T> class error_or;
 
-class ErrorOrValue {
+class error_or_value {
 public:
-	virtual ~ErrorOrValue() = default;
+	virtual ~error_or_value() = default;
 
-	template <typename T> ErrorOr<UnfixVoid<T>> &as() {
-		return static_cast<ErrorOr<UnfixVoid<T>> &>(*this);
+	template <typename T> error_or<unfix_void<T>> &as() {
+		return static_cast<error_or<unfix_void<T>> &>(*this);
 	}
 
-	template <typename T> const ErrorOr<UnfixVoid<T>> &as() const {
-		return static_cast<const ErrorOr<UnfixVoid<T>> &>(*this);
+	template <typename T> const error_or<unfix_void<T>> &as() const {
+		return static_cast<const error_or<unfix_void<T>> &>(*this);
 	}
 };
 
-template <typename T> class ErrorOr final : public ErrorOrValue {
+template <typename T> class error_or final : public error_or_value {
 private:
-	std::variant<Error, FixVoid<T>> value_or_error_;
+	std::variant<error, fix_void<T>> value_or_error_;
 
 	static_assert(!std::is_same_v<T, Void>, "Don't use internal private types");
 
 public:
-	ErrorOr() = default;
-	ErrorOr(const FixVoid<T> &value) : value_or_error_{value} {}
+	error_or() = default;
+	error_or(const fix_void<T> &value) : value_or_error_{value} {}
 
-	ErrorOr(FixVoid<T> &&value) : value_or_error_{std::move(value)} {}
+	error_or(fix_void<T> &&value) : value_or_error_{std::move(value)} {}
 
-	ErrorOr(const Error &error) : value_or_error_{error} {}
-	ErrorOr(Error &&error) : value_or_error_{std::move(error)} {}
+	error_or(const error &error) : value_or_error_{error} {}
+	error_or(error &&error) : value_or_error_{std::move(error)} {}
 
-	bool isValue() const {
-		return std::holds_alternative<FixVoid<T>>(value_or_error_);
+	bool is_value() const {
+		return std::holds_alternative<fix_void<T>>(value_or_error_);
 	}
 
-	bool isError() const {
-		return std::holds_alternative<Error>(value_or_error_);
+	bool is_error() const {
+		return std::holds_alternative<class error>(value_or_error_);
 	}
 
-	Error &error() { return std::get<Error>(value_or_error_); }
+	class error &error() {
+		return std::get<class error>(value_or_error_);
+	}
 
-	const Error &error() const { return std::get<Error>(value_or_error_); }
+	const class error &error() const {
+		return std::get<class error>(value_or_error_);
+	}
 
-	FixVoid<T> &value() { return std::get<FixVoid<T>>(value_or_error_); }
+	fix_void<T> &value() { return std::get<fix_void<T>>(value_or_error_); }
 
-	const FixVoid<T> &value() const {
-		return std::get<FixVoid<T>>(value_or_error_);
+	const fix_void<T> &value() const {
+		return std::get<fix_void<T>>(value_or_error_);
 	}
 };
 
-template <typename T> class ErrorOr<ErrorOr<T>> {
+template <typename T> class error_or<error_or<T>> {
 private:
-	ErrorOr() = delete;
+	error_or() = delete;
 };
 
 } // namespace saw
diff --git a/source/forstio/io.cpp b/source/forstio/io.cpp
index 6bb4b1d..c6ef90c 100644
--- a/source/forstio/io.cpp
+++ b/source/forstio/io.cpp
@@ -4,15 +4,15 @@
 
 namespace saw {
 
-AsyncIoStream::AsyncIoStream(Own<IoStream> str)
+async_io_stream::async_io_stream(own<io_stream> str)
 	: stream_{std::move(str)},
-	  read_ready_{stream_->readReady()
-					  .then([this]() { read_stepper_.readStep(*stream_); })
+	  read_ready_{stream_->read_ready()
+					  .then([this]() { read_stepper_.read_step(*stream_); })
 					  .sink()},
-	  write_ready_{stream_->writeReady()
+	  write_ready_{stream_->write_ready()
 					   .then([this]() { write_stepper_.writeStep(*stream_); })
 					   .sink()},
-	  read_disconnected_{stream_->onReadDisconnected()
+	  read_disconnected_{stream_->on_read_disconnected()
 							 .then([this]() {
 								 if (read_stepper_.on_read_disconnect) {
 									 read_stepper_.on_read_disconnect->feed();
@@ -20,51 +20,51 @@ AsyncIoStream::AsyncIoStream(Own<IoStream> str)
 							 })
 							 .sink()} {}
 
-void AsyncIoStream::read(void *buffer, size_t min_length, size_t max_length) {
+void async_io_stream::read(void *buffer, size_t min_length, size_t max_length) {
 	SAW_ASSERT(buffer && max_length >= min_length && min_length > 0) { return; }
 
 	SAW_ASSERT(!read_stepper_.read_task.has_value()) { return; }
 
-	read_stepper_.read_task =
-		ReadTaskAndStepHelper::ReadIoTask{buffer, min_length, max_length, 0};
-	read_stepper_.readStep(*stream_);
+	read_stepper_.read_task = read_task_and_step_helper::read_io_task{
+		buffer, min_length, max_length, 0};
+	read_stepper_.read_step(*stream_);
 }
 
-Conveyor<size_t> AsyncIoStream::readDone() {
-	auto caf = newConveyorAndFeeder<size_t>();
+conveyor<size_t> async_io_stream::read_done() {
+	auto caf = new_conveyor_and_feeder<size_t>();
 	read_stepper_.read_done = std::move(caf.feeder);
 	return std::move(caf.conveyor);
 }
 
-Conveyor<void> AsyncIoStream::onReadDisconnected() {
-	auto caf = newConveyorAndFeeder<void>();
+conveyor<void> async_io_stream::on_read_disconnected() {
+	auto caf = new_conveyor_and_feeder<void>();
 	read_stepper_.on_read_disconnect = std::move(caf.feeder);
 	return std::move(caf.conveyor);
 }
 
-void AsyncIoStream::write(const void *buffer, size_t length) {
+void async_io_stream::write(const void *buffer, size_t length) {
 	SAW_ASSERT(buffer && length > 0) { return; }
 
 	SAW_ASSERT(!write_stepper_.write_task.has_value()) { return; }
 
 	write_stepper_.write_task =
-		WriteTaskAndStepHelper::WriteIoTask{buffer, length, 0};
+		write_task_and_step_helper::write_io_task{buffer, length, 0};
 	write_stepper_.writeStep(*stream_);
 }
 
-Conveyor<size_t> AsyncIoStream::writeDone() {
-	auto caf = newConveyorAndFeeder<size_t>();
+conveyor<size_t> async_io_stream::write_done() {
+	auto caf = new_conveyor_and_feeder<size_t>();
 	write_stepper_.write_done = std::move(caf.feeder);
 	return std::move(caf.conveyor);
 }
 
-StringNetworkAddress::StringNetworkAddress(const std::string &address,
-										   uint16_t port)
+string_network_address::string_network_address(const std::string &address,
+											   uint16_t port)
 	: address_value_{address}, port_value_{port} {}
 
-const std::string &StringNetworkAddress::address() const {
+const std::string &string_network_address::address() const {
 	return address_value_;
 }
 
-uint16_t StringNetworkAddress::port() const { return port_value_; }
+uint16_t string_network_address::port() const { return port_value_; }
 } // namespace saw
diff --git a/source/forstio/io.h b/source/forstio/io.h
index 8f32faf..395a257 100644
--- a/source/forstio/io.h
+++ b/source/forstio/io.h
@@ -11,155 +11,156 @@ namespace saw {
 /*
  * Input stream
  */
-class InputStream {
+class input_stream {
 public:
-	virtual ~InputStream() = default;
+	virtual ~input_stream() = default;
 
-	virtual ErrorOr<size_t> read(void *buffer, size_t length) = 0;
+	virtual error_or<size_t> read(void *buffer, size_t length) = 0;
 
-	virtual Conveyor<void> readReady() = 0;
+	virtual conveyor<void> read_ready() = 0;
 
-	virtual Conveyor<void> onReadDisconnected() = 0;
+	virtual conveyor<void> on_read_disconnected() = 0;
 };
 
 /*
  * Output stream
  */
-class OutputStream {
+class output_stream {
 public:
-	virtual ~OutputStream() = default;
+	virtual ~output_stream() = default;
 
-	virtual ErrorOr<size_t> write(const void *buffer, size_t length) = 0;
+	virtual error_or<size_t> write(const void *buffer, size_t length) = 0;
 
-	virtual Conveyor<void> writeReady() = 0;
+	virtual conveyor<void> write_ready() = 0;
 };
 
 /*
  * Io stream
  */
-class IoStream : public InputStream, public OutputStream {
+class io_stream : public input_stream, public output_stream {
 public:
-	virtual ~IoStream() = default;
+	virtual ~io_stream() = default;
 };
 
-class AsyncInputStream {
+class async_input_stream {
 public:
-	virtual ~AsyncInputStream() = default;
+	virtual ~async_input_stream() = default;
 
 	virtual void read(void *buffer, size_t min_length, size_t max_length) = 0;
 
-	virtual Conveyor<size_t> readDone() = 0;
-	virtual Conveyor<void> onReadDisconnected() = 0;
+	virtual conveyor<size_t> read_done() = 0;
+	virtual conveyor<void> on_read_disconnected() = 0;
 };
 
-class AsyncOutputStream {
+class async_output_stream {
 public:
-	virtual ~AsyncOutputStream() = default;
+	virtual ~async_output_stream() = default;
 
 	virtual void write(const void *buffer, size_t length) = 0;
 
-	virtual Conveyor<size_t> writeDone() = 0;
+	virtual conveyor<size_t> write_done() = 0;
 };
 
-class AsyncIoStream final : public AsyncInputStream, public AsyncOutputStream {
+class async_io_stream final : public async_input_stream,
+							  public async_output_stream {
 private:
-	Own<IoStream> stream_;
+	own<io_stream> stream_;
 
-	ConveyorSink read_ready_;
-	ConveyorSink write_ready_;
-	ConveyorSink read_disconnected_;
+	conveyor_sink read_ready_;
+	conveyor_sink write_ready_;
+	conveyor_sink read_disconnected_;
 
-	ReadTaskAndStepHelper read_stepper_;
-	WriteTaskAndStepHelper write_stepper_;
+	read_task_and_step_helper read_stepper_;
+	write_task_and_step_helper write_stepper_;
 
 public:
-	AsyncIoStream(Own<IoStream> str);
+	async_io_stream(own<io_stream> str);
 
-	SAW_FORBID_COPY(AsyncIoStream);
-	SAW_FORBID_MOVE(AsyncIoStream);
+	SAW_FORBID_COPY(async_io_stream);
+	SAW_FORBID_MOVE(async_io_stream);
 
 	void read(void *buffer, size_t length, size_t max_length) override;
 
-	Conveyor<size_t> readDone() override;
+	conveyor<size_t> read_done() override;
 
-	Conveyor<void> onReadDisconnected() override;
+	conveyor<void> on_read_disconnected() override;
 
 	void write(const void *buffer, size_t length) override;
 
-	Conveyor<size_t> writeDone() override;
+	conveyor<size_t> write_done() override;
 };
 
-class Server {
+class server {
 public:
-	virtual ~Server() = default;
+	virtual ~server() = default;
 
-	virtual Conveyor<Own<IoStream>> accept() = 0;
+	virtual conveyor<own<io_stream>> accept() = 0;
 };
 
-class NetworkAddress;
+class network_address;
 /**
  * Datagram class. Bound to a local address it is able to receive inbound
  * datagram messages and send them as well as long as an address is provided as
  * well
  */
-class Datagram {
+class datagram {
 public:
-	virtual ~Datagram() = default;
+	virtual ~datagram() = default;
 
-	virtual ErrorOr<size_t> read(void *buffer, size_t length) = 0;
-	virtual Conveyor<void> readReady() = 0;
+	virtual error_or<size_t> read(void *buffer, size_t length) = 0;
+	virtual conveyor<void> read_ready() = 0;
 
-	virtual ErrorOr<size_t> write(const void *buffer, size_t length,
-								  NetworkAddress &dest) = 0;
-	virtual Conveyor<void> writeReady() = 0;
+	virtual error_or<size_t> write(const void *buffer, size_t length,
+								   network_address &dest) = 0;
+	virtual conveyor<void> write_ready() = 0;
 };
 
-class OsNetworkAddress;
-class StringNetworkAddress;
+class os_network_address;
+class string_network_address;
 
-class NetworkAddress {
+class network_address {
 public:
-	using ChildVariant =
-		std::variant<OsNetworkAddress *, StringNetworkAddress *>;
+	using child_variant =
+		std::variant<os_network_address *, string_network_address *>;
 
-	virtual ~NetworkAddress() = default;
+	virtual ~network_address() = default;
 
-	virtual NetworkAddress::ChildVariant representation() = 0;
+	virtual network_address::child_variant representation() = 0;
 
 	virtual const std::string &address() const = 0;
 	virtual uint16_t port() const = 0;
 };
 
-class OsNetworkAddress : public NetworkAddress {
+class os_network_address : public network_address {
 public:
-	virtual ~OsNetworkAddress() = default;
+	virtual ~os_network_address() = default;
 
-	NetworkAddress::ChildVariant representation() override { return this; }
+	network_address::child_variant representation() override { return this; }
 };
 
-class StringNetworkAddress final : public NetworkAddress {
+class string_network_address final : public network_address {
 private:
 	std::string address_value_;
 	uint16_t port_value_;
 
 public:
-	StringNetworkAddress(const std::string &address, uint16_t port);
+	string_network_address(const std::string &address, uint16_t port);
 
 	const std::string &address() const override;
 	uint16_t port() const override;
 
-	NetworkAddress::ChildVariant representation() override { return this; }
+	network_address::child_variant representation() override { return this; }
 };
 
-class Network {
+class network {
 public:
-	virtual ~Network() = default;
+	virtual ~network() = default;
 
 	/**
 	 * Resolve the provided string and uint16 to the preferred storage method
 	 */
-	virtual Conveyor<Own<NetworkAddress>>
-	resolveAddress(const std::string &addr, uint16_t port_hint = 0) = 0;
+	virtual conveyor<own<network_address>>
+	resolve_address(const std::string &addr, uint16_t port_hint = 0) = 0;
 
 	/**
 	 * Parse the provided string and uint16 to the preferred storage method
@@ -172,33 +173,33 @@ public:
 	/**
 	 * Set up a listener on this address
 	 */
-	virtual Own<Server> listen(NetworkAddress &bind_addr) = 0;
+	virtual own<server> listen(network_address &bind_addr) = 0;
 
 	/**
 	 * Connect to a remote address
 	 */
-	virtual Conveyor<Own<IoStream>> connect(NetworkAddress &address) = 0;
+	virtual conveyor<own<io_stream>> connect(network_address &address) = 0;
 
 	/**
 	 * Bind a datagram socket at this address.
 	 */
-	virtual Own<Datagram> datagram(NetworkAddress &address) = 0;
+	virtual own<datagram> datagram(network_address &address) = 0;
 };
 
-class IoProvider {
+class io_provider {
 public:
-	virtual ~IoProvider() = default;
+	virtual ~io_provider() = default;
 
-	virtual Own<InputStream> wrapInputFd(int fd) = 0;
+	virtual own<input_stream> wrap_input_fd(int fd) = 0;
 
-	virtual Network &network() = 0;
+	virtual network &network() = 0;
 };
 
-struct AsyncIoContext {
-	Own<IoProvider> io;
-	EventLoop &event_loop;
-	EventPort &event_port;
+struct async_io_context {
+	own<io_provider> io;
+	event_loop &event_loop;
+	event_port &event_port;
 };
 
-ErrorOr<AsyncIoContext> setupAsyncIo();
+error_or<async_io_context> setup_async_io();
 } // namespace saw
diff --git a/source/forstio/io_auth.cpp b/source/forstio/io_auth.cpp
index 77bea8d..223189b 100644
--- a/source/forstio/io_auth.cpp
+++ b/source/forstio/io_auth.cpp
@@ -1,8 +1,8 @@
 #include "io_auth.h"
 
 namespace saw {
-Peer::Peer(const std::string &identity_) : identity_value_{identity_} {}
-Peer::Peer(std::string &&identity_) : identity_value_{std::move(identity_)} {}
+peer::peer(const std::string &identity_) : identity_value_{identity_} {}
+peer::peer(std::string &&identity_) : identity_value_{std::move(identity_)} {}
 
-const std::string &Peer::identity() const { return identity_value_; }
+const std::string &peer::identity() const { return identity_value_; }
 } // namespace saw
diff --git a/source/forstio/io_auth.h b/source/forstio/io_auth.h
index cea968e..4b107d5 100644
--- a/source/forstio/io_auth.h
+++ b/source/forstio/io_auth.h
@@ -3,10 +3,10 @@
 #include "io.h"
 
 namespace saw {
-class Peer {
+class peer {
 public:
-	Peer(const std::string &ident);
-	Peer(std::string &&ident);
+	peer(const std::string &ident);
+	peer(std::string &&ident);
 
 	const std::string &identity() const;
 
@@ -14,40 +14,40 @@ private:
 	std::string identity_value_;
 };
 
-class AuthenticatedIoStream {
+class authenticated_io_stream {
 public:
 	// This is the easiest way to implement Authenticated streams.
 	// This is a simple pair of the stream and the peer.
 
-	Own<IoStream> stream;
-	Maybe<Own<Peer>> peer;
+	own<io_stream> stream;
+	maybe<own<peer>> peer;
 };
 
-class AuthenticatedServer {
+class authenticated_server {
 public:
-	virtual ~AuthenticatedServer() = default;
+	virtual ~authenticated_server() = default;
 
-	virtual Conveyor<AuthenticatedIoStream> accept() = 0;
+	virtual conveyor<authenticated_io_stream> accept() = 0;
 };
 
 /**
  * Authenticated Network class which provides a peer identity when connecting
  */
-class AuthenticatedNetwork {
+class authenticated_network {
 public:
-	virtual ~AuthenticatedNetwork() = default;
+	virtual ~authenticated_network() = default;
 
 	/**
 	 * Connects to the provided address.
 	 * Returns as soon as it is authenticated or fails
 	 */
-	virtual Conveyor<AuthenticatedIoStream>
-	connect(NetworkAddress &address) = 0;
+	virtual conveyor<authenticated_io_stream>
+	connect(network_address &address) = 0;
 
 	/**
 	 * Creates a server listening for connections
 	 */
-	virtual Own<AuthenticatedServer> listen() = 0;
+	virtual own<authenticated_server> listen() = 0;
 };
 
 } // namespace saw
diff --git a/source/forstio/io_helpers.cpp b/source/forstio/io_helpers.cpp
index 5868cc5..0b0ebf0 100644
--- a/source/forstio/io_helpers.cpp
+++ b/source/forstio/io_helpers.cpp
@@ -5,22 +5,22 @@
 #include <cassert>
 
 namespace saw {
-void ReadTaskAndStepHelper::readStep(InputStream &reader) {
+void read_task_and_step_helper::read_step(input_stream &reader) {
 	while (read_task.has_value()) {
-		ReadIoTask &task = *read_task;
+		read_io_task &task = *read_task;
 
-		ErrorOr<size_t> n_err = reader.read(task.buffer, task.max_length);
-		if (n_err.isError()) {
-			const Error &error = n_err.error();
-			if (error.isCritical()) {
+		error_or<size_t> n_err = reader.read(task.buffer, task.max_length);
+		if (n_err.is_error()) {
+			const error &error = n_err.error();
+			if (error.is_critical()) {
 				if (read_done) {
-					read_done->fail(error.copyError());
+					read_done->fail(error.copy_error());
 				}
 				read_task = std::nullopt;
 			}
 
 			break;
-		} else if (n_err.isValue()) {
+		} else if (n_err.is_value()) {
 			size_t n = n_err.value();
 			if (static_cast<size_t>(n) >= task.min_length &&
 				static_cast<size_t>(n) <= task.max_length) {
@@ -37,20 +37,20 @@ void ReadTaskAndStepHelper::readStep(InputStream &reader) {
 
 		} else {
 			if (read_done) {
-				read_done->fail(criticalError("Read failed"));
+				read_done->fail(critical_error("Read failed"));
 			}
 			read_task = std::nullopt;
 		}
 	}
 }
 
-void WriteTaskAndStepHelper::writeStep(OutputStream &writer) {
+void write_task_and_step_helper::writeStep(output_stream &writer) {
 	while (write_task.has_value()) {
-		WriteIoTask &task = *write_task;
+		write_io_task &task = *write_task;
 
-		ErrorOr<size_t> n_err = writer.write(task.buffer, task.length);
+		error_or<size_t> n_err = writer.write(task.buffer, task.length);
 
-		if (n_err.isValue()) {
+		if (n_err.is_value()) {
 
 			size_t n = n_err.value();
 			assert(n <= task.length);
@@ -64,18 +64,18 @@ void WriteTaskAndStepHelper::writeStep(OutputStream &writer) {
 				task.length -= n;
 				task.already_written += n;
 			}
-		} else if (n_err.isError()) {
-			const Error &error = n_err.error();
-			if (error.isCritical()) {
+		} else if (n_err.is_error()) {
+			const error &error = n_err.error();
+			if (error.is_critical()) {
 				if (write_done) {
-					write_done->fail(error.copyError());
+					write_done->fail(error.copy_error());
 				}
 				write_task = std::nullopt;
 			}
 			break;
 		} else {
 			if (write_done) {
-				write_done->fail(criticalError("Write failed"));
+				write_done->fail(critical_error("Write failed"));
 			}
 			write_task = std::nullopt;
 		}
diff --git a/source/forstio/io_helpers.h b/source/forstio/io_helpers.h
index f86b1c2..1c2626a 100644
--- a/source/forstio/io_helpers.h
+++ b/source/forstio/io_helpers.h
@@ -16,38 +16,38 @@ namespace saw {
  * and gnutls doesn't let me write or read into buffers I have to have this kind
  * of strange abstraction. This may also be reusable for windows/macOS though.
  */
-class InputStream;
+class input_stream;
 
-class ReadTaskAndStepHelper {
+class read_task_and_step_helper {
 public:
-	struct ReadIoTask {
+	struct read_io_task {
 		void *buffer;
 		size_t min_length;
 		size_t max_length;
 		size_t already_read = 0;
 	};
-	std::optional<ReadIoTask> read_task;
-	Own<ConveyorFeeder<size_t>> read_done = nullptr;
+	std::optional<read_io_task> read_task;
+	own<conveyor_feeder<size_t>> read_done = nullptr;
 
-	Own<ConveyorFeeder<void>> on_read_disconnect = nullptr;
+	own<conveyor_feeder<void>> on_read_disconnect = nullptr;
 
 public:
-	void readStep(InputStream &reader);
+	void read_step(input_stream &reader);
 };
 
-class OutputStream;
+class output_stream;
 
-class WriteTaskAndStepHelper {
+class write_task_and_step_helper {
 public:
-	struct WriteIoTask {
+	struct write_io_task {
 		const void *buffer;
 		size_t length;
 		size_t already_written = 0;
 	};
-	std::optional<WriteIoTask> write_task;
-	Own<ConveyorFeeder<size_t>> write_done = nullptr;
+	std::optional<write_io_task> write_task;
+	own<conveyor_feeder<size_t>> write_done = nullptr;
 
 public:
-	void writeStep(OutputStream &writer);
+	void writeStep(output_stream &writer);
 };
 } // namespace saw
diff --git a/source/forstio/io_peer.h b/source/forstio/io_peer.h
index 0376173..cc349f6 100644
--- a/source/forstio/io_peer.h
+++ b/source/forstio/io_peer.h
@@ -8,82 +8,82 @@
 namespace saw {
 
 template <typename Codec, typename Incoming, typename Outgoing,
-		  typename InContainer = MessageContainer<Incoming>,
-		  typename OutContainer = MessageContainer<Outgoing>,
-		  typename BufferT = RingBuffer>
-class StreamingIoPeer {
+		  typename InContainer = message_container<Incoming>,
+		  typename OutContainer = message_container<Outgoing>,
+		  typename BufferT = ring_buffer>
+class streaming_io_peer {
 public:
 	/**
 	 *
 	 */
-	StreamingIoPeer(
-		Own<ConveyorFeeder<HeapMessageRoot<Incoming, InContainer>>> feed,
-		Own<AsyncIoStream> stream, Codec codec, BufferT in, BufferT out);
+	streaming_io_peer(
+		own<conveyor_feeder<HeapMessageRoot<Incoming, InContainer>>> feed,
+		own<async_io_stream> stream, Codec codec, BufferT in, BufferT out);
 	/**
 	 *
 	 */
-	StreamingIoPeer(
-		Own<ConveyorFeeder<HeapMessageRoot<Incoming, InContainer>>> feed,
-		Own<AsyncIoStream> stream);
+	streaming_io_peer(
+		own<conveyor_feeder<HeapMessageRoot<Incoming, InContainer>>> feed,
+		own<async_io_stream> stream);
 
 	/**
 	 * Deleted copy and move constructors
 	 */
-	SAW_FORBID_COPY(StreamingIoPeer);
-	SAW_FORBID_MOVE(StreamingIoPeer);
+	SAW_FORBID_COPY(streaming_io_peer);
+	SAW_FORBID_MOVE(streaming_io_peer);
 
 	/**
 	 * Send a message to the remote peer
 	 */
-	Error send(HeapMessageRoot<Outgoing, OutContainer> builder);
+	error send(HeapMessageRoot<Outgoing, OutContainer> builder);
 
 	/**
 	 * A phantom conveyor feeder. Meant for interfacing with other components
 	 */
-	ConveyorFeeder<HeapMessageRoot<Outgoing, OutContainer>> &feeder();
+	conveyor_feeder<HeapMessageRoot<Outgoing, OutContainer>> &feeder();
 
-	Conveyor<void> onReadDisconnected();
+	conveyor<void> onReadDisconnected();
 
 private:
 	/// @unimplemented
-	class PeerConveyorFeeder final
-		: public ConveyorFeeder<HeapMessageRoot<Outgoing, OutContainer>> {
+	class peer_conveyor_feeder final
+		: public conveyor_feeder<HeapMessageRoot<Outgoing, OutContainer>> {
 	public:
-		PeerConveyorFeeder(
-			StreamingIoPeer<Codec, Incoming, Outgoing, InContainer,
-							OutContainer, BufferT> &peer_)
+		peer_conveyor_feeder(
+			streaming_io_peer<Codec, Incoming, Outgoing, InContainer,
+							  OutContainer, BufferT> &peer_)
 			: peer_{peer_} {}
 
 		void feed(HeapMessageRoot<Outgoing, OutContainer> &&data) override {
 			(void)data;
 		}
 
-		void fail(Error &&error) override { (void)error; }
+		void fail(error &&error) override { (void)error; }
 
 		size_t space() const override { return 0; }
 
 		size_t queued() const override { return 0; }
 
 	private:
-		StreamingIoPeer<Codec, Incoming, Outgoing, InContainer, OutContainer,
-						BufferT> &peer_;
+		streaming_io_peer<Codec, Incoming, Outgoing, InContainer, OutContainer,
+						  BufferT> &peer_;
 	};
 
 private:
-	Own<ConveyorFeeder<HeapMessageRoot<Incoming, InContainer>>>
+	own<conveyor_feeder<HeapMessageRoot<Incoming, InContainer>>>
 		incoming_feeder_ = nullptr;
 
-	Own<AsyncIoStream> io_stream_;
+	own<async_io_stream> io_stream_;
 
 	Codec codec_;
 
 	BufferT in_buffer_;
 	BufferT out_buffer_;
 
-	ConveyorSink sink_read_;
-	ConveyorSink sink_write_;
+	conveyor_sink sink_read_;
+	conveyor_sink sink_write_;
 
-	PeerConveyorFeeder conveyor_feeder_;
+	peer_conveyor_feeder conveyor_feeder_;
 };
 
 /**
@@ -91,13 +91,13 @@ private:
  * This is a convenience wrapper intended for a faster setup of this class
  */
 template <typename Codec, typename Incoming, typename Outgoing,
-		  typename InContainer = MessageContainer<Incoming>,
-		  typename OutContainer = MessageContainer<Outgoing>,
-		  typename BufferT = RingBuffer>
-std::pair<Own<StreamingIoPeer<Codec, Incoming, Outgoing, InContainer,
-							  OutContainer, BufferT>>,
-		  Conveyor<HeapMessageRoot<Incoming, InContainer>>>
-newStreamingIoPeer(Own<AsyncIoStream> stream);
+		  typename InContainer = message_container<Incoming>,
+		  typename OutContainer = message_container<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);
 
 } // namespace saw
 
diff --git a/source/forstio/log.cpp b/source/forstio/log.cpp
index 6c627b1..1a8ed2f 100644
--- a/source/forstio/log.cpp
+++ b/source/forstio/log.cpp
@@ -1,7 +1,7 @@
 #include "log.h"
 
 namespace saw {
-LogIo::LogIo(EventLoop &loop) : loop_{loop} {}
+log_io::log_io(event_loop &loop) : loop_{loop} {}
 
-Log::Log(LogIo &central, EventLoop &loop) : central_{central}, loop_{loop} {}
+log::log(log_io &central, event_loop &loop) : central_{central}, loop_{loop} {}
 } // namespace saw
diff --git a/source/forstio/log.h b/source/forstio/log.h
index c9eaaf2..6927660 100644
--- a/source/forstio/log.h
+++ b/source/forstio/log.h
@@ -3,24 +3,24 @@
 #include "common.h"
 
 namespace saw {
-class EventLoop;
-class LogIo;
-class Log {
+class event_loop;
+class log_io;
+class log {
 public:
 	enum class Type : uint8_t { Info, Warning, Error, Debug };
 
 private:
-	LogIo &central_;
-	EventLoop &loop_;
+	log_io &central_;
+	event_loop &loop_;
 
 public:
-	Log(LogIo &central, EventLoop &loop);
+	log(log_io &central, event_loop &loop);
 };
-class LogIo {
+class log_io {
 private:
-	EventLoop &loop_;
+	event_loop &loop_;
 
 public:
-	LogIo(EventLoop &loop);
+	log_io(event_loop &loop);
 };
 } // namespace saw
diff --git a/source/forstio/message.h b/source/forstio/message.h
index 5ae9177..5bf3afe 100644
--- a/source/forstio/message.h
+++ b/source/forstio/message.h
@@ -15,18 +15,18 @@
 #include "string_literal.h"
 
 namespace saw {
-class MessageBase {
+class message_base {
 protected:
 	bool set_explicitly_ = false;
 
 public:
 	template <class T> T &as() {
-		static_assert(std::is_base_of<MessageBase, T>());
+		static_assert(std::is_base_of<message_base, T>());
 		return dynamic_cast<T &>(*this);
 	}
 
 	template <class T> const T &as() const {
-		static_assert(std::is_base_of<MessageBase, T>());
+		static_assert(std::is_base_of<message_base, T>());
 		return dynamic_cast<const T &>(*this);
 	}
 };
@@ -44,30 +44,30 @@ public:
 /*
  * Struct Message
  */
-template <class... V, StringLiteral... Keys, class Container>
-class Message<schema::Struct<schema::NamedMember<V, Keys>...>, Container> final
-	: public MessageBase {
+template <class... V, string_literal... Keys, class Container>
+class message<schema::Struct<schema::NamedMember<V, Keys>...>, Container> final
+	: public message_base {
 private:
 	using SchemaType = schema::Struct<schema::NamedMember<V, Keys>...>;
-	using MessageType = Message<SchemaType, Container>;
+	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;
+	friend class builder;
+	friend class reader;
 
 public:
-	class Reader;
-	class Builder {
+	class reader;
+	class builder {
 	private:
 		MessageType &message_;
 
 	public:
-		Builder(MessageType &msg) : message_{msg} {}
+		builder(MessageType &msg) : message_{msg} {}
 
-		Reader asReader() { return Reader{message_}; }
+		reader as_reader() { return reader{message_}; }
 
 		/*
 		 * Initialize a member by index
@@ -76,9 +76,9 @@ public:
 		typename std::enable_if<
 			!SchemaIsArray<
 				typename MessageParameterPackType<i, V...>::Type>::Value,
-			typename Container::template ElementType<i>::Builder>::type
+			typename Container::template ElementType<i>::builder>::type
 		init() {
-			return typename Container::template ElementType<i>::Builder{
+			return typename Container::template ElementType<i>::builder{
 				message_.container_.template get<i>()};
 		}
 
@@ -86,14 +86,14 @@ public:
 		 * Initialize a member by their name
 		 * This is the preferred method for schema::Struct messages
 		 */
-		template <StringLiteral Literal>
+		template <string_literal Literal>
 		typename std::enable_if<
 			!SchemaIsArray<typename MessageParameterPackType<
 				MessageParameterKeyPackIndex<Literal, Keys...>::Value,
 				V...>::Type>::Value,
 			typename Container::template ElementType<
 				MessageParameterKeyPackIndex<Literal,
-											 Keys...>::Value>::Builder>::type
+											 Keys...>::Value>::builder>::type
 		init() {
 			constexpr size_t i =
 				MessageParameterKeyPackIndex<Literal, Keys...>::Value;
@@ -105,10 +105,10 @@ public:
 		typename std::enable_if<
 			SchemaIsArray<
 				typename MessageParameterPackType<i, V...>::Type>::Value,
-			typename Container::template ElementType<i>::Builder>::type
+			typename Container::template ElementType<i>::builder>::type
 		init(size_t size = 0) {
 			auto array_builder =
-				typename Container::template ElementType<i>::Builder{
+				typename Container::template ElementType<i>::builder{
 					message_.container_.template get<i>(), size};
 			return array_builder;
 		}
@@ -116,14 +116,14 @@ public:
 		/*
 		 * Version for array schema type
 		 */
-		template <StringLiteral Literal>
+		template <string_literal Literal>
 		typename std::enable_if<
 			SchemaIsArray<typename MessageParameterPackType<
 				MessageParameterKeyPackIndex<Literal, Keys...>::Value,
 				V...>::Type>::Value,
 			typename Container::template ElementType<
 				MessageParameterKeyPackIndex<Literal,
-											 Keys...>::Value>::Builder>::type
+											 Keys...>::Value>::builder>::type
 		init(size_t size) {
 			constexpr size_t i =
 				MessageParameterKeyPackIndex<Literal, Keys...>::Value;
@@ -132,21 +132,21 @@ public:
 		}
 	};
 
-	class Reader {
+	class reader {
 	private:
 		MessageType &message_;
 
 	public:
-		Reader(MessageType &msg) : message_{msg} {}
+		reader(MessageType &msg) : message_{msg} {}
 
-		Builder asBuilder() { return Builder{message_}; }
+		builder as_builder() { 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{
+		typename Container::template ElementType<i>::reader get() {
+			return typename Container::template ElementType<i>::reader{
 				message_.container_.template get<i>()};
 		}
 
@@ -154,9 +154,9 @@ public:
 		 * Get member by name
 		 * This is the preferred method for schema::Struct messages
 		 */
-		template <StringLiteral Literal>
+		template <string_literal Literal>
 		typename Container::template ElementType<
-			MessageParameterKeyPackIndex<Literal, Keys...>::Value>::Reader
+			MessageParameterKeyPackIndex<Literal, Keys...>::Value>::reader
 		get() {
 			// The index of the first match
 			constexpr size_t i =
@@ -166,59 +166,59 @@ public:
 		}
 	};
 
-	Builder build() { return Builder{*this}; }
+	builder build() { return builder{*this}; }
 
-	Reader read() { return Reader{*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 {
+template <class... V, string_literal... Keys, class Container>
+class message<schema::Union<schema::NamedMember<V, Keys>...>, Container> final
+	: public message_base {
 private:
 	using SchemaType = schema::Union<schema::NamedMember<V, Keys>...>;
-	using MessageType = Message<SchemaType, Container>;
+	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;
+	friend class builder;
+	friend class reader;
 
 public:
-	class Reader;
-	class Builder {
+	class reader;
+	class builder {
 	private:
 		MessageType &message_;
 
 	public:
-		Builder(MessageType &msg) : message_{msg} {}
+		builder(MessageType &msg) : message_{msg} {}
 
-		Reader asReader() { return Reader{message_}; }
+		reader as_reader() { return reader{message_}; }
 
 		template <size_t i>
 		typename std::enable_if<
 			!SchemaIsArray<
 				typename MessageParameterPackType<i, V...>::Type>::Value,
-			typename Container::template ElementType<i>::Builder>::type
+			typename Container::template ElementType<i>::builder>::type
 
 		init() {
-			return typename Container::template ElementType<i>::Builder{
+			return typename Container::template ElementType<i>::builder{
 				message_.container_.template get<i>()};
 		}
 
-		template <StringLiteral Literal>
+		template <string_literal Literal>
 		typename std::enable_if<
 			!SchemaIsArray<typename MessageParameterPackType<
 				MessageParameterKeyPackIndex<Literal, Keys...>::Value,
 				V...>::Type>::Value,
 			typename Container::template ElementType<
 				MessageParameterKeyPackIndex<Literal,
-											 Keys...>::Value>::Builder>::type
+											 Keys...>::Value>::builder>::type
 		init() {
 			constexpr size_t i =
 				MessageParameterKeyPackIndex<Literal, Keys...>::Value;
@@ -233,20 +233,20 @@ public:
 		typename std::enable_if<
 			SchemaIsArray<
 				typename MessageParameterPackType<i, V...>::Type>::Value,
-			typename Container::template ElementType<i>::Builder>::type
+			typename Container::template ElementType<i>::builder>::type
 		init(size_t size = 0) {
-			return typename Container::template ElementType<i>::Builder{
+			return typename Container::template ElementType<i>::builder{
 				message_.container_.template get<i>(), size};
 		}
 
-		template <StringLiteral Literal>
+		template <string_literal Literal>
 		typename std::enable_if<
 			SchemaIsArray<typename MessageParameterPackType<
 				MessageParameterKeyPackIndex<Literal, Keys...>::Value,
 				V...>::Type>::Value,
 			typename Container::template ElementType<
 				MessageParameterKeyPackIndex<Literal,
-											 Keys...>::Value>::Builder>::type
+											 Keys...>::Value>::builder>::type
 		init(size_t size) {
 			constexpr size_t i =
 				MessageParameterKeyPackIndex<Literal, Keys...>::Value;
@@ -255,24 +255,24 @@ public:
 		}
 	};
 
-	class Reader {
+	class reader {
 	private:
 		MessageType &message_;
 
 	public:
-		Reader(MessageType &msg) : message_{msg} {}
+		reader(MessageType &msg) : message_{msg} {}
 
-		Builder asBuilder() { return Builder{message_}; }
+		builder as_builder() { return builder{message_}; }
 
 		template <size_t i>
-		typename Container::template ElementType<i>::Reader get() {
-			return typename Container::template ElementType<i>::Reader{
+		typename Container::template ElementType<i>::reader get() {
+			return typename Container::template ElementType<i>::reader{
 				message_.container_.template get<i>()};
 		}
 
-		template <StringLiteral Literal>
+		template <string_literal Literal>
 		typename Container::template ElementType<
-			MessageParameterKeyPackIndex<Literal, Keys...>::Value>::Reader
+			MessageParameterKeyPackIndex<Literal, Keys...>::Value>::reader
 		get() {
 			// The index of the first match
 			constexpr size_t i =
@@ -281,14 +281,14 @@ public:
 			return get<i>();
 		}
 
-		template <StringLiteral Literal>
+		template <string_literal Literal>
 		static constexpr size_t toIndex() noexcept {
 			return MessageParameterKeyPackIndex<Literal, Keys...>::Value;
 		}
 
 		size_t index() const noexcept { return message_.container_.index(); }
 
-		template <StringLiteral Literal> bool hasAlternative() const {
+		template <string_literal Literal> bool hasAlternative() const {
 			return index() == toIndex<Literal>();
 		}
 	};
@@ -298,36 +298,36 @@ public:
  * Array message class. Wrapper around an array schema element
  */
 template <class T, class Container>
-class Message<schema::Array<T>, Container> final : public MessageBase {
+class message<schema::Array<T>, Container> final : public message_base {
 private:
 	using SchemaType = schema::Array<T>;
-	using MessageType = Message<SchemaType, Container>;
+	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;
+	friend class builder;
+	friend class reader;
 
 public:
-	class Reader;
-	class Builder {
+	class reader;
+	class builder {
 	private:
 		MessageType &message_;
 
 	public:
-		Builder(MessageType &msg, size_t size) : message_{msg} {
+		builder(MessageType &msg, size_t size) : message_{msg} {
 			if (size > 0) {
 				message_.container_.resize(size);
 			}
 		}
 
-		Reader asReader() { return Reader{message_}; }
+		reader as_reader() { return reader{message_}; }
 
-		typename Container::ElementType::Builder init(size_t i) {
-			return typename Container::ElementType::Builder{
+		typename Container::ElementType::builder init(size_t i) {
+			return typename Container::ElementType::builder{
 				message_.container_.get(i)};
 		}
 
@@ -336,17 +336,17 @@ public:
 		void resize(size_t size) { message_.container_.resize(size); }
 	};
 
-	class Reader {
+	class reader {
 	private:
 		MessageType &message_;
 
 	public:
-		Reader(MessageType &msg) : message_{msg} {}
+		reader(MessageType &msg) : message_{msg} {}
 
-		Builder asBuilder() { return Builder{message_, 0}; }
+		builder as_builder() { return builder{message_, 0}; }
 
-		typename Container::ElementType::Reader get(size_t i) {
-			return typename Container::ElementType::Reader{
+		typename Container::ElementType::reader get(size_t i) {
+			return typename Container::ElementType::reader{
 				message_.container_.get(i)};
 		}
 
@@ -358,36 +358,36 @@ public:
  * Tuple message class. Wrapper around a tuple schema
  */
 template <class... T, class Container>
-class Message<schema::Tuple<T...>, Container> final : public MessageBase {
+class message<schema::Tuple<T...>, Container> final : public message_base {
 private:
 	using SchemaType = schema::Tuple<T...>;
-	using MessageType = Message<SchemaType, Container>;
+	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;
+	friend class builder;
+	friend class reader;
 
 public:
-	class Reader;
-	class Builder {
+	class reader;
+	class builder {
 		MessageType &message_;
 
 	public:
-		Builder(MessageType &msg) : message_{msg} {}
+		builder(MessageType &msg) : message_{msg} {}
 
-		Reader asReader() { return Reader{message_}; }
+		reader as_reader() { return reader{message_}; }
 
 		template <size_t i>
 		typename std::enable_if<
 			!SchemaIsArray<
 				typename MessageParameterPackType<i, T...>::Type>::Value,
-			typename Container::template ElementType<i>::Builder>::type
+			typename Container::template ElementType<i>::builder>::type
 		init() {
-			return typename Container::template ElementType<i>::Builder{
+			return typename Container::template ElementType<i>::builder{
 				message_.container_.template get<i>()};
 		}
 
@@ -395,24 +395,24 @@ public:
 		typename std::enable_if<
 			SchemaIsArray<
 				typename MessageParameterPackType<i, T...>::Type>::Value,
-			typename Container::template ElementType<i>::Builder>::type
+			typename Container::template ElementType<i>::builder>::type
 		init(size_t size = 0) {
-			return typename Container::template ElementType<i>::Builder{
+			return typename Container::template ElementType<i>::builder{
 				message_.container_.template get<i>(), size};
 		}
 	};
-	class Reader {
+	class reader {
 	private:
 		MessageType &message_;
 
 	public:
-		Reader(MessageType &msg) : message_{msg} {}
+		reader(MessageType &msg) : message_{msg} {}
 
-		Builder asBuilder() { return Builder{message_}; }
+		builder as_builder() { return builder{message_}; }
 
 		template <size_t i>
-		typename Container::template ElementType<i>::Reader get() {
-			return typename Container::template ElementType<i>::Reader{
+		typename Container::template ElementType<i>::reader get() {
+			return typename Container::template ElementType<i>::reader{
 				message_.container_.template get<i>()};
 		}
 	};
@@ -423,43 +423,43 @@ public:
  * 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 {
+class message<schema::Primitive<T, N>, Container> final : public message_base {
 private:
 	using SchemaType = schema::Primitive<T, N>;
-	using MessageType = Message<SchemaType, Container>;
+	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;
+	friend class builder;
+	friend class reader;
 
 public:
-	class Reader;
-	class Builder {
+	class reader;
+	class builder {
 	private:
 		MessageType &message_;
 
 	public:
-		Builder(MessageType &msg) : message_{msg} {}
+		builder(MessageType &msg) : message_{msg} {}
 
-		Reader asReader() { return Reader{message_}; }
+		reader as_reader() { return reader{message_}; }
 
 		void set(const typename Container::ValueType &value) {
 			message_.container_.set(value);
 		}
 	};
 
-	class Reader {
+	class reader {
 	private:
 		MessageType &message_;
 
 	public:
-		Reader(Message &msg) : message_{msg} {}
+		reader(message &msg) : message_{msg} {}
 
-		Builder asBuilder() { return Builder{message_}; }
+		builder as_builder() { return builder{message_}; }
 
 		const typename Container::ValueType &get() const {
 			return message_.container_.get();
@@ -468,64 +468,64 @@ public:
 };
 
 template <class Container>
-class Message<schema::String, Container> final : public MessageBase {
+class message<schema::String, Container> final : public message_base {
 private:
 	using SchemaType = schema::String;
-	using MessageType = Message<SchemaType, Container>;
+	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;
+	friend class builder;
+	friend class reader;
 
 public:
-	class Reader;
-	class Builder {
+	class reader;
+	class builder {
 	private:
 		MessageType &message_;
 
 	public:
-		Builder(MessageType &msg) : message_{msg} {}
+		builder(MessageType &msg) : message_{msg} {}
 
-		Reader asReader() { return Reader{message_}; }
+		reader as_reader() { return reader{message_}; }
 
 		void set(std::string &&str) { message_.container_.set(std::move(str)); }
 		void set(const std::string_view str) { message_.container_.set(str); }
 		void set(const char *str) { set(std::string_view{str}); }
 	};
 
-	class Reader {
+	class reader {
 	private:
 		MessageType &message_;
 
 	public:
-		Reader(MessageType &msg) : message_{msg} {}
+		reader(MessageType &msg) : message_{msg} {}
 
-		Builder asBuilder() { return Builder{message_}; }
+		builder as_builder() { return builder{message_}; }
 
 		const std::string_view get() const { return message_.container_.get(); }
 	};
 };
 
-template <class Schema, class Container = MessageContainer<Schema>>
+template <class Schema, class Container = message_container<Schema>>
 class HeapMessageRoot {
 private:
-	Own<Message<Schema, Container>> root_;
+	own<message<Schema, Container>> root_;
 
 public:
-	HeapMessageRoot(Own<Message<Schema, Container>> r) : root_{std::move(r)} {}
+	HeapMessageRoot(own<message<Schema, Container>> r) : root_{std::move(r)} {}
 
-	typename Message<Schema, Container>::Builder build() {
+	typename message<Schema, Container>::builder build() {
 		assert(root_);
-		return typename Message<Schema, Container>::Builder{*root_};
+		return typename message<Schema, Container>::builder{*root_};
 	}
 
-	typename Message<Schema, Container>::Reader read() {
+	typename message<Schema, Container>::reader read() {
 		assert(root_);
-		return typename Message<Schema, Container>::Reader{*root_};
+		return typename message<Schema, Container>::reader{*root_};
 	}
 };
 
@@ -535,28 +535,28 @@ public:
 	using Schema = schema::Array<T>;
 
 private:
-	Own<Message<Schema, Container>> root_;
+	own<message<Schema, Container>> root_;
 
 public:
-	HeapMessageRoot(Own<Message<Schema, Container>> r) : root_{std::move(r)} {}
+	HeapMessageRoot(own<message<Schema, Container>> r) : root_{std::move(r)} {}
 
-	typename Message<Schema, Container>::Builder build(size_t size) {
+	typename message<Schema, Container>::builder build(size_t size) {
 		assert(root_);
-		return typename Message<Schema, Container>::Builder{*root_, size};
+		return typename message<Schema, Container>::builder{*root_, size};
 	}
 
-	typename Message<Schema, Container>::Reader read() {
+	typename message<Schema, Container>::reader read() {
 		assert(root_);
-		return typename Message<Schema, Container>::Reader{*root_};
+		return typename message<Schema, Container>::reader{*root_};
 	}
 };
 
 /*
  * Minor helper for creating a message root
  */
-template <class Schema, class Container = MessageContainer<Schema>>
+template <class Schema, class Container = message_container<Schema>>
 inline HeapMessageRoot<Schema, Container> heapMessageRoot() {
-	Own<Message<Schema, Container>> root = heap<Message<Schema, Container>>();
+	own<message<Schema, Container>> root = heap<message<Schema, Container>>();
 	return HeapMessageRoot<Schema, Container>{std::move(root)};
 }
 } // namespace saw
diff --git a/source/forstio/message_container.h b/source/forstio/message_container.h
index da7515d..b2ea2b5 100644
--- a/source/forstio/message_container.h
+++ b/source/forstio/message_container.h
@@ -6,9 +6,9 @@
 #include <vector>
 
 namespace saw {
-template <class T> class MessageContainer;
+template <class T> class message_container;
 
-template <class T, class Container = MessageContainer<T>> class Message;
+template <class T, class Container = message_container<T>> class message;
 
 template <size_t N, class... T> struct MessageParameterPackType;
 
@@ -39,7 +39,7 @@ struct MessageParameterPackIndex<T, TL0, TL...> {
  * StringLiterals cannot be resolved as non-type primitive template values can.
  * This is the workaround
  */
-template <StringLiteral V, StringLiteral Key0, StringLiteral... Keys>
+template <string_literal V, string_literal Key0, string_literal... Keys>
 struct MessageParameterKeyPackIndexHelper {
 	static constexpr size_t Value =
 		(V == Key0)
@@ -47,12 +47,12 @@ struct MessageParameterKeyPackIndexHelper {
 			: (1u + MessageParameterKeyPackIndexHelper<V, Keys...>::Value);
 };
 
-template <StringLiteral V, StringLiteral Key0>
+template <string_literal V, string_literal Key0>
 struct MessageParameterKeyPackIndexHelper<V, Key0> {
 	static constexpr size_t Value = (V == Key0) ? (0u) : (1u);
 };
 
-template <StringLiteral V, StringLiteral... Keys>
+template <string_literal V, string_literal... Keys>
 struct MessageParameterKeyPackIndex {
 	static constexpr size_t Value =
 		MessageParameterKeyPackIndexHelper<V, Keys...>::Value;
@@ -68,10 +68,10 @@ template <class T> struct SchemaIsArray<schema::Array<T>> {
 	constexpr static bool Value = true;
 };
 
-template <class... V, StringLiteral... Keys>
-class MessageContainer<schema::Struct<schema::NamedMember<V, Keys>...>> {
+template <class... V, string_literal... Keys>
+class message_container<schema::Struct<schema::NamedMember<V, Keys>...>> {
 private:
-	using ValueType = std::tuple<Message<V, MessageContainer<V>>...>;
+	using ValueType = std::tuple<message<V, message_container<V>>...>;
 	ValueType values_;
 
 public:
@@ -79,7 +79,7 @@ public:
 
 	template <size_t i>
 	using ElementType = typename MessageParameterPackType<
-		i, Message<V, MessageContainer<V>>...>::Type;
+		i, message<V, message_container<V>>...>::Type;
 
 	template <size_t i> ElementType<i> &get() { return std::get<i>(values_); }
 };
@@ -87,10 +87,10 @@ public:
 /*
  * Union storage
  */
-template <class... V, StringLiteral... Keys>
-class MessageContainer<schema::Union<schema::NamedMember<V, Keys>...>> {
+template <class... V, string_literal... Keys>
+class message_container<schema::Union<schema::NamedMember<V, Keys>...>> {
 private:
-	using ValueType = std::variant<Message<V, MessageContainer<V>>...>;
+	using ValueType = std::variant<message<V, message_container<V>>...>;
 	ValueType value_;
 
 public:
@@ -98,12 +98,12 @@ public:
 
 	template <size_t i>
 	using ElementType = typename MessageParameterPackType<
-		i, Message<V, MessageContainer<V>>...>::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;
-			value_ = Message<MessageIV, MessageContainer<MessageIV>>{};
+			value_ = message<MessageIV, message_container<MessageIV>>{};
 		}
 		return std::get<i>(value_);
 	}
@@ -115,17 +115,17 @@ public:
  * Array storage
  */
 
-template <class T> class MessageContainer<schema::Array<T>> {
+template <class T> class message_container<schema::Array<T>> {
 private:
-	using ValueType = std::vector<Message<T, MessageContainer<T>>>;
+	using ValueType = std::vector<message<T, message_container<T>>>;
 	ValueType values_;
 
 public:
 	using SchemaType = schema::Array<T>;
 
-	using ElementType = Message<T, MessageContainer<T>>;
+	using ElementType = message<T, message_container<T>>;
 
-	Message<T, MessageContainer<T>> &get(size_t index) {
+	message<T, message_container<T>> &get(size_t index) {
 		return values_.at(index);
 	}
 
@@ -137,9 +137,9 @@ public:
 /*
  * Tuple storage
  */
-template <class... T> class MessageContainer<schema::Tuple<T...>> {
+template <class... T> class message_container<schema::Tuple<T...>> {
 private:
-	using ValueType = std::tuple<Message<T, MessageContainer<T>>...>;
+	using ValueType = std::tuple<message<T, message_container<T>>...>;
 	ValueType values_;
 
 public:
@@ -147,7 +147,7 @@ public:
 
 	template <size_t i>
 	using ElementType = typename MessageParameterPackType<
-		i, Message<T, MessageContainer<T>>...>::Type;
+		i, message<T, message_container<T>>...>::Type;
 
 	template <size_t i> ElementType<i> &get() { return std::get<i>(values_); }
 };
@@ -208,7 +208,7 @@ struct PrimitiveTypeHelper<schema::Primitive<schema::FloatingPoint, 8>> {
 	using Type = double;
 };
 
-template <class T, size_t N> class MessageContainer<schema::Primitive<T, N>> {
+template <class T, size_t N> class message_container<schema::Primitive<T, N>> {
 public:
 	using SchemaType = schema::Primitive<T, N>;
 	using ValueType =
@@ -218,14 +218,14 @@ private:
 	ValueType value_;
 
 public:
-	MessageContainer() : value_{0} {}
+	message_container() : value_{0} {}
 
 	void set(const ValueType &v) { value_ = v; }
 
 	const ValueType &get() const { return value_; }
 };
 
-template <> class MessageContainer<schema::String> {
+template <> class message_container<schema::String> {
 public:
 	using SchemaType = schema::String;
 	using ValueType = std::string;
diff --git a/source/forstio/proto_kel.h b/source/forstio/proto_kel.h
index dceb1ec..83b0aac 100644
--- a/source/forstio/proto_kel.h
+++ b/source/forstio/proto_kel.h
@@ -13,7 +13,7 @@ public:
 
 private:
 	struct ReadContext {
-		Buffer &buffer;
+		buffer &buffer;
 		size_t offset = 0;
 	};
 
@@ -37,194 +37,194 @@ public:
 
 	const Version version() const { return Version{0, 0, 0}; }
 
-	template <class Schema, class Container = MessageContainer<Schema>>
-	Error encode(typename Message<Schema, Container>::Reader reader,
-				 Buffer &buffer);
+	template <class Schema, class Container = message_container<Schema>>
+	error encode(typename message<Schema, Container>::reader reader,
+				 buffer &buffer);
 
-	template <class Schema, class Container = MessageContainer<Schema>>
-	Error decode(typename Message<Schema, Container>::Builder builder,
-				 Buffer &buffer, const Limits &limits = Limits{});
+	template <class Schema, class Container = message_container<Schema>>
+	error decode(typename message<Schema, Container>::builder builder,
+				 buffer &buffer, const Limits &limits = Limits{});
 };
 
 template <class T> struct ProtoKelEncodeImpl;
 
 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<
+struct ProtoKelEncodeImpl<message<schema::Primitive<T, N>, Container>> {
+	static error
+	encode(typename message<schema::Primitive<T, N>, Container>::reader data,
+		   buffer &buffer) {
+		error err = stream_value<typename PrimitiveTypeHelper<
 			schema::Primitive<T, N>>::Type>::encode(data.get(), buffer);
-		return error;
+		return err;
 	}
 
 	static size_t
-	size(typename Message<schema::Primitive<T, N>, Container>::Reader) {
-		return StreamValue<typename PrimitiveTypeHelper<
+	size(typename message<schema::Primitive<T, N>, Container>::reader) {
+		return stream_value<typename PrimitiveTypeHelper<
 			schema::Primitive<T, N>>::Type>::size();
 	}
 };
 
 template <class Container>
-struct ProtoKelEncodeImpl<Message<schema::String, Container>> {
-	static Error
-	encode(typename Message<schema::String, Container>::Reader data,
-		   Buffer &buffer) {
+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();
 
-		Error error = buffer.writeRequireLength(sizeof(size) + size);
-		if (error.failed()) {
-			return error;
+		error err = buffer.write_require_length(sizeof(size) + size);
+		if (err.failed()) {
+			return err;
 		}
 
-		error = StreamValue<size_t>::encode(size, buffer);
-		if (error.failed()) {
-			return error;
+		err = stream_value<size_t>::encode(size, buffer);
+		if (err.failed()) {
+			return err;
 		}
 		for (size_t i = 0; i < view.size(); ++i) {
 			buffer.write(i) = view[i];
 		}
-		buffer.writeAdvance(view.size());
-		return noError();
+		buffer.write_advance(view.size());
+		return no_error();
 	}
 
 	static size_t
-	size(typename Message<schema::String, Container>::Reader reader) {
+	size(typename message<schema::String, Container>::reader reader) {
 		return sizeof(size_t) + reader.get().size();
 	}
 };
 
 template <class... T, class Container>
-struct ProtoKelEncodeImpl<Message<schema::Tuple<T...>, 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 Message<schema::Tuple<T...>, Container>::Reader,
-				  Buffer &) {
-		return noError();
+	static typename std::enable_if<i == sizeof...(T), error>::type
+	encodeMembers(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) {
-		Error error =
+	static typename std::enable_if<(i < sizeof...(T)), error>::type
+	encodeMembers(typename message<schema::Tuple<T...>, Container>::reader data,
+				  buffer &buffer) {
+		error err =
 			ProtoKelEncodeImpl<typename Container::template ElementType<i>>::
 				encode(data.template get<i>(), buffer);
-		if (error.failed()) {
-			return error;
+		if (err.failed()) {
+			return err;
 		}
 
 		return encodeMembers<i + 1>(data, buffer);
 	}
 
-	static Error
-	encode(typename Message<schema::Tuple<T...>, Container>::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 Message<schema::Tuple<T...>, Container>::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 Message<schema::Tuple<T...>, Container>::Reader reader) {
+			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 Message<schema::Tuple<T...>, Container>::Reader reader) {
+	size(typename message<schema::Tuple<T...>, Container>::reader reader) {
 		return sizeMembers<0>(reader);
 	}
 };
 
-template <typename... V, StringLiteral... K, class Container>
+template <typename... V, string_literal... K, class Container>
 struct ProtoKelEncodeImpl<
-	Message<schema::Struct<schema::NamedMember<V, K>...>, Container>> {
+	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 &) {
-		return noError();
+	static typename std::enable_if<i == sizeof...(V), error>::type
+	encodeMembers(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(
-			typename Message<schema::Struct<schema::NamedMember<V, K>...>,
-							 Container>::Reader data,
-			Buffer &buffer) {
+		i<sizeof...(V), error>::type encodeMembers(
+			typename message<schema::Struct<schema::NamedMember<V, K>...>,
+							 Container>::reader data,
+			buffer &buffer) {
 
-		Error error =
+		error err =
 			ProtoKelEncodeImpl<typename Container::template ElementType<i>>::
 				encode(data.template get<i>(), buffer);
-		if (error.failed()) {
-			return error;
+		if (err.failed()) {
+			return err;
 		}
 		return encodeMembers<i + 1>(data, buffer);
 	}
 
-	static Error
-	encode(typename Message<schema::Struct<schema::NamedMember<V, K>...>,
-							Container>::Reader data,
-		   Buffer &buffer) {
+	static error
+	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 Message<schema::Struct<schema::NamedMember<V, K>...>,
-								 Container>::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 Message<schema::Struct<schema::NamedMember<V, K>...>,
-							 Container>::Reader reader) {
+			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) {
+	size(typename message<schema::Struct<schema::NamedMember<V, K>...>,
+						  Container>::reader reader) {
 		return sizeMembers<0>(reader);
 	}
 };
 
-template <typename... V, StringLiteral... K, class Container>
+template <typename... V, string_literal... K, class Container>
 struct ProtoKelEncodeImpl<
-	Message<schema::Union<schema::NamedMember<V, K>...>, Container>> {
+	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();
+	static typename std::enable_if<i == sizeof...(V), error>::type
+	encodeMembers(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(
-			typename Message<schema::Union<schema::NamedMember<V, K>...>,
-							 Container>::Reader reader,
-			Buffer &buffer) {
+		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<ProtoKelCodec::UnionIdT>::encode(i, buffer);
-			if (error.failed()) {
-				return error;
+			error err =
+				stream_value<ProtoKelCodec::UnionIdT>::encode(i, buffer);
+			if (err.failed()) {
+				return err;
 			}
 			return ProtoKelEncodeImpl<typename Container::template ElementType<
 				i>>::encode(reader.template get<i>(), buffer);
@@ -232,25 +232,25 @@ struct ProtoKelEncodeImpl<
 		return encodeMembers<i + 1>(reader, buffer);
 	}
 
-	static Error
-	encode(typename Message<schema::Union<schema::NamedMember<V, K>...>,
-							Container>::Reader reader,
-		   Buffer &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) {
+	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) {
+			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>());
@@ -262,42 +262,42 @@ struct ProtoKelEncodeImpl<
 	 * Size of union id + member size
 	 */
 	static size_t
-	size(typename Message<schema::Union<schema::NamedMember<V, K>...>,
-						  Container>::Reader reader) {
+	size(typename message<schema::Union<schema::NamedMember<V, K>...>,
+						  Container>::reader reader) {
 		return sizeof(ProtoKelCodec::UnionIdT) + sizeMembers<0>(reader);
 	}
 };
 
 template <class T, class Container>
-struct ProtoKelEncodeImpl<Message<schema::Array<T>, Container>> {
-	static Error
-	encode(typename Message<schema::Array<T>, Container>::Reader data,
-		   Buffer &buffer) {
+struct ProtoKelEncodeImpl<message<schema::Array<T>, Container>> {
+	static error
+	encode(typename message<schema::Array<T>, Container>::reader data,
+		   buffer &buffer) {
 		ProtoKelCodec::ArrayLengthT array_length = data.size();
 		{
-			Error error = StreamValue<ProtoKelCodec::ArrayLengthT>::encode(
+			error err = stream_value<ProtoKelCodec::ArrayLengthT>::encode(
 				array_length, buffer);
-			if (error.failed()) {
-				return error;
+			if (err.failed()) {
+				return err;
 			}
 		}
 
 		for (size_t i = 0; i < array_length; ++i) {
-			Error error =
+			error err =
 				ProtoKelEncodeImpl<typename Container::ElementType>::encode(
 					data.get(i), buffer);
-			if (error.failed()) {
-				return error;
+			if (err.failed()) {
+				return err;
 			}
 		}
-		return noError();
+		return no_error();
 	}
 
 	/*
 	 *
 	 */
 	static size_t
-	size(typename Message<schema::Array<T>, Container>::Reader data) {
+	size(typename message<schema::Array<T>, Container>::reader data) {
 		size_t members = sizeof(ProtoKelCodec::ArrayLengthT);
 		for (size_t i = 0; i < data.size(); ++i) {
 			members +=
@@ -315,159 +315,159 @@ struct ProtoKelEncodeImpl<Message<schema::Array<T>, Container>> {
 template <typename T> struct ProtoKelDecodeImpl;
 
 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) {
+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<
+		error err = stream_value<typename PrimitiveTypeHelper<
 			schema::Primitive<T, N>>::Type>::decode(val, buffer);
 		data.set(val);
-		return error;
+		return err;
 	}
 };
 
 template <class Container>
-struct ProtoKelDecodeImpl<Message<schema::String, Container>> {
-	static Error
-	decode(typename Message<schema::String, Container>::Builder data,
-		   Buffer &buffer) {
+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");
+		if (sizeof(size) > buffer.read_composite_length()) {
+			return recoverable_error("Buffer too small");
 		}
 
-		Error error = StreamValue<size_t>::decode(size, buffer);
-		if (error.failed()) {
-			return error;
+		error err = stream_value<size_t>::decode(size, buffer);
+		if (err.failed()) {
+			return err;
 		}
 
-		if (size > buffer.readCompositeLength()) {
-			return recoverableError("Buffer too small");
+		if (size > buffer.read_composite_length()) {
+			return recoverable_error("Buffer too small");
 		}
 
 		std::string value;
 		value.resize(size);
 
-		if (size > buffer.readCompositeLength()) {
-			return recoverableError("Buffer too small");
+		if (size > buffer.read_composite_length()) {
+			return recoverable_error("Buffer too small");
 		}
 		for (size_t i = 0; i < value.size(); ++i) {
 			value[i] = buffer.read(i);
 		}
-		buffer.readAdvance(value.size());
+		buffer.read_advance(value.size());
 		data.set(std::move(value));
-		return noError();
+		return no_error();
 	}
 };
 
 template <class... T, class Container>
-struct ProtoKelDecodeImpl<Message<schema::Tuple<T...>, 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 Message<schema::Tuple<T...>, Container>::Builder,
-				  Buffer &) {
-		return noError();
+	static typename std::enable_if<i == sizeof...(T), error>::type
+	decodeMembers(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(
-			typename Message<schema::Tuple<T...>, Container>::Builder builder,
-			Buffer &buffer) {
+		i<sizeof...(T), error>::type decodeMembers(
+			typename message<schema::Tuple<T...>, Container>::builder builder,
+			buffer &buffer) {
 
-		Error error =
+		error err =
 			ProtoKelDecodeImpl<typename Container::template ElementType<i>>::
 				decode(builder.template init<i>(), buffer);
-		if (error.failed()) {
-			return error;
+		if (err.failed()) {
+			return err;
 		}
 		return decodeMembers<i + 1>(builder, buffer);
 	}
 
-	static Error
-	decode(typename Message<schema::Tuple<T...>, Container>::Builder builder,
-		   Buffer &buffer) {
+	static error
+	decode(typename message<schema::Tuple<T...>, Container>::builder builder,
+		   buffer &buffer) {
 		return decodeMembers<0>(builder, buffer);
 	}
 };
 
-template <class... V, StringLiteral... K, class Container>
+template <class... V, string_literal... K, class Container>
 struct ProtoKelDecodeImpl<
-	Message<schema::Struct<schema::NamedMember<V, K>...>, Container>> {
+	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 &) {
-		return noError();
+	static typename std::enable_if<i == sizeof...(V), error>::type
+	decodeMembers(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(
-			typename Message<schema::Struct<schema::NamedMember<V, K>...>,
-							 Container>::Builder builder,
-			Buffer &buffer) {
+		i<sizeof...(V), error>::type decodeMembers(
+			typename message<schema::Struct<schema::NamedMember<V, K>...>,
+							 Container>::builder builder,
+			buffer &buffer) {
 
-		Error error =
+		error err =
 			ProtoKelDecodeImpl<typename Container::template ElementType<i>>::
 				decode(builder.template init<i>(), buffer);
-		if (error.failed()) {
-			return error;
+		if (err.failed()) {
+			return err;
 		}
 		return decodeMembers<i + 1>(builder, buffer);
 	}
 
-	static Error
-	decode(typename Message<schema::Struct<schema::NamedMember<V, K>...>,
-							Container>::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 <class... V, StringLiteral... K, class Container>
+template <class... V, string_literal... K, class Container>
 struct ProtoKelDecodeImpl<
-	Message<schema::Union<schema::NamedMember<V, K>...>, Container>> {
+	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) {
-		return noError();
+	static typename std::enable_if<i == sizeof...(V), error>::type
+	decodeMembers(typename message<schema::Union<schema::NamedMember<V, K>...>,
+								   Container>::builder,
+				  buffer &, ProtoKelCodec::UnionIdT) {
+		return no_error();
 	}
 
 	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 builder,
-			Buffer &buffer, ProtoKelCodec::UnionIdT id) {
+		i<sizeof...(V), error>::type decodeMembers(
+			typename message<schema::Union<schema::NamedMember<V, K>...>,
+							 Container>::builder builder,
+			buffer &buffer, ProtoKelCodec::UnionIdT id) {
 
 		if (id == i) {
-			Error error =
+			error err =
 				ProtoKelDecodeImpl<typename Container::template ElementType<
 					i>>::decode(builder.template init<i>(), buffer);
-			if (error.failed()) {
-				return error;
+			if (err.failed()) {
+				return err;
 			}
 		}
 		return decodeMembers<i + 1>(builder, buffer, id);
 	}
 
-	static Error
-	decode(typename Message<schema::Union<schema::NamedMember<V, K>...>,
-							Container>::Builder builder,
-		   Buffer &buffer) {
+	static error
+	decode(typename message<schema::Union<schema::NamedMember<V, K>...>,
+							Container>::builder builder,
+		   buffer &buffer) {
 		ProtoKelCodec::UnionIdT id = 0;
-		Error error = StreamValue<ProtoKelCodec::UnionIdT>::decode(id, buffer);
-		if (error.failed()) {
-			return error;
+		error err = stream_value<ProtoKelCodec::UnionIdT>::decode(id, buffer);
+		if (err.failed()) {
+			return err;
 		}
 		if (id >= sizeof...(V)) {
-			return criticalError("Union doesn't have this many id's");
+			return critical_error("Union doesn't have this many id's");
 		}
 
 		return decodeMembers<0>(builder, buffer, id);
@@ -475,85 +475,85 @@ struct ProtoKelDecodeImpl<
 };
 
 template <class T, class Container>
-struct ProtoKelDecodeImpl<Message<schema::Array<T>, Container>> {
-	static Error
-	decode(typename Message<schema::Array<T>, Container>::Builder data,
-		   Buffer &buffer) {
+struct ProtoKelDecodeImpl<message<schema::Array<T>, Container>> {
+	static error
+	decode(typename message<schema::Array<T>, Container>::builder data,
+		   buffer &buffer) {
 		ProtoKelCodec::ArrayLengthT array_length = 0;
 		{
-			Error error = StreamValue<ProtoKelCodec::ArrayLengthT>::decode(
+			error err = stream_value<ProtoKelCodec::ArrayLengthT>::decode(
 				array_length, buffer);
-			if (error.failed()) {
-				return error;
+			if (err.failed()) {
+				return err;
 			}
 		}
 
 		data.resize(array_length);
 
 		for (size_t i = 0; i < array_length; ++i) {
-			Error error =
+			error err =
 				ProtoKelDecodeImpl<typename Container::ElementType>::decode(
 					data.init(i), buffer);
-			if (error.failed()) {
-				return error;
+			if (err.failed()) {
+				return err;
 			}
 		}
-		return noError();
+		return no_error();
 	}
 };
 
 template <class Schema, class Container>
-Error ProtoKelCodec::encode(typename Message<Schema, Container>::Reader reader,
-							Buffer &buffer) {
-	BufferView view{buffer};
+error ProtoKelCodec::encode(typename message<Schema, Container>::reader reader,
+							buffer &buffer) {
+	buffer_view view{buffer};
 
 	ProtoKelCodec::PacketLengthT packet_length =
-		ProtoKelEncodeImpl<Message<Schema, Container>>::size(reader);
+		ProtoKelEncodeImpl<message<Schema, Container>>::size(reader);
 	// Check the size of the packet for the first
 	// message length description
 
-	Error error = view.writeRequireLength(packet_length +
+	error err = view.write_require_length(packet_length +
 										  sizeof(ProtoKelCodec::PacketLengthT));
-	if (error.failed()) {
-		return error;
+	if (err.failed()) {
+		return err;
 	}
 
 	{
-		Error error = StreamValue<ProtoKelCodec::PacketLengthT>::encode(
+		error err = stream_value<ProtoKelCodec::PacketLengthT>::encode(
 			packet_length, view);
-		if (error.failed()) {
-			return error;
+		if (err.failed()) {
+			return err;
 		}
 	}
 	{
-		Error error = ProtoKelEncodeImpl<Message<Schema, Container>>::encode(
+		error err = ProtoKelEncodeImpl<message<Schema, Container>>::encode(
 			reader, view);
-		if (error.failed()) {
-			return error;
+		if (err.failed()) {
+			return err;
 		}
 	}
 
-	buffer.writeAdvance(view.writeOffset());
-	return noError();
+	buffer.write_advance(view.write_offset());
+	return no_error();
 }
 
 template <class Schema, class Container>
-Error ProtoKelCodec::decode(
-	typename Message<Schema, Container>::Builder builder, Buffer &buffer,
+error ProtoKelCodec::decode(
+	typename message<Schema, Container>::builder builder, buffer &buffer,
 	const Limits &limits) {
-	BufferView view{buffer};
+	buffer_view view{buffer};
 
 	ProtoKelCodec::PacketLengthT packet_length = 0;
 	{
-		Error error = StreamValue<ProtoKelCodec::PacketLengthT>::decode(
+		error err = stream_value<ProtoKelCodec::PacketLengthT>::decode(
 			packet_length, view);
-		if (error.failed()) {
-			return error;
+		if (err.failed()) {
+			return err;
 		}
 	}
 
 	if (packet_length > limits.packet_size) {
-		return criticalError(
+		return critical_error(
 			[packet_length]() {
 				return std::string{"Packet size too big: "} +
 					   std::to_string(packet_length);
@@ -562,21 +562,21 @@ Error ProtoKelCodec::decode(
 	}
 
 	{
-		Error error = ProtoKelDecodeImpl<Message<Schema, Container>>::decode(
+		error err = ProtoKelDecodeImpl<message<Schema, Container>>::decode(
 			builder, view);
-		if (error.failed()) {
-			return error;
+		if (err.failed()) {
+			return err;
 		}
 	}
 	{
-		if (ProtoKelEncodeImpl<Message<Schema, Container>>::size(
-				builder.asReader()) != packet_length) {
-			return criticalError("Bad packet format");
+		if (ProtoKelEncodeImpl<message<Schema, Container>>::size(
+				builder.as_reader()) != packet_length) {
+			return critical_error("Bad packet format");
 		}
 	}
 
-	buffer.readAdvance(view.readOffset());
-	return noError();
+	buffer.read_advance(view.read_offset());
+	return no_error();
 }
 
 } // namespace saw
diff --git a/source/forstio/schema.h b/source/forstio/schema.h
index c69e86f..f2b3d18 100644
--- a/source/forstio/schema.h
+++ b/source/forstio/schema.h
@@ -6,7 +6,7 @@
 namespace saw {
 namespace schema {
 
-template <typename T, StringLiteral Literal> struct NamedMember {};
+template <typename T, string_literal Literal> struct NamedMember {};
 
 template <typename... T> struct Struct {
 	static_assert(
@@ -14,7 +14,7 @@ template <typename... T> struct Struct {
 		"This schema template doesn't support this type of template argument");
 };
 
-template <typename... V, StringLiteral... K>
+template <typename... V, string_literal... K>
 struct Struct<NamedMember<V, K>...> {};
 
 template <typename... T> struct Union {
@@ -23,7 +23,7 @@ template <typename... T> struct Union {
 		"This schema template doesn't support this type of template argument");
 };
 
-template <typename... V, StringLiteral... K>
+template <typename... V, string_literal... K>
 struct Union<NamedMember<V, K>...> {};
 
 template <typename T> struct Array {};
@@ -60,7 +60,7 @@ using Float64 = Primitive<FloatingPoint, 8>;
 /**
  * Classes enabling Rpc calls
  */
-template <class Request, class Response, StringLiteral Literal>
+template <class Request, class Response, string_literal Literal>
 struct Function {};
 
 template <class... T> struct Interface {
@@ -69,7 +69,7 @@ template <class... T> struct Interface {
 		"This schema template doesn't support this type of template argument");
 };
 
-template <class... Request, class... Response, StringLiteral... Literal>
+template <class... Request, class... Response, string_literal... Literal>
 struct Interface<Function<Request, Response, Literal>...> {};
 
 } // namespace schema
diff --git a/source/forstio/stream_endian.h b/source/forstio/stream_endian.h
index 464cb99..4ab011c 100644
--- a/source/forstio/stream_endian.h
+++ b/source/forstio/stream_endian.h
@@ -15,16 +15,16 @@ namespace saw {
  * platform independent. So it does not matter if the memory layout is
  * little endian or big endian
  */
-template <typename T, size_t size = sizeof(T)> class ShiftStreamValue;
+template <typename T, size_t size = sizeof(T)> class shift_stream_value;
 
-template <typename T> class ShiftStreamValue<T, 1> {
+template <typename T> class shift_stream_value<T, 1> {
 public:
-	inline static Error decode(T &val, Buffer &buffer) {
+	inline static error decode(T &val, buffer &buffer) {
 		uint8_t &raw = reinterpret_cast<uint8_t &>(val);
 		return buffer.pop(raw, sizeof(T));
 	}
 
-	inline static Error encode(const T &val, Buffer &buffer) {
+	inline static error encode(const T &val, buffer &buffer) {
 		const uint8_t &raw = reinterpret_cast<const uint8_t &>(val);
 		return buffer.push(raw, sizeof(T));
 	}
@@ -32,11 +32,11 @@ public:
 	inline static size_t size() { return sizeof(T); }
 };
 
-template <typename T> class ShiftStreamValue<T, 2> {
+template <typename T> class shift_stream_value<T, 2> {
 public:
-	inline static Error decode(T &val, Buffer &buffer) {
-		if (buffer.readCompositeLength() < sizeof(T)) {
-			return recoverableError("Buffer too small");
+	inline static error decode(T &val, buffer &buffer) {
+		if (buffer.read_composite_length() < sizeof(T)) {
+			return recoverable_error("Buffer too small");
 		}
 
 		uint16_t raw = 0;
@@ -45,13 +45,13 @@ public:
 			raw |= (static_cast<uint16_t>(buffer.read(i)) << (i * 8));
 		}
 		memcpy(&val, &raw, sizeof(T));
-		buffer.readAdvance(sizeof(T));
+		buffer.read_advance(sizeof(T));
 
-		return noError();
+		return no_error();
 	}
 
-	inline static Error encode(const T &val, Buffer &buffer) {
-		Error error = buffer.writeRequireLength(sizeof(T));
+	inline static error encode(const T &val, buffer &buffer) {
+		error error = buffer.write_require_length(sizeof(T));
 		if (error.failed()) {
 			return error;
 		}
@@ -63,18 +63,18 @@ public:
 			buffer.write(i) = raw >> (i * 8);
 		}
 
-		buffer.writeAdvance(sizeof(T));
-		return noError();
+		buffer.write_advance(sizeof(T));
+		return no_error();
 	}
 
 	inline static size_t size() { return sizeof(T); }
 };
 
-template <typename T> class ShiftStreamValue<T, 4> {
+template <typename T> class shift_stream_value<T, 4> {
 public:
-	inline static Error decode(T &val, Buffer &buffer) {
-		if (buffer.readCompositeLength() < sizeof(T)) {
-			return recoverableError("Buffer too small");
+	inline static error decode(T &val, buffer &buffer) {
+		if (buffer.read_composite_length() < sizeof(T)) {
+			return recoverable_error("Buffer too small");
 		}
 
 		uint32_t raw = 0;
@@ -83,13 +83,13 @@ public:
 			raw |= (static_cast<uint32_t>(buffer.read(i)) << (i * 8));
 		}
 		memcpy(&val, &raw, sizeof(T));
-		buffer.readAdvance(sizeof(T));
+		buffer.read_advance(sizeof(T));
 
-		return noError();
+		return no_error();
 	}
 
-	inline static Error encode(const T &val, Buffer &buffer) {
-		Error error = buffer.writeRequireLength(sizeof(T));
+	inline static error encode(const T &val, buffer &buffer) {
+		error error = buffer.write_require_length(sizeof(T));
 		if (error.failed()) {
 			return error;
 		}
@@ -101,18 +101,18 @@ public:
 			buffer.write(i) = raw >> (i * 8);
 		}
 
-		buffer.writeAdvance(sizeof(T));
-		return noError();
+		buffer.write_advance(sizeof(T));
+		return no_error();
 	}
 
 	inline static size_t size() { return sizeof(T); }
 };
 
-template <typename T> class ShiftStreamValue<T, 8> {
+template <typename T> class shift_stream_value<T, 8> {
 public:
-	inline static Error decode(T &val, Buffer &buffer) {
-		if (buffer.readCompositeLength() < sizeof(T)) {
-			return recoverableError("Buffer too small");
+	inline static error decode(T &val, buffer &buffer) {
+		if (buffer.read_composite_length() < sizeof(T)) {
+			return recoverable_error("Buffer too small");
 		}
 
 		uint64_t raw = 0;
@@ -122,13 +122,13 @@ public:
 		}
 
 		memcpy(&val, &raw, sizeof(T));
-		buffer.readAdvance(sizeof(T));
+		buffer.read_advance(sizeof(T));
 
-		return noError();
+		return no_error();
 	}
 
-	inline static Error encode(const T &val, Buffer &buffer) {
-		Error error = buffer.writeRequireLength(sizeof(T));
+	inline static error encode(const T &val, buffer &buffer) {
+		error error = buffer.write_require_length(sizeof(T));
 		if (error.failed()) {
 			return error;
 		}
@@ -140,13 +140,13 @@ public:
 			buffer.write(i) = raw >> (i * 8);
 		}
 
-		buffer.writeAdvance(sizeof(T));
-		return noError();
+		buffer.write_advance(sizeof(T));
+		return no_error();
 	}
 
 	inline static size_t size() { return sizeof(T); }
 };
 
-template <typename T> using StreamValue = ShiftStreamValue<T>;
+template <typename T> using stream_value = shift_stream_value<T>;
 
 } // namespace saw
diff --git a/source/forstio/string_literal.h b/source/forstio/string_literal.h
index 2624ecd..d530a54 100644
--- a/source/forstio/string_literal.h
+++ b/source/forstio/string_literal.h
@@ -9,9 +9,9 @@ namespace saw {
  * literal. It guarantees compile time uniqueness and thus allows using strings
  * in template parameters.
  */
-template <class CharT, size_t N> class StringLiteral {
+template <class CharT, size_t N> class string_literal {
 public:
-	constexpr StringLiteral(const CharT (&input)[N]) noexcept {
+	constexpr string_literal(const CharT (&input)[N]) noexcept {
 		for (size_t i = 0; i < N; ++i) {
 			data[i] = input[i];
 		}
@@ -24,17 +24,17 @@ public:
 	}
 
 	constexpr bool
-	operator==(const StringLiteral<CharT, N> &) const noexcept = default;
+	operator==(const string_literal<CharT, N> &) const noexcept = default;
 
 	template <class CharTR, size_t NR>
 	constexpr bool
-	operator==(const StringLiteral<CharTR, NR> &) const noexcept {
+	operator==(const string_literal<CharTR, NR> &) const noexcept {
 		return false;
 	}
 };
 
 template <typename T, T... Chars>
-constexpr StringLiteral<T, sizeof...(Chars)> operator""_key() {
-	return StringLiteral<T, sizeof...(Chars) + 1u>{Chars..., '\0'};
+constexpr string_literal<T, sizeof...(Chars)> operator""_key() {
+	return string_literal<T, sizeof...(Chars) + 1u>{Chars..., '\0'};
 }
 } // namespace saw
diff --git a/source/forstio/tls/tls.cpp b/source/forstio/tls/tls.cpp
index edec2f4..eb7423c 100644
--- a/source/forstio/tls/tls.cpp
+++ b/source/forstio/tls/tls.cpp
@@ -38,60 +38,60 @@ Tls::~Tls() {}
 
 Tls::Impl &Tls::getImpl() { return *impl; }
 
-class TlsIoStream final : public IoStream {
+class TlsIoStream final : public io_stream {
 private:
-	Own<IoStream> internal;
+	own<io_stream> internal;
 	gnutls_session_t session_handle;
 
 public:
-	TlsIoStream(Own<IoStream> internal_) : internal{std::move(internal_)} {}
+	TlsIoStream(own<io_stream> internal_) : internal{std::move(internal_)} {}
 
 	~TlsIoStream() { gnutls_bye(session_handle, GNUTLS_SHUT_RDWR); }
 
-	ErrorOr<size_t> read(void *buffer, size_t length) override {
+	error_or<size_t> read(void *buffer, size_t length) override {
 		ssize_t size = gnutls_record_recv(session_handle, buffer, length);
 		if (size < 0) {
 			if(gnutls_error_is_fatal(size) == 0){
-				return recoverableError([size](){return std::string{"Read recoverable Error "}+std::string{gnutls_strerror(size)};}, "Error read r");
+				return recoverable_error([size](){return std::string{"Read recoverable Error "}+std::string{gnutls_strerror(size)};}, "Error read r");
 			}else{
-				return criticalError([size](){return std::string{"Read critical Error "}+std::string{gnutls_strerror(size)};}, "Error read c");
+				return critical_error([size](){return std::string{"Read critical Error "}+std::string{gnutls_strerror(size)};}, "Error read c");
 			}
 		}else if(size == 0){
-			return criticalError("Disconnected");
+			return critical_error("Disconnected");
 		}
 
 		return static_cast<size_t>(length);
 	}
 
-	Conveyor<void> readReady() override { return internal->readReady(); }
+	conveyor<void> read_ready() override { return internal->read_ready(); }
 
-	Conveyor<void> onReadDisconnected() override {
-		return internal->onReadDisconnected();
+	conveyor<void> on_read_disconnected() override {
+		return internal->on_read_disconnected();
 	}
 
-	ErrorOr<size_t> write(const void *buffer, size_t length) override {
+	error_or<size_t> write(const void *buffer, size_t length) override {
 		ssize_t size = gnutls_record_send(session_handle, buffer, length);
 		if(size < 0){
 			if(gnutls_error_is_fatal(size) == 0){
-				return recoverableError([size](){return std::string{"Write recoverable Error "}+std::string{gnutls_strerror(size)} + " " + std::to_string(size);}, "Error write r");
+				return recoverable_error([size](){return std::string{"Write recoverable Error "}+std::string{gnutls_strerror(size)} + " " + std::to_string(size);}, "Error write r");
 			}else{
-				return criticalError([size](){return std::string{"Write critical Error "}+std::string{gnutls_strerror(size)} + " " + std::to_string(size);}, "Error write c");
+				return critical_error([size](){return std::string{"Write critical Error "}+std::string{gnutls_strerror(size)} + " " + std::to_string(size);}, "Error write c");
 			}
 		}
 
 		return static_cast<size_t>(size);
 	}
 
-	Conveyor<void> writeReady() override { return internal->writeReady(); }
+	conveyor<void> write_ready() override { return internal->write_ready(); }
 
 	gnutls_session_t &session() { return session_handle; }
 };
 
-TlsServer::TlsServer(Own<Server> srv) : internal{std::move(srv)} {}
+TlsServer::TlsServer(own<server> srv) : internal{std::move(srv)} {}
 
-Conveyor<Own<IoStream>> TlsServer::accept() {
-	SAW_ASSERT(internal) { return Conveyor<Own<IoStream>>{FixVoid<Own<IoStream>>{nullptr}}; }
-	return internal->accept().then([](Own<IoStream> stream) -> Own<IoStream> {
+conveyor<own<io_stream>> TlsServer::accept() {
+	SAW_ASSERT(internal) { return conveyor<own<io_stream>>{fix_void<own<io_stream>>{nullptr}}; }
+	return internal->accept().then([](own<io_stream> stream) -> own<io_stream> {
 		/// @todo handshake
 
 
@@ -105,14 +105,14 @@ namespace {
 */
 struct TlsClientStreamHelper {
 public:
-	Own<ConveyorFeeder<Own<IoStream>>> feeder;
-	ConveyorSink connection_sink;
-	ConveyorSink stream_reader;
-	ConveyorSink stream_writer;
+	own<conveyor_feeder<own<io_stream>>> feeder;
+	conveyor_sink connection_sink;
+	conveyor_sink stream_reader;
+	conveyor_sink stream_writer;
 
-	Own<TlsIoStream> stream = nullptr;
+	own<TlsIoStream> stream = nullptr;
 public:
-	TlsClientStreamHelper(Own<ConveyorFeeder<Own<IoStream>>> f):
+	TlsClientStreamHelper(own<conveyor_feeder<own<io_stream>>> f):
 		feeder{std::move(f)}
 	{}
 
@@ -121,11 +121,11 @@ public:
 			return;
 		}
 
-		stream_reader = stream->readReady().then([this](){
+		stream_reader = stream->read_ready().then([this](){
 			turn();
 		}).sink();
 
-		stream_writer = stream->writeReady().then([this](){
+		stream_writer = stream->write_ready().then([this](){
 			turn();
 		}).sink();
 	}
@@ -145,7 +145,7 @@ public:
 			} while ( (ret == GNUTLS_E_AGAIN || ret == GNUTLS_E_INTERRUPTED) && gnutls_error_is_fatal(ret) == 0);
 
 			if(gnutls_error_is_fatal(ret)){
-				feeder->fail(criticalError("Couldn't create Tls connection"));
+				feeder->fail(critical_error("Couldn't create Tls connection"));
 				stream = nullptr;
 			}else if(ret == GNUTLS_E_SUCCESS){
 				feeder->feed(std::move(stream));
@@ -155,20 +155,20 @@ public:
 };
 }
 
-Own<Server> TlsNetwork::listen(NetworkAddress& address) {
+own<server> TlsNetwork::listen(network_address& address) {
 	return heap<TlsServer>(internal.listen(address));
 }
 
-Conveyor<Own<IoStream>> TlsNetwork::connect(NetworkAddress& address) {
+conveyor<own<io_stream>> TlsNetwork::connect(network_address& address) {
 	// Helper setups
-	auto caf = newConveyorAndFeeder<Own<IoStream>>();
-	Own<TlsClientStreamHelper> helper = heap<TlsClientStreamHelper>(std::move(caf.feeder));
+	auto caf = new_conveyor_and_feeder<own<io_stream>>();
+	own<TlsClientStreamHelper> helper = heap<TlsClientStreamHelper>(std::move(caf.feeder));
 	TlsClientStreamHelper* hlp_ptr = helper.get();
 	
 	// Conveyor entangled structure
 	auto prim_conv = internal.connect(address).then([this, hlp_ptr, addr = address.address()](
-										Own<IoStream> stream) -> ErrorOr<void> {
-		IoStream* inner_stream = stream.get();
+										own<io_stream> stream) -> error_or<void> {
+		io_stream* inner_stream = stream.get();
 		auto tls_stream = heap<TlsIoStream>(std::move(stream));
 
 		auto &session = tls_stream->session();
@@ -201,20 +201,20 @@ Conveyor<Own<IoStream>> TlsNetwork::connect(NetworkAddress& address) {
 	return caf.conveyor.attach(std::move(helper));
 }
 
-Own<Datagram> TlsNetwork::datagram(NetworkAddress& address){
+own<datagram> TlsNetwork::datagram(network_address& address){
 	///@unimplemented
 	return nullptr;
 }
 
 static ssize_t forst_tls_push_func(gnutls_transport_ptr_t p, const void *data,
 						 size_t size) {
-	IoStream *stream = reinterpret_cast<IoStream *>(p);
+	io_stream *stream = reinterpret_cast<io_stream *>(p);
 	if (!stream) {
 		return -1;
 	}
 
-	ErrorOr<size_t> length = stream->write(data, size);
-	if (length.isError() || !length.isValue()) {
+	error_or<size_t> length = stream->write(data, size);
+	if (length.is_error() || !length.is_value()) {
 		return -1;
 	}
 
@@ -222,29 +222,29 @@ static ssize_t forst_tls_push_func(gnutls_transport_ptr_t p, const void *data,
 }
 
 static ssize_t forst_tls_pull_func(gnutls_transport_ptr_t p, void *data, size_t size) {
-	IoStream *stream = reinterpret_cast<IoStream *>(p);
+	io_stream *stream = reinterpret_cast<io_stream *>(p);
 	if (!stream) {
 		return -1;
 	}
 
-	ErrorOr<size_t> length = stream->read(data, size);
-	if (length.isError() || !length.isValue()) {
+	error_or<size_t> length = stream->read(data, size);
+	if (length.is_error() || !length.is_value()) {
 		return -1;
 	}
 
 	return static_cast<ssize_t>(length.value());
 }
 
-TlsNetwork::TlsNetwork(Tls& tls_, Network &network) : tls{tls_},internal{network} {}
+TlsNetwork::TlsNetwork(Tls& tls_, network &network) : tls{tls_},internal{network} {}
 
-Conveyor<Own<NetworkAddress>> TlsNetwork::resolveAddress(const std::string &addr,
+conveyor<own<network_address>> TlsNetwork::resolve_address(const std::string &addr,
 													   uint16_t port) {
 	/// @todo tls server name needed. Check validity. Won't matter later on, because gnutls should fail anyway. But
 	/// it's better to find the error source sooner rather than later
-	return internal.resolveAddress(addr, port);
+	return internal.resolve_address(addr, port);
 }
 
-std::optional<Own<TlsNetwork>> setupTlsNetwork(Network &network) {
+std::optional<own<TlsNetwork>> setupTlsNetwork(network &network) {
 	return std::nullopt;
 }
 } // namespace saw
diff --git a/source/forstio/tls/tls.h b/source/forstio/tls/tls.h
index 1f5dfd5..319a0b9 100644
--- a/source/forstio/tls/tls.h
+++ b/source/forstio/tls/tls.h
@@ -9,30 +9,30 @@
 namespace saw {
 class Tls;
 
-class TlsServer final : public Server {
+class TlsServer final : public server {
 private:
-	Own<Server> internal;
+	own<server> internal;
 
 public:
-	TlsServer(Own<Server> srv);
+	TlsServer(own<server> srv);
 
-	Conveyor<Own<IoStream>> accept() override;
+	conveyor<own<io_stream>> accept() override;
 };
 
-class TlsNetwork final : public Network {
+class TlsNetwork final : public network {
 private:
 	Tls& tls;
-	Network &internal;
+	network &internal;
 public:
-	TlsNetwork(Tls& tls_, Network &network_);
+	TlsNetwork(Tls& tls_, network &network_);
 
-	Conveyor<Own<NetworkAddress>> resolveAddress(const std::string &addr, uint16_t port = 0) override;
+	conveyor<own<network_address>> resolve_address(const std::string &addr, uint16_t port = 0) override;
 	
-	Own<Server> listen(NetworkAddress& address) override;
+	own<server> listen(network_address& address) override;
 
-	Conveyor<Own<IoStream>> connect(NetworkAddress& address) override;
+	conveyor<own<io_stream>> connect(network_address& address) override;
 
-	Own<Datagram> datagram(NetworkAddress& address) override;
+	own<class datagram> datagram(network_address& address) override;
 };
 
 /**
@@ -42,7 +42,7 @@ public:
 class Tls {
 private:
 	class Impl;
-	Own<Impl> impl;
+	own<Impl> impl;
 public:
 	Tls();
 	~Tls();
@@ -58,13 +58,13 @@ public:
 		Version version;
 	};
 
-	Network& tlsNetwork();
+	network& tlsNetwork();
 
 	Impl &getImpl();
 private:
 	Options options;
 };
 
-std::optional<Own<TlsNetwork>> setupTlsNetwork(Network &network);
+std::optional<own<TlsNetwork>> setupTlsNetwork(network &network);
 
 } // namespace saw
diff --git a/test/async.cpp b/test/async.cpp
index 817cc6f..6ff082f 100644
--- a/test/async.cpp
+++ b/test/async.cpp
@@ -6,38 +6,38 @@ namespace {
 SAW_TEST("Async Immediate"){
 	using namespace saw;
 
-	EventLoop event_loop;
-	WaitScope wait_scope{event_loop};
+	event_loop event_loop;
+	wait_scope wait_scope{event_loop};
 
-	Conveyor<size_t> number{5};
+	conveyor<size_t> number{5};
 
-	Conveyor<bool> is_number = number.then([](size_t val){
+	conveyor<bool> is_number = number.then([](size_t val){
 		return val == 5;
 	});
 
 	wait_scope.poll();
 
-	ErrorOr<bool> error_or_number = is_number.take();
+	error_or<bool> error_or_number = is_number.take();
 
-	SAW_EXPECT(!error_or_number.isError(), error_or_number.error().message());
-	SAW_EXPECT(error_or_number.isValue(), "Return is not a value");
+	SAW_EXPECT(!error_or_number.is_error(), error_or_number.error().message());
+	SAW_EXPECT(error_or_number.is_value(), "Return is not a value");
 	SAW_EXPECT(error_or_number.value(), "Value is not 5");
 }
 
 SAW_TEST("Async Adapt"){
 	using namespace saw;
 
-	EventLoop event_loop;
-	WaitScope wait_scope{event_loop};
+	event_loop event_loop;
+	wait_scope wait_scope{event_loop};
 
-	auto feeder_conveyor = newConveyorAndFeeder<size_t>();
+	auto feeder_conveyor = new_conveyor_and_feeder<size_t>();
 
 	feeder_conveyor.feeder->feed(5);
 
-	ErrorOr<size_t> foo = feeder_conveyor.conveyor.take();
+	error_or<size_t> foo = feeder_conveyor.conveyor.take();
 
-	SAW_EXPECT(!foo.isError(), foo.error().message());
-	SAW_EXPECT(foo.isValue(), "Return is not a value");
+	SAW_EXPECT(!foo.is_error(), foo.error().message());
+	SAW_EXPECT(foo.is_value(), "Return is not a value");
 	SAW_EXPECT(foo.value() == 5, "Values not 5, but " + std::to_string(foo.value()));
 }
 
@@ -45,72 +45,72 @@ SAW_TEST("Async Adapt"){
 SAW_TEST("Async Adapt Multiple"){
 	using namespace saw;
 
-	EventLoop event_loop;
-	WaitScope wait_scope{event_loop};
+	event_loop event_loop;
+	wait_scope wait_scope{event_loop};
 
-	auto feeder_conveyor = newConveyorAndFeeder<size_t>();
+	auto feeder_conveyor = new_conveyor_and_feeder<size_t>();
 
 	feeder_conveyor.feeder->feed(5);
 
-	ErrorOr<size_t> foo = feeder_conveyor.conveyor.take();
+	error_or<size_t> foo = feeder_conveyor.conveyor.take();
 
-	SAW_EXPECT(!foo.isError(), foo.error().message());
-	SAW_EXPECT(foo.isValue(), "Return is not a value");
+	SAW_EXPECT(!foo.is_error(), foo.error().message());
+	SAW_EXPECT(foo.is_value(), "Return is not a value");
 	SAW_EXPECT(foo.value() == 5, "Values not 5, but " + std::to_string(foo.value()));
 
 	feeder_conveyor.feeder->feed(10);
 
-	ErrorOr<size_t> bar = feeder_conveyor.conveyor.take();
+	error_or<size_t> bar = feeder_conveyor.conveyor.take();
 
-	SAW_EXPECT(!foo.isError(), bar.error().message());
-	SAW_EXPECT(bar.isValue(), "Return is not a value");
+	SAW_EXPECT(!foo.is_error(), bar.error().message());
+	SAW_EXPECT(bar.is_value(), "Return is not a value");
 	SAW_EXPECT(bar.value() == 10, "Values not 10, but " + std::to_string(bar.value()));
 
 	feeder_conveyor.feeder->feed(2);
 	feeder_conveyor.feeder->feed(4234);
 
-	ErrorOr<size_t> a = feeder_conveyor.conveyor.take();
-	ErrorOr<size_t> b = feeder_conveyor.conveyor.take();
+	error_or<size_t> a = feeder_conveyor.conveyor.take();
+	error_or<size_t> b = feeder_conveyor.conveyor.take();
 
-	SAW_EXPECT(!foo.isError(), a.error().message());
-	SAW_EXPECT(a.isValue(), "Return is not a value");
+	SAW_EXPECT(!foo.is_error(), a.error().message());
+	SAW_EXPECT(a.is_value(), "Return is not a value");
 	SAW_EXPECT(a.value() == 2, "Values not 2, but " + std::to_string(a.value()));
 
-	SAW_EXPECT(!foo.isError(), b.error().message());
-	SAW_EXPECT(b.isValue(), "Return is not a value");
+	SAW_EXPECT(!foo.is_error(), b.error().message());
+	SAW_EXPECT(b.is_value(), "Return is not a value");
 	SAW_EXPECT(b.value() == 4234, "Values not 4234, but " + std::to_string(b.value()));
 }
 
 SAW_TEST("Async Conversion"){
 	using namespace saw;
 
-	EventLoop event_loop;
-	WaitScope wait_scope{event_loop};
+	event_loop event_loop;
+	wait_scope wait_scope{event_loop};
 
-	auto feeder_conveyor = newConveyorAndFeeder<size_t>();
+	auto feeder_conveyor = new_conveyor_and_feeder<size_t>();
 
-	Conveyor<std::string> string_conveyor = feeder_conveyor.conveyor.then([](size_t foo){
+	conveyor<std::string> string_conveyor = feeder_conveyor.conveyor.then([](size_t foo){
 		return std::to_string(foo);
 	});
 
 	feeder_conveyor.feeder->feed(10);
 
-	ErrorOr<std::string> foo = string_conveyor.take();
+	error_or<std::string> foo = string_conveyor.take();
 
-	SAW_EXPECT(!foo.isError(), foo.error().message());
-	SAW_EXPECT(foo.isValue(), "Return is not a value");
+	SAW_EXPECT(!foo.is_error(), foo.error().message());
+	SAW_EXPECT(foo.is_value(), "Return is not a value");
 	SAW_EXPECT(foo.value() == std::to_string(10), "Values is not 10, but " + foo.value());
 }
 
 SAW_TEST("Async Conversion Multistep"){
 	using namespace saw;
 
-	EventLoop event_loop;
-	WaitScope wait_scope{event_loop};
+	event_loop event_loop;
+	wait_scope wait_scope{event_loop};
 
-	auto feeder_conveyor = newConveyorAndFeeder<size_t>();
+	auto feeder_conveyor = new_conveyor_and_feeder<size_t>();
 
-	Conveyor<bool> conveyor = feeder_conveyor.conveyor.then([](size_t foo){
+	conveyor<bool> conveyor = feeder_conveyor.conveyor.then([](size_t foo){
 		return std::to_string(foo);
 	}).then([](const std::string& value){
 		return value != "10";
@@ -120,29 +120,29 @@ SAW_TEST("Async Conversion Multistep"){
 
 	feeder_conveyor.feeder->feed(10);
 
-	ErrorOr<bool> foo = conveyor.take();
+	error_or<bool> foo = conveyor.take();
 
-	SAW_EXPECT(!foo.isError(), foo.error().message());
-	SAW_EXPECT(foo.isValue(), "Return is not a value");
+	SAW_EXPECT(!foo.is_error(), foo.error().message());
+	SAW_EXPECT(foo.is_value(), "Return is not a value");
 	SAW_EXPECT(foo.value(), "Values is not true");
 }
 
 SAW_TEST("Async Scheduling"){
 	using namespace saw;
 
-	EventLoop event_loop;
-	WaitScope wait_scope{event_loop};
+	event_loop event_loop;
+	wait_scope wait_scope{event_loop};
 
-	auto feeder_conveyor = newConveyorAndFeeder<size_t>();
+	auto feeder_conveyor = new_conveyor_and_feeder<size_t>();
 
 	/*
 	* Attach node test data
 	*/
-	Own<size_t> counter = heap<size_t>();
+	own<size_t> counter = heap<size_t>();
 	size_t* ctr_ptr = counter.get();
 	*ctr_ptr = 0;
 
-	Conveyor<std::string> string_conveyor = feeder_conveyor.conveyor
+	conveyor<std::string> string_conveyor = feeder_conveyor.conveyor
 	.then([ctr_ptr](size_t foo){
 		return std::to_string(foo + ++(*ctr_ptr));
 	})
@@ -163,34 +163,34 @@ SAW_TEST("Async Scheduling"){
 
 	wait_scope.poll();
 
-	ErrorOr<std::string> foo_10 = string_conveyor.take();
+	error_or<std::string> foo_10 = string_conveyor.take();
 
-	SAW_EXPECT(!foo_10.isError(), foo_10.error().message());
-	SAW_EXPECT(foo_10.isValue(), "Return is not a value");
+	SAW_EXPECT(!foo_10.is_error(), foo_10.error().message());
+	SAW_EXPECT(foo_10.is_value(), "Return is not a value");
 	SAW_EXPECT(foo_10.value() == (std::string{"pre"} + std::to_string(11) + std::string{"post"}), "Values is not pre11post, but " + foo_10.value());
 
-	ErrorOr<std::string> foo_20 = string_conveyor.take();
+	error_or<std::string> foo_20 = string_conveyor.take();
 
-	SAW_EXPECT(!foo_20.isError(), foo_20.error().message());
-	SAW_EXPECT(foo_20.isValue(), "Return is not a value");
+	SAW_EXPECT(!foo_20.is_error(), foo_20.error().message());
+	SAW_EXPECT(foo_20.is_value(), "Return is not a value");
 	SAW_EXPECT(foo_20.value() == (std::string{"pre"} + std::to_string(22) + std::string{"post"}), "Values is not pre22post, but " + foo_20.value());
 
-	ErrorOr<std::string> foo_30 = string_conveyor.take();
+	error_or<std::string> foo_30 = string_conveyor.take();
 
-	SAW_EXPECT(!foo_30.isError(), foo_30.error().message());
-	SAW_EXPECT(foo_30.isValue(), "Return is not a value");
+	SAW_EXPECT(!foo_30.is_error(), foo_30.error().message());
+	SAW_EXPECT(foo_30.is_value(), "Return is not a value");
 	SAW_EXPECT(foo_30.value() == (std::string{"pre"} + std::to_string(33) + std::string{"post"}), "Values is not pre33post, but " + foo_30.value());
 }
 
 SAW_TEST("Async Detach"){
 	using namespace saw;
 
-	EventLoop event_loop;
-	WaitScope wait_scope{event_loop};
+	event_loop event_loop;
+	wait_scope wait_scope{event_loop};
 
 	int num = 0;
 
-	Conveyor<int>{10}.then([&num](int bar){
+	conveyor<int>{10}.then([&num](int bar){
 		num = bar;
 	}).detach();
 
@@ -202,14 +202,14 @@ SAW_TEST("Async Detach"){
 SAW_TEST("Async Merge"){
 	using namespace saw;
 
-	EventLoop event_loop;
-	WaitScope wait_scope{event_loop};
+	event_loop event_loop;
+	wait_scope wait_scope{event_loop};
 
-	auto cam = Conveyor<int>{10}.merge();
+	auto cam = conveyor<int>{10}.merge();
 
-	cam.second.attach(Conveyor<int>{11});
+	cam.second.attach(conveyor<int>{11});
 
-	cam.second.attach(Conveyor<int>{14});
+	cam.second.attach(conveyor<int>{14});
 
 	size_t elements_passed = 0;
 	bool wrong_value = false;
@@ -231,12 +231,12 @@ SAW_TEST("Async Merge"){
 SAW_TEST("Async Connect"){
 	using namespace saw;
 
-	EventLoop event_loop;
-	WaitScope wait_scope{event_loop};
+	event_loop event_loop;
+	wait_scope wait_scope{event_loop};
 
-	auto caf1 = newConveyorAndFeeder<int>();
+	auto caf1 = new_conveyor_and_feeder<int>();
 
-	auto caf2 = newConveyorAndFeeder<float>();
+	auto caf2 = new_conveyor_and_feeder<float>();
 
 	bool val_passed = false;
 	auto conveyor1 = caf1.conveyor.then([&val_passed](int val) -> float{
diff --git a/test/message.cpp b/test/message.cpp
index c287a2a..06192d8 100644
--- a/test/message.cpp
+++ b/test/message.cpp
@@ -88,7 +88,7 @@ SAW_TEST("Message Struct"){
 
 using TestArray = schema::Array<schema::UInt32>;
 
-void arrayCheck(saw::Message<TestArray>::Builder builder){
+void arrayCheck(saw::message<TestArray>::builder builder){
 	auto one = builder.init(0);
 	auto two = builder.init(1);
 	auto three = builder.init(2);
@@ -97,7 +97,7 @@ void arrayCheck(saw::Message<TestArray>::Builder builder){
 	two.set(45);
 	three.set(1230);
 
-	auto reader = builder.asReader();
+	auto reader = builder.as_reader();
 
 	SAW_EXPECT(reader.get(0).get() == 24 && reader.get(1).get() == 45 && reader.get(2).get(), "Wrong values");
 }
diff --git a/test/proto_kel.cpp b/test/proto_kel.cpp
index fe8953b..83dc55f 100644
--- a/test/proto_kel.cpp
+++ b/test/proto_kel.cpp
@@ -32,13 +32,13 @@ SAW_TEST("Primitive Encoding"){
 
 	builder.set(value);
 
-	RingBuffer temp_buffer;
+	ring_buffer temp_buffer;
 	ProtoKelCodec codec;
 
-	Error error = codec.encode<TestSize>(root.read(), temp_buffer);
+	error err = codec.encode<TestSize>(root.read(), temp_buffer);
 
-	SAW_EXPECT(!error.failed(), error.message());
-	SAW_EXPECT(temp_buffer.readCompositeLength() == (sizeof(value)+sizeof(ProtoKelCodec::PacketLengthT)), "Bad Size: " + std::to_string(temp_buffer.readCompositeLength()));
+	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[pkt_shift] == 5 && temp_buffer[pkt_shift+1] == 0 && temp_buffer[pkt_shift+2] == 0 && temp_buffer[pkt_shift+3] == 0, "Wrong encoded values");
 }
@@ -54,14 +54,14 @@ SAW_TEST("List Encoding"){
 	auto second = builder.init<1>();
 	second.set(43871);
 
-	RingBuffer buffer;
+	ring_buffer buffer;
 	ProtoKelCodec codec;
 
-	Error error = codec.encode<TestTuple>(root.read(), buffer);
+	error err = codec.encode<TestTuple>(root.read(), buffer);
 
-	SAW_EXPECT(!error.failed(), error.message());
-	SAW_EXPECT(buffer.readCompositeLength() == 14, "Bad Size: " + std::to_string(buffer.readCompositeLength()));
-	SAW_EXPECT("06 00 00 00\n00 00 00 00\nbf 94 20 00\n5f ab" == buffer.toHex(), "Not equal encoding\n"+buffer.toHex());
+	SAW_EXPECT(!err.failed(), err.message());
+	SAW_EXPECT(buffer.read_composite_length() == 14, "Bad Size: " + std::to_string(buffer.read_composite_length()));
+	SAW_EXPECT("06 00 00 00\n00 00 00 00\nbf 94 20 00\n5f ab" == buffer.to_hex(), "Not equal encoding\n"+buffer.to_hex());
 }
 
 SAW_TEST("Struct Encoding"){
@@ -80,15 +80,15 @@ SAW_TEST("Struct Encoding"){
 	auto string_name = builder.init<"test_name">();
 	string_name.set("test_name");
 
-	RingBuffer buffer;
+	ring_buffer buffer;
 	ProtoKelCodec codec;
 
-	Error error = codec.encode<TestStruct>(builder.asReader(), buffer);
+	error err = codec.encode<TestStruct>(builder.as_reader(), buffer);
 
-	SAW_EXPECT(!error.failed(), error.message());
-	SAW_EXPECT(buffer.readCompositeLength() == 40, "Bad Size: " + std::to_string(buffer.readCompositeLength()));
+	SAW_EXPECT(!err.failed(), err.message());
+	SAW_EXPECT(buffer.read_composite_length() == 40, "Bad Size: " + std::to_string(buffer.read_composite_length()));
 	SAW_EXPECT("20 00 00 00\n00 00 00 00\n17 00 00 00\n03 00 00 00\n00 00 00 00\n66 6f 6f 09\n00 00 00 00\n00 00 00 74\n65 73 74 5f\n6e 61 6d 65"
-		== buffer.toHex(), "Not equal encoding:\n"+buffer.toHex());
+		== buffer.to_hex(), "Not equal encoding:\n"+buffer.to_hex());
 }
 
 SAW_TEST("Union Encoding"){
@@ -100,15 +100,15 @@ SAW_TEST("Union Encoding"){
 		auto test_uint = builder.init<"test_uint">();
 		test_uint.set(23);
 
-		RingBuffer buffer;
+		ring_buffer buffer;
 		ProtoKelCodec codec;
 
-		Error error = codec.encode<TestUnion>(builder.asReader(), buffer);
+		error err = codec.encode<TestUnion>(builder.as_reader(), buffer);
 
-		SAW_EXPECT(!error.failed(), error.message());
-		SAW_EXPECT(buffer.readCompositeLength() == 16, "Bad Size: " + std::to_string(buffer.readCompositeLength()));
+		SAW_EXPECT(!err.failed(), err.message());
+		SAW_EXPECT(buffer.read_composite_length() == 16, "Bad Size: " + std::to_string(buffer.read_composite_length()));
 		SAW_EXPECT("08 00 00 00\n00 00 00 00\n00 00 00 00\n17 00 00 00"
-			== buffer.toHex(), "Not equal encoding:\n"+buffer.toHex());
+			== buffer.to_hex(), "Not equal encoding:\n"+buffer.to_hex());
 	}
 	{
 		auto root = heapMessageRoot<TestUnion>();
@@ -117,15 +117,15 @@ SAW_TEST("Union Encoding"){
 		auto test_string = builder.init<"test_string">();
 		test_string.set("foo");
 
-		RingBuffer buffer;
+		ring_buffer buffer;
 		ProtoKelCodec codec;
 
-		Error error = codec.encode<TestUnion>(builder.asReader(), buffer);
+		error err = codec.encode<TestUnion>(builder.as_reader(), buffer);
 
-		SAW_EXPECT(!error.failed(), error.message());
-		SAW_EXPECT(buffer.readCompositeLength() == 23, "Bad Size: " + std::to_string(buffer.readCompositeLength()));
+		SAW_EXPECT(!err.failed(), err.message());
+		SAW_EXPECT(buffer.read_composite_length() == 23, "Bad Size: " + std::to_string(buffer.read_composite_length()));
 		SAW_EXPECT("0f 00 00 00\n00 00 00 00\n01 00 00 00\n03 00 00 00\n00 00 00 00\n66 6f 6f"
-			== buffer.toHex(), "Not equal encoding:\n"+buffer.toHex());
+			== buffer.to_hex(), "Not equal encoding:\n"+buffer.to_hex());
 	}
 }
 
@@ -133,7 +133,7 @@ SAW_TEST("Tuple Decoding"){
 	using namespace saw;
 	const uint8_t buffer_raw[] = {0x06, 0, 0, 0, 0, 0, 0, 0, 0xbf, 0x94, 0x20, 0x00, 0x5f, 0xab};
 
-	RingBuffer buffer;
+	ring_buffer buffer;
 	buffer.push(*buffer_raw, sizeof(buffer_raw));
 
 	ProtoKelCodec codec;
@@ -141,10 +141,10 @@ SAW_TEST("Tuple Decoding"){
 	auto root = heapMessageRoot<TestTuple>();
 	auto builder = root.build();
 
-	Error error = codec.decode<TestTuple>(builder, buffer);
-	SAW_EXPECT(!error.failed(), error.message());
+	error err = codec.decode<TestTuple>(builder, buffer);
+	SAW_EXPECT(!err.failed(), err.message());
 	
-	auto reader = builder.asReader();
+	auto reader = builder.as_reader();
 
 	auto first = reader.get<0>();
 	auto second = reader.get<1>();
@@ -156,7 +156,7 @@ SAW_TEST("Struct Decoding"){
 	using namespace saw;
 	const uint8_t buffer_raw[] = {0x20,0,0,0,0,0,0,0,0x17,0,0,0,0x03,0,0,0,0,0,0,0,0x66,0x6f,0x6f,0x09,0,0,0,0,0,0,0,0x74,0x65,0x73,0x74,0x5f,0x6e,0x61,0x6d,0x65};
 
-	RingBuffer buffer;
+	ring_buffer buffer;
 	buffer.push(*buffer_raw, sizeof(buffer_raw));
 
 	ProtoKelCodec codec;
@@ -164,14 +164,14 @@ SAW_TEST("Struct Decoding"){
 	auto root = heapMessageRoot<TestStruct>();
 	auto builder = root.build();
 
-	Error error = codec.decode<TestStruct>(builder, buffer);
-	auto reader = builder.asReader();
+	error err = codec.decode<TestStruct>(builder, buffer);
+	auto reader = builder.as_reader();
 
 	auto foo_string = reader.get<"test_string">();
 	auto test_uint = reader.get<"test_uint">();
 	auto test_name = reader.get<"test_name">();
 
-	SAW_EXPECT(!error.failed(), error.message());
+	SAW_EXPECT(!err.failed(), err.message());
 	SAW_EXPECT(foo_string.get() == "foo" && test_uint.get() == 23 && test_name.get() == "test_name", "Values not correctly decoded");
 }
 
@@ -179,18 +179,18 @@ SAW_TEST("Union Decoding"){
 	using namespace saw;
 	const uint8_t buffer_raw[] = {0x0f,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x03,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x66,0x6f,0x6f};
 
-	RingBuffer buffer;
+	ring_buffer buffer;
 	buffer.push(*buffer_raw, sizeof(buffer_raw));
 
 	ProtoKelCodec codec;
 
 	auto root = heapMessageRoot<TestUnion>();
 	auto builder = root.build();
-	auto reader = builder.asReader();
+	auto reader = builder.as_reader();
 
-	Error error = codec.decode<TestUnion>(builder, buffer);
+	error err = codec.decode<TestUnion>(builder, buffer);
 
-	SAW_EXPECT(!error.failed(), error.message());
+	SAW_EXPECT(!err.failed(), err.message());
 	SAW_EXPECT(reader.hasAlternative<"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()});
@@ -218,10 +218,10 @@ SAW_TEST("Array Encoding"){
 	two.init<"test_string">().set("bar");
 	two.init<"test_name">().set("Bravo");
 
-	RingBuffer buffer;
+	ring_buffer buffer;
 
-	Error error = codec.encode<TestArrayStruct>(root.read(), buffer);
+	error err = codec.encode<TestArrayStruct>(root.read(), buffer);
 
-	SAW_EXPECT(!error.failed(), "Error occured");
+	SAW_EXPECT(!err.failed(), "Error occured");
 }
 }