diff --git a/include/client.hpp b/include/client.hpp
index 2e256b8..b9d2e89 100644
--- a/include/client.hpp
+++ b/include/client.hpp
@@ -1,26 +1,25 @@
 #pragma once
 
 #include <boost/asio.hpp>
-#include "boost/bind.hpp"
 #include <functional>
 #include <sstream>
 #include <string>
 #include <vector>
 
-class client
-{
-public:
+#include "boost/bind.hpp"
+
+class client {
+ public:
   client(boost::asio::io_service& io_service,
          const boost::asio::ip::address& multicast_address,
-         short multicast_port,
-         unsigned short tcp_port);
+         short multicast_port, unsigned short tcp_port);
 
   void init();
   void set_outbound_interface(const boost::asio::ip::address_v4& address);
   void handle_send_to(const boost::system::error_code& error);
   void handle_timeout(const boost::system::error_code& error);
 
-private:
+ private:
   boost::asio::ip::udp::endpoint endpoint_;
   boost::asio::ip::udp::socket socket_;
   boost::asio::deadline_timer timer_;
diff --git a/include/server.hpp b/include/server.hpp
index 781eac8..d4096ff 100644
--- a/include/server.hpp
+++ b/include/server.hpp
@@ -1,63 +1,55 @@
 #pragma once
 
+#include <boost/asio.hpp>
 #include <cstdlib>
 #include <iostream>
-#include <boost/asio.hpp>
 
 #include "protocol.hpp"
+#include "spdlog/spdlog.h"
 
 using boost::asio::ip::udp;
 
-class server
-{
-public:
+class server {
+ public:
   server(boost::asio::io_context& io_context, short port)
-    : socket_(io_context, udp::endpoint(udp::v4(), port))
-  {
+      : socket_(io_context, udp::endpoint(udp::v4(), port)) {
     do_receive();
   }
 
-  void do_receive()
-  {
-    std::cout << "do_receive\n";
+  void do_receive() {
+    spdlog::debug("do receive");
     socket_.async_receive_from(
         boost::asio::buffer(data_, max_length), sender_endpoint_,
-        [this](boost::system::error_code ec, std::size_t bytes_recvd)
-        {
-          if (!ec && bytes_recvd > 0)
-          {
+        [this](boost::system::error_code ec, std::size_t bytes_recvd) {
+          if (!ec && bytes_recvd > 0) {
             std::cout << data_ << std::endl;
 
-            auto* msg_obj = reinterpret_cast<commons::protocol::generic_message_base*>(data_);
+            auto* msg_obj =
+                reinterpret_cast<commons::protocol::generic_message_base*>(
+                    data_);
+            spdlog::debug("Object Type: {}",
+                          static_cast<int>(msg_obj->get_type()));
+            spdlog::debug("Object Size: {}", msg_obj->get_size());
 
-            std::cout << "Received Type: " << static_cast<int>(msg_obj->get_type()) << "\n";
-            std::cout << "Received Size: " << msg_obj->get_size() << "\n";
-
-            auto* casted_obj = reinterpret_cast<commons::protocol::draw_rectangle*>(msg_obj);
-
-            std::cout << "Positon: X = " << casted_obj->position.x
-                              << " Y = " << casted_obj->position.y << std::endl;
+            auto* casted_obj =
+                reinterpret_cast<commons::protocol::draw_rectangle*>(msg_obj);
+            spdlog::debug("Position: X = {}, Y = {}", casted_obj->position.x,
+                          casted_obj->position.y);
 
             do_send(bytes_recvd);
-          }
-          else
-          {
+          } else {
             do_receive();
           }
         });
   }
 
-  void do_send(std::size_t length)
-  {
-    socket_.async_send_to(
-        boost::asio::buffer(data_, length), sender_endpoint_,
-        [this](boost::system::error_code /*ec*/, std::size_t /*bytes_sent*/)
-        {
-          do_receive();
-        });
+  void do_send(std::size_t length) {
+    socket_.async_send_to(boost::asio::buffer(data_, length), sender_endpoint_,
+                          [this](boost::system::error_code /*ec*/,
+                                 std::size_t /*bytes_sent*/) { do_receive(); });
   }
 
-private:
+ private:
   udp::socket socket_;
   udp::endpoint sender_endpoint_;
   enum { max_length = 1024 };
diff --git a/src/client.cpp b/src/client.cpp
index fe4f595..ee31a2a 100644
--- a/src/client.cpp
+++ b/src/client.cpp
@@ -1,65 +1,56 @@
 #include "client.hpp"
 
-#include "protocol.hpp"
-
 #include <iostream>
 
+#include "protocol.hpp"
+#include "spdlog/spdlog.h"
+
 client::client(boost::asio::io_service& io_service,
                const boost::asio::ip::address& multicast_address,
-               short multicast_port,
-               unsigned short tcp_port)
-  : endpoint_(multicast_address, multicast_port)
-  , socket_(io_service, endpoint_.protocol())
-  , timer_(io_service)
-  , port_(tcp_port)
-{}
+               short multicast_port, unsigned short tcp_port)
+    : endpoint_(multicast_address, multicast_port),
+      socket_(io_service, endpoint_.protocol()),
+      timer_(io_service),
+      port_(tcp_port) {}
 
-void client::init()
-{
-  std::cout << "Send test msg\n";
+void client::init() {
+  spdlog::debug("Send test msg");
 
   auto msg = std::make_unique<commons::protocol::draw_rectangle>();
   msg->position = commons::protocol::vec2{3, 2};
 
   void* void_ptr = reinterpret_cast<void*>(msg.get());
   auto size = sizeof(*msg.get());
-  std::cout << "Object Type: " << static_cast<int>(msg->get_type()) << "\n";
-  std::cout << "Object size: " << size << "\n";
-
-  std::cout << "Positon: X = " << msg->position.x
-                    << " Y = " << msg->position.y << std::endl;
+  spdlog::debug("Object Type: {}", static_cast<int>(msg->get_type()));
+  spdlog::debug("Object Size: {}", size);
+  spdlog::debug("Position: X = {}, Y = {}", msg->position.x, msg->position.y);
 
   socket_.async_send_to(
-    boost::asio::buffer(void_ptr, size), endpoint_,
-    std::bind(&client::handle_send_to, this,
-      std::placeholders::_1));
+      boost::asio::buffer(void_ptr, size), endpoint_,
+      std::bind(&client::handle_send_to, this, std::placeholders::_1));
 }
 
-void client::set_outbound_interface(const boost::asio::ip::address_v4& address)
-{
+void client::set_outbound_interface(
+    const boost::asio::ip::address_v4& address) {
   boost::asio::ip::multicast::outbound_interface option(address);
   socket_.set_option(option);
 }
 
-void client::handle_send_to(const boost::system::error_code& error)
-{
-  if(!error)
-  {
+void client::handle_send_to(const boost::system::error_code& error) {
+  if (!error) {
     timer_.expires_from_now(boost::posix_time::seconds(1));
-    timer_.async_wait( std::bind(&client::handle_timeout, this,
-          std::placeholders::_1));
+    timer_.async_wait(
+        std::bind(&client::handle_timeout, this, std::placeholders::_1));
   }
 }
 
-void client::handle_timeout(const boost::system::error_code& error)
-{
-  if (!error)
-  {
-      //spdlog::trace("Resending Message: '{}'", "TestMessage");
-      std::cout << "done\n";
-      //socket_.async_send_to(
-      //    boost::asio::buffer("TestMessage"), endpoint_,
-      //    std::bind(&client::handle_send_to, this,
-      //      std::placeholders::_1));
+void client::handle_timeout(const boost::system::error_code& error) {
+  if (!error) {
+    // spdlog::trace("Resending Message: '{}'", "TestMessage");
+    spdlog::debug("done");
+    // socket_.async_send_to(
+    //     boost::asio::buffer("TestMessage"), endpoint_,
+    //     std::bind(&client::handle_send_to, this,
+    //       std::placeholders::_1));
   }
 }
diff --git a/src/main.cpp b/src/main.cpp
index b7645f9..c0e8dc7 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -1,55 +1,46 @@
 #include <iostream>
 
+#include "client.hpp"
 #include "protocol.hpp"
 #include "server.hpp"
-#include "client.hpp"
+#include "spdlog/spdlog.h"
 
+void init_spdlog() {
+  spdlog::set_level(spdlog::level::debug);  // Set global log level to debug
+  // spdlog::set_pattern("[%H:%M:%S %z] [%n] [%^---%L---%$] [thread %t] %v");
+  spdlog::debug("Setting Loglevel to debug...");
+}
 
-int main(int argc, char* argv[])
-{
-  try
-  {
-    boost::asio::io_context io_context;
-    if(argc == 1)
-    {
-      std::cout << "Running client\n";
-      client s(io_context, boost::asio::ip::make_address("0.0.0.0"), 9000, 0);
-      s.init();
-      io_context.run();
+void run_client() {
+  boost::asio::io_context io_context;
+  spdlog::info("Running client...");
+  client s(io_context, boost::asio::ip::make_address("0.0.0.0"), 9000, 0);
+  s.init();
+  io_context.run();
+}
+
+void run_server() {
+  boost::asio::io_context io_context;
+  spdlog::info("Running client...");
+  server s(io_context, 9000);
+  io_context.run();
+}
+
+int main(int argc, char *argv[]) {
+  init_spdlog();
+
+  try {
+    if (argc == 1) {
+      run_client();
     }
 
-    if(argc == 2)
-    {
-      std::cout << "Running server\n";
-      server s(io_context, 9000);
-      io_context.run();
+    if (argc == 2) {
+      run_server();
     }
 
-  }
-  catch (std::exception& e)
-  {
+  } catch (std::exception &e) {
     std::cerr << "Exception: " << e.what() << "\n";
   }
 
   return 0;
-
-//	using namespace commons::protocol;
-//	auto draw_msg = draw_rectangle{};
-//
-//	for(int i = 0; i < 3; ++i)
-//	{
-//		std::cout << "Size of " << i << " is " << get_size(static_cast<Type>(i)) << "\n";
-//	}
-//
-//	auto rectangle = std::make_unique<draw_pixel>();
-//	void* void_ptr = reinterpret_cast<void*>(rectangle.get());
-//
-//	generic_message_base* rectangle_ptr = reinterpret_cast<generic_message_base*>(void_ptr);
-//
-//	std::cout << "Type: " << static_cast<int>(rectangle_ptr->get_type()) << "\n";
-//	std::cout << "Size: " << static_cast<int>(rectangle_ptr->get_size()) << "\n";
-//
-//	auto* final_msg = get_object(rectangle_ptr->get_type(), rectangle_ptr);
-//
-//	return 0;
 }