diff --git a/backend/backend.c b/backend/backend.c
index dc34c80b..79a21682 100644
--- a/backend/backend.c
+++ b/backend/backend.c
@@ -3,47 +3,45 @@
 #include <stdlib.h>
 #include <string.h>
 #include <errno.h>
+#include <assert.h>
 #include <libinput.h>
 #include <wlr/backend/session.h>
 #include <wlr/backend/interface.h>
-#include <wlr/backend/drm.h>
-#include <wlr/backend/libinput.h>
+//#include <wlr/backend/drm.h>
+//#include <wlr/backend/libinput.h>
 #include <wlr/backend/wayland.h>
-#include <wlr/backend/multi.h>
+//#include <wlr/backend/multi.h>
 #include <wlr/util/log.h>
-#include "backend/libinput.h"
 #include "backend/udev.h"
 
-struct wlr_backend *wlr_backend_create(const struct wlr_backend_impl *impl,
-		struct wlr_backend_state *state) {
-	struct wlr_backend *backend = calloc(1, sizeof(struct wlr_backend));
-	if (!backend) {
-		wlr_log(L_ERROR, "Allocation failed: %s", strerror(errno));
-		return NULL;
-	}
-	backend->state = state;
+void wlr_backend_create(struct wlr_backend *backend,
+		const struct wlr_backend_impl *impl) {
+	assert(backend);
 	backend->impl = impl;
 	wl_signal_init(&backend->events.input_add);
 	wl_signal_init(&backend->events.input_remove);
 	wl_signal_init(&backend->events.output_add);
 	wl_signal_init(&backend->events.output_remove);
-	return backend;
 }
 
 bool wlr_backend_init(struct wlr_backend *backend) {
-	return backend->impl->init(backend->state);
+	if (backend->impl->init) {
+		return backend->impl->init(backend);
+	}
+	return true;
 }
 
 void wlr_backend_destroy(struct wlr_backend *backend) {
-	backend->impl->destroy(backend->state);
-	free(backend);
+	if (backend->impl->destroy) {
+		backend->impl->destroy(backend);
+	}
 }
 
 struct wlr_egl *wlr_backend_get_egl(struct wlr_backend *backend) {
-	if (!backend->impl->get_egl) {
-		return NULL;
+	if (backend->impl->get_egl) {
+		return backend->impl->get_egl(backend);
 	}
-	return backend->impl->get_egl(backend->state);
+	return NULL;
 }
 
 static struct wlr_backend *attempt_wl_backend(struct wl_display *display) {
@@ -77,64 +75,65 @@ struct wlr_backend *wlr_backend_autocreate(struct wl_display *display) {
 			return backend;
 		}
 	}
-
-	if (getenv("DISPLAY")) {
-		wlr_log(L_ERROR, "X11 backend is not implemented"); // TODO
-		return NULL;
-	}
-
-	// Attempt DRM+libinput
-
-	struct wlr_session *session = wlr_session_start(display);
-	if (!session) {
-		wlr_log(L_ERROR, "Failed to start a DRM session");
-		return NULL;
-	}
-
-	struct wlr_udev *udev = wlr_udev_create(display);
-	if (!udev) {
-		wlr_log(L_ERROR, "Failed to start udev");
-		goto error_session;
-	}
-
-	int gpu = wlr_udev_find_gpu(udev, session);
-	if (gpu == -1) {
-		wlr_log(L_ERROR, "Failed to open DRM device");
-		goto error_udev;
-	}
-
-	backend = wlr_multi_backend_create(session, udev);
-	if (!backend) {
-		goto error_gpu;
-	}
-
-	struct wlr_backend *libinput = wlr_libinput_backend_create(display, session, udev);
-	if (!libinput) {
-		goto error_multi;
-	}
-
-	struct wlr_backend *drm = wlr_drm_backend_create(display, session, udev, gpu);
-	if (!drm) {
-		goto error_libinput;
-	}
-
-	wlr_multi_backend_add(backend, libinput);
-	wlr_multi_backend_add(backend, drm);
-	return backend;
-
-error_libinput:
-	wlr_backend_destroy(libinput);
-error_multi:
-	wlr_backend_destroy(backend);
-error_gpu:
-	wlr_session_close_file(session, gpu);
-error_udev:
-	wlr_udev_destroy(udev);
-error_session:
-	wlr_session_finish(session);
 	return NULL;
-}
 
-struct libinput_device *wlr_libinput_get_device_handle(struct wlr_input_device *dev) {
-	return dev->state->handle;
+//	if (getenv("DISPLAY")) {
+//		wlr_log(L_ERROR, "X11 backend is not implemented"); // TODO
+//		return NULL;
+//	}
+//
+//	// Attempt DRM+libinput
+//
+//	struct wlr_session *session = wlr_session_start(display);
+//	if (!session) {
+//		wlr_log(L_ERROR, "Failed to start a DRM session");
+//		return NULL;
+//	}
+//
+//	struct wlr_udev *udev = wlr_udev_create(display);
+//	if (!udev) {
+//		wlr_log(L_ERROR, "Failed to start udev");
+//		goto error_session;
+//	}
+//
+//	int gpu = wlr_udev_find_gpu(udev, session);
+//	if (gpu == -1) {
+//		wlr_log(L_ERROR, "Failed to open DRM device");
+//		goto error_udev;
+//	}
+//
+//	backend = wlr_multi_backend_create(session, udev);
+//	if (!backend) {
+//		goto error_gpu;
+//	}
+//
+//	struct wlr_backend *libinput = wlr_libinput_backend_create(display, session, udev);
+//	if (!libinput) {
+//		goto error_multi;
+//	}
+//
+//	struct wlr_backend *drm = wlr_drm_backend_create(display, session, udev, gpu);
+//	if (!drm) {
+//		goto error_libinput;
+//	}
+//
+//	wlr_multi_backend_add(backend, libinput);
+//	wlr_multi_backend_add(backend, drm);
+//	return backend;
+//
+//error_libinput:
+//	wlr_backend_destroy(libinput);
+//error_multi:
+//	wlr_backend_destroy(backend);
+//error_gpu:
+//	wlr_session_close_file(session, gpu);
+//error_udev:
+//	wlr_udev_destroy(udev);
+//error_session:
+//	wlr_session_finish(session);
+//	return NULL;
 }
+
+//struct libinput_device *wlr_libinput_get_device_handle(struct wlr_input_device *dev) {
+//	return dev->state->handle;
+//}
diff --git a/backend/meson.build b/backend/meson.build
index 7fcf00b8..44d7ba03 100644
--- a/backend/meson.build
+++ b/backend/meson.build
@@ -4,19 +4,19 @@ backend_files = files(
   'session/direct-ipc.c',
   'session/direct.c',
   'session/session.c',
-  'drm/backend.c',
-  'drm/drm.c',
-  'drm/drm-atomic.c',
-  'drm/drm-legacy.c',
-  'drm/drm-properties.c',
-  'drm/drm-util.c',
-  'libinput/backend.c',
-  'libinput/events.c',
-  'libinput/keyboard.c',
-  'libinput/pointer.c',
-  'libinput/tablet_pad.c',
-  'libinput/tablet_tool.c',
-  'libinput/touch.c',
+  #'drm/backend.c',
+  #'drm/drm.c',
+  #'drm/drm-atomic.c',
+  #'drm/drm-legacy.c',
+  #'drm/drm-properties.c',
+  #'drm/drm-util.c',
+  #'libinput/backend.c',
+  #'libinput/events.c',
+  #'libinput/keyboard.c',
+  #'libinput/pointer.c',
+  #'libinput/tablet_pad.c',
+  #'libinput/tablet_tool.c',
+  #'libinput/touch.c',
   'multi/backend.c',
   'wayland/backend.c',
   'wayland/output.c',
diff --git a/backend/multi/backend.c b/backend/multi/backend.c
index 9563356d..63cad33e 100644
--- a/backend/multi/backend.c
+++ b/backend/multi/backend.c
@@ -15,9 +15,10 @@ struct subbackend_state {
 	struct wl_listener output_remove;
 };
 
-static bool multi_backend_init(struct wlr_backend_state *state) {
-	for (size_t i = 0; i < state->backends->length; ++i) {
-		struct subbackend_state *sub = state->backends->items[i];
+static bool multi_backend_init(struct wlr_backend *_backend) {
+	struct wlr_multi_backend *backend = (struct wlr_multi_backend *)_backend;
+	for (size_t i = 0; i < backend->backends->length; ++i) {
+		struct subbackend_state *sub = backend->backends->items[i];
 		if (!wlr_backend_init(sub->backend)) {
 			wlr_log(L_ERROR, "Failed to initialize backend %zd", i);
 			return false;
@@ -26,21 +27,23 @@ static bool multi_backend_init(struct wlr_backend_state *state) {
 	return true;
 }
 
-static void multi_backend_destroy(struct wlr_backend_state *state) {
-	for (size_t i = 0; i < state->backends->length; ++i) {
-		struct subbackend_state *sub = state->backends->items[i];
+static void multi_backend_destroy(struct wlr_backend *_backend) {
+	struct wlr_multi_backend *backend = (struct wlr_multi_backend *)_backend;
+	for (size_t i = 0; i < backend->backends->length; ++i) {
+		struct subbackend_state *sub = backend->backends->items[i];
 		wlr_backend_destroy(sub->backend);
 		free(sub);
 	}
-	list_free(state->backends);
-	wlr_session_finish(state->session);
-	wlr_udev_destroy(state->udev);
-	free(state);
+	list_free(backend->backends);
+	wlr_session_finish(backend->session);
+	wlr_udev_destroy(backend->udev);
+	free(backend);
 }
 
-static struct wlr_egl *multi_backend_get_egl(struct wlr_backend_state *state) {
-	for (size_t i = 0; i < state->backends->length; ++i) {
-		struct subbackend_state *sub = state->backends->items[i];
+static struct wlr_egl *multi_backend_get_egl(struct wlr_backend *_backend) {
+	struct wlr_multi_backend *backend = (struct wlr_multi_backend *)_backend;
+	for (size_t i = 0; i < backend->backends->length; ++i) {
+		struct subbackend_state *sub = backend->backends->items[i];
 		struct wlr_egl *egl = wlr_backend_get_egl(sub->backend);
 		if (egl) {
 			return egl;
@@ -57,25 +60,25 @@ struct wlr_backend_impl backend_impl = {
 
 struct wlr_backend *wlr_multi_backend_create(struct wlr_session *session,
 		struct wlr_udev *udev) {
-	struct wlr_backend_state *state =
-		calloc(1, sizeof(struct wlr_backend_state));
-	if (!state) {
+	struct wlr_multi_backend *backend =
+		calloc(1, sizeof(struct wlr_multi_backend));
+	if (!backend) {
 		wlr_log(L_ERROR, "Backend allocation failed");
 		return NULL;
 	}
 
-	state->backends = list_create();
-	if (!state->backends) {
-		free(state);
+	backend->backends = list_create();
+	if (!backend->backends) {
+		free(backend);
 		wlr_log(L_ERROR, "Backend allocation failed");
 		return NULL;
 	}
 
-	struct wlr_backend *backend = wlr_backend_create(&backend_impl, state);
-	state->backend = backend;
-	state->session = session;
-	state->udev = udev;
-	return backend;
+	wlr_backend_create(&backend->backend, &backend_impl);
+
+	backend->session = session;
+	backend->udev = udev;
+	return &backend->backend;
 }
 
 bool wlr_backend_is_multi(struct wlr_backend *b) {
@@ -106,11 +109,12 @@ static void output_remove_reemit(struct wl_listener *listener, void *data) {
 	wl_signal_emit(&state->container->events.output_remove, data);
 }
 
-void wlr_multi_backend_add(struct wlr_backend *multi,
+void wlr_multi_backend_add(struct wlr_backend *_multi,
 		struct wlr_backend *backend) {
+	struct wlr_multi_backend *multi = (struct wlr_multi_backend *)_multi;
 	struct subbackend_state *sub = calloc(1, sizeof(struct subbackend_state));
 	sub->backend = backend;
-	sub->container = multi;
+	sub->container = &multi->backend;
 
 	sub->input_add.notify = input_add_reemit;
 	sub->input_remove.notify = input_remove_reemit;
@@ -127,13 +131,14 @@ void wlr_multi_backend_add(struct wlr_backend *multi,
 	wl_signal_add(&backend->events.output_add, &sub->output_add);
 	wl_signal_add(&backend->events.output_remove, &sub->output_remove);
 
-	list_add(multi->state->backends, sub);
+	list_add(multi->backends, sub);
 }
 
-struct wlr_session *wlr_multi_get_session(struct wlr_backend *base) {
-	if (base->impl != &backend_impl)
+struct wlr_session *wlr_multi_get_session(struct wlr_backend *_backend) {
+	// TODO: assert(wlr_backend_is_multi(_backend));
+	if (_backend->impl != &backend_impl) {
 		return NULL;
-
-	struct wlr_backend_state *multi = base->state;
-	return multi->session;
+	}
+	struct wlr_multi_backend *backend = (struct wlr_multi_backend *)_backend;
+	return backend->session;
 }
diff --git a/backend/wayland/backend.c b/backend/wayland/backend.c
index ddad1418..d1234c67 100644
--- a/backend/wayland/backend.c
+++ b/backend/wayland/backend.c
@@ -12,17 +12,17 @@
 #include "backend/wayland.h"
 
 static int dispatch_events(int fd, uint32_t mask, void *data) {
-	struct wlr_backend_state *state = data;
+	struct wlr_wl_backend *backend = data;
 	int count = 0;
 	if (mask & WL_EVENT_READABLE) {
-		count = wl_display_dispatch(state->remote_display);
+		count = wl_display_dispatch(backend->remote_display);
 	}
 	if (mask & WL_EVENT_WRITABLE) {
-		count = wl_display_flush(state->remote_display);
+		count = wl_display_flush(backend->remote_display);
 	}
 	if (mask == 0) {
-		count = wl_display_dispatch_pending(state->remote_display);
-		wl_display_flush(state->remote_display);
+		count = wl_display_dispatch_pending(backend->remote_display);
+		wl_display_flush(backend->remote_display);
 	}
 	return count;
 }
@@ -32,73 +32,76 @@ static int dispatch_events(int fd, uint32_t mask, void *data) {
  * compositor and creates surfaces for each output, then registers globals on
  * the specified display.
  */
-static bool wlr_wl_backend_init(struct wlr_backend_state* state) {
+static bool wlr_wl_backend_init(struct wlr_backend *_backend) {
+	struct wlr_wl_backend *backend = (struct wlr_wl_backend *)_backend;
 	wlr_log(L_INFO, "Initializating wayland backend");
 
-	state->remote_display = wl_display_connect(NULL);
-	if (!state->remote_display) {
+	backend->remote_display = wl_display_connect(NULL);
+	if (!backend->remote_display) {
 		wlr_log_errno(L_ERROR, "Could not connect to remote display");
 		return false;
 	}
 
-	if (!(state->registry = wl_display_get_registry(state->remote_display))) {
+	if (!(backend->registry = wl_display_get_registry(backend->remote_display))) {
 		wlr_log_errno(L_ERROR, "Could not obtain reference to remote registry");
 		return false;
 	}
 
-	wlr_wl_registry_poll(state);
-	if (!(state->compositor) || (!(state->shell))) {
+	wlr_wl_registry_poll(backend);
+	if (!(backend->compositor) || (!(backend->shell))) {
 		wlr_log_errno(L_ERROR, "Could not obtain retrieve required globals");
 		return false;
 	}
 
-	wlr_egl_init(&state->egl, EGL_PLATFORM_WAYLAND_EXT, state->remote_display);
-	wlr_egl_bind_display(&state->egl, state->local_display);
+	wlr_egl_init(&backend->egl, EGL_PLATFORM_WAYLAND_EXT, backend->remote_display);
+	wlr_egl_bind_display(&backend->egl, backend->local_display);
 
-	for (size_t i = 0; i < state->requested_outputs; ++i) {
-		wlr_wl_output_create(state->backend);
+	for (size_t i = 0; i < backend->requested_outputs; ++i) {
+		wlr_wl_output_create(&backend->backend);
 	}
 
-	struct wl_event_loop *loop = wl_display_get_event_loop(state->local_display);
-	int fd = wl_display_get_fd(state->remote_display);
+	struct wl_event_loop *loop = wl_display_get_event_loop(backend->local_display);
+	int fd = wl_display_get_fd(backend->remote_display);
 	int events = WL_EVENT_READABLE | WL_EVENT_ERROR |
 		WL_EVENT_HANGUP | WL_EVENT_WRITABLE;
-	state->remote_display_src = wl_event_loop_add_fd(loop, fd, events,
-			dispatch_events, state);
-	wl_event_source_check(state->remote_display_src);
+	backend->remote_display_src = wl_event_loop_add_fd(loop, fd, events,
+			dispatch_events, backend);
+	wl_event_source_check(backend->remote_display_src);
 
 	return true;
 }
 
-static void wlr_wl_backend_destroy(struct wlr_backend_state *state) {
-	if (!state) {
+static void wlr_wl_backend_destroy(struct wlr_backend *_backend) {
+	struct wlr_wl_backend *backend = (struct wlr_wl_backend *)_backend;
+	if (!_backend) {
 		return;
 	}
 
-	for (size_t i = 0; i < state->outputs->length; ++i) {
-		wlr_output_destroy(state->outputs->items[i]);
+	for (size_t i = 0; i < backend->outputs->length; ++i) {
+		wlr_output_destroy(backend->outputs->items[i]);
 	}
 
-	for (size_t i = 0; i < state->devices->length; ++i) {
-		wlr_input_device_destroy(state->devices->items[i]);
+	for (size_t i = 0; i < backend->devices->length; ++i) {
+		wlr_input_device_destroy(backend->devices->items[i]);
 	}
 
-	list_free(state->devices);
-	list_free(state->outputs);
-	free(state->seatName);
-
-	wlr_egl_free(&state->egl);
-	if (state->seat) wl_seat_destroy(state->seat);
-	if (state->shm) wl_shm_destroy(state->shm);
-	if (state->shell) wl_shell_destroy(state->shell);
-	if (state->compositor) wl_compositor_destroy(state->compositor);
-	if (state->registry) wl_registry_destroy(state->registry);
-	if (state->remote_display) wl_display_disconnect(state->remote_display);
-	free(state);
+	list_free(backend->devices);
+	list_free(backend->outputs);
+	free(backend->seat_name);
+
+	wlr_egl_free(&backend->egl);
+	if (backend->seat) wl_seat_destroy(backend->seat);
+	if (backend->shm) wl_shm_destroy(backend->shm);
+	if (backend->shell) wl_shell_destroy(backend->shell);
+	if (backend->compositor) wl_compositor_destroy(backend->compositor);
+	if (backend->registry) wl_registry_destroy(backend->registry);
+	if (backend->remote_display) wl_display_disconnect(backend->remote_display);
+	free(backend);
 }
 
-static struct wlr_egl *wlr_wl_backend_get_egl(struct wlr_backend_state *state) {
-	return &state->egl;
+static struct wlr_egl *wlr_wl_backend_get_egl(struct wlr_backend *_backend) {
+	struct wlr_wl_backend *backend = (struct wlr_wl_backend *)_backend;
+	return &backend->egl;
 }
 
 static struct wlr_backend_impl backend_impl = {
@@ -111,52 +114,45 @@ bool wlr_backend_is_wl(struct wlr_backend *b) {
 	return b->impl == &backend_impl;
 }
 
-struct wlr_output *wlr_wl_output_for_surface(struct wlr_backend_state *backend,
-	struct wl_surface *surface) {
+struct wlr_output *wlr_wl_output_for_surface(struct wlr_wl_backend *backend,
+		struct wl_surface *surface) {
 	for (size_t i = 0; i < backend->outputs->length; ++i) {
 		struct wlr_output *output = backend->outputs->items[i];
-		if(output->state->surface == surface)
+		if (output->state->surface == surface) {
 			return output;
+		}
 	}
-
 	return NULL;
 }
 
 struct wlr_backend *wlr_wl_backend_create(struct wl_display *display) {
 	wlr_log(L_INFO, "Creating wayland backend");
 
-	struct wlr_backend_state *state = calloc(1, sizeof(struct wlr_backend_state));
-	if (!state) {
-		wlr_log(L_ERROR, "Allocation failed: %s", strerror(errno));
-		return NULL;
-	}
-
-	struct wlr_backend *backend = wlr_backend_create(&backend_impl, state);
+	struct wlr_wl_backend *backend = calloc(1, sizeof(struct wlr_wl_backend));
 	if (!backend) {
 		wlr_log(L_ERROR, "Allocation failed: %s", strerror(errno));
 		return NULL;
 	}
+	wlr_backend_create(&backend->backend, &backend_impl);
 
-	if (!(state->devices = list_create())) {
+	if (!(backend->devices = list_create())) {
 		wlr_log(L_ERROR, "Could not allocate devices list");
 		goto error;
 	}
 
-	if (!(state->outputs = list_create())) {
+	if (!(backend->outputs = list_create())) {
 		wlr_log(L_ERROR, "Could not allocate outputs list");
 		goto error;
 	}
 
-	state->local_display = display;
-	state->backend = backend;
-	return backend;
+	backend->local_display = display;
+	return &backend->backend;
 
 error:
-	if (state) {
-		list_free(state->devices);
-		list_free(state->outputs);
+	if (backend) {
+		list_free(backend->devices);
+		list_free(backend->outputs);
 	}
-	free(state);
 	free(backend);
 	return NULL;
 }
diff --git a/backend/wayland/output.c b/backend/wayland/output.c
index 318f1f05..5416f112 100644
--- a/backend/wayland/output.c
+++ b/backend/wayland/output.c
@@ -46,8 +46,10 @@ static void wlr_wl_output_transform(struct wlr_output_state *output,
 }
 
 static void wlr_wl_output_destroy(struct wlr_output_state *output) {
-	wl_signal_emit(&output->backend->backend->events.output_remove, output->wlr_output);
-	if(output->frame_callback) wl_callback_destroy(output->frame_callback);
+	wl_signal_emit(&output->backend->backend.events.output_remove, output->wlr_output);
+	if (output->frame_callback) {
+		wl_callback_destroy(output->frame_callback);
+	}
 	eglDestroySurface(output->backend->egl.display, output->surface);
 	wl_egl_window_destroy(output->egl_window);
 	wl_shell_surface_destroy(output->shell_surface);
@@ -92,7 +94,7 @@ static struct wl_shell_surface_listener shell_surface_listener = {
 
 struct wlr_output *wlr_wl_output_create(struct wlr_backend *_backend) {
 	assert(wlr_backend_is_wl(_backend));
-	struct wlr_backend_state *backend = _backend->state;
+	struct wlr_wl_backend *backend = (struct wlr_wl_backend *)_backend;
 	if (!backend->remote_display) {
 		++backend->requested_outputs;
 		return NULL;
@@ -158,6 +160,6 @@ struct wlr_output *wlr_wl_output_create(struct wlr_backend *_backend) {
 
 	wlr_output_create_global(wlr_output, backend->local_display);
 	list_add(backend->outputs, wlr_output);
-	wl_signal_emit(&backend->backend->events.output_add, wlr_output);
+	wl_signal_emit(&backend->backend.events.output_add, wlr_output);
 	return wlr_output;
 }
diff --git a/backend/wayland/registry.c b/backend/wayland/registry.c
index ddd2a79b..9564b1dd 100644
--- a/backend/wayland/registry.c
+++ b/backend/wayland/registry.c
@@ -7,22 +7,22 @@
 
 static void registry_global(void *data, struct wl_registry *registry,
 		uint32_t name, const char *interface, uint32_t version) {
-	struct wlr_backend_state *state = data;
+	struct wlr_wl_backend *backend = data;
 	wlr_log(L_DEBUG, "Remote wayland global: %s v%d", interface, version);
 
 	if (strcmp(interface, wl_compositor_interface.name) == 0) {
-		state->compositor = wl_registry_bind(registry, name,
+		backend->compositor = wl_registry_bind(registry, name,
 				&wl_compositor_interface, version);
 	} else if (strcmp(interface, wl_shell_interface.name) == 0) {
-		state->shell = wl_registry_bind(registry, name,
+		backend->shell = wl_registry_bind(registry, name,
 				&wl_shell_interface, version);
 	} else if (strcmp(interface, wl_shm_interface.name) == 0) {
-		state->shm = wl_registry_bind(registry, name,
+		backend->shm = wl_registry_bind(registry, name,
 				&wl_shm_interface, version);
 	} else if (strcmp(interface, wl_seat_interface.name) == 0) {
-		state->seat = wl_registry_bind(registry, name,
+		backend->seat = wl_registry_bind(registry, name,
 				&wl_seat_interface, version);
-		wl_seat_add_listener(state->seat, &seat_listener, state);
+		wl_seat_add_listener(backend->seat, &seat_listener, backend);
 	}
 }
 
@@ -36,8 +36,8 @@ static const struct wl_registry_listener registry_listener = {
 	.global_remove = registry_global_remove
 };
 
-void wlr_wl_registry_poll(struct wlr_backend_state *state) {
-	wl_registry_add_listener(state->registry, &registry_listener, state);
-	wl_display_dispatch(state->remote_display);
-	wl_display_roundtrip(state->remote_display);
+void wlr_wl_registry_poll(struct wlr_wl_backend *backend) {
+	wl_registry_add_listener(backend->registry, &registry_listener, backend);
+	wl_display_dispatch(backend->remote_display);
+	wl_display_roundtrip(backend->remote_display);
 }
diff --git a/backend/wayland/wl_seat.c b/backend/wayland/wl_seat.c
index 7fb63cbe..80cc194d 100644
--- a/backend/wayland/wl_seat.c
+++ b/backend/wayland/wl_seat.c
@@ -169,7 +169,7 @@ static struct wl_keyboard_listener keyboard_listener = {
 };
 
 static void input_device_destroy(struct wlr_input_device_state *state) {
-	wl_signal_emit(&state->backend->backend->events.input_remove, state->wlr_device);
+	wl_signal_emit(&state->backend->backend.events.input_remove, state->wlr_device);
 	if (state->resource)
 		wl_proxy_destroy(state->resource);
 	free(state);
@@ -187,7 +187,7 @@ static struct wlr_pointer_impl pointer_impl = {
 	.destroy = pointer_destroy
 };
 
-static struct wlr_input_device *allocate_device(struct wlr_backend_state *state,
+static struct wlr_input_device *allocate_device(struct wlr_wl_backend *backend,
 		enum wlr_input_device_type type) {
 	struct wlr_input_device_state *devstate;
 	if (!(devstate = calloc(1, sizeof(struct wlr_input_device_state)))) {
@@ -195,7 +195,7 @@ static struct wlr_input_device *allocate_device(struct wlr_backend_state *state,
 		return NULL;
 	}
 
-	devstate->backend = state;
+	devstate->backend = backend;
 
 	int vendor = 0;
 	int product = 0;
@@ -208,14 +208,14 @@ static struct wlr_input_device *allocate_device(struct wlr_backend_state *state,
 		return NULL;
 	}
 	devstate->wlr_device = wlr_device;
-	list_add(state->devices, wlr_device);
+	list_add(backend->devices, wlr_device);
 	return wlr_device;
 }
 
 static void seat_handle_capabilities(void *data, struct wl_seat *wl_seat,
 		enum wl_seat_capability caps) {
-	struct wlr_backend_state *state = data;
-	assert(state->seat == wl_seat);
+	struct wlr_wl_backend *backend = data;
+	assert(backend->seat == wl_seat);
 
 	if ((caps & WL_SEAT_CAPABILITY_POINTER)) {
 		wlr_log(L_DEBUG, "seat %p offered pointer", (void*) wl_seat);
@@ -226,7 +226,7 @@ static void seat_handle_capabilities(void *data, struct wl_seat *wl_seat,
 		}
 
 		struct wlr_input_device *wlr_device;
-		if (!(wlr_device = allocate_device(state, WLR_INPUT_DEVICE_POINTER))) {
+		if (!(wlr_device = allocate_device(backend, WLR_INPUT_DEVICE_POINTER))) {
 			free(pointer_state);
 			wlr_log(L_ERROR, "Unable to allocate wlr_device for pointer");
 			return;
@@ -236,11 +236,11 @@ static void seat_handle_capabilities(void *data, struct wl_seat *wl_seat,
 		wl_pointer_add_listener(wl_pointer, &pointer_listener, wlr_device);
 		wlr_device->pointer = wlr_pointer_create(&pointer_impl, pointer_state);
 		wlr_device->state->resource = wl_pointer;
-		wl_signal_emit(&state->backend->events.input_add, wlr_device);
+		wl_signal_emit(&backend->backend.events.input_add, wlr_device);
 	}
 	if ((caps & WL_SEAT_CAPABILITY_KEYBOARD)) {
 		wlr_log(L_DEBUG, "seat %p offered keyboard", (void*) wl_seat);
-		struct wlr_input_device *wlr_device = allocate_device(state,
+		struct wlr_input_device *wlr_device = allocate_device(backend,
 			WLR_INPUT_DEVICE_KEYBOARD);
 		if (!wlr_device) {
 			wlr_log(L_ERROR, "Unable to allocate wl_pointer device");
@@ -251,15 +251,16 @@ static void seat_handle_capabilities(void *data, struct wl_seat *wl_seat,
 		wl_keyboard_add_listener(wl_keyboard, &keyboard_listener, wlr_device);
 		wlr_device->keyboard = wlr_keyboard_create(NULL, NULL);
 		wlr_device->state->resource = wl_keyboard;
-		wl_signal_emit(&state->backend->events.input_add, wlr_device);
+		wl_signal_emit(&backend->backend.events.input_add, wlr_device);
 	}
 }
 
 static void seat_handle_name(void *data, struct wl_seat *wl_seat, const char *name) {
-	struct wlr_backend_state *state = data;
-	assert(state->seat == wl_seat);
+	struct wlr_wl_backend *backend = data;
+	assert(backend->seat == wl_seat);
 	// Do we need to check if seatName was previously set for name change?
-	state->seatName = strdup(name);
+	free(backend->seat_name);
+	backend->seat_name = strdup(name);
 }
 
 const struct wl_seat_listener seat_listener = {
diff --git a/include/backend/drm.h b/include/backend/drm.h
index 35265e21..26e3eddb 100644
--- a/include/backend/drm.h
+++ b/include/backend/drm.h
@@ -81,8 +81,9 @@ void wlr_drm_renderer_free(struct wlr_drm_renderer *renderer);
 
 struct wlr_drm_interface;
 
-struct wlr_backend_state {
-	struct wlr_backend *base;
+struct wlr_drm_backend_state {
+	struct wlr_backend backend;
+
 	const struct wlr_drm_interface *iface;
 
 	int fd;
diff --git a/include/backend/libinput.h b/include/backend/libinput.h
index bb83c749..0a93e1f6 100644
--- a/include/backend/libinput.h
+++ b/include/backend/libinput.h
@@ -7,8 +7,9 @@
 #include <wlr/util/list.h>
 #include "backend/udev.h"
 
-struct wlr_backend_state {
-	struct wlr_backend *backend;
+struct wlr_libinput_backend_state {
+	struct wlr_backend backend;
+
 	struct wlr_session *session;
 	struct wlr_udev *udev;
 	struct wl_display *display;
diff --git a/include/backend/multi.h b/include/backend/multi.h
index 5ac9cc1d..af747332 100644
--- a/include/backend/multi.h
+++ b/include/backend/multi.h
@@ -7,8 +7,9 @@
 #include <wlr/util/list.h>
 #include <wlr/backend/session.h>
 
-struct wlr_backend_state {
-	struct wlr_backend *backend;
+struct wlr_multi_backend {
+	struct wlr_backend backend;
+
 	struct wlr_session *session;
 	struct wlr_udev *udev;
 	list_t *backends;
diff --git a/include/backend/wayland.h b/include/backend/wayland.h
index be96128e..3097c8cf 100644
--- a/include/backend/wayland.h
+++ b/include/backend/wayland.h
@@ -9,10 +9,11 @@
 #include <wlr/types/wlr_input_device.h>
 #include <wlr/util/list.h>
 
-struct wlr_backend_state {
+struct wlr_wl_backend {
+	struct wlr_backend backend;
+
 	/* local state */
 	struct wl_display *local_display;
-	struct wlr_backend *backend;
 	list_t *devices;
 	list_t *outputs;
 	struct wlr_egl egl;
@@ -25,11 +26,11 @@ struct wlr_backend_state {
 	struct wl_shell *shell;
 	struct wl_shm *shm;
 	struct wl_seat *seat;
-	char *seatName;
+	char *seat_name;
 };
 
 struct wlr_output_state {
-	struct wlr_backend_state *backend;
+	struct wlr_wl_backend *backend;
 	struct wlr_output *wlr_output;
 	struct wl_surface *surface;
 	struct wl_shell_surface *shell_surface;
@@ -39,7 +40,7 @@ struct wlr_output_state {
 };
 
 struct wlr_input_device_state {
-	struct wlr_backend_state *backend;
+	struct wlr_wl_backend *backend;
 	struct wlr_input_device *wlr_device;
 	void *resource;
 };
@@ -49,8 +50,8 @@ struct wlr_pointer_state {
 	struct wlr_output *current_output;
 };
 
-void wlr_wl_registry_poll(struct wlr_backend_state *backend);
-struct wlr_output *wlr_wl_output_for_surface(struct wlr_backend_state *backend,
+void wlr_wl_registry_poll(struct wlr_wl_backend *backend);
+struct wlr_output *wlr_wl_output_for_surface(struct wlr_wl_backend *backend,
 	struct wl_surface *surface);
 
 extern const struct wl_seat_listener seat_listener;
diff --git a/include/wlr/backend.h b/include/wlr/backend.h
index ce5b2568..f87e88bd 100644
--- a/include/wlr/backend.h
+++ b/include/wlr/backend.h
@@ -6,11 +6,9 @@
 #include <wlr/egl.h>
 
 struct wlr_backend_impl;
-struct wlr_backend_state;
 
 struct wlr_backend {
 	const struct wlr_backend_impl *impl;
-	struct wlr_backend_state *state;
 
 	struct {
 		struct wl_signal input_add;
diff --git a/include/wlr/backend/interface.h b/include/wlr/backend/interface.h
index e791bdcf..adca23eb 100644
--- a/include/wlr/backend/interface.h
+++ b/include/wlr/backend/interface.h
@@ -5,15 +5,13 @@
 #include <wlr/backend.h>
 #include <wlr/egl.h>
 
-struct wlr_backend_state;
-
 struct wlr_backend_impl {
-	bool (*init)(struct wlr_backend_state *state);
-	void (*destroy)(struct wlr_backend_state *state);
-	struct wlr_egl *(*get_egl)(struct wlr_backend_state *state);
+	bool (*init)(struct wlr_backend *backend);
+	void (*destroy)(struct wlr_backend *backend);
+	struct wlr_egl *(*get_egl)(struct wlr_backend *backend);
 };
 
-struct wlr_backend *wlr_backend_create(const struct wlr_backend_impl *impl,
-		struct wlr_backend_state *state);
+void wlr_backend_create(struct wlr_backend *backend,
+		const struct wlr_backend_impl *impl);
 
 #endif