diff --git a/backend/drm/backend.c b/backend/drm/backend.c
index ab66adf5..9fbfe58c 100644
--- a/backend/drm/backend.c
+++ b/backend/drm/backend.c
@@ -9,7 +9,7 @@
 #include <wlr/backend/session.h>
 #include <wlr/backend/interface.h>
 #include <wlr/interfaces/wlr_output.h>
-#include <wlr/util/list.h>
+#include <wlr/types/wlr_list.h>
 #include <wlr/util/log.h>
 #include <wlr/render/egl.h>
 #include "backend/drm/drm.h"
@@ -29,8 +29,8 @@ static void wlr_drm_backend_destroy(struct wlr_backend *backend) {
 
 	wlr_drm_restore_outputs(drm);
 
-	for (size_t i = 0; drm->outputs && i < drm->outputs->length; ++i) {
-		struct wlr_drm_connector *conn = drm->outputs->items[i];
+	struct wlr_drm_connector *conn;
+	wl_list_for_each(conn, &drm->outputs, link) {
 		wlr_output_destroy(&conn->output);
 	}
 
@@ -38,7 +38,6 @@ static void wlr_drm_backend_destroy(struct wlr_backend *backend) {
 	wlr_drm_renderer_finish(&drm->renderer);
 	wlr_session_close_file(drm->session, drm->fd);
 	wl_event_source_remove(drm->drm_event);
-	list_free(drm->outputs);
 	free(drm);
 }
 
@@ -64,8 +63,8 @@ static void session_signal(struct wl_listener *listener, void *data) {
 	if (session->active) {
 		wlr_log(L_INFO, "DRM fd resumed");
 
-		for (size_t i = 0; i < drm->outputs->length; ++i) {
-			struct wlr_drm_connector *conn = drm->outputs->items[i];
+		struct wlr_drm_connector *conn;
+		wl_list_for_each(conn, &drm->outputs, link){
 			wlr_drm_connector_start_renderer(conn);
 
 			if (!conn->crtc) {
@@ -110,11 +109,7 @@ struct wlr_backend *wlr_drm_backend_create(struct wl_display *display,
 	wlr_backend_init(&drm->backend, &backend_impl);
 
 	drm->session = session;
-	drm->outputs = list_create();
-	if (!drm->outputs) {
-		wlr_log(L_ERROR, "Failed to allocate list");
-		goto error_backend;
-	}
+	wl_list_init(&drm->outputs);
 
 	drm->fd = gpu_fd;
 	drm->parent = (struct wlr_drm_backend *)parent;
@@ -158,8 +153,6 @@ error_event:
 	wl_event_source_remove(drm->drm_event);
 error_fd:
 	wlr_session_close_file(drm->session, drm->fd);
-	list_free(drm->outputs);
-error_backend:
 	free(drm);
 	return NULL;
 }
diff --git a/backend/drm/drm.c b/backend/drm/drm.c
index 04d7ea77..31255a7c 100644
--- a/backend/drm/drm.c
+++ b/backend/drm/drm.c
@@ -311,7 +311,7 @@ static void realloc_planes(struct wlr_drm_backend *drm, const uint32_t *crtc_in)
 static void realloc_crtcs(struct wlr_drm_backend *drm, struct wlr_drm_connector *conn) {
 	uint32_t crtc[drm->num_crtcs];
 	uint32_t crtc_res[drm->num_crtcs];
-	uint32_t possible_crtc[drm->outputs->length];
+	uint32_t possible_crtc[wl_list_length(&drm->outputs)];
 
 	for (size_t i = 0; i < drm->num_crtcs; ++i) {
 		crtc[i] = UNMATCHED;
@@ -319,9 +319,9 @@ static void realloc_crtcs(struct wlr_drm_backend *drm, struct wlr_drm_connector
 
 	memset(possible_crtc, 0, sizeof(possible_crtc));
 
-	ssize_t index = -1;
-	for (size_t i = 0; i < drm->outputs->length; ++i) {
-		struct wlr_drm_connector *c = drm->outputs->items[i];
+	ssize_t index = -1, i = 0;
+	struct wlr_drm_connector *c;
+	wl_list_for_each(c, &drm->outputs, link) {
 		if (c == conn) {
 			index = i;
 		}
@@ -332,11 +332,12 @@ static void realloc_crtcs(struct wlr_drm_backend *drm, struct wlr_drm_connector
 
 		possible_crtc[i] = c->possible_crtc;
 		crtc[c->crtc - drm->crtcs] = i;
+		i++;
 	}
 	assert(index != -1);
 
 	possible_crtc[index] = conn->possible_crtc;
-	match_obj(drm->outputs->length, possible_crtc, drm->num_crtcs,
+	match_obj(wl_list_length(&drm->outputs), possible_crtc, drm->num_crtcs,
 		crtc, crtc_res);
 
 	bool matched = false;
@@ -361,7 +362,14 @@ static void realloc_crtcs(struct wlr_drm_backend *drm, struct wlr_drm_connector
 		}
 
 		if (crtc_res[i] != crtc[i]) {
-			struct wlr_drm_connector *c = drm->outputs->items[crtc_res[i]];
+			struct wlr_drm_connector *c;
+			size_t pos = 0;
+			wl_list_for_each(c, &drm->outputs, link) {
+				if (pos == crtc_res[i]) {
+					break;
+				}
+				pos++;
+			}
 			c->crtc = &drm->crtcs[i];
 		}
 	}
@@ -436,8 +444,7 @@ static bool wlr_drm_connector_set_mode(struct wlr_output *output,
 
 	// Since realloc_crtcs can deallocate planes on OTHER outputs,
 	// we actually need to reinitalise all of them
-	for (size_t i = 0; i < drm->outputs->length; ++i) {
-		struct wlr_drm_connector *conn = drm->outputs->items[i];
+	wl_list_for_each(conn, &drm->outputs, link) {
 		struct wlr_output_mode *mode = conn->output.current_mode;
 		struct wlr_drm_crtc *crtc = conn->crtc;
 
@@ -660,13 +667,6 @@ static int retry_pageflip(void *data) {
 	return 0;
 }
 
-static int find_id(const void *item, const void *cmp_to) {
-	const struct wlr_drm_connector *conn = item;
-	const uint32_t *id = cmp_to;
-
-	return (int)conn->id - (int)*id;
-}
-
 static const int32_t subpixel_map[] = {
 	[DRM_MODE_SUBPIXEL_UNKNOWN] = WL_OUTPUT_SUBPIXEL_UNKNOWN,
 	[DRM_MODE_SUBPIXEL_HORIZONTAL_RGB] = WL_OUTPUT_SUBPIXEL_HORIZONTAL_RGB,
@@ -685,7 +685,7 @@ void wlr_drm_scan_connectors(struct wlr_drm_backend *drm) {
 		return;
 	}
 
-	size_t seen_len = drm->outputs->length;
+	size_t seen_len = wl_list_length(&drm->outputs);
 	// +1 so it can never be 0
 	bool seen[seen_len + 1];
 	memset(seen, 0, sizeof(seen));
@@ -697,11 +697,16 @@ void wlr_drm_scan_connectors(struct wlr_drm_backend *drm) {
 			wlr_log_errno(L_ERROR, "Failed to get DRM connector");
 			continue;
 		}
-
-		struct wlr_drm_connector *wlr_conn;
-		int index = list_seq_find(drm->outputs, find_id, &drm_conn->connector_id);
-
-		if (index == -1) {
+		int index = 0;
+		struct wlr_drm_connector *c, *wlr_conn = NULL;
+		wl_list_for_each(c, &drm->outputs, link) {
+			index++;
+			if (c->id == drm_conn->connector_id) {
+				wlr_conn = c;
+				break;
+			}
+		}
+		if (!wlr_conn) {
 			wlr_conn = calloc(1, sizeof(*wlr_conn));
 			if (!wlr_conn) {
 				wlr_log_errno(L_ERROR, "Allocation failed");
@@ -741,17 +746,10 @@ void wlr_drm_scan_connectors(struct wlr_drm_backend *drm) {
 			parse_edid(&wlr_conn->output, edid_len, edid);
 			free(edid);
 
-			if (list_add(drm->outputs, wlr_conn) == -1) {
-				wlr_log_errno(L_ERROR, "Allocation failed");
-				drmModeFreeConnector(drm_conn);
-				wl_event_source_remove(wlr_conn->retry_pageflip);
-				free(wlr_conn);
-				continue;
-			}
+			wl_list_insert(&drm->outputs, &wlr_conn->link);
 			wlr_output_create_global(&wlr_conn->output, drm->display);
 			wlr_log(L_INFO, "Found display '%s'", wlr_conn->output.name);
 		} else {
-			wlr_conn = drm->outputs->items[index];
 			seen[index] = true;
 		}
 
@@ -776,11 +774,7 @@ void wlr_drm_scan_connectors(struct wlr_drm_backend *drm) {
 					mode->wlr_mode.width, mode->wlr_mode.height,
 					mode->wlr_mode.refresh);
 
-				if (list_add(wlr_conn->output.modes, mode) == -1) {
-					wlr_log_errno(L_ERROR, "Allocation failed");
-					free(mode);
-					continue;
-				}
+				wl_list_insert(&wlr_conn->output.modes, &mode->wlr_mode.link);
 			}
 
 			wlr_conn->state = WLR_DRM_CONN_NEEDS_MODESET;
@@ -799,12 +793,14 @@ void wlr_drm_scan_connectors(struct wlr_drm_backend *drm) {
 
 	drmModeFreeResources(res);
 
-	for (size_t i = seen_len; i-- > 0;) {
-		if (seen[i]) {
+	struct wlr_drm_connector *conn, *tmp_conn;
+	size_t index = seen_len - 1;
+	wl_list_for_each_safe(conn, tmp_conn, &drm->outputs, link) {
+		if (seen[index]) {
+			index--;
 			continue;
 		}
-
-		struct wlr_drm_connector *conn = drm->outputs->items[i];
+		index--;
 
 		wlr_log(L_INFO, "'%s' disappeared", conn->output.name);
 		wlr_drm_connector_cleanup(conn);
@@ -812,8 +808,6 @@ void wlr_drm_scan_connectors(struct wlr_drm_backend *drm) {
 		drmModeFreeCrtc(conn->old_crtc);
 		wl_event_source_remove(conn->retry_pageflip);
 		free(conn);
-
-		list_del(drm->outputs, i);
 	}
 }
 
@@ -848,10 +842,10 @@ int wlr_drm_event(int fd, uint32_t mask, void *data) {
 }
 
 void wlr_drm_restore_outputs(struct wlr_drm_backend *drm) {
-	uint64_t to_close = (1 << drm->outputs->length) - 1;
+	uint64_t to_close = (1 << wl_list_length(&drm->outputs)) - 1;
 
-	for (size_t i = 0; i < drm->outputs->length; ++i) {
-		struct wlr_drm_connector *conn = drm->outputs->items[i];
+	struct wlr_drm_connector *conn;
+	wl_list_for_each(conn, &drm->outputs, link) {
 		if (conn->state == WLR_DRM_CONN_CONNECTED) {
 			conn->state = WLR_DRM_CONN_CLEANUP;
 		}
@@ -861,11 +855,13 @@ void wlr_drm_restore_outputs(struct wlr_drm_backend *drm) {
 
 	while (to_close && time(NULL) < timeout) {
 		wlr_drm_event(drm->fd, 0, NULL);
-		for (size_t i = 0; i < drm->outputs->length; ++i) {
-			struct wlr_drm_connector *conn = drm->outputs->items[i];
+		size_t i = 0;
+		struct wlr_drm_connector *conn;
+		wl_list_for_each(conn, &drm->outputs, link) {
 			if (conn->state != WLR_DRM_CONN_CLEANUP || !conn->pageflip_pending) {
 				to_close &= ~(1 << i);
 			}
+			i++;
 		}
 	}
 
@@ -873,8 +869,7 @@ void wlr_drm_restore_outputs(struct wlr_drm_backend *drm) {
 		wlr_log(L_ERROR, "Timed out stopping output renderers");
 	}
 
-	for (size_t i = 0; i < drm->outputs->length; ++i) {
-		struct wlr_drm_connector *conn = drm->outputs->items[i];
+	wl_list_for_each(conn, &drm->outputs, link) {
 		drmModeCrtc *crtc = conn->old_crtc;
 		if (!crtc) {
 			continue;
diff --git a/backend/libinput/backend.c b/backend/libinput/backend.c
index 3d3c90ce..b278b8f7 100644
--- a/backend/libinput/backend.c
+++ b/backend/libinput/backend.c
@@ -99,7 +99,7 @@ static void wlr_libinput_backend_destroy(struct wlr_backend *_backend) {
 	}
 	struct wlr_libinput_backend *backend = (struct wlr_libinput_backend *)_backend;
 	for (size_t i = 0; i < backend->wlr_device_lists->length; i++) {
-		list_t *wlr_devices = backend->wlr_device_lists->items[i];
+		struct wlr_list *wlr_devices = backend->wlr_device_lists->items[i];
 		for (size_t j = 0; j < wlr_devices->length; j++) {
 			struct wlr_input_device *wlr_dev = wlr_devices->items[j];
 			wl_signal_emit(&backend->backend.events.input_remove, wlr_dev);
diff --git a/backend/libinput/events.c b/backend/libinput/events.c
index 2a396536..f6634814 100644
--- a/backend/libinput/events.c
+++ b/backend/libinput/events.c
@@ -3,19 +3,19 @@
 #include <libinput.h>
 #include <wlr/backend/session.h>
 #include <wlr/interfaces/wlr_input_device.h>
-#include <wlr/util/list.h>
 #include <wlr/util/log.h>
+#include <wayland-util.h>
 #include "backend/libinput.h"
 
 struct wlr_input_device *get_appropriate_device(
 		enum wlr_input_device_type desired_type,
 		struct libinput_device *libinput_dev) {
-	list_t *wlr_devices = libinput_device_get_user_data(libinput_dev);
+	struct wl_list *wlr_devices = libinput_device_get_user_data(libinput_dev);
 	if (!wlr_devices) {
 		return NULL;
 	}
-	for (size_t i = 0; i < wlr_devices->length; ++i) {
-		struct wlr_input_device *dev = wlr_devices->items[i];
+	struct wlr_input_device *dev;
+	wl_list_for_each(dev, wlr_devices, link) {
 		if (dev->type == desired_type) {
 			return dev;
 		}
@@ -35,7 +35,7 @@ static struct wlr_input_device_impl input_device_impl = {
 
 static struct wlr_input_device *allocate_device(
 		struct wlr_libinput_backend *backend, struct libinput_device *libinput_dev,
-		list_t *wlr_devices, enum wlr_input_device_type type) {
+		struct wl_list *wlr_devices, enum wlr_input_device_type type) {
 	int vendor = libinput_device_get_id_vendor(libinput_dev);
 	int product = libinput_device_get_id_product(libinput_dev);
 	const char *name = libinput_device_get_name(libinput_dev);
@@ -44,10 +44,7 @@ static struct wlr_input_device *allocate_device(
 		return NULL;
 	}
 	struct wlr_input_device *wlr_dev = &wlr_libinput_dev->wlr_input_device;
-	if (list_add(wlr_devices, wlr_dev) == -1) {
-		free(wlr_libinput_dev);
-		return NULL;
-	}
+	wl_list_insert(wlr_devices, &wlr_dev->link);
 	wlr_libinput_dev->handle = libinput_dev;
 	libinput_device_ref(libinput_dev);
 	wlr_input_device_init(wlr_dev, type, &input_device_impl,
@@ -67,7 +64,8 @@ static void handle_device_added(struct wlr_libinput_backend *backend,
 	int vendor = libinput_device_get_id_vendor(libinput_dev);
 	int product = libinput_device_get_id_product(libinput_dev);
 	const char *name = libinput_device_get_name(libinput_dev);
-	list_t *wlr_devices = list_create();
+	struct wl_list *wlr_devices = calloc(1, sizeof(struct wl_list));
+	wl_list_init(wlr_devices);
 	if (!wlr_devices) {
 		goto fail;
 	}
@@ -145,23 +143,26 @@ static void handle_device_added(struct wlr_libinput_backend *backend,
 		// TODO
 	}
 
-	if (wlr_devices->length > 0) {
+	if (wl_list_length(wlr_devices) > 0) {
 		libinput_device_set_user_data(libinput_dev, wlr_devices);
 		list_add(backend->wlr_device_lists, wlr_devices);
 	} else {
-		list_free(wlr_devices);
+		free(wlr_devices);
 	}
 	return;
 
 fail:
 	wlr_log(L_ERROR, "Could not allocate new device");
-	list_foreach(wlr_devices, free);
-	list_free(wlr_devices);
+	struct wlr_input_device *dev, *tmp_dev;
+	wl_list_for_each_safe(dev, tmp_dev, wlr_devices, link) {
+		free(dev);
+	}
+	free(wlr_devices);
 }
 
 static void handle_device_removed(struct wlr_libinput_backend *backend,
 		struct libinput_device *libinput_dev) {
-	list_t *wlr_devices = libinput_device_get_user_data(libinput_dev);
+	struct wl_list *wlr_devices = libinput_device_get_user_data(libinput_dev);
 	int vendor = libinput_device_get_id_vendor(libinput_dev);
 	int product = libinput_device_get_id_product(libinput_dev);
 	const char *name = libinput_device_get_name(libinput_dev);
@@ -169,10 +170,10 @@ static void handle_device_removed(struct wlr_libinput_backend *backend,
 	if (!wlr_devices) {
 		return;
 	}
-	for (size_t i = 0; i < wlr_devices->length; i++) {
-		struct wlr_input_device *wlr_dev = wlr_devices->items[i];
-		wl_signal_emit(&backend->backend.events.input_remove, wlr_dev);
-		wlr_input_device_destroy(wlr_dev);
+	struct wlr_input_device *dev, *tmp_dev;
+	wl_list_for_each_safe(dev, tmp_dev, wlr_devices, link) {
+		wl_signal_emit(&backend->backend.events.input_remove, dev);
+		wlr_input_device_destroy(dev);
 	}
 	for (size_t i = 0; i < backend->wlr_device_lists->length; i++) {
 		if (backend->wlr_device_lists->items[i] == wlr_devices) {
@@ -180,7 +181,7 @@ static void handle_device_removed(struct wlr_libinput_backend *backend,
 			break;
 		}
 	}
-	list_free(wlr_devices);
+	free(wlr_devices);
 }
 
 void wlr_libinput_event(struct wlr_libinput_backend *backend,
diff --git a/backend/multi/backend.c b/backend/multi/backend.c
index ae1d6803..a7ee648c 100644
--- a/backend/multi/backend.c
+++ b/backend/multi/backend.c
@@ -13,14 +13,15 @@ struct subbackend_state {
 	struct wl_listener input_remove;
 	struct wl_listener output_add;
 	struct wl_listener output_remove;
+	struct wl_list link;
 };
 
 static bool multi_backend_start(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 subbackend_state *sub;
+	wl_list_for_each(sub, &backend->backends, link) {
 		if (!wlr_backend_start(sub->backend)) {
-			wlr_log(L_ERROR, "Failed to initialize backend %zd", i);
+			wlr_log(L_ERROR, "Failed to initialize backend.");
 			return false;
 		}
 	}
@@ -29,20 +30,19 @@ static bool multi_backend_start(struct wlr_backend *_backend) {
 
 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];
+	struct subbackend_state *sub;
+	wl_list_for_each(sub, &backend->backends, link) {
 		wlr_backend_destroy(sub->backend);
 		free(sub);
 	}
-	list_free(backend->backends);
 	wlr_session_destroy(backend->session);
 	free(backend);
 }
 
 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 subbackend_state *sub;
+	wl_list_for_each(sub, &backend->backends, link) {
 		struct wlr_egl *egl = wlr_backend_get_egl(sub->backend);
 		if (egl) {
 			return egl;
@@ -65,13 +65,7 @@ struct wlr_backend *wlr_multi_backend_create(struct wlr_session *session) {
 		return NULL;
 	}
 
-	backend->backends = list_create();
-	if (!backend->backends) {
-		free(backend);
-		wlr_log(L_ERROR, "Backend allocation failed");
-		return NULL;
-	}
-
+	wl_list_init(&backend->backends);
 	wlr_backend_init(&backend->backend, &backend_impl);
 
 	backend->session = session;
@@ -116,11 +110,7 @@ void wlr_multi_backend_add(struct wlr_backend *_multi,
 		wlr_log(L_ERROR, "Could not add backend: allocation failed");
 		return;
 	}
-	if (list_add(multi->backends, sub) == -1) {
-		wlr_log(L_ERROR, "Could not add backend: allocation failed");
-		free(sub);
-		return;
-	}
+	wl_list_insert(&multi->backends, &sub->link);
 
 	sub->backend = backend;
 	sub->container = &multi->backend;
diff --git a/backend/wayland/backend.c b/backend/wayland/backend.c
index 5018eeb0..532935b8 100644
--- a/backend/wayland/backend.c
+++ b/backend/wayland/backend.c
@@ -64,16 +64,16 @@ static void wlr_wl_backend_destroy(struct wlr_backend *_backend) {
 		return;
 	}
 
-	for (size_t i = 0; i < backend->outputs->length; ++i) {
-		wlr_output_destroy(backend->outputs->items[i]);
+	struct wlr_wl_backend_output *output, *tmp_output;
+	wl_list_for_each_safe(output, tmp_output, &backend->outputs, link) {
+		wlr_output_destroy(&output->wlr_output);
 	}
 
-	for (size_t i = 0; i < backend->devices->length; ++i) {
-		wlr_input_device_destroy(backend->devices->items[i]);
+	struct wlr_input_device *input_device, *tmp_input_device;
+	wl_list_for_each_safe(input_device, tmp_input_device, &backend->devices, link) {
+		wlr_input_device_destroy(input_device);
 	}
 
-	list_free(backend->devices);
-	list_free(backend->outputs);
 	free(backend->seat_name);
 
 	wl_event_source_remove(backend->remote_display_src);
@@ -104,8 +104,8 @@ bool wlr_backend_is_wl(struct wlr_backend *b) {
 
 struct wlr_wl_backend_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_wl_backend_output *output = backend->outputs->items[i];
+	struct wlr_wl_backend_output *output;
+	wl_list_for_each(output, &backend->outputs, link) {
 		if (output->surface == surface) {
 			return output;
 		}
@@ -123,15 +123,8 @@ struct wlr_backend *wlr_wl_backend_create(struct wl_display *display) {
 	}
 	wlr_backend_init(&backend->backend, &backend_impl);
 
-	if (!(backend->devices = list_create())) {
-		wlr_log(L_ERROR, "Could not allocate devices list");
-		goto error;
-	}
-
-	if (!(backend->outputs = list_create())) {
-		wlr_log(L_ERROR, "Could not allocate outputs list");
-		goto error;
-	}
+	wl_list_init(&backend->devices);
+	wl_list_init(&backend->outputs);
 
 	backend->local_display = display;
 
@@ -150,12 +143,4 @@ struct wlr_backend *wlr_wl_backend_create(struct wl_display *display) {
 	wlr_egl_bind_display(&backend->egl, backend->local_display);
 
 	return &backend->backend;
-
-error:
-	if (backend) {
-		list_free(backend->devices);
-		list_free(backend->outputs);
-	}
-	free(backend);
-	return NULL;
 }
diff --git a/backend/wayland/output.c b/backend/wayland/output.c
index 0216823e..3194e2cf 100644
--- a/backend/wayland/output.c
+++ b/backend/wayland/output.c
@@ -248,8 +248,8 @@ struct wlr_output *wlr_wl_output_create(struct wlr_backend *_backend) {
 	wlr_output->height = 480;
 	strncpy(wlr_output->make, "wayland", sizeof(wlr_output->make));
 	strncpy(wlr_output->model, "wayland", sizeof(wlr_output->model));
-	snprintf(wlr_output->name, sizeof(wlr_output->name), "WL-%zd",
-			backend->outputs->length + 1);
+	snprintf(wlr_output->name, sizeof(wlr_output->name), "WL-%d",
+			wl_list_length(&backend->outputs) + 1);
 	wlr_output_update_matrix(wlr_output);
 
 	output->backend = backend;
@@ -306,10 +306,7 @@ struct wlr_output *wlr_wl_output_create(struct wlr_backend *_backend) {
 		goto error;
 	}
 
-	if (list_add(backend->outputs, wlr_output) == -1) {
-		wlr_log(L_ERROR, "Allocation failed");
-		goto error;
-	}
+	wl_list_insert(&backend->outputs, &output->link);
 	wlr_output_create_global(wlr_output, backend->local_display);
 	wl_signal_emit(&backend->backend.events.output_add, wlr_output);
 	return wlr_output;
diff --git a/backend/wayland/wl_seat.c b/backend/wayland/wl_seat.c
index d3ff9b64..30074abd 100644
--- a/backend/wayland/wl_seat.c
+++ b/backend/wayland/wl_seat.c
@@ -204,11 +204,7 @@ static struct wlr_input_device *allocate_device(struct wlr_wl_backend *backend,
 	struct wlr_input_device *wlr_device = &wlr_wl_dev->wlr_input_device;
 	wlr_input_device_init(wlr_device, type, &input_device_impl,
 			name, vendor, product);
-	if (list_add(backend->devices, wlr_device) == -1) {
-		wlr_log_errno(L_ERROR, "Allocation failed");
-		free(wlr_wl_dev);
-		return NULL;
-	}
+	wl_list_insert(&backend->devices, &wlr_device->link);
 	return wlr_device;
 }
 
diff --git a/examples/pointer.c b/examples/pointer.c
index 92faaf0c..8c3c8b85 100644
--- a/examples/pointer.c
+++ b/examples/pointer.c
@@ -21,6 +21,7 @@
 #include <wlr/xcursor.h>
 #include <wlr/types/wlr_cursor.h>
 #include <wlr/util/log.h>
+#include <wlr/types/wlr_list.h>
 #include "shared.h"
 #include "config.h"
 #include "cat.h"
@@ -45,7 +46,7 @@ struct sample_state {
 	struct wl_listener touch_up;
 	struct wl_listener touch_down;
 	struct wl_listener touch_cancel;
-	list_t *touch_points;
+	struct wlr_list *touch_points;
 
 	struct wl_listener tablet_tool_axis;
 	struct wl_listener tablet_tool_proxmity;
diff --git a/examples/shared.c b/examples/shared.c
index 1fdd5775..4cde15d1 100644
--- a/examples/shared.c
+++ b/examples/shared.c
@@ -413,8 +413,10 @@ static void output_add_notify(struct wl_listener *listener, void *data) {
 	wlr_log(L_DEBUG, "Output '%s' added", output->name);
 	wlr_log(L_DEBUG, "%s %s %"PRId32"mm x %"PRId32"mm", output->make, output->model,
 		output->phys_width, output->phys_height);
-	if (output->modes->length > 0) {
-		wlr_output_set_mode(output, output->modes->items[0]);
+	if (wl_list_length(&output->modes) > 0) {
+		struct wlr_output_mode *mode = NULL;
+		wl_container_of((&output->modes)->prev, mode, link);
+		wlr_output_set_mode(output, mode);
 	}
 	struct output_state *ostate = calloc(1, sizeof(struct output_state));
 	clock_gettime(CLOCK_MONOTONIC, &ostate->last_frame);
diff --git a/examples/touch.c b/examples/touch.c
index db025942..60fb0ae4 100644
--- a/examples/touch.c
+++ b/examples/touch.c
@@ -16,7 +16,7 @@
 #include <wlr/render.h>
 #include <wlr/backend.h>
 #include <wlr/backend/session.h>
-#include <wlr/util/list.h>
+#include <wlr/types/wlr_list.h>
 #include <wlr/util/log.h>
 #include "shared.h"
 #include "cat.h"
@@ -24,7 +24,7 @@
 struct sample_state {
 	struct wlr_renderer *renderer;
 	struct wlr_texture *cat_texture;
-	list_t *touch_points;
+	struct wlr_list *touch_points;
 };
 
 struct touch_point {
diff --git a/include/backend/drm/drm.h b/include/backend/drm/drm.h
index b0f5838e..4d23f963 100644
--- a/include/backend/drm/drm.h
+++ b/include/backend/drm/drm.h
@@ -8,12 +8,13 @@
 #include <xf86drmMode.h>
 #include <EGL/egl.h>
 #include <gbm.h>
+#include <wayland-util.h>
 
 #include <wlr/backend/session.h>
 #include <wlr/backend/drm.h>
 #include <wlr/types/wlr_output.h>
 #include <wlr/render/egl.h>
-#include <wlr/util/list.h>
+#include <wlr/types/wlr_list.h>
 
 #include "iface.h"
 #include "properties.h"
@@ -92,7 +93,7 @@ struct wlr_drm_backend {
 	struct wl_listener session_signal;
 	struct wl_listener drm_invalidated;
 
-	list_t *outputs;
+	struct wl_list outputs;
 
 	struct wlr_drm_renderer renderer;
 	struct wlr_session *session;
@@ -128,6 +129,7 @@ struct wlr_drm_connector {
 
 	bool pageflip_pending;
 	struct wl_event_source *retry_pageflip;
+	struct wl_list link;
 };
 
 bool wlr_drm_check_features(struct wlr_drm_backend *drm);
diff --git a/include/backend/libinput.h b/include/backend/libinput.h
index bb6083a4..93b859a7 100644
--- a/include/backend/libinput.h
+++ b/include/backend/libinput.h
@@ -5,7 +5,7 @@
 #include <wlr/types/wlr_input_device.h>
 #include <wlr/backend/interface.h>
 #include <wlr/interfaces/wlr_input_device.h>
-#include <wlr/util/list.h>
+#include <wlr/types/wlr_list.h>
 
 struct wlr_libinput_backend {
 	struct wlr_backend backend;
@@ -18,7 +18,7 @@ struct wlr_libinput_backend {
 
 	struct wl_listener session_signal;
 
-	list_t *wlr_device_lists;
+	struct wlr_list *wlr_device_lists;
 };
 
 struct wlr_libinput_input_device {
diff --git a/include/backend/multi.h b/include/backend/multi.h
index 2c409b3a..82f85016 100644
--- a/include/backend/multi.h
+++ b/include/backend/multi.h
@@ -3,14 +3,14 @@
 
 #include <wlr/backend/interface.h>
 #include <wlr/backend/multi.h>
-#include <wlr/util/list.h>
 #include <wlr/backend/session.h>
+#include <wayland-util.h>
 
 struct wlr_multi_backend {
 	struct wlr_backend backend;
 
 	struct wlr_session *session;
-	list_t *backends;
+	struct wl_list backends;
 };
 
 #endif
diff --git a/include/backend/wayland.h b/include/backend/wayland.h
index 88aeabca..e1c89b11 100644
--- a/include/backend/wayland.h
+++ b/include/backend/wayland.h
@@ -9,7 +9,7 @@
 #include <wlr/backend/wayland.h>
 #include <wlr/types/wlr_output.h>
 #include <wlr/types/wlr_input_device.h>
-#include <wlr/util/list.h>
+#include <wayland-util.h>
 
 struct wlr_wl_backend {
 	struct wlr_backend backend;
@@ -17,8 +17,8 @@ struct wlr_wl_backend {
 	/* local state */
 	bool started;
 	struct wl_display *local_display;
-	list_t *devices;
-	list_t *outputs;
+	struct wl_list devices;
+	struct wl_list outputs;
 	struct wlr_egl egl;
 	size_t requested_outputs;
 	/* remote state */
@@ -51,6 +51,7 @@ struct wlr_wl_backend_output {
 	uint32_t enter_serial;
 
 	void *egl_surface;
+	struct wl_list link;
 };
 
 struct wlr_wl_input_device {
diff --git a/include/rootston/desktop.h b/include/rootston/desktop.h
index 1225bdcd..c3859afb 100644
--- a/include/rootston/desktop.h
+++ b/include/rootston/desktop.h
@@ -9,7 +9,7 @@
 #include <wlr/types/wlr_xdg_shell_v6.h>
 #include <wlr/types/wlr_gamma_control.h>
 #include <wlr/types/wlr_screenshooter.h>
-#include <wlr/util/list.h>
+#include <wlr/types/wlr_list.h>
 #include "rootston/view.h"
 #include "rootston/config.h"
 
@@ -22,7 +22,7 @@ struct roots_output {
 };
 
 struct roots_desktop {
-	list_t *views;
+	struct wlr_list *views;
 
 	struct wl_list outputs;
 	struct timespec last_frame;
diff --git a/include/wlr/types/wlr_data_source.h b/include/wlr/types/wlr_data_source.h
index 19834cb6..f54ac0a9 100644
--- a/include/wlr/types/wlr_data_source.h
+++ b/include/wlr/types/wlr_data_source.h
@@ -2,13 +2,13 @@
 #define WLR_TYPES_WLR_DATA_SOURCE_H
 
 #include <wayland-server.h>
-#include <wlr/util/list.h>
+#include <wlr/types/wlr_list.h>
 
 struct wlr_data_source_impl;
 
 struct wlr_data_source {
 	struct wlr_data_source_impl *impl;
-	list_t *types;
+	struct wlr_list *types;
 	void *data;
 
 	struct {
diff --git a/include/wlr/types/wlr_input_device.h b/include/wlr/types/wlr_input_device.h
index 50b0fb88..306a1166 100644
--- a/include/wlr/types/wlr_input_device.h
+++ b/include/wlr/types/wlr_input_device.h
@@ -45,6 +45,8 @@ struct wlr_input_device {
 	} events;
 
 	void *data;
+
+	struct wl_list link;
 };
 
 #endif
diff --git a/include/wlr/util/list.h b/include/wlr/types/wlr_list.h
similarity index 62%
rename from include/wlr/util/list.h
rename to include/wlr/types/wlr_list.h
index 02039d89..6a4fe863 100644
--- a/include/wlr/util/list.h
+++ b/include/wlr/types/wlr_list.h
@@ -3,57 +3,57 @@
 
 #include <stddef.h>
 
-typedef struct {
+struct wlr_list {
 	size_t capacity;
 	size_t length;
 	void **items;
-} list_t;
+};
 
 /**
  * Creates a new list, may return `NULL` on failure
  */
-list_t *list_create(void);
-void list_free(list_t *list);
-void list_foreach(list_t *list, void (*callback)(void *item));
+struct wlr_list *list_create(void);
+void list_free(struct wlr_list *list);
+void list_foreach(struct wlr_list *list, void (*callback)(void *item));
 /**
  * Add `item` to the end of a list.
  * Returns: new list length or `-1` on failure
  */
-int list_add(list_t *list, void *item);
+int list_add(struct wlr_list *list, void *item);
 /**
  * Add `item` to the end of a list.
  * Returns: new list length or `-1` on failure
  */
-int list_push(list_t *list, void *item);
+int list_push(struct wlr_list *list, void *item);
 /**
  * Place `item` into index `index` in the list
  * Returns: new list length or `-1` on failure
  */
-int list_insert(list_t *list, size_t index, void *item);
+int list_insert(struct wlr_list *list, size_t index, void *item);
 /**
  * Remove an item from the list
  */
-void list_del(list_t *list, size_t index);
+void list_del(struct wlr_list *list, size_t index);
 /**
  * Remove and return an item from the end of the list
  */
-void *list_pop(list_t *list);
+void *list_pop(struct wlr_list *list);
 /**
  * Get a reference to the last item of a list without removal
  */
-void *list_peek(list_t *list);
+void *list_peek(struct wlr_list *list);
 /**
  * Append each item in `source` to `list`
  * Does not modify `source`
  * Returns: new list length or `-1` on failure
  */
-int list_cat(list_t *list, list_t *source);
+int list_cat(struct wlr_list *list, struct wlr_list *source);
 // See qsort. Remember to use *_qsort functions as compare functions,
 // because they dereference the left and right arguments first!
-void list_qsort(list_t *list, int compare(const void *left, const void *right));
+void list_qsort(struct wlr_list *list, int compare(const void *left, const void *right));
 // Return index for first item in list that returns 0 for given compare
 // function or -1 if none matches.
-int list_seq_find(list_t *list,
+int list_seq_find(struct wlr_list *list,
 		int compare(const void *item, const void *cmp_to),
 		const void *cmp_to);
 
diff --git a/include/wlr/types/wlr_output.h b/include/wlr/types/wlr_output.h
index a2d595ea..d8649bbb 100644
--- a/include/wlr/types/wlr_output.h
+++ b/include/wlr/types/wlr_output.h
@@ -1,15 +1,15 @@
 #ifndef WLR_TYPES_WLR_OUTPUT_H
 #define WLR_TYPES_WLR_OUTPUT_H
 
-#include <stdbool.h>
+#include <wayland-util.h>
 #include <wayland-server.h>
-#include <wlr/backend.h>
-#include <wlr/util/list.h>
+#include <stdbool.h>
 
 struct wlr_output_mode {
 	uint32_t flags; // enum wl_output_mode
 	int32_t width, height;
 	int32_t refresh; // mHz
+	struct wl_list link;
 };
 
 struct wlr_output_impl;
@@ -34,7 +34,7 @@ struct wlr_output {
 	float transform_matrix[16];
 
 	/* Note: some backends may have zero modes */
-	list_t *modes;
+	struct wl_list modes;
 	struct wlr_output_mode *current_mode;
 
 	struct {
diff --git a/include/wlr/xwayland.h b/include/wlr/xwayland.h
index 09f9fbac..c25d0eb0 100644
--- a/include/wlr/xwayland.h
+++ b/include/wlr/xwayland.h
@@ -5,6 +5,7 @@
 #include <stdbool.h>
 #include <wlr/types/wlr_compositor.h>
 #include <xcb/xcb.h>
+#include <wlr/types/wlr_list.h>
 
 #ifdef HAS_XCB_ICCCM
 	#include <xcb/xcb_icccm.h>
@@ -78,7 +79,7 @@ struct wlr_xwayland_surface {
 	char *class;
 	char *instance;
 	struct wlr_xwayland_surface *parent;
-	list_t *state; // list of xcb_atom_t
+	struct wlr_list *state; // list of xcb_atom_t
 	pid_t pid;
 
 	xcb_atom_t *window_type;
diff --git a/rootston/output.c b/rootston/output.c
index 5b7297ae..99f70bcf 100644
--- a/rootston/output.c
+++ b/rootston/output.c
@@ -166,9 +166,11 @@ void output_add_notify(struct wl_listener *listener, void *data) {
 	wlr_log(L_DEBUG, "%s %s %"PRId32"mm x %"PRId32"mm",
 			wlr_output->make, wlr_output->model,
 			wlr_output->phys_width, wlr_output->phys_height);
-	if (wlr_output->modes->length > 0) {
-		wlr_output_set_mode(wlr_output, wlr_output->modes->items[0]);
-	}
+        if (wl_list_length(&wlr_output->modes) > 0) {
+                struct wlr_output_mode *mode = NULL;
+                mode = wl_container_of((&wlr_output->modes)->prev, mode, link);
+                wlr_output_set_mode(wlr_output, mode);
+        }
 
 	struct roots_output *output = calloc(1, sizeof(struct roots_output));
 	clock_gettime(CLOCK_MONOTONIC, &output->last_frame);
diff --git a/types/meson.build b/types/meson.build
index a151e8a3..bd71dac6 100644
--- a/types/meson.build
+++ b/types/meson.build
@@ -1,15 +1,20 @@
 lib_wlr_types = static_library(
 	'wlr_types',
 	files(
+		'wlr_box.c',
+		'wlr_compositor.c',
+		'wlr_cursor.c',
 		'wlr_data_device_manager.c',
 		'wlr_data_source.c',
+		'wlr_gamma_control.c',
 		'wlr_input_device.c',
 		'wlr_keyboard.c',
+		'wlr_list.c',
 		'wlr_output.c',
 		'wlr_output_layout.c',
 		'wlr_pointer.c',
-		'wlr_cursor.c',
 		'wlr_region.c',
+		'wlr_screenshooter.c',
 		'wlr_seat.c',
 		'wlr_surface.c',
 		'wlr_tablet_pad.c',
@@ -17,10 +22,6 @@ lib_wlr_types = static_library(
 		'wlr_touch.c',
 		'wlr_xdg_shell_v6.c',
 		'wlr_wl_shell.c',
-		'wlr_compositor.c',
-		'wlr_box.c',
-		'wlr_gamma_control.c',
-		'wlr_screenshooter.c',
 	),
 	include_directories: wlr_inc,
 	dependencies: [wayland_server, pixman, wlr_protos],
diff --git a/types/wlr_data_source.c b/types/wlr_data_source.c
index 83064fac..2c227778 100644
--- a/types/wlr_data_source.c
+++ b/types/wlr_data_source.c
@@ -4,7 +4,7 @@
 #include <string.h>
 #include <unistd.h>
 #include <wayland-server.h>
-#include <wlr/util/list.h>
+#include <wlr/types/wlr_list.h>
 #include <wlr/util/log.h>
 #include <wlr/types/wlr_data_source.h>
 #include <wlr/types/wlr_data_device_manager.h>
diff --git a/util/list.c b/types/wlr_list.c
similarity index 69%
rename from util/list.c
rename to types/wlr_list.c
index 4abd689b..365ad236 100644
--- a/util/list.c
+++ b/types/wlr_list.c
@@ -3,10 +3,10 @@
 #include <stdbool.h>
 #include <string.h>
 #include <stddef.h>
-#include <wlr/util/list.h>
+#include <wlr/types/wlr_list.h>
 
-list_t *list_create(void) {
-	list_t *list = malloc(sizeof(list_t));
+struct wlr_list *list_create(void) {
+	struct wlr_list *list = malloc(sizeof(struct wlr_list));
 	if (!list) {
 		return NULL;
 	}
@@ -20,7 +20,7 @@ list_t *list_create(void) {
 	return list;
 }
 
-static bool list_resize(list_t *list) {
+static bool list_resize(struct wlr_list *list) {
 	if (list->length == list->capacity) {
 		void *new_items = realloc(list->items, sizeof(void*) * (list->capacity + 10));
 		if (!new_items) {
@@ -32,7 +32,7 @@ static bool list_resize(list_t *list) {
 	return true;
 }
 
-void list_free(list_t *list) {
+void list_free(struct wlr_list *list) {
 	if (list == NULL) {
 		return;
 	}
@@ -40,7 +40,7 @@ void list_free(list_t *list) {
 	free(list);
 }
 
-void list_foreach(list_t *list, void (*callback)(void *item)) {
+void list_foreach(struct wlr_list *list, void (*callback)(void *item)) {
 	if (list == NULL || callback == NULL) {
 		return;
 	}
@@ -49,7 +49,7 @@ void list_foreach(list_t *list, void (*callback)(void *item)) {
 	}
 }
 
-int list_add(list_t *list, void *item) {
+int list_add(struct wlr_list *list, void *item) {
 	if (!list_resize(list)) {
 		return -1;
 	}
@@ -57,11 +57,11 @@ int list_add(list_t *list, void *item) {
 	return list->length;
 }
 
-int list_push(list_t *list, void *item) {
+int list_push(struct wlr_list *list, void *item) {
 	return list_add(list, item);
 }
 
-int list_insert(list_t *list, size_t index, void *item) {
+int list_insert(struct wlr_list *list, size_t index, void *item) {
 	if (!list_resize(list)) {
 		return -1;
 	}
@@ -71,22 +71,22 @@ int list_insert(list_t *list, size_t index, void *item) {
 	return list->length;
 }
 
-void list_del(list_t *list, size_t index) {
+void list_del(struct wlr_list *list, size_t index) {
 	list->length--;
 	memmove(&list->items[index], &list->items[index + 1], sizeof(void*) * (list->length - index));
 }
 
-void *list_pop(list_t *list) {
+void *list_pop(struct wlr_list *list) {
 	void *_ = list->items[list->length - 1];
 	list_del(list, list->length - 1);
 	return _;
 }
 
-void *list_peek(list_t *list) {
+void *list_peek(struct wlr_list *list) {
 	return list->items[list->length - 1];
 }
 
-int list_cat(list_t *list, list_t *source) {
+int list_cat(struct wlr_list *list, struct wlr_list *source) {
 	size_t old_len = list->length;
 	size_t i;
 	for (i = 0; i < source->length; ++i) {
@@ -98,11 +98,11 @@ int list_cat(list_t *list, list_t *source) {
 	return list->length;
 }
 
-void list_qsort(list_t *list, int compare(const void *left, const void *right)) {
+void list_qsort(struct wlr_list *list, int compare(const void *left, const void *right)) {
 	qsort(list->items, list->length, sizeof(void *), compare);
 }
 
-int list_seq_find(list_t *list,
+int list_seq_find(struct wlr_list *list,
 		int compare(const void *item, const void *data),
 		const void *data) {
 	for (size_t i = 0; i < list->length; i++) {
diff --git a/types/wlr_output.c b/types/wlr_output.c
index 03cff0bb..33324d5c 100644
--- a/types/wlr_output.c
+++ b/types/wlr_output.c
@@ -8,7 +8,7 @@
 #include <wlr/types/wlr_output.h>
 #include <wlr/types/wlr_surface.h>
 #include <wlr/interfaces/wlr_output.h>
-#include <wlr/util/list.h>
+#include <wlr/types/wlr_list.h>
 #include <wlr/util/log.h>
 #include <GLES2/gl2.h>
 #include <wlr/render/matrix.h>
@@ -26,8 +26,8 @@ static void wl_output_send_to_resource(struct wl_resource *resource) {
 			output->make, output->model, output->transform);
 	}
 	if (version >= WL_OUTPUT_MODE_SINCE_VERSION) {
-		for (size_t i = 0; i < output->modes->length; ++i) {
-			struct wlr_output_mode *mode = output->modes->items[i];
+		struct wlr_output_mode *mode;
+		wl_list_for_each(mode, &output->modes, link) {
 			// TODO: mode->flags should just be preferred
 			uint32_t flags = mode->flags;
 			if (output->current_mode == mode) {
@@ -37,7 +37,7 @@ static void wl_output_send_to_resource(struct wl_resource *resource) {
 				mode->width, mode->height, mode->refresh);
 		}
 
-		if (output->modes->length == 0) {
+		if (wl_list_length(&output->modes) == 0) {
 			// Output has no mode, send the current width/height
 			wl_output_send_mode(resource, WL_OUTPUT_MODE_CURRENT,
 				output->width, output->height, 0);
@@ -310,7 +310,7 @@ void wlr_output_init(struct wlr_output *output, struct wlr_backend *backend,
 		const struct wlr_output_impl *impl) {
 	output->backend = backend;
 	output->impl = impl;
-	output->modes = list_create();
+	wl_list_init(&output->modes);
 	output->transform = WL_OUTPUT_TRANSFORM_NORMAL;
 	output->scale = 1;
 	wl_signal_init(&output->events.frame);
@@ -334,11 +334,11 @@ void wlr_output_destroy(struct wlr_output *output) {
 	wlr_texture_destroy(output->cursor.texture);
 	wlr_renderer_destroy(output->cursor.renderer);
 
-	for (size_t i = 0; output->modes && i < output->modes->length; ++i) {
-		struct wlr_output_mode *mode = output->modes->items[i];
+	struct wlr_output_mode *mode, *tmp_mode;
+	wl_list_for_each_safe(mode, tmp_mode, &output->modes, link) {
 		free(mode);
 	}
-	list_free(output->modes);
+	wl_list_remove(&output->modes);
 	if (output->impl && output->impl->destroy) {
 		output->impl->destroy(output);
 	} else {
diff --git a/util/meson.build b/util/meson.build
index a612325f..dd620818 100644
--- a/util/meson.build
+++ b/util/meson.build
@@ -1,7 +1,6 @@
 lib_wlr_util = static_library(
 	'wlr_util',
 	files(
-		'list.c',
 		'log.c',
 	),
 	include_directories: wlr_inc,