diff --git a/cagebreak.c b/cagebreak.c
index 223beae..c99bd95 100644
--- a/cagebreak.c
+++ b/cagebreak.c
@@ -55,6 +55,7 @@
 #include "server.h"
 #include "view.h"
 #include "xdg_shell.h"
+#include "ipc_server.h"
 #if CG_HAS_XWAYLAND
 #include "xwayland.h"
 #endif
@@ -189,16 +190,19 @@ set_configuration(struct cg_server *server,
 		        config_file_path);
 		return -1;
 	}
-	size_t max_line_size = 256;
-	char line[max_line_size * sizeof(char)];
+	char line[MAX_LINE_SIZE * sizeof(char)];
 	for(unsigned int line_num = 1;
-	    fgets(line, max_line_size, config_file) != NULL; ++line_num) {
+	    fgets(line, MAX_LINE_SIZE, config_file) != NULL; ++line_num) {
 		line[strcspn(line, "\n")] = '\0';
 		if(*line != '\0' && *line != '#') {
-			if(parse_rc_line(server, line) != 0) {
+			char *errstr;
+			if(parse_rc_line(server, line, &errstr) != 0) {
 				wlr_log(WLR_ERROR, "Error in config file \"%s\", line %d\n",
 				        config_file_path, line_num);
 				fclose(config_file);
+				if(errstr != NULL) {
+					free(errstr);
+				}
 				return -1;
 			}
 		}
@@ -286,10 +290,9 @@ main(int argc, char *argv[]) {
 	server.modes[1] = strdup("root");
 	server.modes[2] = strdup("resize");
 	server.modes[3] = NULL;
-	if(server.modes[0] == NULL || server.modes[1] == NULL ||
-	   server.modes[2] == NULL) {
+	if(server.modes[0] == NULL || server.modes[1] == NULL || server.modes[2] == NULL) {
 		wlr_log(WLR_ERROR, "Error allocating default modes");
-		goto end;
+		return 1;
 	}
 
 	server.nws = 1;
@@ -512,6 +515,12 @@ main(int argc, char *argv[]) {
 	wlr_xwayland_set_seat(xwayland, server.seat->seat);
 #endif
 
+	if(ipc_init(&server) != 0) {
+		wlr_log(WLR_ERROR, "Failed to initialize IPC");
+		ret = 1;
+		goto end;
+	}
+
 	{ // config_file should only be visible as long as it is valid
 		char *config_file = get_config_file();
 		if(config_file == NULL) {
@@ -534,7 +543,7 @@ main(int argc, char *argv[]) {
 		}
 	}
 
-	/* Place the cursor to the topl left of the output layout. */
+	/* Place the cursor to the top left of the output layout. */
 	wlr_cursor_warp(server.seat->cursor, NULL, 0, 0);
 
 	wl_display_run(server.wl_display);
diff --git a/fuzz/fuzz-parse.c b/fuzz/fuzz-parse.c
index 2434feb..45e74da 100644
--- a/fuzz/fuzz-parse.c
+++ b/fuzz/fuzz-parse.c
@@ -406,7 +406,11 @@ set_configuration(struct cg_server *server, char *content) {
 	    (line = strtok_r(NULL, "\n", &content)) != NULL; ++line_num) {
 		line[strcspn(line, "\n")] = '\0';
 		if(*line != '\0' && *line != '#') {
-			if(parse_rc_line(server, line) != 0) {
+			char *errstr;
+			if(parse_rc_line(server, line, &errstr) != 0) {
+				if(errstr != NULL) {
+					free(errstr);
+				}
 				return -1;
 			}
 		}
diff --git a/ipc_server.c b/ipc_server.c
new file mode 100644
index 0000000..35eea2d
--- /dev/null
+++ b/ipc_server.c
@@ -0,0 +1,258 @@
+/*
+ * Cagebreak: A Wayland tiling compositor.
+ *
+ * Copyright (C) 2020 The Cagebreak Authors
+ * Copyright (C) 2018-2020 Jente Hidskes
+ *
+ * See the LICENSE file accompanying this file.
+ */
+
+#define _POSIX_C_SOURCE 200112L
+
+#include "ipc_server.h"
+#include "server.h"
+#include "parse.h"
+#include "message.h"
+
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <sys/ioctl.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <wlr/util/log.h>
+#include <stdlib.h>
+
+static void handle_display_destroy(struct wl_listener *listener, void *data) {
+	struct cg_ipc_handle *ipc = wl_container_of(listener, ipc,display_destroy);
+	if (ipc->event_source != NULL) {
+		wl_event_source_remove(ipc->event_source);
+	}
+	close(ipc->socket);
+	unlink(ipc->sockaddr->sun_path);
+
+	struct cg_ipc_client *tmp_client, *client;
+	wl_list_for_each_safe(client, tmp_client, &ipc->client_list, link) {
+		ipc_client_disconnect(client);
+	}
+
+	free(ipc->sockaddr);
+
+	wl_list_remove(&ipc->display_destroy.link);
+}
+
+int ipc_init(struct cg_server *server) {
+	struct cg_ipc_handle *ipc = &server->ipc;
+	ipc->socket = socket(AF_UNIX, SOCK_STREAM, 0);
+	if (ipc->socket == -1) {
+		wlr_log(WLR_ERROR, "Unable to create IPC socket");
+		return -1;
+	}
+	if (fcntl(ipc->socket, F_SETFD, FD_CLOEXEC) == -1) {
+		wlr_log(WLR_ERROR,"Unable to set CLOEXEC on IPC socket");
+		return -1;
+	}
+	if (fcntl(ipc->socket, F_SETFL, O_NONBLOCK) == -1) {
+		wlr_log(WLR_ERROR, "Unable to set NONBLOCK on IPC socket");
+		return -1;
+	}
+
+	ipc->sockaddr = malloc(sizeof(struct sockaddr_un));
+
+	if(ipc->sockaddr == NULL) {
+		wlr_log(WLR_ERROR, "Unable to allocate socket address");
+		return -1;
+	}
+
+	ipc->sockaddr->sun_family=AF_UNIX;
+	int max_path_size = sizeof(ipc->sockaddr->sun_path);
+	const char *sockdir=getenv("XDG_RUNTIME_DIR");
+	if(sockdir == NULL) {
+		sockdir = "/tmp";
+	}
+
+	if (max_path_size <= snprintf(ipc->sockaddr->sun_path, max_path_size,
+			"%s/cagebreak-ipc.%i.%i.sock", sockdir, getuid(), getpid())) {
+		wlr_log(WLR_ERROR,"Unable to write socket path to ipc->sockaddr->sun_path. Path too long");
+		free(ipc->sockaddr);
+		return -1;
+	}
+
+	unlink(ipc->sockaddr->sun_path);
+
+	if (bind(ipc->socket, (struct sockaddr *)ipc->sockaddr, sizeof(*ipc->sockaddr)) == -1) {
+		wlr_log(WLR_ERROR, "Unable to bind IPC socket");
+		free(ipc->sockaddr);
+		return -1;
+	}
+
+	if (listen(ipc->socket, 3) == -1) {
+		wlr_log(WLR_ERROR, "Unable to listen on IPC socket");
+		free(ipc->sockaddr);
+		return -1;
+	}
+
+	setenv("CAGEBREAK_SOCKET", ipc->sockaddr->sun_path, 1);
+
+	wl_list_init(&ipc->client_list);
+
+	ipc->display_destroy.notify = handle_display_destroy;
+	wl_display_add_destroy_listener(server->wl_display, &ipc->display_destroy);
+
+	ipc->event_source = wl_event_loop_add_fd(server->event_loop, ipc->socket,
+			WL_EVENT_READABLE, ipc_handle_connection, server);
+	return 0;
+}
+
+int ipc_handle_connection(int fd, uint32_t mask, void *data) {
+	(void) fd;
+	struct cg_server *server = data;
+	struct cg_ipc_handle *ipc = &server->ipc;
+	if(mask != WL_EVENT_READABLE) {
+		wlr_log(WLR_ERROR, "Expected to receive a WL_EVENT_READABLE");
+		return 0;
+	}
+
+	int client_fd = accept(ipc->socket, NULL, NULL);
+	if (client_fd == -1) {
+		wlr_log(WLR_ERROR, "Unable to accept IPC client connection");
+		return 0;
+	}
+
+	int flags;
+	if ((flags = fcntl(client_fd, F_GETFD)) == -1
+			|| fcntl(client_fd, F_SETFD, flags|FD_CLOEXEC) == -1) {
+		wlr_log(WLR_ERROR, "Unable to set CLOEXEC on IPC client socket");
+		close(client_fd);
+		return 0;
+	}
+	if ((flags = fcntl(client_fd, F_GETFL)) == -1
+			|| fcntl(client_fd, F_SETFL, flags|O_NONBLOCK) == -1) {
+		wlr_log(WLR_ERROR, "Unable to set NONBLOCK on IPC client socket");
+		close(client_fd);
+		return 0;
+	}
+
+	struct cg_ipc_client *client = malloc(sizeof(struct cg_ipc_client));
+	if (!client) {
+		wlr_log(WLR_ERROR, "Unable to allocate ipc client");
+		close(client_fd);
+		return 0;
+	}
+	// +1 for \n and +1 for \0
+	client->read_buffer = malloc(sizeof(char)*(MAX_LINE_SIZE+2));
+	client->read_buf_len = 0;
+	client->read_discard = 0;
+	client->server = server;
+	client->fd = client_fd;
+	client->event_source = wl_event_loop_add_fd(server->event_loop,
+			client_fd, WL_EVENT_READABLE, ipc_client_handle_readable, client);
+	client->writable_event_source = NULL;
+
+	client->write_buffer_size = 128;
+	client->write_buffer_len = 0;
+	client->write_buffer = malloc(client->write_buffer_size);
+	if (!client->write_buffer) {
+		wlr_log(WLR_ERROR, "Unable to allocate ipc client write buffer");
+		close(client_fd);
+		return 0;
+	}
+
+	wl_list_insert(&ipc->client_list, &client->link);
+	return 0;
+}
+
+int ipc_client_handle_readable(int client_fd, uint32_t mask, void *data) {
+	struct cg_ipc_client *client = data;
+
+	if (mask & WL_EVENT_ERROR) {
+		wlr_log(WLR_ERROR, "IPC Client socket error, removing client");
+		ipc_client_disconnect(client);
+		return 0;
+	}
+
+	if (mask & WL_EVENT_HANGUP) {
+		ipc_client_disconnect(client);
+		return 0;
+	}
+
+	int read_available;
+	if (ioctl(client_fd, FIONREAD, &read_available) < 0) {
+		wlr_log(WLR_ERROR, "Unable to read IPC socket buffer size");
+		ipc_client_disconnect(client);
+		return 0;
+	}
+
+	int read_size = read_available < MAX_LINE_SIZE+1-client->read_buf_len ? read_available:MAX_LINE_SIZE+1-client->read_buf_len;
+	// Append to buffer
+	ssize_t received = recv(client_fd, client->read_buffer+client->read_buf_len, read_size, 0);
+	if (received == -1) {
+		wlr_log(WLR_ERROR, "Unable to receive data from IPC client");
+		ipc_client_disconnect(client);
+		return 0;
+	}
+	client->read_buf_len+=received;
+
+	ipc_client_handle_command(client);
+
+	return 0;
+}
+
+void ipc_client_disconnect(struct cg_ipc_client *client) {
+	if (client == NULL) {
+		wlr_log(WLR_ERROR, "Client \"NULL\" was passed to ipc_client_disconnect");
+		return;
+	}
+
+	shutdown(client->fd, SHUT_RDWR);
+
+	wl_event_source_remove(client->event_source);
+	if (client->writable_event_source) {
+		wl_event_source_remove(client->writable_event_source);
+	}
+	wl_list_remove(&client->link);
+	free(client->write_buffer);
+	free(client->read_buffer);
+	close(client->fd);
+	free(client);
+}
+
+void ipc_client_handle_command(struct cg_ipc_client *client) {
+	if (client == NULL) {
+		wlr_log(WLR_ERROR, "Client \"NULL\" was passed to ipc_client_handle_command");
+		return;
+	}
+	client->read_buffer[client->read_buf_len]='\0';
+	char *nl_pos;
+	uint32_t offset=0;
+	while((nl_pos = strchr(client->read_buffer+offset,'\n')) != NULL){
+		if(client->read_discard) {
+			client->read_discard = 0;
+		} else {
+			*nl_pos='\0';
+			char *line=client->read_buffer+offset;
+			if(*line != '\0' && *line != '#') {
+				message_clear(client->server->curr_output);
+				char *errstr;
+				if(parse_rc_line(client->server, line, &errstr) != 0) {
+					if(errstr != NULL) {
+						message_printf(client->server->curr_output, "%s", errstr);
+						wlr_log(WLR_ERROR, "%s",errstr);
+						free(errstr);
+					}
+					wlr_log(WLR_ERROR, "Error parsing input from IPC socket");
+				}
+			}
+		}
+		offset=(nl_pos-client->read_buffer)+1;
+	}
+	if(offset == 0) {
+		wlr_log(WLR_ERROR, "Line received was longer that %d, discarding it",MAX_LINE_SIZE);
+		client->read_buf_len = 0;
+		client->read_discard = 1;
+		return;
+	}
+	if(offset<client->read_buf_len) {
+		memmove(client->read_buffer, client->read_buffer+offset, client->read_buf_len-offset);
+	}
+	client->read_buf_len-=offset;
+}
diff --git a/ipc_server.h b/ipc_server.h
new file mode 100644
index 0000000..91d09b2
--- /dev/null
+++ b/ipc_server.h
@@ -0,0 +1,44 @@
+#ifndef CG_IPC_SERVER_H
+#define CG_IPC_SERVER_H
+
+#include "config.h"
+
+#include <sys/types.h>
+#include <inttypes.h>
+#include <wayland-server-core.h>
+
+struct cg_server;
+
+struct cg_ipc_client {
+	struct wl_event_source *event_source;
+	struct wl_event_source *writable_event_source;
+	struct cg_server *server;
+	struct wl_list link;
+	int fd;
+	uint32_t security_policy;
+	size_t write_buffer_len;
+	size_t write_buffer_size;
+	char *write_buffer;
+	// The following is for storing data between event_loop calls
+	uint16_t read_buf_len;
+	uint8_t read_discard;// 1 if the current line is to be discarded
+	char *read_buffer;
+};
+
+struct cg_ipc_handle {
+	int socket;
+	struct wl_event_source *event_source;
+	struct wl_list client_list;
+	struct wl_listener display_destroy;
+	struct sockaddr_un *sockaddr;
+};
+
+int ipc_init(struct cg_server *server);
+int ipc_handle_connection(int fd, uint32_t mask, void *data);
+int ipc_client_handle_readable(int client_fd, uint32_t mask, void *data);
+//int ipc_client_handle_writable(int client_fd, uint32_t mask, void *data);
+void ipc_client_disconnect(struct cg_ipc_client *client);
+void ipc_client_handle_command(struct cg_ipc_client *client);
+//bool ipc_send_reply(struct ipc_client *client, const char *payload, uint32_t payload_length);
+
+#endif
diff --git a/meson.build b/meson.build
index 4c8643b..fb52671 100644
--- a/meson.build
+++ b/meson.build
@@ -123,6 +123,7 @@ conf_data.set_quoted('CG_VERSION', version)
 cagebreak_main_file = [ 'cagebreak.c', ]
 cagebreak_source_strings = [
   'idle_inhibit_v1.c',
+  'ipc_server.c',
   'keybinding.c',
   'workspace.c',
   'output.c',
@@ -139,6 +140,7 @@ cagebreak_source_strings = [
 
 cagebreak_header_strings = [
   'idle_inhibit_v1.h',
+  'ipc_server.h',
   'keybinding.h',
   'workspace.h',
   'output.h',
diff --git a/parse.c b/parse.c
index 82cc0f2..12f7ee5 100644
--- a/parse.c
+++ b/parse.c
@@ -11,12 +11,34 @@
 #include "server.h"
 #include "workspace.h"
 
+char *malloc_vsprintf(const char *fmt, va_list ap) {
+	va_list ap2;
+	va_copy(ap2,ap);
+	int len = vsnprintf(NULL, 0, fmt, ap);
+	char *ret=malloc(sizeof(char)*(len+1));
+	vsnprintf(ret, len+1, fmt, ap2);
+	va_end(ap2);
+	return ret;
+}
+
+char *log_error(const char *fmt, ...) {
+	va_list args;
+	va_start(args,fmt);
+	char *ret=malloc_vsprintf(fmt, args);
+	if(ret != NULL) {
+		wlr_log(WLR_ERROR, "%s", ret);
+	}
+	va_end(args);
+	return ret;
+
+}
+
 /* parses a key definition (e.g. "S-Tab") and sets key and modifiers in
  * keybinding respectivly */
 int
-parse_key(struct keybinding *keybinding, const char *key_def) {
+parse_key(struct keybinding *keybinding, const char *key_def,char **errstr) {
 	if(key_def == NULL) {
-		wlr_log(WLR_ERROR, "Expected key definition, got nothing.");
+		*errstr=log_error("Expected key definition, got nothing.");
 		return -1;
 	}
 	keybinding->modifiers = 0;
@@ -44,14 +66,14 @@ parse_key(struct keybinding *keybinding, const char *key_def) {
 			keybinding->modifiers |= WLR_MODIFIER_MOD5;
 			break;
 		default:
-			wlr_log(WLR_ERROR, "Unknown modifier \"%c\"", key_def[0]);
+			*errstr=log_error("Unknown modifier \"%c\"", key_def[0]);
 			return -1;
 		}
 		key_def += 2;
 	}
 	xkb_keysym_t keysym = xkb_keysym_from_name(key_def, XKB_KEYSYM_NO_FLAGS);
 	if(keysym == XKB_KEY_NoSymbol) {
-		wlr_log(WLR_ERROR, "Could not convert key \"%s\" to keysym.", key_def);
+		*errstr=log_error("Could not convert key \"%s\" to keysym.", key_def);
 		return -1;
 	}
 	keybinding->key = keysym;
@@ -60,25 +82,24 @@ parse_key(struct keybinding *keybinding, const char *key_def) {
 
 int
 parse_command(struct cg_server *server, struct keybinding *keybinding,
-              char *saveptr);
+              char *saveptr, char **errstr);
 
 /* Parse a keybinding definition and return it if successful, else return NULL
  */
 struct keybinding *
-parse_keybinding(struct cg_server *server, char **saveptr) {
+parse_keybinding(struct cg_server *server, char **saveptr, char **errstr) {
 	struct keybinding *keybinding = malloc(sizeof(struct keybinding));
 	if(keybinding == NULL) {
-		wlr_log(WLR_ERROR,
-		        "Failed to allocate memory for keybinding in parse_keybinding");
+		*errstr=log_error("Failed to allocate memory for keybinding in parse_keybinding");
 		return NULL;
 	}
 	char *key = strtok_r(NULL, " ", saveptr);
-	if(parse_key(keybinding, key) != 0) {
+	if(parse_key(keybinding, key, errstr) != 0) {
 		wlr_log(WLR_ERROR, "Could not parse key definition \"%s\"", key);
 		free(keybinding);
 		return NULL;
 	}
-	if(parse_command(server, keybinding, *saveptr) != 0) {
+	if(parse_command(server, keybinding, *saveptr, errstr) != 0) {
 		free(keybinding);
 		return NULL;
 	}
@@ -86,8 +107,8 @@ parse_keybinding(struct cg_server *server, char **saveptr) {
 }
 
 struct keybinding *
-parse_bind(struct cg_server *server, char **saveptr) {
-	struct keybinding *keybinding = parse_keybinding(server, saveptr);
+parse_bind(struct cg_server *server, char **saveptr, char **errstr) {
+	struct keybinding *keybinding = parse_keybinding(server, saveptr, errstr);
 	if(keybinding == NULL) {
 		wlr_log(WLR_ERROR, "Could not parse keybinding for \"bind\".");
 		return NULL;
@@ -97,18 +118,18 @@ parse_bind(struct cg_server *server, char **saveptr) {
 }
 
 struct keybinding *
-parse_definekey(struct cg_server *server, char **saveptr) {
+parse_definekey(struct cg_server *server, char **saveptr, char **errstr) {
 	char *mode = strtok_r(NULL, " ", saveptr);
 	if(mode == NULL) {
-		wlr_log(WLR_ERROR, "Too few arguments to \"definekey\". Expected mode");
+		*errstr=log_error("Too few arguments to \"definekey\". Expected mode");
 		return NULL;
 	}
 	int mode_idx = get_mode_index_from_name(server->modes, mode);
 	if(mode_idx == -1) {
-		wlr_log(WLR_ERROR, "Unknown mode \"%s\"", mode);
+		*errstr=log_error("Unknown mode \"%s\"", mode);
 		return NULL;
 	}
-	struct keybinding *keybinding = parse_keybinding(server, saveptr);
+	struct keybinding *keybinding = parse_keybinding(server, saveptr, errstr);
 	if(keybinding == NULL) {
 		wlr_log(WLR_ERROR, "Could not parse keybinding for \"definekey\"");
 		return NULL;
@@ -118,16 +139,13 @@ parse_definekey(struct cg_server *server, char **saveptr) {
 }
 
 int
-parse_background(struct cg_server *server, float *color, char **saveptr) {
+parse_background(struct cg_server *server, float *color, char **saveptr, char **errstr) {
 	/* Read rgb numbers */
 	for(unsigned int i = 0; i < 3; ++i) {
 		char *nstr = strtok_r(NULL, " \n", saveptr);
 		int nstrlen;
 		if(nstr == NULL || (nstrlen = strlen(nstr)) == 0) {
-			wlr_log(WLR_ERROR,
-			        "Expected three space-separated numbers (rgb) for "
-			        "background color setting. Got %d.",
-			        i);
+			*errstr=log_error("Expected three space-separated numbers (rgb) for background color setting. Got %d.", i);
 			return -1;
 		}
 		if(nstr[nstrlen - 1] == '\n') {
@@ -137,17 +155,11 @@ parse_background(struct cg_server *server, float *color, char **saveptr) {
 		char *endptr = NULL;
 		float nval = strtof(nstr, &endptr);
 		if(endptr != nstr + nstrlen) {
-			wlr_log(
-			    WLR_ERROR,
-			    "Could not parse number \"%s\" for background color setting.",
-			    nstr);
+			*errstr=log_error("Could not parse number \"%s\" for background color setting.", nstr);
 			return -1;
 		}
 		if(nval < 0 || nval > 1) {
-			wlr_log(WLR_ERROR,
-			        "Expected a number between 0 and 1 for setting of "
-			        "background color. Got %f.",
-			        nval);
+			*errstr=log_error("Expected a number between 0 and 1 for setting of background color. Got %f.", nval);
 			return -1;
 		}
 		color[i] = nval;
@@ -156,15 +168,14 @@ parse_background(struct cg_server *server, float *color, char **saveptr) {
 }
 
 struct keybinding *
-parse_escape(char **saveptr) {
+parse_escape(char **saveptr, char **errstr) {
 	struct keybinding *keybinding = malloc(sizeof(struct keybinding));
 	if(keybinding == NULL) {
-		wlr_log(WLR_ERROR,
-		        "Failed to allocate memory for keybinding in parse_escape");
+		*errstr=log_error("Failed to allocate memory for keybinding in parse_escape");
 		return NULL;
 	}
 	char *key = strtok_r(NULL, " ", saveptr);
-	if(parse_key(keybinding, key) != 0) {
+	if(parse_key(keybinding, key, errstr) != 0) {
 		wlr_log(WLR_ERROR,
 		        "Could not parse key definition \"%s\" for \"escape\"", key);
 		free(keybinding);
@@ -177,27 +188,25 @@ parse_escape(char **saveptr) {
 }
 
 char *
-parse_definemode(char **saveptr) {
+parse_definemode(char **saveptr, char **errstr) {
 	char *mode = strtok_r(NULL, " ", saveptr);
 	if(mode == NULL) {
-		wlr_log(WLR_ERROR, "Expected mode to succeed \"definemode\" keyword.");
+		*errstr=log_error("Expected mode to succeed \"definemode\" keyword.");
 		return NULL;
 	}
 	return strdup(mode);
 }
 
 int
-parse_workspaces(char **saveptr) {
+parse_workspaces(char **saveptr, char **errstr) {
 	char *nws_str = strtok_r(NULL, " ", saveptr);
 	if(nws_str == NULL) {
-		wlr_log(WLR_ERROR,
-		        "Expected argument for \"workspaces\" command, got none.");
+		*errstr=log_error("Expected argument for \"workspaces\" command, got none.");
 		return -1;
 	}
 	long nws = strtol(nws_str, NULL, 10);
 	if(!(1 <= nws && nws <= 30)) {
-		wlr_log(WLR_ERROR,
-		        "More than 30 workspaces are not supported. Received %li", nws);
+		*errstr=log_error("More than 30 workspaces are not supported. Received %li", nws);
 		return -1;
 	}
 	return nws;
@@ -240,88 +249,62 @@ parse_float(char **saveptr, const char *delim) {
 }
 
 int
-parse_output_config(struct wl_list *config_list, char **saveptr) {
+parse_output_config(struct wl_list *config_list, char **saveptr, char **errstr) {
 	struct cg_output_config *cfg = malloc(sizeof(struct cg_output_config));
 	if(cfg == NULL) {
-		wlr_log(WLR_ERROR,
-		        "Failed to allocate memory for output configuration");
+		*errstr=log_error("Failed to allocate memory for output configuration");
 		goto error;
 	}
 	char *name = strtok_r(NULL, " ", saveptr);
 	if(name == NULL) {
-		wlr_log(WLR_ERROR,
-		        "Expected name of output to be configured, got none");
+		*errstr=log_error("Expected name of output to be configured, got none");
 		goto error;
 	}
 	char *pos_str = strtok_r(NULL, " ", saveptr);
 	if(pos_str == NULL || strcmp(pos_str, "pos") != 0) {
-		wlr_log(
-		    WLR_ERROR,
-		    "Expected keyword \"pos\" in output configuration for output %s",
-		    name);
+		*errstr=log_error("Expected keyword \"pos\" in output configuration for output %s", name);
 		goto error;
 	}
 
 	cfg->pos.x = parse_uint(saveptr, " ");
 	if(cfg->pos.x < 0) {
-		wlr_log(
-		    WLR_ERROR,
-		    "Error parsing x coordinate of output configuration for output %s",
-		    name);
+		*errstr=log_error("Error parsing x coordinate of output configuration for output %s", name);
 		goto error;
 	}
 
 	cfg->pos.y = parse_uint(saveptr, " ");
 	if(cfg->pos.y < 0) {
-		wlr_log(
-		    WLR_ERROR,
-		    "Error parsing y coordinate of output configuration for output %s",
-		    name);
+		*errstr=log_error("Error parsing y coordinate of output configuration for output %s", name);
 		goto error;
 	}
 
 	char *res_str = strtok_r(NULL, " ", saveptr);
 	if(res_str == NULL || strcmp(res_str, "res") != 0) {
-		wlr_log(
-		    WLR_ERROR,
-		    "Expected keyword \"res\" in output configuration for output %s",
-		    name);
+		*errstr=log_error("Expected keyword \"res\" in output configuration for output %s", name);
 		goto error;
 	}
 
 	cfg->pos.width = parse_uint(saveptr, "x");
 	if(cfg->pos.width <= 0) {
-		wlr_log(WLR_ERROR,
-		        "Error parsing width of output configuration for output %s "
-		        "(hint: width must be larger than 0)",
-		        name);
+		*errstr=log_error("Error parsing width of output configuration for output %s (hint: width must be larger than 0)", name);
 		goto error;
 	}
 
 	cfg->pos.height = parse_uint(saveptr, " ");
 	if(cfg->pos.height <= 0) {
-		wlr_log(WLR_ERROR,
-		        "Error parsing height of output configuration for output %s "
-		        "(hint: height must e larger than 0)",
-		        name);
+		*errstr=log_error("Error parsing height of output configuration for output %s (hint: height must e larger than 0)", name);
 		goto error;
 	}
 
 	char *rate_str = strtok_r(NULL, " ", saveptr);
 	if(rate_str == NULL || strcmp(rate_str, "rate") != 0) {
-		wlr_log(
-		    WLR_ERROR,
-		    "Expected keyword \"rate\" in output configuration for output %s",
-		    name);
+		*errstr=log_error("Expected keyword \"rate\" in output configuration for output %s", name);
 		goto error;
 	}
 
 	cfg->refresh_rate = parse_float(saveptr, " ");
 	if(cfg->refresh_rate <= 0.0) {
-		wlr_log(
-		    WLR_ERROR,
-		    "Error parsing refresh rate of output configuration for output %s",
-		    name);
+		*errstr=log_error("Error parsing refresh rate of output configuration for output %s", name);
 		goto error;
 	}
 
@@ -346,10 +329,10 @@ error:
 
 int
 parse_command(struct cg_server *server, struct keybinding *keybinding,
-              char *saveptr) {
+              char *saveptr, char** errstr) {
 	char *action = strtok_r(NULL, " ", &saveptr);
 	if(action == NULL) {
-		wlr_log(WLR_ERROR, "Expected an action to parse, got none.");
+		*errstr=log_error("Expexted an action to parse, got none.");
 		return -1;
 	}
 	keybinding->data = (union keybinding_params){.c = NULL};
@@ -386,8 +369,7 @@ parse_command(struct cg_server *server, struct keybinding *keybinding,
 	} else if(strcmp(action, "exec") == 0) {
 		keybinding->action = KEYBINDING_RUN_COMMAND;
 		if(saveptr == NULL) {
-			wlr_log(WLR_ERROR, "Not enough paramaters to \"exec\". Expected "
-			                   "string to execute.");
+			*errstr=log_error("Not enough paramaters to \"exec\". Expected " "string to execute.");
 			return -1;
 		}
 		keybinding->data.c = strdup(saveptr);
@@ -407,17 +389,13 @@ parse_command(struct cg_server *server, struct keybinding *keybinding,
 		keybinding->action = KEYBINDING_SWITCH_WORKSPACE;
 		char *nws_str = strtok_r(NULL, " ", &saveptr);
 		if(nws_str == NULL) {
-			wlr_log(WLR_ERROR,
-			        "Expected argument for \"workspace\" action, got none.");
+			*errstr=log_error("Expected argument for \"workspace\" action, got none.");
 			return -1;
 		}
 
 		long ws = strtol(nws_str, NULL, 10);
 		if(ws < 1) {
-			wlr_log(WLR_ERROR,
-			        "Workspace number must be a integer number larger or equal "
-			        "to 1. Got %ld",
-			        ws);
+			*errstr=log_error("Workspace number must be an integer number larger or equal to 1. Got %ld", ws);
 			return -1;
 		}
 		keybinding->data.u = ws - 1;
@@ -425,17 +403,13 @@ parse_command(struct cg_server *server, struct keybinding *keybinding,
 		keybinding->action = KEYBINDING_MOVE_VIEW_TO_WORKSPACE;
 		char *nws_str = strtok_r(NULL, " ", &saveptr);
 		if(nws_str == NULL) {
-			wlr_log(WLR_ERROR,
-			        "Expected argument for \"workspace\" action, got none.");
+			*errstr=log_error("Expected argument for \"workspace\" action, got none.");
 			return -1;
 		}
 
 		long ws = strtol(nws_str, NULL, 10);
 		if(ws < 1) {
-			wlr_log(WLR_ERROR,
-			        "Workspace number must be an integer larger or equal to 1. "
-			        "Got %ld",
-			        ws);
+			*errstr=log_error("Workspace number must be an integer larger or equal to 1. Got %ld", ws);
 			return -1;
 		}
 		keybinding->data.u = ws - 1;
@@ -461,8 +435,7 @@ parse_command(struct cg_server *server, struct keybinding *keybinding,
 		keybinding->action = KEYBINDING_CHANGE_TTY;
 		char *ntty = strtok_r(NULL, " ", &saveptr);
 		if(ntty == NULL) {
-			wlr_log(WLR_ERROR,
-			        "Expected argument for \"switchvt\" command, got none.");
+			*errstr=log_error("Expected argument for \"switchvt\" command, got none.");
 			return -1;
 		}
 		long tty = strtol(ntty, NULL, 10);
@@ -471,13 +444,12 @@ parse_command(struct cg_server *server, struct keybinding *keybinding,
 		keybinding->action = KEYBINDING_SWITCH_MODE;
 		char *mode = strtok_r(NULL, " ", &saveptr);
 		if(mode == NULL) {
-			wlr_log(WLR_ERROR,
-			        "Expected mode after \"switch_mode\". Got nothing.");
+			*errstr=log_error("Expected mode after \"switch_mode\". Got nothing.");
 			return -1;
 		}
 		int mode_idx = get_mode_index_from_name(server->modes, mode);
 		if(mode_idx == -1) {
-			wlr_log(WLR_ERROR, "Unknown mode \"%s\" for switch_mode", mode);
+			*errstr=log_error("Unknown mode \"%s\" for switch_mode", mode);
 			return -1;
 		}
 		keybinding->data.u = (unsigned int)mode_idx;
@@ -485,78 +457,74 @@ parse_command(struct cg_server *server, struct keybinding *keybinding,
 		keybinding->action = KEYBINDING_SWITCH_DEFAULT_MODE;
 		char *mode = strtok_r(NULL, " ", &saveptr);
 		if(mode == NULL) {
-			wlr_log(
-			    WLR_ERROR,
-			    "Expected mode after \"switch_default_mode\". Got nothing.");
+			*errstr=log_error("Expected mode after \"switch_default_mode\". Got nothing.");
 			return -1;
 		}
 		int mode_idx = get_mode_index_from_name(server->modes, mode);
 		if(mode_idx == -1) {
-			wlr_log(WLR_ERROR, "Unknown mode \"%s\" for switch_default_mode",
-			        mode);
+			*errstr=log_error("Unknown mode \"%s\" for switch_default_mode", mode);
 			return -1;
 		}
 		keybinding->data.u = (unsigned int)mode_idx;
 	} else if(strcmp(action, "bind") == 0) {
 		keybinding->action = KEYBINDING_DEFINEKEY;
-		keybinding->data.kb = parse_bind(server, &saveptr);
+		keybinding->data.kb = parse_bind(server, &saveptr, errstr);
 		if(keybinding->data.kb == NULL) {
 			return -1;
 		}
 	} else if(strcmp(action, "definekey") == 0) {
 		keybinding->action = KEYBINDING_DEFINEKEY;
-		keybinding->data.kb = parse_definekey(server, &saveptr);
+		keybinding->data.kb = parse_definekey(server, &saveptr, errstr);
 		if(keybinding->data.kb == NULL) {
 			return -1;
 		}
 	} else if(strcmp(action, "background") == 0) {
 		keybinding->action = KEYBINDING_BACKGROUND;
-		if(parse_background(server, keybinding->data.color, &saveptr) != 0) {
+		if(parse_background(server, keybinding->data.color, &saveptr, errstr) != 0) {
 			return -1;
 		}
 	} else if(strcmp(action, "escape") == 0) {
 		keybinding->action = KEYBINDING_DEFINEKEY;
-		keybinding->data.kb = parse_escape(&saveptr);
+		keybinding->data.kb = parse_escape(&saveptr, errstr);
 		if(keybinding->data.kb == NULL) {
 			return -1;
 		}
 	} else if(strcmp(action, "definemode") == 0) {
 		keybinding->action = KEYBINDING_DEFINEMODE;
-		keybinding->data.c = parse_definemode(&saveptr);
+		keybinding->data.c = parse_definemode(&saveptr, errstr);
 		if(keybinding->data.c == NULL) {
 			return -1;
 		}
 	} else if(strcmp(action, "workspaces") == 0) {
 		keybinding->action = KEYBINDING_WORKSPACES;
-		keybinding->data.i = parse_workspaces(&saveptr);
+		keybinding->data.i = parse_workspaces(&saveptr, errstr);
 		if(keybinding->data.i < 0) {
 			return -1;
 		}
 	} else if(strcmp(action, "output") == 0) {
-		if(parse_output_config(&server->output_config, &saveptr) != 0) {
+		if(parse_output_config(&server->output_config, &saveptr, errstr) != 0) {
 			return -1;
 		}
 	} else {
-		wlr_log(WLR_ERROR, "Error, unsupported action \"%s\".", action);
+		*errstr=log_error("Error, unsupported action \"%s\".", action);
 		return -1;
 	}
 	return 0;
 }
 
 int
-parse_rc_line(struct cg_server *server, char *line) {
+parse_rc_line(struct cg_server *server, char *line, char **errstr) {
 	char *saveptr = strdup(line); // Used internally by strtok_r
 
 	struct keybinding *keybinding = malloc(sizeof(struct keybinding));
 	if(keybinding == NULL) {
-		wlr_log(WLR_ERROR,
-		        "Failed to allocate memory for temporary keybinding struct.");
+		*errstr=log_error("Failed to allocate memory for temporary keybinding struct.");
 		free(keybinding);
 		free(saveptr);
 		return -1;
 	}
-	if(parse_command(server, keybinding, saveptr) != 0) {
-		wlr_log(WLR_ERROR, "Error parsing config file.");
+	if(parse_command(server, keybinding, saveptr, errstr) != 0) {
+		wlr_log(WLR_ERROR, "Error parsing command.");
 		free(keybinding);
 		free(saveptr);
 		return -1;
diff --git a/parse.h b/parse.h
index 622697f..2a5da8d 100644
--- a/parse.h
+++ b/parse.h
@@ -2,9 +2,11 @@
 
 #define PARSE_H
 
+# define MAX_LINE_SIZE 256
+
 struct cg_server;
 
 int
-parse_rc_line(struct cg_server *server, char *line);
+parse_rc_line(struct cg_server *server, char *line, char **errstr);
 
 #endif /* end of include guard PARSE_H */
diff --git a/server.h b/server.h
index 930cb56..24c2fb1 100644
--- a/server.h
+++ b/server.h
@@ -2,6 +2,7 @@
 #define CG_SERVER_H
 
 #include "config.h"
+#include "ipc_server.h"
 
 #include <wayland-server-core.h>
 #include <wlr/types/wlr_xdg_decoration_v1.h>
@@ -40,6 +41,8 @@ struct cg_server {
 
 	enum wl_output_transform output_transform;
 
+	struct cg_ipc_handle ipc;
+
 	bool running;
 	char **modes;
 	uint16_t nws;