diff --git a/.gitignore b/.gitignore
index f9013c5..5192dea 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,4 @@
+
 *.a
 *.log
 *.so
diff --git a/compile_commands.json b/compile_commands.json
deleted file mode 120000
index 2df4830..0000000
--- a/compile_commands.json
+++ /dev/null
@@ -1 +0,0 @@
-/mnt/combined/servers/acserver_GT4/utils/ACPlayer_tracker/build/compile_commands.json
\ No newline at end of file
diff --git a/include/handle.hpp b/include/handle.hpp
new file mode 100644
index 0000000..b57f823
--- /dev/null
+++ b/include/handle.hpp
@@ -0,0 +1,193 @@
+#ifndef HANDLE_HPP
+#define HANDLE_HPP
+
+#include <cstddef>
+#include <cstdint>
+#include <cstdlib>
+#include <iostream>
+#include <stdexcept>
+#include <string>
+#include <thread>
+#include <vector>
+
+#include "file.hpp" // for parce_args
+#include "net.hpp"  // for socket operations
+#include "server_structs.h"
+
+using namespace std;
+
+class PacketReader {
+  private:
+	const u_char *buffer_;
+	size_t buffer_size_;
+	size_t offset_ = 0;
+	bool error_ = false;
+
+  public:
+	PacketReader();  // TODO:
+	~PacketReader(); // TODO:
+
+	bool read_uint8(uint8_t &value) {
+		size_t __bytes = sizeof(value);
+
+		if (offset_ + __bytes > buffer_size_) {
+			error_ = true;
+			return false;
+		}
+
+		memcpy(&value, buffer_ + offset_, sizeof(value));
+
+		offset_++;
+		return true;
+	}
+
+	bool read_uint16(uint16_t &value) {
+		size_t __bytes = sizeof(value);
+
+		if (offset_ + __bytes > buffer_size_) {
+			error_ = true;
+			return false;
+		}
+
+		memcpy(&value, buffer_ + offset_, sizeof(value));
+		value = ntohs(value);
+
+		offset_ += 2;
+		return true;
+	}
+
+	bool read_uint32(uint32_t &value) {
+		size_t __bytes = sizeof(value);
+
+		if (offset_ + __bytes > buffer_size_) {
+			error_ = true;
+			return false;
+		}
+
+		memcpy(&value, buffer_ + offset_, sizeof(value));
+		value = ntohl(value);
+
+		offset_ += 4;
+		return true;
+	}
+
+	bool read_float(float &value) {
+		size_t __bytes = sizeof(value);
+
+		if (offset_ + __bytes > buffer_size_) {
+			error_ = true;
+			return false;
+		}
+
+		uint32_t v_int;
+		memcpy(&v_int, buffer_ + offset_, sizeof(v_int));
+		v_int = ntohl(v_int);
+
+		memcpy(&value, &v_int, sizeof(value));
+
+		offset_ += 4;
+		return true;
+	}
+
+	bool read_string_utf32l(string &value) {
+		uint8_t __length;
+		if (!read_uint8(__length))
+			return false;
+
+		if (offset_ + (__length * sizeof(uint32_t)) > buffer_size_) {
+			error_ = true;
+			return false;
+		}
+
+		value.clear();
+		for (size_t i = 0; i < __length; i++) {
+			uint32_t codeunit;
+			if (!read_uint32(codeunit))
+				return false;
+
+			if (codeunit == 0) {
+				break; // null terminator
+			}
+
+			value.push_back(static_cast<char>(codeunit));
+		}
+
+		return true;
+	}
+
+	bool has_error() const {
+		return error_;
+	}
+};
+
+class ProtocolHandler {
+  private:
+	trackAtributes track_info_;
+	carAtributes player_info_[64];
+
+  public:
+	ProtocolHandler();
+	~ProtocolHandler();
+
+	bool handle_new_session(PacketReader &reader) {
+
+		if (!reader.read_uint8(track_info_.protocol_version))
+			return false;
+		if (!reader.read_uint8(track_info_.session_index))
+			return false;
+		if (!reader.read_uint8(track_info_.current_session_index))
+			return false;
+		if (!reader.read_uint8(track_info_.session_count))
+			return false;
+
+        /*
+         * str_len_8 = read_uint8((const u_int8_t *)buffer, recv_bytes, &offset, &ok);
+			read_utf32le_string((const u_int8_t *)buffer, recv_bytes, &offset, trackInfo.server_name, str_len_8, &ok);
+
+			str_len_8 = read_uint8((const u_int8_t *)buffer, recv_bytes, &offset, &ok);
+			read_string((const u_int8_t *)buffer, recv_bytes, &offset, trackInfo.track, str_len_8, &ok);
+
+			str_len_8 = read_uint8((const u_int8_t *)buffer, recv_bytes, &offset, &ok);
+			read_string((const u_int8_t *)buffer, recv_bytes, &offset, trackInfo.track_config, str_len_8, &ok);
+
+			str_len_8 = read_uint8((const u_int8_t *)buffer, recv_bytes, &offset, &ok);
+			read_string((const u_int8_t *)buffer, recv_bytes, &offset, trackInfo.session_name, str_len_8, &ok);
+
+			trackInfo.typ = read_uint8((const u_int8_t *)buffer, recv_bytes, &offset, &ok);
+			trackInfo.time = read_uint16((const u_int8_t *)buffer, recv_bytes, &offset, &ok);
+			trackInfo.laps = read_uint16((const u_int8_t *)buffer, recv_bytes, &offset, &ok);
+			trackInfo.wait_time = read_uint16((const u_int8_t *)buffer, recv_bytes, &offset, &ok);
+			trackInfo.ambient_temp = read_uint8((const u_int8_t *)buffer, recv_bytes, &offset, &ok);
+			trackInfo.road_temp = read_uint8((const u_int8_t *)buffer, recv_bytes, &offset, &ok);
+
+			str_len_8 = read_uint8((const u_int8_t *)buffer, recv_bytes, &offset, &ok);
+			read_string((const u_int8_t *)buffer, recv_bytes, &offset, trackInfo.weather_graphics, str_len_8, &ok);
+         */
+
+        if (!reader.read_string_utf32l(track_info_.server_name))
+            return false;
+        if (!reader.read_string_utf32l(track_info_.track))
+            return false;
+        if (!reader.read_string_utf32l(track_info_.track_config))
+            return false;
+        if (!reader.read_string_utf32l(track_info_.session_name))
+            return false;
+        if (!reader.read_uint8(track_info_.typ))
+            return false;
+        if (!reader.read_uint16(track_info_.time))
+            return false;
+        if (!reader.read_uint16(track_info_.laps))
+            return false;
+        if (!reader.read_uint16(track_info_.wait_time))
+            return false;
+        if (!reader.read_uint8(track_info_.ambient_temp))
+            return false;
+        if (!reader.read_uint8(track_info_.road_temp))
+            return false;
+        if (!reader.read_string_utf32l(track_info_.weather_graphics))
+            return false;
+
+		return true;
+	}
+};
+#endif // HANDLE_HPP
diff --git a/include/log.h b/include/log.h
new file mode 100644
index 0000000..b88745d
--- /dev/null
+++ b/include/log.h
@@ -0,0 +1,23 @@
+#ifndef LOG_H
+#define LOG_H
+
+#include <stdio.h>
+#include <stdarg.h>
+#include <time.h>
+
+typedef enum {
+    LOG_INFO,
+    LOG_DEBUG,
+    LOG_WARN,
+    LOG_ERROR
+} LogLevel;
+
+void log_print(LogLevel level, const char* format, ...);
+
+#define log_info(...)  log_print(LOG_INFO, __VA_ARGS__)
+#define log_debug(...) log_print(LOG_DEBUG, __VA_ARGS__)
+#define log_warn(...)  log_print(LOG_WARN, __VA_ARGS__)
+#define log_error(...) log_print(LOG_ERROR, __VA_ARGS__)
+
+#endif // LOG_H
+
diff --git a/include/mapper.hpp b/include/mapper.hpp
new file mode 100644
index 0000000..fac161e
--- /dev/null
+++ b/include/mapper.hpp
@@ -0,0 +1,45 @@
+#ifndef MAPPER_HPP
+#define MAPPER_HPP
+
+#include <cstdint>
+#include <cstddef>
+
+#include "parcer.h"
+#include "server_structs.h"
+
+// INFO: This is basically a identity mapper between raw byte buffer and structs defined in server_structs.h
+class Mapper {
+  private:
+	const uint_least8_t *buffer;
+	size_t buffer_size;
+	size_t offset;
+	bool ok;
+
+  public:
+    Mapper(const uint_least8_t *buf, size_t buf_size);
+
+    uint8_t get_message_type();
+    bool is_ok() const { return ok; }
+
+    void parse_new_session(trackAtributes &track);
+    void parse_new_connection(carAtributes &car);
+    void parse_connection_closed(carAtributes &car);
+    void parse_car_update(carAtributes &car);
+    void parse_car_info(carAtributes &car);
+    void parse_lap_completed(uint8_t &car_id, uint32_t &lap_time, uint32_t &cuts);
+    void parse_collision_event(uint8_t &car1, uint8_t &car2, uint8_t &event_type);
+    void parse_chat(uint8_t &car_id, char *message, size_t max_len);
+    void parse_client_loaded(uint8_t &car_id);
+    
+    void set_size(size_t size) { this->buffer_size = size; }
+    void update_buffer(const uint8_t *buf, size_t size) {
+        this->buffer = buf;
+        this->buffer_size = size;
+        reset();
+    }
+  private:
+    // INFO: Reset the offset to 1 because the first byte is message type 
+    void reset() { offset = 1; ok = true; }
+};
+
+#endif // MAPPER_HPP
diff --git a/include/net.hpp b/include/net.hpp
index 8193c82..7c6e12f 100644
--- a/include/net.hpp
+++ b/include/net.hpp
@@ -9,6 +9,7 @@
 #include <sys/un.h>
 #include <unistd.h>
 
+#include "log.h"
 #include "server_structs.h"
 
 using namespace std;
diff --git a/include/parcer.c.old b/include/parcer.c.old
new file mode 100644
index 0000000..510d3f6
--- /dev/null
+++ b/include/parcer.c.old
@@ -0,0 +1,141 @@
+#include "parcer.h"
+#include "server_structs.h"
+#include <sys/types.h>
+
+int ensure(size_t recv_len, size_t offset, size_t need) {
+	return (offset + need <= recv_len);
+}
+
+u_int8_t read_uint8(const u_int8_t *buf, size_t recv_len, size_t *offset, int *ok) {
+	if (!ensure(recv_len, *offset, sizeof(uint8_t))) {
+		*ok = 0;
+		return 0;
+	}
+	u_int8_t v;
+	memcpy(&v, buf + *offset, sizeof(v));
+	*offset += sizeof(v);
+	return v;
+}
+
+u_int16_t read_uint16(const u_int8_t *buf, size_t recv_len, size_t *offset, int *ok) {
+	if (!ensure(recv_len, *offset, sizeof(uint16_t))) {
+		*ok = 0;
+		return 0;
+	}
+	u_int16_t v;
+	memcpy(&v, buf + *offset, sizeof(v));
+	*offset += sizeof(v);
+	return (u_int16_t)ntohs(v);
+}
+
+u_int32_t read_uint32(const u_int8_t *buf, size_t recv_len, size_t *offset, int *ok) {
+	if (!ensure(recv_len, *offset, sizeof(uint32_t))) {
+		*ok = 0;
+		return 0;
+	}
+	u_int32_t v;
+	memcpy(&v, buf + *offset, sizeof(v));
+	*offset += sizeof(v);
+	return (u_int32_t)ntohl(v);
+}
+
+int32_t read_int32(const u_int8_t *buf, size_t recv_len, size_t *offset, int *ok) {
+	if (!ensure(recv_len, *offset, sizeof(int32_t))) {
+		*ok = 0;
+		return 0;
+	}
+	int32_t v;
+	memcpy(&v, buf + *offset, sizeof(v));
+	*offset += sizeof(v);
+	return (int32_t)ntohl(v);
+}
+
+float read_float(const u_int8_t *buf, size_t recv_len, size_t *offset, int *ok) {
+	if (!ensure(recv_len, *offset, sizeof(float))) {
+		*ok = 0;
+		return 0.0f;
+	}
+	u_int32_t v_int;
+	memcpy(&v_int, buf + *offset, sizeof(v_int));
+	*offset += sizeof(v_int);
+	v_int = ntohl(v_int);
+	float v_float;
+	memcpy(&v_float, &v_int, sizeof(v_float));
+	return v_float;
+}
+
+void read_bytes(const u_int8_t *buf, size_t recv_len, size_t *offset, u_int8_t *out, size_t len, int *ok) {
+	if (!ensure(recv_len, *offset, len)) {
+		*ok = 0;
+		return;
+	}
+	memcpy(out, buf + *offset, len);
+	*offset += len;
+}
+
+void read_utf32le_string(const uint8_t *buffer, size_t buf_size, size_t *offset, char *dest, size_t max_len, int *ok) {
+	size_t i = *offset;
+	size_t j = 0;
+
+	while (i + 3 < buf_size && j < max_len) {
+		uint32_t codeunit = buffer[i] | (buffer[i + 1] << 8) | (buffer[i + 2] << 16) | (buffer[i + 3] << 24);
+
+		if (codeunit == 0) {
+			i += 4; // termina a string
+			break;
+		}
+
+		if (codeunit < 0x80) {
+			dest[j++] = (char)codeunit;
+		} else {
+			dest[j++] = '?'; // substitui caracteres fora de ASCII
+		}
+
+		i += 4;
+	}
+
+	dest[j] = '\0';
+	*offset = i;
+	*ok = 1;
+}
+
+void read_utf16le_string(const uint8_t *buffer, size_t buf_size, size_t *offset, char *dest, size_t max_len, int *ok) {
+	size_t i = *offset;
+	size_t j = 0;
+
+	while (i + 1 < buf_size && j < max_len - 1) {
+		uint16_t codeunit = buffer[i] | (buffer[i + 1] << 8);
+
+		if (codeunit == 0) {
+			i += 2; // termina a string
+			break;
+		}
+
+		if (codeunit < 0x80) {
+			dest[j++] = (char)codeunit;
+		} else {
+			dest[j++] = '?'; // substitui caracteres fora de ASCII
+		}
+
+		i += 2;
+	}
+
+	dest[j] = '\0';
+	*offset = i;
+	*ok = 1;
+}
+
+void read_string(const u_int8_t *buf, size_t recv_len, size_t *offset, char *out, size_t len, int *ok) {
+	if (!ensure(recv_len, *offset, len)) {
+		*ok = 0;
+		return;
+	}
+
+	for (size_t i = 0; i <= len; i++) {
+		out[i] = (char)buf[*offset + i];
+	}
+	out[len] = '\0'; // Ensure null termination
+	*offset += len;
+	*ok = 1;
+}
+
diff --git a/include/parcer.h b/include/parcer.h
index 55565da..d2e24cf 100644
--- a/include/parcer.h
+++ b/include/parcer.h
@@ -27,6 +27,10 @@ u_int8_t read_uint8(const u_int8_t *buf, size_t recv_len, size_t *offset, int *o
 // Advances the offset by 2 bytes.
 u_int16_t read_uint16(const u_int8_t *buf, size_t recv_len, size_t *offset, int *ok);
 
+// Reads a 16-bit unsigned integer from the buffer in little-endian byte order.
+// Advances the offset by 2 bytes.
+u_int16_t read_uint16_le(const u_int8_t *buf, size_t recv_len, size_t *offset, int *ok);
+
 // Reads a 32-bit unsigned integer from the buffer in network byte order.
 // Advances the offset by 4 bytes.
 u_int32_t read_uint32(const u_int8_t *buf, size_t recv_len, size_t *offset, int *ok);
diff --git a/include/parcer.h.old b/include/parcer.h.old
new file mode 100644
index 0000000..d55b470
--- /dev/null
+++ b/include/parcer.h.old
@@ -0,0 +1,62 @@
+#ifndef PARCER_H
+#define PARCER_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include "server_structs.hpp"
+
+// Ensures that there are at least 'need' bytes available in the buffer
+// starting from 'offset'. Returns 1 if enough bytes are available, 0 otherwise.
+int ensure(size_t recv_len, size_t offset, size_t need);
+
+// Reads an 8-bit unsigned integer from the buffer.
+// Advances the offset by 1 byte.
+u_int8_t read_uint8(const u_int8_t *buf, size_t recv_len, size_t *offset, int *ok);
+
+// Reads a 16-bit unsigned integer from the buffer in network byte order.
+// Advances the offset by 2 bytes.
+u_int16_t read_uint16(const u_int8_t *buf, size_t recv_len, size_t *offset, int *ok);
+
+// Reads a 32-bit unsigned integer from the buffer in network byte order.
+// Advances the offset by 4 bytes.
+u_int32_t read_uint32(const u_int8_t *buf, size_t recv_len, size_t *offset, int *ok);
+
+// Reads a 32-bit signed integer from the buffer in network byte order.
+// Advances the offset by 4 bytes.
+int32_t read_int32(const u_int8_t *buf, size_t recv_len, size_t *offset, int *ok);
+
+// Reads a 32-bit float from the buffer in network byte order.
+// Advances the offset by 4 bytes.
+float read_float(const u_int8_t *buf, size_t recv_len, size_t *offset, int *ok);
+
+// Reads a fixed number of bytes into the output buffer.
+// The output buffer must be at least 'len' bytes long.
+void read_bytes(const u_int8_t *buf, size_t recv_len, size_t *offset, u_int8_t *out, size_t len, int *ok);
+
+// Reads a length-prefixed string. The length is a single byte.
+// The string is not null-terminated in the buffer, but the function
+void read_utf32le_string(const uint8_t *buffer, size_t buf_size, size_t *offset, char *dest, size_t max_len, int *ok);
+
+// reads up to max_len - 1 characters and null-terminates the destination buffer.
+// The string is encoded in UTF-32LE.
+void read_utf16le_string(const uint8_t *buffer, size_t buf_size, size_t *offset, char *dest, size_t max_len, int *ok);
+
+// Reads a null-terminated string from the buffer.
+// The string is read into the output buffer, which must be at least max_len bytes long
+void read_string(const u_int8_t *buf, size_t recv_len, size_t *offset, char *out, size_t max_len, int *ok);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // PARCER_H
diff --git a/include/server_structs.h b/include/server_structs.h
index 9969f09..20b48df 100644
--- a/include/server_structs.h
+++ b/include/server_structs.h
@@ -199,6 +199,7 @@ enum ACSP_MessageType {
 	// ============================
 	// PROTOCOL VERSION
 	// ============================
+    //   DONE: Update this when protocol changes
 	PROTOCOL_VERSION = 4,
 
 	// ============================
diff --git a/include/server_structs.hpp b/include/server_structs.hpp
new file mode 100644
index 0000000..449409a
--- /dev/null
+++ b/include/server_structs.hpp
@@ -0,0 +1,158 @@
+#ifndef SERVER_STRUCTS_H
+#define SERVER_STRUCTS_H
+
+#include <cstddef>
+#include <cstdint>
+#include <cstdlib>
+#include <string>
+#include <sys/cdefs.h>
+#include <sys/types.h>
+
+using namespace std;
+
+typedef struct app_info {
+    // From args
+    u_int16_t app_id;
+    u_int16_t app_port_in;
+    u_int16_t app_port_out;
+
+    // From .env
+    const char *app_api_socket_path;
+    u_int16_t max_players;
+    const char *app_server_out_ip;
+} __attribute__((packed)) app_info;
+
+typedef struct postion {
+	float x;
+	float y;
+	float z;
+} __attribute__((packed)) postion;
+
+typedef enum flag {
+    NO_FLAG = 0,
+    YELLOW_FLAG = 1,
+    BLUE_FLAG = 2,
+    BLACK_FLAG = 3,
+    CHECKERED_FLAG = 4,
+} __attribute__((packed)) flag;
+
+typedef struct carAtributes {
+	// Related to ACSP_CAR_INFO
+	u_char isConnected; // 1 = connected, 0 = disconnected
+    u_char isLoading;  // 1 = loading, 0 = not isLoading
+
+	string car_model[64];
+	string car_skin[64];
+	string driver_name[64];
+	string driver_team[64];
+	string driver_GUID[64];
+
+	// Related to ACSP_CAR_UPDATE
+	u_int8_t carID;
+	postion position;
+	postion velocity;
+	u_int8_t carGear;
+	u_int16_t carRPM;
+    u_int32_t lap_time;
+    u_int32_t cuts;
+    u_int32_t total_cuts;
+    u_int32_t total_cuts_alltime;
+    u_int16_t total_laps_completed;
+    u_int16_t contacts;
+    u_int16_t total_contacts;
+
+    flag current_flag; // TODO: implement flag status updates
+                       // TAG:3
+
+	float normalizedSplinePos;
+} __attribute__((packed)) carAtributes;
+
+
+typedef enum SessionType {
+	PRACTICE = 0,
+	RACE = 1,
+	QUALIFYING = 2,
+} __attribute__((packed)) SessionType;
+
+typedef struct trackAtributes{
+	u_int8_t protocol_version;
+
+	u_int8_t session_index;
+	u_int8_t current_session_index;
+	u_int8_t session_count;
+	SessionType session_type;
+
+	string server_name;
+	string track[64];
+	string track_config[64];
+	string session_name[64];
+
+	u_int8_t typ;
+	u_int16_t time;
+	u_int16_t laps;
+	u_int16_t wait_time;
+	u_int8_t ambient_temp;
+	u_int8_t road_temp;
+
+	string weather_graphics[64];
+	u_int32_t elapsed_ms;
+} __attribute__((packed)) trackAtributes;
+
+typedef struct api_packet {
+    u_char message_type; // ACSP_MessageType
+    u_int8_t tracker_id;
+    u_int8_t connected_players;
+
+    carAtributes cars[64];
+    trackAtributes track_info;
+} __attribute__((packed)) api_packet;
+
+enum ACSP_MessageType {
+	// ============================
+	// PROTOCOL VERSION
+	// ============================
+	PROTOCOL_VERSION = 4,
+
+	// ============================
+	// SERVER → CLIENT MESSAGES
+	// ============================
+	ACSP_NEW_SESSION = 50,
+	ACSP_NEW_CONNECTION = 51,
+	ACSP_CONNECTION_CLOSED = 52,
+	ACSP_CAR_UPDATE = 53,
+	ACSP_CAR_INFO = 54, // Response to ACSP_GET_CAR_INFO
+	ACSP_END_SESSION = 55,
+	ACSP_VERSION = 56,
+	ACSP_CHAT = 57,
+	ACSP_CLIENT_LOADED = 58,
+	ACSP_SESSION_INFO = 59,
+	ACSP_ERROR = 60,
+	ACSP_LAP_COMPLETED = 73,
+
+	// ============================
+	// EVENTS
+	// ============================
+	ACSP_CLIENT_EVENT = 130,
+
+	// ============================
+	// EVENT TYPES
+	// ============================
+	ACSP_CE_COLLISION_WITH_CAR = 10,
+	ACSP_CE_COLLISION_WITH_ENV = 11,
+
+	// ============================
+	// CLIENT → SERVER COMMANDS
+	// ============================
+	ACSP_REALTIMEPOS_INTERVAL = 200,
+	ACSP_GET_CAR_INFO = 201,
+	ACSP_SEND_CHAT = 202,      // Sends chat to one car
+	ACSP_BROADCAST_CHAT = 203, // Sends chat to everybody
+	ACSP_GET_SESSION_INFO = 204,
+	ACSP_SET_SESSION_INFO = 205,
+	ACSP_KICK_USER = 206,
+	ACSP_NEXT_SESSION = 207,
+	ACSP_RESTART_SESSION = 208,
+	ACSP_ADMIN_COMMAND = 209 // Send message plus a string
+};
+
+#endif // SERVER_STRUCTS_H
diff --git a/include/session.hpp b/include/session.hpp
index 1d7ab86..425564c 100644
--- a/include/session.hpp
+++ b/include/session.hpp
@@ -14,7 +14,6 @@ private:
 
 public:
     SessionManager(u_int8_t sid);
-    ~SessionManager();
     
     void on_new_session(const trackAtributes &track);
     void on_player_connected(const carAtributes &car);
diff --git a/include/socket.c.old b/include/socket.c.old
new file mode 100644
index 0000000..baed2dc
--- /dev/null
+++ b/include/socket.c.old
@@ -0,0 +1,90 @@
+#include "socket.h"
+
+// =========================
+// UDP SOCKET FUCNTIONS
+// =========================
+
+// Create a UDP socket
+// @return: Socket file descriptor, or -1 on error
+int create_udp_socket(void) {
+	int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
+	if (sockfd < 0) {
+		perror("[!] socket() failed");
+		return -1;
+	}
+	return sockfd;
+}
+
+// Create a UDP socket and connect it to a specific IP and port
+// Used for sending data (no bind needed)
+// @param ip: Destination IP address as a string
+// @return: Socket file descriptor, or -1 on error
+int connect_udp_socket(const char *ip, uint16_t port) {
+	int sockfd = create_udp_socket();
+	if (sockfd < 0)
+		return -1;
+
+	struct sockaddr_in servaddr;
+	memset(&servaddr, 0, sizeof(servaddr));
+	servaddr.sin_family = AF_INET;
+	servaddr.sin_port = htons(port);
+	servaddr.sin_addr.s_addr = inet_addr(ip);
+
+	if (connect(sockfd, (const struct sockaddr *)&servaddr, sizeof(servaddr)) < 0) {
+		perror("[!] connect() failed");
+		close(sockfd);
+		return -1;
+	}
+
+	printf("[+] Connected UDP socket to %s:%d\n", ip, port);
+	return sockfd;
+}
+
+// Create and bind a UDP socket to a local IP and port
+// Used for listening for incoming data
+// @param ip: Local IP address to bind to
+// @param port: Local port to bind to
+// @return: Socket file descriptor, or -1 on error
+int create_bound_udp_socket(const char *ip, uint16_t port) {
+	int sockfd = create_udp_socket();
+	if (sockfd < 0)
+		return -1;
+
+	struct sockaddr_in addr;
+	memset(&addr, 0, sizeof(addr));
+	addr.sin_family = AF_INET;
+	addr.sin_port = htons(port);
+	addr.sin_addr.s_addr = inet_addr(ip);
+
+	if (bind(sockfd, (const struct sockaddr *)&addr, sizeof(addr)) < 0) {
+		perror("[!] bind() failed");
+		close(sockfd);
+		return -1;
+	}
+
+	printf("[+] Bound UDP socket on %s:%d\n", ip, port);
+	return sockfd;
+}
+
+// Send a UDP message to the specified IP and port
+// @param sockfd: Socket file descriptor
+// @param message: Message to send
+// @param dest_ip: Destination IP address as a string
+// @param dest_port: Destination port
+// @return: Number of bytes sent, or -1 on error
+ssize_t send_udp_message(int sockfd, const char *message, const char *dest_ip, uint16_t dest_port) {
+	struct sockaddr_in destaddr;
+	memset(&destaddr, 0, sizeof(destaddr));
+	destaddr.sin_family = AF_INET;
+	destaddr.sin_port = htons(dest_port);
+	destaddr.sin_addr.s_addr = inet_addr(dest_ip);
+
+	ssize_t n = sendto(sockfd, message, strlen(message), 0, (const struct sockaddr *)&destaddr, sizeof(destaddr));
+	if (n < 0) {
+		perror("[!] sendto() failed");
+		return -1;
+	}
+
+	printf("[+] Sent %zd bytes to %s:%d\n", n, dest_ip, dest_port);
+	return n;
+}
diff --git a/include/socket.h.old b/include/socket.h.old
new file mode 100644
index 0000000..499bb2b
--- /dev/null
+++ b/include/socket.h.old
@@ -0,0 +1,42 @@
+#ifndef SOCKET_H
+#define SOCKET_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef _WIN32
+#include <winsock2.h>
+#include <ws2tcpip.h>
+#pragma comment(lib, "ws2_32.lib") // link Winsock
+#else
+#include <arpa/inet.h>
+#include <netinet/in.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <unistd.h>
+#endif
+
+// =========================
+// UDP SOCKET FUCNTIONS
+// =========================
+// Server hosts a UDP socket at 127.0.0.1:12000
+// Client sends a message to the server at 11000
+
+// UDP socket creation & management
+int create_udp_socket(void);
+int connect_udp_socket(const char *ip, uint16_t port);
+int create_bound_udp_socket(const char *ip, uint16_t port);
+
+// UDP messaging
+ssize_t send_udp_message(int sockfd, const char *message, const char *dest_ip, uint16_t dest_port);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // SOCKET_H
diff --git a/source/log.c b/source/log.c
new file mode 100644
index 0000000..dd40712
--- /dev/null
+++ b/source/log.c
@@ -0,0 +1,24 @@
+#include "log.h"
+
+void log_print(LogLevel level, const char* format, ...) {
+    time_t now = time(NULL);
+    struct tm *t = localtime(&now);
+
+    const char* level_tag;
+    switch(level) {
+        case LOG_INFO:  level_tag = "INF"; break;
+        case LOG_DEBUG: level_tag = "DBG"; break;
+        case LOG_ERROR: level_tag = "ERR"; break;
+        case LOG_WARN:  level_tag = "WRN"; break;
+        default:        level_tag = "UNK"; break;
+    }
+
+    // %02d ensures it prints "05" instead of just "5"
+    printf("[%02d:%02d:%02d %s] ", 
+           t->tm_hour, t->tm_min, t->tm_sec, level_tag);
+
+    va_list args;
+    va_start(args, format);
+    vprintf(format, args); // vprintf takes a va_list instead of ...
+    va_end(args);
+}
diff --git a/source/main.cpp b/source/main.cpp
index e5b232c..584ef1c 100644
--- a/source/main.cpp
+++ b/source/main.cpp
@@ -1,27 +1,31 @@
 #include <cstddef>
 #include <cstdint>
 #include <iostream>
+#include <signal.h>
 #include <stdexcept>
 #include <string>
 #include <sys/types.h>
-#include <vector>
 #include <unistd.h>
-#include <signal.h>
+#include <vector>
 
 #include "app.hpp"          // for app_info struct
 #include "file.hpp"         // for parce_args
+#include "log.h"            // for logging
 #include "net.hpp"          // for socket operations
 #include "server_structs.h" // for api_packet and ACSP_MessageType
 #include "session.hpp"      // for SessionManager
+#include "mapper.hpp"       // for Mapper 
+
+const u_int8_t UPDATE_INTERVAL = 120; // in milliseconds
 
 using namespace std;
 
 volatile bool STOP_PROGRAM = false;
 
 void signal_handler(int signum) {
-    if (signum == SIGINT || signum == SIGTERM) {
-        STOP_PROGRAM = true;
-    }
+	if (signum == SIGINT || signum == SIGTERM) {
+		STOP_PROGRAM = true;
+	}
 }
 
 int main(int argc, char *argv[]) {
@@ -30,36 +34,47 @@ int main(int argc, char *argv[]) {
 
 	Socket sock;
 
-	SessionManager session_manager(app.app_id); // Server ID 1 for now
+	SessionManager session_manager(app.app_id);
 
-	char buffer[2048];
+    uint8_t buffer[1028];
+    Mapper map(buffer, 1028);
+
+    trackAtributes track;
+
+    track.server_name = new char[256];
+    track.track = new char[64];
+    track.track_config = new char[64];
+    track.session_name = new char[64];
+    track.weather_graphics = new char[64];
 
 	try {
 		// Connect socket to API
-		sock.connect_unix(app.app_api_socket_path.c_str(), app.app_port_out);
+		// sock.connect_unix(app.app_api_socket_path.c_str(), app.app_port_out);
 		// Connect socket to Server
 		sock.connect_server(app.app_server_out_ip.c_str(), app.app_port_out);
 		sock.bind_server("127.0.0.1", app.app_port_in);
 
 		// Await server for initial data
 		sock.receive_server(buffer, sizeof(buffer));
-		cout << "[+] Received info from server!" << endl;
+		log_info("Connected to server, awaiting version confirmation...\n");
 
 		if (buffer[0] == ACSP_VERSION) {
-			cout << "[+] Server API Version: " << (int)buffer[1] << endl;
+			log_info("Server version confirmed. Sending update rate request @ %ums\n", UPDATE_INTERVAL);
+		} else {
+			throw runtime_error("Did not receive version confirmation from server.");
 		}
 
-		// Right after confirmation, send update rate request
 		char request[516] = {0};
 		request[0] = ACSP_REALTIMEPOS_INTERVAL;
-		request[1] = 120;
+		request[1] = UPDATE_INTERVAL;
 
 		sock.send_server(request, sizeof(request));
-		cout << "[!] Info: " << endl;
-		cout << "    > API Socket Path: " << app.app_api_socket_path << endl;
-		cout << "    > Server Out IP: " << app.app_server_out_ip << endl;
-		cout << "    > App Port In: " << app.app_port_in << endl;
-		cout << "    > App Port Out: " << app.app_port_out << endl;
+		log_debug("Info:\n");
+		log_debug("\t\tApp ID: %d\n", app.app_id);
+        log_debug("\t\tAPI Socket Path: %s\n", app.app_api_socket_path.c_str());
+        log_debug("\t\tServer Out IP: %s\n", app.app_server_out_ip.c_str());
+        log_debug("\t\tApp Port In: %d\n", app.app_port_in);
+        log_debug("\t\tApp Port Out: %d\n", app.app_port_out);
 
 	} catch (const runtime_error &e) {
 		cerr << "Error: " << e.what() << endl;
@@ -73,37 +88,67 @@ int main(int argc, char *argv[]) {
 	while (STOP_PROGRAM == false) {
 		// Receive data from server
 		ssize_t received = sock.receive_server(buffer, sizeof(buffer));
-		if (received > 0) {
-			switch (buffer[0]) {
-			case ACSP_VERSION: {
-				cout << "[?] Received Version Packet?\nResending Update Rate Request..." << endl;
-            
-                char request[516] = {0};
-                request[0] = ACSP_REALTIMEPOS_INTERVAL;
-                request[1] = 120;
-                sock.send_server(request, sizeof(request));
 
+
+		if (received > 0) {
+            map.update_buffer(buffer, static_cast<size_t>(received));
+			switch (map.get_message_type()) {
+                // DONE: 
+			case ACSP_VERSION: {    
+				log_warn("Received Version Again? (Probably server restart) Resending Update Request @ %ums\n", UPDATE_INTERVAL);
+
+				char request[516] = {0};
+				request[0] = ACSP_REALTIMEPOS_INTERVAL;
+				request[1] = UPDATE_INTERVAL;
+				sock.send_server(request, sizeof(request));
+
+				break;
+			}
+                
+                // TODO: 
+			case ACSP_CAR_UPDATE: {
+                log_info("Received car update.\n"); 
+				break;
+			}
+                
+                // TODO: 
+			case ACSP_NEW_SESSION: {
+				log_info("New session started.\n");
+                map.parse_new_session(track);
+                if (map.is_ok()) {
+                    session_manager.on_new_session(track);
+                } else {
+                    log_error("Failed to parse new session data.\n");
+                }
+
+                // TESTING: Print track info 
+                log_info("Track Info:\n");
+                log_info("\t\tServer Name: %s\n", track.server_name);
+                log_info("\t\tTrack: %s\n", track.track);
+                log_info("\t\tTrack Config: %s\n", track.track_config);
+                log_info("\t\tSession Name: %s\n", track.session_name);
+                log_info("\t\tWeather Graphics: %s\n", track.weather_graphics);
+                log_info("\t\tSession Type: %d\n", track.session_type);
+                log_info("\t\tLaps: %d\n", track.laps);
+                log_info("\t\tTime: %d\n", track.time);
+                log_info("\t\tAmbient Temp: %d\n", track.ambient_temp);
+                log_info("\t\tRoad Temp: %d\n", track.road_temp);
+                log_info("\t\tElapsed MS: %u\n", track.elapsed_ms);
+                                
                 break;
 			}
 
-			case ACSP_CAR_UPDATE: {
-				cout << "[+] Received Car Update Packet with " << (int)packet.connected_players << " connected players." << endl;
-				break;
-			}
-
-			case ACSP_NEW_SESSION: {
-				cout << "[+] New Session Started: " << packet.track_info.session_name << endl;
-				break;
-			}
-
 			default: {
-				cout << "[!] Unknown packet type received: " << (int)buffer[0] << endl;
 				break;
 			}
 			}
 		}
 	}
 
+    delete[] track.server_name;
+    delete[] track.track;
+    delete[] track.track_config;
+    delete[] track.session_name;
+    delete[] track.weather_graphics;
 	return 0;
 }
-
diff --git a/source/mapper.cpp b/source/mapper.cpp
new file mode 100644
index 0000000..5b67fa3
--- /dev/null
+++ b/source/mapper.cpp
@@ -0,0 +1,56 @@
+#include "mapper.hpp"
+#include "parcer.h"
+
+Mapper::Mapper(const uint8_t *buf, size_t size) : buffer(buf), buffer_size(size), offset(0), ok(1) {}
+
+uint8_t Mapper::get_message_type() {
+	if (buffer_size < 1) {
+		this->ok = false;
+		return 0;
+	}
+
+	return buffer[0];
+}
+
+void Mapper::parse_new_session(trackAtributes &track) {
+	reset();
+    int __ok;
+
+	track.protocol_version = read_uint8(buffer, buffer_size, &offset, &__ok);
+	track.session_index = read_uint8(buffer, buffer_size, &offset, &__ok);
+	track.current_session_index = read_uint8(buffer, buffer_size, &offset, &__ok);
+	track.session_count = read_uint8(buffer, buffer_size, &offset, &__ok);
+
+	track.session_type = (SessionType)track.session_index;
+
+	uint8_t str_len = read_uint8(buffer, buffer_size, &offset, &__ok);
+	read_utf32le_string(buffer, buffer_size, &offset, track.server_name, str_len, &__ok);
+
+	str_len = read_uint8(buffer, buffer_size, &offset, &__ok);
+	read_string(buffer, buffer_size, &offset, track.track, str_len, &__ok);
+
+	str_len = read_uint8(buffer, buffer_size, &offset, &__ok);
+	read_string(buffer, buffer_size, &offset, track.track_config, str_len, &__ok);
+
+	str_len = read_uint8(buffer, buffer_size, &offset, &__ok);
+	read_string(buffer, buffer_size, &offset, track.session_name, str_len, &__ok);
+
+	track.typ = read_uint8(buffer, buffer_size, &offset, &__ok);
+	track.time = read_uint16_le(buffer, buffer_size, &offset, &__ok);
+	track.laps = read_uint16_le(buffer, buffer_size, &offset, &__ok);
+	track.wait_time = read_uint16_le(buffer, buffer_size, &offset, &__ok);
+	track.ambient_temp = read_uint8(buffer, buffer_size, &offset, &__ok);
+	track.road_temp = read_uint8(buffer, buffer_size, &offset, &__ok);
+
+	str_len = read_uint8(buffer, buffer_size, &offset, &__ok);
+	read_string(buffer, buffer_size, &offset, track.weather_graphics, str_len, &__ok);
+
+	track.elapsed_ms = read_uint32(buffer, buffer_size, &offset, &__ok);
+
+    if (__ok == 0) {
+        this->ok = false;
+    } else {
+        this->ok = true;
+    }
+}
+
diff --git a/source/net.cpp b/source/net.cpp
index a0795fc..fed24b3 100644
--- a/source/net.cpp
+++ b/source/net.cpp
@@ -1,4 +1,5 @@
 #include "net.hpp"
+#include "log.c"
 #include <sys/types.h>
 
 Socket::Socket() {
@@ -32,11 +33,11 @@ void Socket::bind_server(const char *ip, uint16_t port) {
 	bind_addr.sin_addr.s_addr = inet_addr(ip);
 
 	if (bind(sock_server, (const struct sockaddr *)&bind_addr, sizeof(bind_addr)) < 0) {
-		perror("[!] bind() failed");
+		log_error("Failed to bind UDP socket on %s:%d\n", ip, port);
 		throw runtime_error("Failed to bind UDP socket");
 	}
 
-	printf("[+] Bound UDP socket on %s:%d\n", ip, port);
+	log_info("Successfully bound UDP socket on %s:%d\n", ip, port);
 }
 
 void Socket::connect_unix(const char *ip, uint16_t port) {
@@ -63,7 +64,7 @@ void Socket::send_server() {
 ssize_t Socket::receive_server(void *buffer, size_t len) {
 	ssize_t recv_bytes = recv(sock_server, buffer, len, 0);
 	if (recv_bytes < 0) {
-		perror("[!] recv() failed");
+		log_error("Failed to receive data from server socket\n");
 		return -1;
 	}
 	return recv_bytes;
diff --git a/source/parcer.c b/source/parcer.c
index 0c877fd..ff5c4f1 100644
--- a/source/parcer.c
+++ b/source/parcer.c
@@ -1,8 +1,8 @@
 #include "parcer.h"
 #include "server_structs.h"
+#include <arpa/inet.h>
 #include <netinet/in.h>
 #include <sys/types.h>
-#include <arpa/inet.h>
 
 int ensure(size_t recv_len, size_t offset, size_t need) {
 	return (offset + need <= recv_len);
@@ -27,9 +27,22 @@ u_int16_t read_uint16(const u_int8_t *buf, size_t recv_len, size_t *offset, int
 	u_int16_t v;
 	memcpy(&v, buf + *offset, sizeof(v));
 	*offset += sizeof(v);
+
 	return (u_int16_t)ntohs(v);
 }
 
+u_int16_t read_uint16_le(const u_int8_t *buf, size_t recv_len, size_t *offset, int *ok) {
+	if (!ensure(recv_len, *offset, sizeof(uint16_t))) {
+		*ok = 0;
+		return 0;
+	}
+	u_int16_t v;
+	memcpy(&v, buf + *offset, sizeof(v));
+	*offset += sizeof(v);
+
+	return v;
+}
+
 u_int32_t read_uint32(const u_int8_t *buf, size_t recv_len, size_t *offset, int *ok) {
 	if (!ensure(recv_len, *offset, sizeof(uint32_t))) {
 		*ok = 0;
@@ -140,4 +153,3 @@ void read_string(const u_int8_t *buf, size_t recv_len, size_t *offset, char *out
 	*offset += len;
 	*ok = 1;
 }
-