branch-merge: land udev support

A certain class of machines don't work in plymouth because
they draw the kernel console to /dev/dri/card1 instead of
/dev/dri/card2.

This branch fixes that, by adding support for querying udev
to determine the available drm devices.

As part of this effort, some clean up was performed:

1) a bunch of bit rotted tests were removed
2) large chunks of code were moved from main.c to helper
objects implemented in other files.
3) Other parts of main.c were moved around or refactored
so they were easier to read.

Based on work from Kevin Murphy <kemurphy.cmu@gmail.com>

https://bugs.freedesktop.org/show_bug.cgi?id=25943

49 files changed, 1714 insertions, 2226 deletions

diff --git a/configure.ac b/configure.ac
index 7bdfd821..7b0f68cd 100644
--- a/configure.ac
+++ b/configure.ac
@@ -38,6 +38,10 @@ PKG_CHECK_MODULES(IMAGE, [libpng >= 1.2.16 ])
 AC_SUBST(IMAGE_CFLAGS)
 AC_SUBST(IMAGE_LIBS)
 
+PKG_CHECK_MODULES(UDEV, [libudev]);
+AC_SUBST(UDEV_CFLAGS)
+AC_SUBST(UDEV_LIBS)
+
 PLYMOUTH_CFLAGS=""
 PLYMOUTH_LIBS="-lm -lrt -ldl"
 
diff --git a/src/Makefile.am b/src/Makefile.am
index a9e6eb17..c535f21c 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -1,4 +1,4 @@
-SUBDIRS = libply libply-splash-core libply-splash-graphics . plugins client viewer tests
+SUBDIRS = libply libply-splash-core libply-splash-graphics . plugins client viewer
 if ENABLE_UPSTART_MONITORING
 SUBDIRS += upstart-bridge
 endif
@@ -15,12 +15,13 @@ plymouthdbindir = $(plymouthdaemondir)
 plymouthdbin_PROGRAMS = plymouthd
 
 plymouthd_CFLAGS = $(PLYMOUTH_CFLAGS)                                         \
+		   $(UDEV_CFLAGS)                                             \
 		   -DPLYMOUTH_PLUGIN_PATH=\"$(PLYMOUTH_PLUGIN_PATH)\"         \
 		   -DPLYMOUTH_THEME_PATH=\"$(PLYMOUTH_THEME_PATH)/\"          \
 		   -DPLYMOUTH_POLICY_DIR=\"$(PLYMOUTH_POLICY_DIR)/\"          \
 		   -DPLYMOUTH_RUNTIME_DIR=\"$(PLYMOUTH_RUNTIME_DIR)\"         \
 		   -DPLYMOUTH_CONF_DIR=\"$(PLYMOUTH_CONF_DIR)/\"
-plymouthd_LDADD = $(PLYMOUTH_LIBS) libply/libply.la libply-splash-core/libply-splash-core.la
+plymouthd_LDADD = $(PLYMOUTH_LIBS) $(UDEV_LIBS) libply/libply.la libply-splash-core/libply-splash-core.la
 plymouthd_SOURCES =                                                            \
                    ply-boot-protocol.h                                        \
                    ply-boot-server.h                                          \
diff --git a/src/client/Makefile.am b/src/client/Makefile.am
index 9487901b..ead574a9 100644
--- a/src/client/Makefile.am
+++ b/src/client/Makefile.am
@@ -1,5 +1,3 @@
-SUBDIRS = . tests
-
 INCLUDES = -I$(top_srcdir)                                                    \
            -I$(top_srcdir)/src                                                \
            -I$(top_srcdir)/src/libply                                         \
diff --git a/src/client/ply-boot-client.c b/src/client/ply-boot-client.c
index 56458ceb..3480676a 100644
--- a/src/client/ply-boot-client.c
+++ b/src/client/ply-boot-client.c
@@ -869,137 +869,4 @@ ply_boot_client_attach_to_event_loop (ply_boot_client_t *client,
 
 }
 
-#ifdef PLY_BOOT_CLIENT_ENABLE_TEST
-
-#include <stdio.h>
-
-#include "ply-event-loop.h"
-#include "ply-boot-client.h"
-
-static void
-on_pinged (ply_event_loop_t *loop)
-{
-  printf ("PING!\n");
-}
-
-static void
-on_ping_failed (ply_event_loop_t *loop)
-{
-  printf ("PING FAILED! %m\n");
-  ply_event_loop_exit (loop, 1);
-}
-
-static void
-on_update (ply_event_loop_t *loop)
-{
-  printf ("UPDATE!\n");
-}
-
-static void
-on_update_failed (ply_event_loop_t *loop)
-{
-  printf ("UPDATE FAILED! %m\n");
-  ply_event_loop_exit (loop, 1);
-}
-
-static void
-on_newroot (ply_event_loop_t *loop)
-{
-  printf ("NEWROOT!\n");
-}
-
-static void
-on_system_initialized (ply_event_loop_t *loop)
-{
-  printf ("SYSTEM INITIALIZED!\n");
-}
-
-static void
-on_system_initialized_failed (ply_event_loop_t *loop)
-{
-  printf ("SYSTEM INITIALIZATION REQUEST FAILED!\n");
-  ply_event_loop_exit (loop, 1);
-}
-
-static void
-on_quit (ply_event_loop_t *loop)
-{
-  printf ("QUIT!\n");
-  ply_event_loop_exit (loop, 0);
-}
-
-static void
-on_quit_failed (ply_event_loop_t *loop)
-{
-  printf ("QUIT FAILED! %m\n");
-  ply_event_loop_exit (loop, 2);
-}
-
-static void
-on_disconnect (ply_event_loop_t *loop)
-{
-  printf ("DISCONNECT!\n");
-  ply_event_loop_exit (loop, 1);
-}
-
-int
-main (int    argc,
-      char **argv)
-{
-  ply_event_loop_t *loop;
-  ply_boot_client_t *client;
-  int exit_code;
-
-  exit_code = 0;
-
-  loop = ply_event_loop_new ();
-
-  client = ply_boot_client_new ();
-
-  if (!ply_boot_client_connect (client, 
-                                (ply_boot_client_disconnect_handler_t) on_disconnect,
-                                loop))
-    {
-      perror ("could not start boot client");
-      return errno;
-    }
-
-  ply_boot_client_attach_to_event_loop (client, loop);
-  ply_boot_client_ping_daemon (client, 
-                               (ply_boot_client_response_handler_t) on_pinged,
-                               (ply_boot_client_response_handler_t) on_ping_failed,
-                               loop);
-
-  ply_boot_client_update_daemon (client, 
-                                 "loading",
-                                 (ply_boot_client_response_handler_t) on_update,
-                                 (ply_boot_client_response_handler_t) on_update_failed,
-                                 loop);
-
-  ply_boot_client_update_daemon (client, 
-                                 "loading more",
-                                 (ply_boot_client_response_handler_t) on_update,
-                                 (ply_boot_client_response_handler_t) on_update_failed,
-                                 loop);
-
-  ply_boot_client_tell_daemon_system_is_initialized (client, 
-                                       (ply_boot_client_response_handler_t) 
-                                       on_system_initialized,
-                                       (ply_boot_client_response_handler_t) 
-                                       on_system_initialized_failed,
-                                       loop);
-
-  ply_boot_client_tell_daemon_to_quit (client, 
-                                       (ply_boot_client_response_handler_t) on_quit,
-                                       (ply_boot_client_response_handler_t) on_quit_failed,
-                                       loop);
-
-  exit_code = ply_event_loop_run (loop);
-
-  ply_boot_client_free (client);
-
-  return exit_code;
-}
-
-#endif /* PLY_BOOT_CLIENT_ENABLE_TEST */
 /* vim: set ts=4 sw=4 expandtab autoindent cindent cino={.5s,(0: */
diff --git a/src/client/tests/Makefile.am b/src/client/tests/Makefile.am
deleted file mode 100644
index c6dbfdbd..00000000
--- a/src/client/tests/Makefile.am
+++ /dev/null
@@ -1,10 +0,0 @@
-INCLUDES =                                                                    \
-           -I$(top_srcdir)                                                    \
-           -I$(srcdir)/..                                                     \
-           -I$(srcdir)/../..                                                  \
-           -I$(srcdir)
-TESTS = 
-
-noinst_PROGRAMS = $(TESTS)
-
-MAINTAINERCLEANFILES = Makefile.in
diff --git a/src/client/tests/ply-boot-client-test.am b/src/client/tests/ply-boot-client-test.am
deleted file mode 100644
index f733032f..00000000
--- a/src/client/tests/ply-boot-client-test.am
+++ /dev/null
@@ -1,16 +0,0 @@
-TESTS += ply-boot-client-test
-
-ply_boot_client_test_CFLAGS = $(PLYMOUTH_CFLAGS) -DPLY_BOOT_CLIENT_ENABLE_TEST
-ply_boot_client_test_LDADD = $(PLYMOUTH_LIBS)
-
-ply_boot_client_test_SOURCES =                                                \
-                          $(srcdir)/../ply-utils.h                            \
-                          $(srcdir)/../ply-utils.c                            \
-                          $(srcdir)/../ply-logger.h                           \
-                          $(srcdir)/../ply-logger.c                           \
-                          $(srcdir)/../ply-list.h                             \
-                          $(srcdir)/../ply-list.c                             \
-                          $(srcdir)/../ply-event-loop.h                       \
-                          $(srcdir)/../ply-event-loop.c                       \
-                          $(srcdir)/../ply-boot-client.h                      \
-                          $(srcdir)/../ply-boot-client.c
diff --git a/src/libply-splash-core/Makefile.am b/src/libply-splash-core/Makefile.am
index 1758556a..287b11b2 100644
--- a/src/libply-splash-core/Makefile.am
+++ b/src/libply-splash-core/Makefile.am
@@ -15,11 +15,13 @@ libply_splash_coredir = $(includedir)/plymouth-1/ply-splash-core
 libply_splash_core_HEADERS = \
 		    ply-boot-splash.h                                         \
 		    ply-boot-splash-plugin.h                                  \
+		    ply-device-manager.h                                      \
 		    ply-keyboard.h                                            \
 		    ply-pixel-buffer.h                                        \
 		    ply-pixel-display.h                                       \
 		    ply-renderer.h                                            \
 		    ply-renderer-plugin.h                                     \
+		    ply-seat.h                                                \
 		    ply-terminal.h                                            \
 		    ply-text-display.h                                        \
 		    ply-text-progress-bar.h                                   \
@@ -36,6 +38,7 @@ libply_splash_core_la_LDFLAGS = -export-symbols-regex '^[^_].*' \
 		    -no-undefined
 libply_splash_core_la_SOURCES = \
 		    $(libply_splash_core_HEADERS)                              \
+		    ply-device-manager.c                                      \
 		    ply-keyboard.c                                           \
 		    ply-pixel-display.c                                      \
 		    ply-text-display.c                                       \
@@ -44,6 +47,7 @@ libply_splash_core_la_SOURCES = \
 		    ply-terminal.c                                           \
 		    ply-pixel-buffer.c                                       \
 		    ply-renderer.c                                           \
+		    ply-seat.c                                               \
 		    ply-boot-splash.c
 
 MAINTAINERCLEANFILES = Makefile.in
diff --git a/src/libply-splash-core/ply-boot-splash.c b/src/libply-splash-core/ply-boot-splash.c
index 93d93450..160ce45e 100644
--- a/src/libply-splash-core/ply-boot-splash.c
+++ b/src/libply-splash-core/ply-boot-splash.c
@@ -48,10 +48,6 @@
 #define UPDATES_PER_SECOND 30
 #endif
 
-#define KEY_CTRL_L ('\100' ^'L')
-#define KEY_CTRL_T ('\100' ^'T')
-#define KEY_CTRL_V ('\100' ^'V')
-
 struct _ply_boot_splash
 {
   ply_event_loop_t *loop;
@@ -59,11 +55,9 @@ struct _ply_boot_splash
   const ply_boot_splash_plugin_interface_t *plugin_interface;
   ply_boot_splash_plugin_t *plugin;
   ply_boot_splash_mode_t mode;
-  ply_keyboard_t *keyboard;
   ply_buffer_t *boot_buffer;
   ply_trigger_t *idle_trigger;
-  ply_list_t *pixel_displays;
-  ply_list_t *text_displays;
+  ply_list_t *seats;
 
   char *theme_path;
   char *plugin_dir;
@@ -100,18 +94,30 @@ ply_boot_splash_new (const char     *theme_path,
   splash->mode = PLY_BOOT_SPLASH_MODE_INVALID;
 
   splash->boot_buffer = boot_buffer;
-  splash->pixel_displays = ply_list_new ();
-  splash->text_displays = ply_list_new ();
+  splash->seats = ply_list_new ();
 
   return splash;
 }
 
 static void
-refresh_displays (ply_boot_splash_t *splash)
+detach_from_seat (ply_boot_splash_t *splash,
+                  ply_seat_t        *seat)
 {
-  ply_list_node_t *node;
+  ply_keyboard_t *keyboard;
+  ply_list_t *displays;
+  ply_list_node_t *node, *next_node;
 
-  node = ply_list_get_first_node (splash->pixel_displays);
+  ply_trace ("removing keyboard");
+  if (splash->plugin_interface->unset_keyboard != NULL)
+    {
+      keyboard = ply_seat_get_keyboard (seat);
+      splash->plugin_interface->unset_keyboard (splash->plugin, keyboard);
+    }
+
+  ply_trace ("removing pixel displays");
+  displays = ply_seat_get_pixel_displays (seat);
+
+  node = ply_list_get_first_node (displays);
   while (node != NULL)
     {
       ply_pixel_display_t *display;
@@ -119,184 +125,137 @@ refresh_displays (ply_boot_splash_t *splash)
       unsigned long width, height;
 
       display = ply_list_node_get_data (node);
-      next_node = ply_list_get_next_node (splash->pixel_displays, node);
+      next_node = ply_list_get_next_node (displays, node);
 
       width = ply_pixel_display_get_width (display);
       height = ply_pixel_display_get_height (display);
 
-      ply_pixel_display_draw_area (display, 0, 0, width, height);
+      ply_trace ("Removing %lux%lu pixel display", width, height);
+
+      if (splash->plugin_interface->remove_pixel_display != NULL)
+        splash->plugin_interface->remove_pixel_display (splash->plugin, display);
+
       node = next_node;
     }
 
-  node = ply_list_get_first_node (splash->text_displays);
+  ply_trace ("removing text displays");
+  displays = ply_seat_get_text_displays (seat);
+
+  node = ply_list_get_first_node (displays);
   while (node != NULL)
     {
       ply_text_display_t *display;
-      ply_list_node_t *next_node;
       int number_of_columns, number_of_rows;
 
       display = ply_list_node_get_data (node);
-      next_node = ply_list_get_next_node (splash->text_displays, node);
+      next_node = ply_list_get_next_node (displays, node);
 
       number_of_columns = ply_text_display_get_number_of_columns (display);
       number_of_rows = ply_text_display_get_number_of_rows (display);
 
-      ply_text_display_draw_area (display, 0, 0,
-                                  number_of_columns,
-                                  number_of_rows);
+      ply_trace ("Removing %dx%d text display", number_of_columns, number_of_rows);
+
+      if (splash->plugin_interface->remove_text_display != NULL)
+        splash->plugin_interface->remove_text_display (splash->plugin, display);
+
       node = next_node;
     }
 }
 
-static ply_terminal_t *
-find_local_console_terminal (ply_boot_splash_t *splash)
+static void
+attach_to_seat (ply_boot_splash_t *splash,
+                ply_seat_t        *seat)
 {
-  ply_list_node_t *node;
-  node = ply_list_get_first_node (splash->text_displays);
+  ply_keyboard_t *keyboard;
+  ply_list_t *displays;
+  ply_list_node_t *node, *next_node;
 
-  while (node != NULL)
+  if (splash->plugin_interface->set_keyboard != NULL)
     {
-      ply_text_display_t *display;
-      ply_terminal_t *terminal;
-      ply_list_node_t *next_node;
+      keyboard = ply_seat_get_keyboard (seat);
+      splash->plugin_interface->set_keyboard (splash->plugin, keyboard);
+    }
 
-      display = ply_list_node_get_data (node);
-      next_node = ply_list_get_next_node (splash->text_displays, node);
+  if (splash->plugin_interface->add_pixel_display != NULL)
+    {
+      displays = ply_seat_get_pixel_displays (seat);
 
-      terminal = ply_text_display_get_terminal (display);
+      ply_trace ("adding pixel displays");
+      node = ply_list_get_first_node (displays);
+      while (node != NULL)
+        {
+          ply_pixel_display_t *display;
+          ply_list_node_t *next_node;
+          unsigned long width, height;
 
-      if (terminal != NULL && ply_terminal_is_vt (terminal))
-        return terminal;
+          display = ply_list_node_get_data (node);
+          next_node = ply_list_get_next_node (displays, node);
 
-      node = next_node;
-    }
+          width = ply_pixel_display_get_width (display);
+          height = ply_pixel_display_get_height (display);
 
-  return NULL;
-}
+          ply_trace ("Adding %lux%lu pixel display", width, height);
 
-static void
-on_keyboard_input (ply_boot_splash_t *splash,
-                   const char        *keyboard_input,
-                   size_t             character_size)
-{
-  wchar_t key;
+          splash->plugin_interface->add_pixel_display (splash->plugin, display);
 
-  if ((ssize_t) mbrtowc (&key, keyboard_input, character_size, NULL) > 0)
-    {
-      switch (key)
-        {
-          case KEY_CTRL_L:
-            refresh_displays (splash);
-          return;
-
-          case KEY_CTRL_T:
-            ply_trace ("toggle text mode!");
-            splash->should_force_text_mode = !splash->should_force_text_mode;
-
-            if (ply_list_get_length (splash->pixel_displays) >= 1)
-              {
-                ply_terminal_t *terminal;
-
-                terminal = find_local_console_terminal (splash);
-
-                if (terminal != NULL)
-                  {
-                    if (splash->should_force_text_mode)
-                      {
-                        ply_terminal_set_mode (terminal, PLY_TERMINAL_MODE_TEXT);
-                        ply_terminal_ignore_mode_changes (terminal, true);
-                      }
-                    else
-                      ply_terminal_ignore_mode_changes (terminal, false);
-                  }
-              }
-            ply_trace ("text mode toggled!");
-          return;
-
-          case KEY_CTRL_V:
-            ply_trace ("toggle verbose mode!");
-            ply_toggle_tracing ();
-            ply_trace ("verbose mode toggled!");
-          return;
+          node = next_node;
         }
     }
-}
 
-void
-ply_boot_splash_set_keyboard (ply_boot_splash_t *splash,
-                              ply_keyboard_t    *keyboard)
-{
-  splash->keyboard = keyboard;
+  if (splash->plugin_interface->add_text_display != NULL)
+    {
+      displays = ply_seat_get_text_displays (seat);
 
-  ply_keyboard_add_input_handler (keyboard,
-                                  (ply_keyboard_input_handler_t)
-                                  on_keyboard_input, splash);
+      ply_trace ("adding text displays");
+      node = ply_list_get_first_node (displays);
+      while (node != NULL)
+        {
+          ply_text_display_t *display;
+          int number_of_columns, number_of_rows;
 
-  if (splash->plugin_interface->set_keyboard == NULL)
-    return;
+          display = ply_list_node_get_data (node);
+          next_node = ply_list_get_next_node (displays, node);
 
-  splash->plugin_interface->set_keyboard (splash->plugin, keyboard);
-}
+          number_of_columns = ply_text_display_get_number_of_columns (display);
+          number_of_rows = ply_text_display_get_number_of_rows (display);
 
-void
-ply_boot_splash_unset_keyboard (ply_boot_splash_t *splash)
-{
-  ply_keyboard_remove_input_handler (splash->keyboard,
-                                     (ply_keyboard_input_handler_t)
-                                     on_keyboard_input);
+          ply_trace ("Adding %dx%d text display", number_of_columns, number_of_rows);
 
-  if (splash->plugin_interface->set_keyboard == NULL)
-    return;
+          splash->plugin_interface->add_text_display (splash->plugin, display);
 
-  splash->plugin_interface->unset_keyboard (splash->plugin, splash->keyboard);
+          node = next_node;
+        }
+    }
 }
 
 void
-ply_boot_splash_add_pixel_display (ply_boot_splash_t   *splash,
-                                   ply_pixel_display_t *display)
+ply_boot_splash_attach_to_seat (ply_boot_splash_t *splash,
+                                ply_seat_t        *seat)
 {
-  ply_list_append_data (splash->pixel_displays, display);
-
-  if (splash->plugin_interface->add_pixel_display == NULL)
-    return;
-
-  splash->plugin_interface->add_pixel_display (splash->plugin, display);
-}
+  ply_list_node_t *node;
 
-void
-ply_boot_splash_remove_pixel_display (ply_boot_splash_t   *splash,
-                                      ply_pixel_display_t *display)
-{
-  ply_list_remove_data (splash->pixel_displays, display);
+  node = ply_list_find_node (splash->seats, seat);
 
-  if (splash->plugin_interface->remove_pixel_display == NULL)
+  if (node != NULL)
     return;
 
-  splash->plugin_interface->remove_pixel_display (splash->plugin, display);
+  ply_list_append_data (splash->seats, seat);
+  attach_to_seat (splash, seat);
 }
 
 void
-ply_boot_splash_add_text_display (ply_boot_splash_t   *splash,
-                                  ply_text_display_t *display)
+ply_boot_splash_detach_from_seat (ply_boot_splash_t *splash,
+                                  ply_seat_t        *seat)
 {
-  ply_list_append_data (splash->text_displays, display);
+  ply_list_node_t *node;
 
-  if (splash->plugin_interface->add_text_display == NULL)
-    return;
+  node = ply_list_find_node (splash->seats, seat);
 
-  splash->plugin_interface->add_text_display (splash->plugin, display);
-}
-
-void
-ply_boot_splash_remove_text_display (ply_boot_splash_t   *splash,
-                                     ply_text_display_t *display)
-{
-  ply_list_remove_data (splash->text_displays, display);
-
-  if (splash->plugin_interface->remove_pixel_display == NULL)
+  if (node == NULL)
     return;
 
-  splash->plugin_interface->remove_text_display (splash->plugin, display);
+  ply_list_remove_data (splash->seats, seat);
+  detach_from_seat (splash, seat);
 }
 
 bool
@@ -432,56 +391,24 @@ ply_boot_splash_unload (ply_boot_splash_t *splash)
 }
 
 static void
-remove_displays (ply_boot_splash_t *splash)
+detach_from_seats (ply_boot_splash_t *splash)
 {
-  ply_list_node_t *node, *next_node;
+  ply_list_node_t *node;
 
-  ply_trace ("removing pixel displays");
+  ply_trace ("detaching from seats");
 
-  node = ply_list_get_first_node (splash->pixel_displays);
+  node = ply_list_get_first_node (splash->seats);
   while (node != NULL)
     {
-      ply_pixel_display_t *display;
+      ply_seat_t *seat;
       ply_list_node_t *next_node;
-      unsigned long width, height;
 
-      display = ply_list_node_get_data (node);
-      next_node = ply_list_get_next_node (splash->pixel_displays, node);
+      seat = ply_list_node_get_data (node);
+      next_node = ply_list_get_next_node (splash->seats, node);
 
-      width = ply_pixel_display_get_width (display);
-      height = ply_pixel_display_get_height (display);
+      detach_from_seat (splash, seat);
 
-      ply_trace ("Removing %lux%lu pixel display", width, height);
-
-      if (splash->plugin_interface->remove_pixel_display != NULL)
-        splash->plugin_interface->remove_pixel_display (splash->plugin, display);
-
-      ply_trace ("Removing node");
-      ply_list_remove_node (splash->pixel_displays, node);
-
-      node = next_node;
-    }
-
-  ply_trace ("removing text displays");
-  node = ply_list_get_first_node (splash->text_displays);
-  while (node != NULL)
-    {
-      ply_text_display_t *display;
-      int number_of_columns, number_of_rows;
-
-      display = ply_list_node_get_data (node);
-      next_node = ply_list_get_next_node (splash->text_displays, node);
-
-      number_of_columns = ply_text_display_get_number_of_columns (display);
-      number_of_rows = ply_text_display_get_number_of_rows (display);
-
-      ply_trace ("Removing %dx%d text display", number_of_columns, number_of_rows);
-
-      if (splash->plugin_interface->remove_text_display != NULL)
-        splash->plugin_interface->remove_text_display (splash->plugin, display);
-
-      ply_trace ("Removing node");
-      ply_list_remove_node (splash->text_displays, node);
+      ply_list_remove_node (splash->seats, node);
 
       node = next_node;
     }
@@ -508,9 +435,8 @@ ply_boot_splash_free (ply_boot_splash_t *splash)
                                              splash);
     }
 
-  remove_displays (splash);
-  ply_list_free (splash->pixel_displays);
-  ply_list_free (splash->text_displays);
+  detach_from_seats (splash);
+  ply_list_free (splash->seats);
 
   if (splash->module_handle != NULL)
     ply_boot_splash_unload (splash);
@@ -676,16 +602,6 @@ ply_boot_splash_hide (ply_boot_splash_t *splash)
   splash->plugin_interface->hide_splash_screen (splash->plugin,
                                                 splash->loop);
 
-  if (ply_list_get_length (splash->pixel_displays) >= 1)
-    {
-      ply_terminal_t *terminal;
-
-      terminal = find_local_console_terminal (splash);
-
-      if (terminal != NULL)
-        ply_terminal_set_mode (terminal, PLY_TERMINAL_MODE_TEXT);
-    }
-
   splash->mode = PLY_BOOT_SPLASH_MODE_INVALID;
 
   if (splash->loop != NULL)
@@ -820,148 +736,4 @@ ply_boot_splash_become_idle (ply_boot_splash_t                  *splash,
   splash->plugin_interface->become_idle (splash->plugin, splash->idle_trigger);
 }
 
-#ifdef PLY_BOOT_SPLASH_ENABLE_TEST
-
-#include <stdio.h>
-
-#include "ply-event-loop.h"
-#include "ply-boot-splash.h"
-
-typedef struct test_state test_state_t;
-struct test_state {
-  ply_event_loop_t *loop;
-  ply_boot_splash_t *splash;
-  ply_buffer_t *buffer;
-};
-
-static void
-on_timeout (ply_boot_splash_t *splash)
-{
-  ply_boot_splash_update_status (splash, "foo");
-  ply_event_loop_watch_for_timeout (splash->loop, 
-                                    5.0,
-                                   (ply_event_loop_timeout_handler_t)
-                                   on_timeout,
-                                   splash);
-}
-
-static void
-on_quit (test_state_t *state)
-{
-    ply_boot_splash_hide (state->splash);
-    ply_event_loop_exit (state->loop, 0);
-}
-
-static void
-add_displays_to_splash_from_renderer (test_state_t   *state,
-                                      ply_renderer_t *renderer)
-{
-  ply_list_t *heads;
-  ply_list_node_t *node;
-
-  heads = ply_renderer_get_heads (renderer);
-
-  node = ply_list_get_first_node (heads);
-  while (node != NULL)
-    {
-      ply_list_node_t *next_node;
-      ply_renderer_head_t *head;
-      ply_pixel_display_t *display;
-
-      head = ply_list_node_get_data (node);
-      next_node = ply_list_get_next_node (heads, node);
-
-      display = ply_pixel_display_new (renderer, head);
-
-      ply_boot_splash_add_pixel_display (state->splash, display);
-
-      node = next_node;
-    }
-}
-
-int
-main (int    argc,
-      char **argv)
-{
-  int exit_code;
-  test_state_t state;
-  char *tty_name;
-  const char *theme_path;
-  ply_text_display_t *text_display;
-  ply_renderer_t *renderer;
-  ply_terminal_t *terminal;
-  ply_keyboard_t *keyboard;
-
-  exit_code = 0;
-
-  state.loop = ply_event_loop_new ();
-
-  if (argc > 1)
-    theme_path = argv[1];
-  else
-    theme_path = PLYMOUTH_THEME_PATH "/fade-in/fade-in.plymouth";
-
-  if (argc > 2)
-    asprintf(&tty_name, "tty%s", argv[2]);
-  else
-    tty_name = strdup("tty0");
-
-  terminal = ply_terminal_new (tty_name);
-
-  if (!ply_terminal_open (terminal))
-    {
-      perror ("could not open tty");
-      return errno;
-    }
-
-  renderer = ply_renderer_new (NULL, terminal);
-  free(tty_name);
-
-  if (!ply_renderer_open (renderer))
-    {
-      perror ("could not open renderer /dev/fb");
-      ply_renderer_free (renderer);
-      return errno;
-    }
-
-  keyboard = ply_keyboard_new_for_renderer (renderer);
-  ply_keyboard_add_escape_handler (keyboard,
-                                   (ply_keyboard_escape_handler_t) on_quit, &state);
-
-  state.buffer = ply_buffer_new ();
-  state.splash = ply_boot_splash_new (theme_path, PLYMOUTH_PLUGIN_PATH, state.buffer);
-
-  if (!ply_boot_splash_load (state.splash))
-    {
-      perror ("could not load splash screen");
-      return errno;
-    }
-
-  ply_boot_splash_set_keyboard (state.splash, keyboard);
-  add_displays_to_splash_from_renderer (&state, renderer);
-
-  text_display = ply_text_display_new (terminal);
-  ply_boot_splash_add_text_display (state.splash, text_display);
-
-  ply_boot_splash_attach_to_event_loop (state.splash, state.loop);
-
-  if (!ply_boot_splash_show (state.splash, PLY_BOOT_SPLASH_MODE_BOOT_UP))
-    {
-      perror ("could not show splash screen");
-      return errno;
-    }
-
-  ply_event_loop_watch_for_timeout (state.loop, 
-                                    1.0,
-                                   (ply_event_loop_timeout_handler_t)
-                                   on_timeout,
-                                   state.splash);
-  exit_code = ply_event_loop_run (state.loop);
-  ply_boot_splash_free (state.splash);
-  ply_buffer_free (state.buffer);
-
-  return exit_code;
-}
-
-#endif /* PLY_BOOT_SPLASH_ENABLE_TEST */
 /* vim: set ts=4 sw=4 expandtab autoindent cindent cino={.5s,(0: */
diff --git a/src/libply-splash-core/ply-boot-splash.h b/src/libply-splash-core/ply-boot-splash.h
index a79e9396..335039ba 100644
--- a/src/libply-splash-core/ply-boot-splash.h
+++ b/src/libply-splash-core/ply-boot-splash.h
@@ -33,10 +33,12 @@
 #include "ply-pixel-display.h"
 #include "ply-text-display.h"
 #include "ply-progress.h"
+#include "ply-seat.h"
 
 #include "ply-boot-splash-plugin.h"
 
 typedef struct _ply_boot_splash ply_boot_splash_t;
+typedef struct _ply_seat ply_seat_t;
 
 typedef void (* ply_boot_splash_on_idle_handler_t) (void *user_data);
 
@@ -48,17 +50,10 @@ ply_boot_splash_t *ply_boot_splash_new (const char   *  theme_path,
 bool ply_boot_splash_load (ply_boot_splash_t *splash);
 bool ply_boot_splash_load_built_in (ply_boot_splash_t *splash);
 void ply_boot_splash_unload (ply_boot_splash_t *splash);
-void ply_boot_splash_set_keyboard (ply_boot_splash_t *splash,
-                                   ply_keyboard_t    *keyboard);
-void ply_boot_splash_unset_keyboard (ply_boot_splash_t *splash);
-void ply_boot_splash_add_pixel_display (ply_boot_splash_t   *splash,
-                                        ply_pixel_display_t *display);
-void ply_boot_splash_remove_pixel_display (ply_boot_splash_t   *splash,
-                                           ply_pixel_display_t *display);
-void ply_boot_splash_add_text_display (ply_boot_splash_t   *splash,
-                                        ply_text_display_t *display);
-void ply_boot_splash_remove_text_display (ply_boot_splash_t   *splash,
-                                           ply_text_display_t *display);
+void ply_boot_splash_attach_to_seat (ply_boot_splash_t *splash,
+                                     ply_seat_t        *seat);
+void ply_boot_splash_detach_from_seat (ply_boot_splash_t *splash,
+                                       ply_seat_t        *seat);
 void ply_boot_splash_free (ply_boot_splash_t *splash);
 bool ply_boot_splash_show (ply_boot_splash_t *splash,
                            ply_boot_splash_mode_t mode);
diff --git a/src/libply-splash-core/ply-device-manager.c b/src/libply-splash-core/ply-device-manager.c
new file mode 100644
index 00000000..9a66988b
--- /dev/null
+++ b/src/libply-splash-core/ply-device-manager.c
@@ -0,0 +1,771 @@
+/* ply-device-manager.c - device manager
+ *
+ * Copyright (C) 2013 Red Hat, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+#include "config.h"
+#include "ply-device-manager.h"
+
+#include <assert.h>
+#include <fcntl.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+
+#include <libudev.h>
+
+#include "ply-logger.h"
+#include "ply-event-loop.h"
+#include "ply-hashtable.h"
+#include "ply-list.h"
+#include "ply-utils.h"
+
+static void create_seat_for_terminal_and_renderer_type (ply_device_manager_t *manager,
+                                                        const char           *device_path,
+                                                        ply_terminal_t       *terminal,
+                                                        ply_renderer_type_t   renderer_type);
+struct _ply_device_manager
+{
+  ply_device_manager_flags_t  flags;
+  ply_event_loop_t           *loop;
+  ply_hashtable_t            *terminals;
+  ply_terminal_t             *local_console_terminal;
+  ply_list_t                 *seats;
+  struct udev                *udev_context;
+  struct udev_monitor        *udev_monitor;
+
+  ply_seat_added_handler_t    seat_added_handler;
+  ply_seat_removed_handler_t  seat_removed_handler;
+  void                       *seat_event_handler_data;
+};
+
+static void
+detach_from_event_loop (ply_device_manager_t *manager)
+{
+  assert (manager != NULL);
+
+  manager->loop = NULL;
+}
+
+static void
+attach_to_event_loop (ply_device_manager_t *manager,
+                      ply_event_loop_t     *loop)
+{
+  assert (manager != NULL);
+  assert (loop != NULL);
+  assert (manager->loop == NULL);
+
+  manager->loop = loop;
+
+  ply_event_loop_watch_for_exit (loop, (ply_event_loop_exit_handler_t)
+                                 detach_from_event_loop,
+                                 manager);
+}
+
+static bool
+device_is_for_local_console (ply_device_manager_t *manager,
+                             struct udev_device   *device)
+{
+  const char *device_path;
+  struct udev_device *bus_device;
+  char *bus_device_path;
+  const char *boot_vga;
+  bool for_local_console;
+
+  /* Look at the associated bus device to see if this card is the
+   * card the kernel is using for its console. */
+  device_path = udev_device_get_syspath (device);
+  asprintf (&bus_device_path, "%s/device", device_path);
+  bus_device = udev_device_new_from_syspath (manager->udev_context, bus_device_path);
+
+  boot_vga = udev_device_get_sysattr_value (bus_device, "boot_vga");
+  free (bus_device_path);
+
+  if (boot_vga != NULL && strcmp (boot_vga, "1") == 0)
+    for_local_console = true;
+  else
+    for_local_console = false;
+
+  return for_local_console;
+}
+
+static char *
+get_drm_device_node_path_from_fb_device (ply_device_manager_t *manager,
+                                         struct udev_device   *fb_device)
+{
+  struct udev_enumerate *card_matches;
+  struct udev_list_entry *card_entry;
+  const char *id_path;
+  char *device_node_path = NULL;
+
+  /* We want to see if the framebuffer is associated with a DRM-capable
+   * graphics card, if it is, we'll use the DRM device */
+  card_matches = udev_enumerate_new (manager->udev_context);
+  udev_enumerate_add_match_is_initialized(card_matches);
+  udev_enumerate_add_match_parent (card_matches, udev_device_get_parent (fb_device));
+  udev_enumerate_add_match_subsystem (card_matches, "drm");
+  id_path = udev_device_get_property_value (fb_device, "ID_PATH");
+  udev_enumerate_add_match_property (card_matches, "ID_PATH", id_path);
+
+  udev_enumerate_scan_devices (card_matches);
+
+  /* there should only ever be at most one match so we don't iterate through
+   * the list, but just look at the first entry */
+  card_entry = udev_enumerate_get_list_entry (card_matches);
+
+  if (card_entry != NULL)
+    {
+      struct udev_device *card_device = NULL;
+      const char *card_node;
+      const char *card_path;
+
+      card_path = udev_list_entry_get_name (card_entry);
+      card_device = udev_device_new_from_syspath (manager->udev_context, card_path);
+      card_node = udev_device_get_devnode (card_device);
+      if (card_node != NULL)
+        device_node_path = strdup (card_node);
+
+      udev_device_unref (card_device);
+    }
+
+  udev_enumerate_unref (card_matches);
+  return device_node_path;
+}
+
+static void
+create_seat_for_udev_device (ply_device_manager_t *manager,
+                             struct udev_device   *device)
+{
+  bool for_local_console;
+  char *card_path;
+  ply_terminal_t *terminal = NULL;
+
+  for_local_console = device_is_for_local_console (manager, device);
+
+  if (for_local_console)
+    terminal = manager->local_console_terminal;
+
+  card_path = get_drm_device_node_path_from_fb_device (manager, device);
+
+  if (card_path != NULL)
+    {
+      create_seat_for_terminal_and_renderer_type (manager,
+                                                  card_path,
+                                                  terminal,
+                                                  PLY_RENDERER_TYPE_DRM);
+      free (card_path);
+    }
+  else
+    {
+      const char *fb_device_node_path;
+
+      fb_device_node_path = udev_device_get_devnode (device);
+      if (fb_device_node_path != NULL)
+        create_seat_for_terminal_and_renderer_type (manager,
+                                                    fb_device_node_path,
+                                                    terminal,
+                                                    PLY_RENDERER_TYPE_FRAME_BUFFER);
+    }
+}
+
+static void
+free_seat_from_device_path (ply_device_manager_t *manager,
+                            const char           *device_path)
+{
+  ply_list_node_t *node;
+
+  node = ply_list_get_first_node (manager->seats);
+  while (node != NULL)
+    {
+      ply_seat_t *seat;
+      ply_renderer_t *renderer;
+      ply_list_node_t *next_node;
+      const char *renderer_device_path;
+
+      seat = ply_list_node_get_data (node);
+      next_node = ply_list_get_next_node (manager->seats, node);
+      renderer = ply_seat_get_renderer (seat);
+
+      if (renderer != NULL)
+        {
+          renderer_device_path = ply_renderer_get_device_name (renderer);
+
+          if (renderer_device_path != NULL)
+            {
+              if (strcmp (device_path, renderer_device_path) == 0)
+                {
+                  ply_trace ("removing seat associated with %s", device_path);
+
+                  if (manager->seat_removed_handler != NULL)
+                    manager->seat_removed_handler (manager->seat_event_handler_data, seat);
+
+                  ply_seat_free (seat);
+                  ply_list_remove_node (manager->seats, node);
+                  break;
+                }
+            }
+        }
+
+      node = next_node;
+    }
+}
+
+static void
+free_seat_for_udev_device (ply_device_manager_t *manager,
+                           struct udev_device   *device)
+{
+  char *card_path;
+
+ card_path = get_drm_device_node_path_from_fb_device (manager, device);
+
+  if (card_path != NULL)
+    {
+      free_seat_from_device_path (manager, card_path);
+      free (card_path);
+    }
+  else
+    {
+      const char *fb_device_node_path;
+
+      fb_device_node_path = udev_device_get_devnode (device);
+
+      if (fb_device_node_path != NULL)
+        free_seat_from_device_path (manager, fb_device_node_path);
+    }
+}
+
+static void
+scan_graphics_devices (ply_device_manager_t *manager)
+{
+  struct udev_enumerate *fb_matches;
+  struct udev_list_entry *fb_entry;
+
+  ply_trace ("scanning for graphics devices");
+  /* graphics subsystem is for /dev/fb devices.  kms drivers provide /dev/fb for backward
+   * compatibility, and do so at the end of their initialization, so we can be confident
+   * that when this subsystem is available the drm device is fully initialized */
+  fb_matches = udev_enumerate_new (manager->udev_context);
+  udev_enumerate_add_match_is_initialized(fb_matches);
+  udev_enumerate_add_match_subsystem (fb_matches, "graphics");
+
+  /* We only care about devices assigned to a (any) seat. Floating
+   * devices should be ignored.  As a side-effect, this conveniently
+   * filters out the fbcon device which we don't care about.
+   */
+  udev_enumerate_add_match_tag (fb_matches, "seat");
+  udev_enumerate_scan_devices (fb_matches);
+
+  udev_list_entry_foreach (fb_entry, udev_enumerate_get_list_entry (fb_matches))
+    {
+      struct udev_device *fb_device = NULL;
+      const char *fb_node;
+      const char *fb_path;
+
+      fb_path = udev_list_entry_get_name (fb_entry);
+      fb_device = udev_device_new_from_syspath (manager->udev_context, fb_path);
+      fb_node = udev_device_get_devnode (fb_device);
+      if (fb_node != NULL)
+        create_seat_for_udev_device (manager, fb_device);
+
+      udev_device_unref (fb_device);
+    }
+
+  udev_enumerate_unref (fb_matches);
+}
+
+static void
+on_udev_graphics_event (ply_device_manager_t *manager)
+{
+  struct udev_device *device;
+  const char *action;
+
+  device = udev_monitor_receive_device (manager->udev_monitor);
+  if (device == NULL)
+    return;
+
+  action = udev_device_get_action (device);
+
+  if (action == NULL)
+    return;
+
+  if (strcmp (action, "add") == 0)
+    create_seat_for_udev_device (manager, device);
+  else if (strcmp (action, "remove") == 0)
+    free_seat_for_udev_device (manager, device);
+
+  udev_device_unref (device);
+}
+
+static void
+watch_for_udev_events (ply_device_manager_t *manager)
+{
+  int fd;
+  assert (manager != NULL);
+  assert (manager->udev_monitor == NULL);
+
+  ply_trace ("watching for udev graphics device add and remove events");
+  manager->udev_monitor = udev_monitor_new_from_netlink (manager->udev_context, "udev");
+
+  /* The filter matching here mimics the matching done in scan_graphics_devices.
+   * See the comments in that function, for an explanation of what we're doing.
+   */
+  udev_monitor_filter_add_match_subsystem_devtype (manager->udev_monitor, "graphics", NULL);
+  udev_monitor_filter_add_match_tag (manager->udev_monitor, "seat");
+  udev_monitor_enable_receiving (manager->udev_monitor);
+
+  fd = udev_monitor_get_fd (manager->udev_monitor);
+  ply_event_loop_watch_fd (manager->loop,
+                           fd,
+                           PLY_EVENT_LOOP_FD_STATUS_HAS_DATA,
+                           (ply_event_handler_t)
+                           on_udev_graphics_event,
+                           NULL,
+                           manager);
+
+}
+
+static void
+free_seats (ply_device_manager_t *manager)
+{
+  ply_list_node_t *node;
+
+  ply_trace ("removing seats");
+  node = ply_list_get_first_node (manager->seats);
+  while (node != NULL)
+    {
+      ply_seat_t *seat;
+      ply_list_node_t *next_node;
+
+      seat = ply_list_node_get_data (node);
+      next_node = ply_list_get_next_node (manager->seats, node);
+
+      if (manager->seat_removed_handler != NULL)
+        manager->seat_removed_handler (manager->seat_event_handler_data, seat);
+
+      ply_seat_free (seat);
+      ply_list_remove_node (manager->seats, node);
+
+      node = next_node;
+    }
+}
+
+static void
+free_terminal (char                 *device,
+               ply_terminal_t       *terminal,
+               ply_device_manager_t *manager)
+{
+  ply_hashtable_remove (manager->terminals, device);
+
+  ply_terminal_close (terminal);
+  ply_terminal_free (terminal);
+}
+
+static void
+free_terminals (ply_device_manager_t *manager)
+{
+  ply_hashtable_foreach (manager->terminals,
+                         (ply_hashtable_foreach_func_t *)
+                         free_terminal,
+                         manager);
+}
+
+static ply_terminal_t *
+get_terminal (ply_device_manager_t *manager,
+              const char           *device_name)
+{
+  char *full_name = NULL;
+  ply_terminal_t *terminal;
+
+  if (strncmp (device_name, "/dev/", strlen ("/dev/")) == 0)
+    full_name = strdup (device_name);
+  else
+    asprintf (&full_name, "/dev/%s", device_name);
+
+  if (strcmp (full_name, "/dev/tty0") == 0 ||
+      strcmp (full_name, "/dev/tty") == 0)
+    {
+      terminal = manager->local_console_terminal;
+      goto done;
+    }
+
+  terminal = ply_hashtable_lookup (manager->terminals, full_name);
+
+  if (terminal == NULL)
+    {
+      terminal = ply_terminal_new (full_name);
+
+      ply_hashtable_insert (manager->terminals,
+                            (void *) ply_terminal_get_name (terminal),
+                            terminal);
+    }
+
+done:
+  free (full_name);
+  return terminal;
+}
+
+ply_device_manager_t *
+ply_device_manager_new (const char                 *default_tty,
+                        ply_device_manager_flags_t  flags)
+{
+  ply_device_manager_t *manager;
+
+  manager = calloc (1, sizeof (ply_device_manager_t));
+  manager->loop = NULL;
+  manager->terminals = ply_hashtable_new (ply_hashtable_string_hash, ply_hashtable_string_compare);
+  manager->local_console_terminal = ply_terminal_new (default_tty);
+  ply_hashtable_insert (manager->terminals,
+                        (void *) ply_terminal_get_name (manager->local_console_terminal),
+                        manager->local_console_terminal);
+  manager->seats = ply_list_new ();
+  manager->flags = flags;
+
+  if (!(flags & PLY_DEVICE_MANAGER_FLAGS_IGNORE_UDEV))
+    manager->udev_context = udev_new ();
+
+  attach_to_event_loop (manager, ply_event_loop_get_default ());
+
+  return manager;
+}
+
+void
+ply_device_manager_free (ply_device_manager_t *manager)
+{
+  ply_trace ("freeing device manager");
+
+  if (manager == NULL)
+    return;
+
+  free_seats (manager);
+  ply_list_free (manager->seats);
+
+  free_terminals (manager);
+  ply_hashtable_free (manager->terminals);
+
+  if (manager->udev_monitor != NULL)
+    udev_monitor_unref (manager->udev_monitor);
+
+  if (manager->udev_context != NULL)
+    udev_unref (manager->udev_context);
+
+  free (manager);
+}
+
+static int
+add_consoles_from_file (ply_device_manager_t *manager,
+                        const char           *path)
+{
+  int fd;
+  char contents[512] = "";
+  ssize_t contents_length;
+  int num_consoles;
+  const char *remaining_file_contents;
+
+  ply_trace ("opening %s", path);
+  fd = open (path, O_RDONLY);
+
+  if (fd < 0)
+    {
+      ply_trace ("couldn't open it: %m");
+      return 0;
+    }
+
+  ply_trace ("reading file");
+  contents_length = read (fd, contents, sizeof (contents) - 1);
+
+  if (contents_length <= 0)
+    {
+      ply_trace ("couldn't read it: %m");
+      close (fd);
+      return 0;
+    }
+  close (fd);
+
+  remaining_file_contents = contents;
+  num_consoles = 0;
+
+  while (remaining_file_contents < contents + contents_length)
+    {
+      char *console;
+      size_t console_length;
+      const char *console_device;
+      ply_terminal_t *terminal;
+
+      /* Advance past any leading whitespace */
+      remaining_file_contents += strspn (remaining_file_contents, " \n\t\v");
+
+      if (*remaining_file_contents == '\0')
+        {
+          /* There's nothing left after the whitespace, we're done */
+          break;
+        }
+
+      /* Find trailing whitespace and NUL terminate.  If strcspn
+       * doesn't find whitespace, it gives us the length of the string
+       * until the next NUL byte, which we'll just overwrite with
+       * another NUL byte anyway. */
+      console_length = strcspn (remaining_file_contents, " \n\t\v");
+      console = strndup (remaining_file_contents, console_length);
+
+      terminal = get_terminal (manager, console);
+      console_device = ply_terminal_get_name (terminal);
+
+      free (console);
+
+      ply_trace ("console %s found!", console_device);
+      num_consoles++;
+
+      /* Move past the parsed console string, and the whitespace we
+       * may have found above.  If we found a NUL above and not whitespace,
+       * then we're going to jump past the end of the buffer and the loop
+       * will terminate
+       */
+      remaining_file_contents += console_length + 1;
+    }
+
+  return num_consoles;
+}
+
+static void
+create_seat_for_terminal_and_renderer_type (ply_device_manager_t *manager,
+                                            const char           *device_path,
+                                            ply_terminal_t       *terminal,
+                                            ply_renderer_type_t   renderer_type)
+{
+  ply_seat_t *seat;
+
+  ply_trace ("creating seat for %s (renderer type: %u) (terminal: %s)",
+             device_path? : "", renderer_type, terminal? ply_terminal_get_name (terminal): "none");
+  seat = ply_seat_new (terminal);
+
+  if (!ply_seat_open (seat, renderer_type, device_path))
+    {
+      ply_trace ("could not create seat");
+      ply_seat_free (seat);
+      return;
+    }
+
+  ply_list_append_data (manager->seats, seat);
+
+  if (manager->seat_added_handler != NULL)
+    manager->seat_added_handler (manager->seat_event_handler_data, seat);
+}
+
+static void
+create_seat_for_terminal (const char           *device_path,
+                          ply_terminal_t       *terminal,
+                          ply_device_manager_t *manager)
+{
+  create_seat_for_terminal_and_renderer_type (manager,
+                                              device_path,
+                                              terminal,
+                                              PLY_RENDERER_TYPE_NONE);
+}
+static bool
+create_seats_from_terminals (ply_device_manager_t *manager)
+{
+  int num_consoles;
+  bool seats_created;
+
+  ply_trace ("checking for consoles");
+
+  if (manager->flags & PLY_DEVICE_MANAGER_FLAGS_IGNORE_SERIAL_CONSOLES)
+    {
+      num_consoles = 0;
+      ply_trace ("ignoring all consoles but default console because explicitly told to.");
+    }
+  else
+    {
+      num_consoles = add_consoles_from_file (manager, "/sys/class/tty/console/active");
+
+      if (num_consoles == 0)
+        ply_trace ("ignoring all consoles but default console because /sys/class/tty/console/active could not be read");
+    }
+
+  if (num_consoles > 1)
+    {
+      ply_trace ("serial consoles detected, managing them with details forced");
+      ply_hashtable_foreach (manager->terminals,
+                             (ply_hashtable_foreach_func_t *)
+                             create_seat_for_terminal,
+                             manager);
+      seats_created = true;
+    }
+  else if (num_consoles <= 1 && (manager->flags & PLY_DEVICE_MANAGER_FLAGS_IGNORE_UDEV))
+    {
+      ply_trace ("udev disabled, managing seat right away");
+      create_seat_for_terminal_and_renderer_type (manager,
+                                                  ply_terminal_get_name (manager->local_console_terminal),
+                                                  manager->local_console_terminal,
+                                                  PLY_RENDERER_TYPE_AUTO);
+      seats_created = true;
+    }
+  else
+    {
+      ply_trace ("will manage seat when ready");
+      seats_created = false;
+    }
+
+  return seats_created;
+}
+
+void
+ply_device_manager_watch_seats (ply_device_manager_t       *manager,
+                                ply_seat_added_handler_t    seat_added_handler,
+                                ply_seat_removed_handler_t  seat_removed_handler,
+                                void                       *data)
+{
+  bool seats_created;
+
+  manager->seat_added_handler = seat_added_handler;
+  manager->seat_removed_handler = seat_removed_handler;
+  manager->seat_event_handler_data = data;
+
+  /* Try to create seats for each terminal device right away, if possible
+   */
+  seats_created = create_seats_from_terminals (manager);
+
+  /* In most cases, though, we need to create devices based on udev device topology
+   */
+  if (!seats_created)
+    {
+      watch_for_udev_events (manager);
+      scan_graphics_devices (manager);
+    }
+}
+
+bool
+ply_device_manager_has_open_seats (ply_device_manager_t *manager)
+{
+  ply_list_node_t *node;
+
+  node = ply_list_get_first_node (manager->seats);
+  while (node != NULL)
+    {
+      ply_seat_t *seat;
+      ply_list_node_t *next_node;
+
+      seat = ply_list_node_get_data (node);
+      next_node = ply_list_get_next_node (manager->seats, node);
+
+      if (ply_seat_is_open (seat))
+        return true;
+
+      node = next_node;
+    }
+
+  return false;
+}
+
+ply_list_t *
+ply_device_manager_get_seats (ply_device_manager_t *manager)
+{
+  return manager->seats;
+}
+
+ply_terminal_t *
+ply_device_manager_get_default_terminal (ply_device_manager_t *manager)
+{
+  return manager->local_console_terminal;
+}
+
+void
+ply_device_manager_activate_renderers (ply_device_manager_t *manager)
+{
+  ply_list_node_t *node;
+
+  ply_trace ("activating renderers");
+  node = ply_list_get_first_node (manager->seats);
+  while (node != NULL)
+    {
+      ply_seat_t *seat;
+      ply_list_node_t *next_node;
+
+      seat = ply_list_node_get_data (node);
+      next_node = ply_list_get_next_node (manager->seats, node);
+
+      ply_seat_activate_renderer (seat);
+
+      node = next_node;
+    }
+}
+
+void
+ply_device_manager_deactivate_renderers (ply_device_manager_t *manager)
+{
+  ply_list_node_t *node;
+
+  ply_trace ("deactivating renderers");
+  node = ply_list_get_first_node (manager->seats);
+  while (node != NULL)
+    {
+      ply_seat_t *seat;
+      ply_list_node_t *next_node;
+
+      seat = ply_list_node_get_data (node);
+      next_node = ply_list_get_next_node (manager->seats, node);
+
+      ply_seat_deactivate_renderer (seat);
+
+      node = next_node;
+    }
+}
+
+void
+ply_device_manager_activate_keyboards (ply_device_manager_t *manager)
+{
+  ply_list_node_t *node;
+
+  ply_trace ("activating keyboards");
+  node = ply_list_get_first_node (manager->seats);
+  while (node != NULL)
+    {
+      ply_seat_t *seat;
+      ply_list_node_t *next_node;
+
+      seat = ply_list_node_get_data (node);
+      next_node = ply_list_get_next_node (manager->seats, node);
+
+      ply_seat_activate_keyboard (seat);
+
+      node = next_node;
+    }
+}
+
+void
+ply_device_manager_deactivate_keyboards (ply_device_manager_t *manager)
+{
+  ply_list_node_t *node;
+
+  ply_trace ("deactivating keyboards");
+  node = ply_list_get_first_node (manager->seats);
+  while (node != NULL)
+    {
+      ply_seat_t *seat;
+      ply_list_node_t *next_node;
+
+      seat = ply_list_node_get_data (node);
+      next_node = ply_list_get_next_node (manager->seats, node);
+
+      ply_seat_deactivate_keyboard (seat);
+
+      node = next_node;
+    }
+}
diff --git a/src/libply-splash-core/ply-device-manager.h b/src/libply-splash-core/ply-device-manager.h
new file mode 100644
index 00000000..d9c58e87
--- /dev/null
+++ b/src/libply-splash-core/ply-device-manager.h
@@ -0,0 +1,56 @@
+/* ply-device-manager.h - udev monitor
+ *
+ * Copyright (C) 2013 Red Hat, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+#ifndef PLY_DEVICE_MANAGER_H
+#define PLY_DEVICE_MANAGER_H
+
+#include <stdbool.h>
+#include "ply-seat.h"
+
+typedef enum
+{
+  PLY_DEVICE_MANAGER_FLAGS_NONE                   = 0,
+  PLY_DEVICE_MANAGER_FLAGS_IGNORE_SERIAL_CONSOLES = 1 << 0,
+  PLY_DEVICE_MANAGER_FLAGS_IGNORE_UDEV            = 1 << 1
+} ply_device_manager_flags_t;
+
+typedef struct _ply_device_manager ply_device_manager_t;
+typedef void (* ply_seat_added_handler_t) (void *, ply_seat_t *);
+typedef void (* ply_seat_removed_handler_t) (void *, ply_seat_t *);
+
+#ifndef PLY_HIDE_FUNCTION_DECLARATIONS
+ply_device_manager_t *ply_device_manager_new (const char                 *default_tty,
+                                              ply_device_manager_flags_t  flags);
+void ply_device_manager_watch_seats (ply_device_manager_t *manager,
+                                     ply_seat_added_handler_t seat_added_handler,
+                                     ply_seat_removed_handler_t seat_removed_handler,
+                                     void *data);
+bool ply_device_manager_has_open_seats (ply_device_manager_t *manager);
+ply_list_t *ply_device_manager_get_seats (ply_device_manager_t *manager);
+void ply_device_manager_free (ply_device_manager_t *manager);
+void ply_device_manager_activate_keyboards (ply_device_manager_t *manager);
+void ply_device_manager_deactivate_keyboards (ply_device_manager_t *manager);
+void ply_device_manager_activate_renderers (ply_device_manager_t *manager);
+void ply_device_manager_deactivate_renderers (ply_device_manager_t *manager);
+ply_terminal_t *ply_device_manager_get_default_terminal (ply_device_manager_t *manager);
+
+#endif
+
+#endif
+/* vim: set ts=4 sw=4 expandtab autoindent cindent cino={.5s,(0: */
diff --git a/src/libply-splash-core/ply-renderer.c b/src/libply-splash-core/ply-renderer.c
index 3559e013..04a99cef 100644
--- a/src/libply-splash-core/ply-renderer.c
+++ b/src/libply-splash-core/ply-renderer.c
@@ -49,7 +49,7 @@ struct _ply_renderer
   const ply_renderer_plugin_interface_t *plugin_interface;
   ply_renderer_backend_t *backend;
 
-  char *plugin_path;
+  ply_renderer_type_t type;
   char *device_name;
   ply_terminal_t *terminal;
 
@@ -63,16 +63,15 @@ typedef const ply_renderer_plugin_interface_t *
 static void ply_renderer_unload_plugin (ply_renderer_t *renderer);
 
 ply_renderer_t *
-ply_renderer_new (const char     *plugin_path,
-                  const char     *device_name,
-                  ply_terminal_t *terminal)
+ply_renderer_new (ply_renderer_type_t  renderer_type,
+                  const char          *device_name,
+                  ply_terminal_t      *terminal)
 {
   ply_renderer_t *renderer;
 
   renderer = calloc (1, sizeof (struct _ply_renderer));
 
-  if (plugin_path != NULL)
-    renderer->plugin_path = strdup (plugin_path);
+  renderer->type = renderer_type;
 
   if (device_name != NULL)
     renderer->device_name = strdup (device_name);
@@ -95,10 +94,15 @@ ply_renderer_free (ply_renderer_t *renderer)
     }
 
   free (renderer->device_name);
-  free (renderer->plugin_path);
   free (renderer);
 }
 
+const char *
+ply_renderer_get_device_name (ply_renderer_t *renderer)
+{
+  return renderer->device_name;
+}
+
 static bool
 ply_renderer_load_plugin (ply_renderer_t *renderer,
                           const char     *module_path)
@@ -258,29 +262,28 @@ ply_renderer_open (ply_renderer_t *renderer)
 {
   int i;
 
-  /* FIXME: at some point we may want to make this
-   * part more dynamic (so you don't have to edit this
-   * list to add a new renderer)
-   */
-  const char *known_plugins[] =
+  struct
     {
-      PLYMOUTH_PLUGIN_PATH "renderers/x11.so",
-      PLYMOUTH_PLUGIN_PATH "renderers/drm.so",
-      PLYMOUTH_PLUGIN_PATH "renderers/frame-buffer.so",
-      NULL
+      ply_renderer_type_t  type;
+      const char          *path;
+    } known_plugins[] =
+    {
+      { PLY_RENDERER_TYPE_X11, PLYMOUTH_PLUGIN_PATH "renderers/x11.so" },
+      { PLY_RENDERER_TYPE_DRM, PLYMOUTH_PLUGIN_PATH "renderers/drm.so" },
+      { PLY_RENDERER_TYPE_FRAME_BUFFER, PLYMOUTH_PLUGIN_PATH "renderers/frame-buffer.so" },
+      { PLY_RENDERER_TYPE_NONE, NULL }
     };
 
-  if (renderer->plugin_path != NULL)
+  for (i = 0; known_plugins[i].type != PLY_RENDERER_TYPE_NONE; i++)
     {
-      return ply_renderer_open_plugin (renderer, renderer->plugin_path);
+      if (renderer->type == known_plugins[i].type ||
+          renderer->type == PLY_RENDERER_TYPE_AUTO)
+        {
+          if (ply_renderer_open_plugin (renderer, known_plugins[i].path))
+            return true;
+        }
     }
 
-  for (i = 0; known_plugins[i] != NULL; i++)
-    {
-      if (ply_renderer_open_plugin (renderer, known_plugins[i]))
-        return true;
-  }
-
   ply_trace ("could not find suitable rendering plugin");
   return false;
 }
diff --git a/src/libply-splash-core/ply-renderer.h b/src/libply-splash-core/ply-renderer.h
index 4b3bd1a3..3d483413 100644
--- a/src/libply-splash-core/ply-renderer.h
+++ b/src/libply-splash-core/ply-renderer.h
@@ -35,12 +35,21 @@ typedef struct _ply_renderer ply_renderer_t;
 typedef struct _ply_renderer_head ply_renderer_head_t;
 typedef struct _ply_renderer_input_source ply_renderer_input_source_t;
 
+typedef enum
+{
+  PLY_RENDERER_TYPE_NONE = -1,
+  PLY_RENDERER_TYPE_AUTO,
+  PLY_RENDERER_TYPE_DRM,
+  PLY_RENDERER_TYPE_FRAME_BUFFER,
+  PLY_RENDERER_TYPE_X11
+} ply_renderer_type_t;
+
 typedef void (* ply_renderer_input_source_handler_t) (void                        *user_data,
                                                       ply_buffer_t                *key_buffer,
                                                       ply_renderer_input_source_t *input_source);
 
 #ifndef PLY_HIDE_FUNCTION_DECLARATIONS
-ply_renderer_t *ply_renderer_new (const char     *plugin_path,
+ply_renderer_t *ply_renderer_new (ply_renderer_type_t renderer_type,
                                   const char     *device_name,
                                   ply_terminal_t *terminal);
 void ply_renderer_free (ply_renderer_t *renderer);
@@ -48,6 +57,7 @@ bool ply_renderer_open (ply_renderer_t *renderer);
 void ply_renderer_close (ply_renderer_t *renderer);
 void ply_renderer_activate (ply_renderer_t *renderer);
 void ply_renderer_deactivate (ply_renderer_t *renderer);
+const char *ply_renderer_get_device_name (ply_renderer_t *renderer);
 ply_list_t *ply_renderer_get_heads (ply_renderer_t *renderer);
 ply_pixel_buffer_t *ply_renderer_get_buffer_for_head (ply_renderer_t      *renderer,
                                                       ply_renderer_head_t *head);
diff --git a/src/libply-splash-core/ply-seat.c b/src/libply-splash-core/ply-seat.c
new file mode 100644
index 00000000..d1493a71
--- /dev/null
+++ b/src/libply-splash-core/ply-seat.c
@@ -0,0 +1,365 @@
+/* ply-seat.c - APIs for encapsulating a keyboard and one or more displays
+ *
+ * Copyright (C) 2013 Red Hat, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ *
+ * Written by: Ray Strode <rstrode@redhat.com>
+ */
+#include "config.h"
+#include "ply-seat.h"
+
+#include <assert.h>
+#include <errno.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include "ply-boot-splash.h"
+#include "ply-event-loop.h"
+#include "ply-keyboard.h"
+#include "ply-pixel-display.h"
+#include "ply-text-display.h"
+#include "ply-list.h"
+#include "ply-logger.h"
+#include "ply-utils.h"
+
+struct _ply_seat
+{
+  ply_event_loop_t *loop;
+
+  ply_boot_splash_t *splash;
+  ply_terminal_t *terminal;
+  ply_renderer_t *renderer;
+  ply_keyboard_t *keyboard;
+  ply_list_t *text_displays;
+  ply_list_t *pixel_displays;
+
+  uint32_t renderer_active : 1;
+  uint32_t keyboard_active : 1;
+};
+
+ply_seat_t *
+ply_seat_new (ply_terminal_t *terminal)
+{
+  ply_seat_t *seat;
+
+  seat = calloc (1, sizeof (ply_seat_t));
+
+  seat->loop = ply_event_loop_get_default ();
+  seat->terminal = terminal;
+  seat->text_displays = ply_list_new ();
+  seat->pixel_displays = ply_list_new ();
+
+  return seat;
+}
+
+static void
+add_pixel_displays (ply_seat_t *seat)
+{
+  ply_list_t *heads;
+  ply_list_node_t *node;
+
+  heads = ply_renderer_get_heads (seat->renderer);
+
+  ply_trace ("Adding displays for %d heads",
+             ply_list_get_length (heads));
+
+  node = ply_list_get_first_node (heads);
+  while (node != NULL)
+    {
+      ply_list_node_t *next_node;
+      ply_renderer_head_t *head;
+      ply_pixel_display_t *display;
+
+      head = ply_list_node_get_data (node);
+      next_node = ply_list_get_next_node (heads, node);
+
+      display = ply_pixel_display_new (seat->renderer, head);
+
+      ply_list_append_data (seat->pixel_displays, display);
+
+      node = next_node;
+    }
+}
+
+static void
+add_text_displays (ply_seat_t *seat)
+{
+  ply_text_display_t *display;
+
+  display = ply_text_display_new (seat->terminal);
+  ply_list_append_data (seat->text_displays, display);
+}
+
+bool
+ply_seat_open (ply_seat_t          *seat,
+               ply_renderer_type_t  renderer_type,
+               const char          *device)
+{
+  if (renderer_type != PLY_RENDERER_TYPE_NONE)
+    {
+      ply_renderer_t *renderer;
+
+      renderer = ply_renderer_new (renderer_type, device, seat->terminal);
+
+      if (!ply_renderer_open (renderer) && renderer_type != PLY_RENDERER_TYPE_AUTO)
+        {
+          ply_trace ("could not open renderer for %s", device);
+          ply_renderer_free (renderer);
+          return false;
+        }
+
+      seat->renderer = renderer;
+      seat->renderer_active = true;
+    }
+
+  if (seat->renderer != NULL)
+    {
+      seat->keyboard = ply_keyboard_new_for_renderer (seat->renderer);
+      add_pixel_displays (seat);
+
+    }
+  else
+    {
+      seat->keyboard = ply_keyboard_new_for_terminal (seat->terminal);
+      add_text_displays (seat);
+    }
+  seat->keyboard_active = true;
+
+  return true;
+}
+
+bool
+ply_seat_is_open (ply_seat_t *seat)
+{
+  return ply_list_get_length (seat->pixel_displays) > 0 ||
+         ply_list_get_length (seat->text_displays) > 0;
+}
+
+void
+ply_seat_deactivate_keyboard (ply_seat_t *seat)
+{
+  if (!seat->keyboard_active)
+    return;
+
+  seat->keyboard_active = false;
+
+  if (seat->keyboard == NULL)
+    return;
+
+  ply_trace ("deactivating keybord");
+  ply_keyboard_stop_watching_for_input (seat->keyboard);
+}
+
+void
+ply_seat_deactivate_renderer (ply_seat_t *seat)
+{
+  if (!seat->renderer_active)
+    return;
+
+  seat->renderer_active = false;
+
+  if (seat->renderer == NULL)
+    return;
+
+  ply_trace ("deactivating renderer");
+  ply_renderer_deactivate (seat->renderer);
+}
+
+void
+ply_seat_activate_keyboard (ply_seat_t *seat)
+{
+  if (seat->keyboard_active)
+    return;
+
+  if (seat->keyboard == NULL)
+    return;
+
+  ply_trace ("activating keyboard");
+  ply_keyboard_watch_for_input (seat->keyboard);
+
+  seat->keyboard_active = true;
+}
+
+void
+ply_seat_activate_renderer (ply_seat_t *seat)
+{
+  if (seat->renderer_active)
+    return;
+
+  if (seat->renderer == NULL)
+    return;
+
+  ply_trace ("activating renderer");
+  ply_renderer_activate (seat->renderer);
+
+  seat->renderer_active = true;
+}
+
+void
+ply_seat_refresh_displays (ply_seat_t *seat)
+{
+  ply_list_node_t *node;
+
+  node = ply_list_get_first_node (seat->pixel_displays);
+  while (node != NULL)
+    {
+      ply_pixel_display_t *display;
+      ply_list_node_t *next_node;
+      unsigned long width, height;
+
+      display = ply_list_node_get_data (node);
+      next_node = ply_list_get_next_node (seat->pixel_displays, node);
+
+      width = ply_pixel_display_get_width (display);
+      height = ply_pixel_display_get_height (display);
+
+      ply_pixel_display_draw_area (display, 0, 0, width, height);
+      node = next_node;
+    }
+
+  node = ply_list_get_first_node (seat->text_displays);
+  while (node != NULL)
+    {
+      ply_text_display_t *display;
+      ply_list_node_t *next_node;
+      int number_of_columns, number_of_rows;
+
+      display = ply_list_node_get_data (node);
+      next_node = ply_list_get_next_node (seat->text_displays, node);
+
+      number_of_columns = ply_text_display_get_number_of_columns (display);
+      number_of_rows = ply_text_display_get_number_of_rows (display);
+
+      ply_text_display_draw_area (display, 0, 0,
+                                  number_of_columns,
+                                  number_of_rows);
+      node = next_node;
+    }
+}
+
+void
+ply_seat_close (ply_seat_t *seat)
+{
+  if (seat->renderer == NULL)
+    return;
+
+  ply_trace ("destroying renderer");
+  ply_renderer_close (seat->renderer);
+  ply_renderer_free (seat->renderer);
+  seat->renderer = NULL;
+}
+
+void
+ply_seat_set_splash (ply_seat_t        *seat,
+                     ply_boot_splash_t *splash)
+{
+  if (seat->splash == splash)
+    return;
+
+  if (seat->splash != NULL)
+    ply_boot_splash_detach_from_seat (splash, seat);
+
+  if (splash != NULL)
+    ply_boot_splash_attach_to_seat (splash, seat);
+
+  seat->splash = splash;
+}
+
+static void
+free_pixel_displays (ply_seat_t *seat)
+{
+  ply_list_node_t *node;
+
+  ply_trace ("freeing %d pixel displays", ply_list_get_length (seat->pixel_displays));
+  node = ply_list_get_first_node (seat->pixel_displays);
+  while (node != NULL)
+    {
+      ply_list_node_t *next_node;
+      ply_pixel_display_t *display;
+
+      next_node = ply_list_get_next_node (seat->pixel_displays, node);
+      display = ply_list_node_get_data (node);
+      ply_pixel_display_free (display);
+
+      ply_list_remove_node (seat->pixel_displays, node);
+
+      node = next_node;
+    }
+}
+
+static void
+free_text_displays (ply_seat_t *seat)
+{
+  ply_list_node_t *node;
+
+  ply_trace ("freeing %d text displays", ply_list_get_length (seat->text_displays));
+  node = ply_list_get_first_node (seat->text_displays);
+  while (node != NULL)
+    {
+      ply_list_node_t *next_node;
+      ply_text_display_t *display;
+
+      next_node = ply_list_get_next_node (seat->text_displays, node);
+      display = ply_list_node_get_data (node);
+      ply_text_display_free (display);
+
+      ply_list_remove_node (seat->text_displays, node);
+
+      node = next_node;
+    }
+}
+
+void
+ply_seat_free (ply_seat_t *seat)
+{
+  if (seat == NULL)
+    return;
+
+  free_pixel_displays (seat);
+  free_text_displays (seat);
+  ply_keyboard_free (seat->keyboard);
+
+  free (seat);
+}
+
+ply_list_t *
+ply_seat_get_pixel_displays (ply_seat_t *seat)
+{
+  return seat->pixel_displays;
+}
+
+ply_list_t *
+ply_seat_get_text_displays (ply_seat_t *seat)
+{
+  return seat->text_displays;
+}
+
+ply_keyboard_t *
+ply_seat_get_keyboard (ply_seat_t *seat)
+{
+  return seat->keyboard;
+}
+
+ply_renderer_t *
+ply_seat_get_renderer (ply_seat_t *seat)
+{
+  return seat->renderer;
+}
+
+/* vim: set ts=4 sw=4 et ai ci cino={.5s,^-2,+.5s,t0,g0,e-2,n-2,p2s,(0,=.5s,:.5s */
diff --git a/src/libply-splash-core/ply-seat.h b/src/libply-splash-core/ply-seat.h
new file mode 100644
index 00000000..d5d33978
--- /dev/null
+++ b/src/libply-splash-core/ply-seat.h
@@ -0,0 +1,66 @@
+/* ply-seat.h - APIs for encapsulating a keyboard and one or more displays
+ *
+ * Copyright (C) 2013 Red Hat, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ *
+ * Written By: Ray Strode <rstrode@redhat.com>
+ */
+#ifndef PLY_SEAT_H
+#define PLY_SEAT_H
+
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <unistd.h>
+
+#include "ply-boot-splash.h"
+#include "ply-buffer.h"
+#include "ply-event-loop.h"
+#include "ply-keyboard.h"
+#include "ply-list.h"
+#include "ply-pixel-display.h"
+#include "ply-terminal.h"
+#include "ply-text-display.h"
+
+typedef struct _ply_boot_splash ply_boot_splash_t;
+typedef struct _ply_seat ply_seat_t;
+
+#ifndef PLY_HIDE_FUNCTION_DECLARATIONS
+ply_seat_t *ply_seat_new (ply_terminal_t *terminal);
+
+void ply_seat_free (ply_seat_t *seat);
+bool ply_seat_open (ply_seat_t          *seat,
+                    ply_renderer_type_t  renderer_type,
+                    const char          *device);
+bool ply_seat_is_open (ply_seat_t *seat);
+void ply_seat_deactivate_keyboard (ply_seat_t *seat);
+void ply_seat_activate_keyboard (ply_seat_t *seat);
+void ply_seat_deactivate_renderer (ply_seat_t *seat);
+void ply_seat_activate_renderer (ply_seat_t *seat);
+void ply_seat_refresh_displays (ply_seat_t *seat);
+void ply_seat_close (ply_seat_t *seat);
+void ply_seat_set_splash (ply_seat_t        *seat,
+                          ply_boot_splash_t *splash);
+
+ply_list_t *ply_seat_get_pixel_displays (ply_seat_t *seat);
+ply_list_t *ply_seat_get_text_displays (ply_seat_t *seat);
+ply_keyboard_t *ply_seat_get_keyboard (ply_seat_t *seat);
+ply_renderer_t *ply_seat_get_renderer (ply_seat_t *seat);
+#endif
+
+#endif /* PLY_SEAT_H */
+/* vim: set ts=4 sw=4 et ai ci cino={.5s,^-2,+.5s,t0,g0,e-2,n-2,p2s,(0,=.5s,:.5s */
diff --git a/src/libply-splash-core/ply-terminal.c b/src/libply-splash-core/ply-terminal.c
index 2e95dc8c..992dd3f3 100644
--- a/src/libply-splash-core/ply-terminal.c
+++ b/src/libply-splash-core/ply-terminal.c
@@ -876,6 +876,12 @@ ply_terminal_free (ply_terminal_t *terminal)
   free (terminal);
 }
 
+const char *
+ply_terminal_get_name (ply_terminal_t *terminal)
+{
+  return terminal->name;
+}
+
 int
 ply_terminal_get_vt_number (ply_terminal_t *terminal)
 {
diff --git a/src/libply-splash-core/ply-terminal.h b/src/libply-splash-core/ply-terminal.h
index 8b4b0177..48b4f77f 100644
--- a/src/libply-splash-core/ply-terminal.h
+++ b/src/libply-splash-core/ply-terminal.h
@@ -91,6 +91,7 @@ void ply_terminal_set_mode (ply_terminal_t     *terminal,
 void ply_terminal_ignore_mode_changes (ply_terminal_t *terminal,
                                        bool            should_ignore);
 
+const char *ply_terminal_get_name (ply_terminal_t *terminal);
 int ply_terminal_get_vt_number (ply_terminal_t *terminal);
 bool ply_terminal_activate_vt (ply_terminal_t *terminal);
 bool ply_terminal_deactivate_vt (ply_terminal_t *terminal);
diff --git a/src/libply/Makefile.am b/src/libply/Makefile.am
index 302e47d1..41b3a463 100644
--- a/src/libply/Makefile.am
+++ b/src/libply/Makefile.am
@@ -1,4 +1,3 @@
-SUBDIRS = tests
 INCLUDES = -I$(top_srcdir)                                                    \
            -I$(srcdir)                                                        \
            -DPLYMOUTH_TIME_DIRECTORY=\"$(localstatedir)/lib/plymouth/\"       
diff --git a/src/libply/ply-array.c b/src/libply/ply-array.c
index 41134b86..999c86e5 100644
--- a/src/libply/ply-array.c
+++ b/src/libply/ply-array.c
@@ -171,34 +171,4 @@ ply_array_steal_uint32_elements (ply_array_t *array)
   return data;
 }
 
-#ifdef PLY_ARRAY_ENABLE_TEST
-#include <stdio.h>
-
-int
-main (int    argc,
-      char **argv)
-{
-  ply_array_t *array;
-  int i;
-  char **data;
-
-  array = ply_array_new (PLY_ARRAY_ELEMENT_TYPE_POINTER);
-
-  ply_array_add_pointer_element (array, "foo");
-  ply_array_add_pointer_element (array, "bar");
-  ply_array_add_pointer_element (array, "baz");
-  ply_array_add_pointer_element (array, "qux");
-
-  data = (char **) ply_array_get_pointer_elements (array);
-  for (i = 0; data[i] != NULL; i++)
-    {
-      printf ("element '%d' has data '%s'\n", i, data[i]);
-      i++;
-    }
-
-  ply_array_free (array);
-  return 0;
-}
-
-#endif
 /* vim: set ts=4 sw=4 expandtab autoindent cindent cino={.5s,(0: */
diff --git a/src/libply/ply-bitarray.c b/src/libply/ply-bitarray.c
index 89e22169..3d0cdd0c 100644
--- a/src/libply/ply-bitarray.c
+++ b/src/libply/ply-bitarray.c
@@ -42,64 +42,4 @@ ply_bitarray_count (ply_bitarray_t *bitarray,
   return count;
 }
 
-
-
-
-#ifdef PLY_BITARRAY_ENABLE_TEST
-#include <stdio.h>
-
-int
-main (int    argc,
-      char **argv)
-{
-  ply_bitarray_t *bitarray;
-  int i, i2;
-  printf ("bitarray test start\n");
-  bitarray = ply_bitarray_new (134);
-  
-  for (i=0; i<64; i++)
-    {
-      if (ply_bitarray_lookup (bitarray, i))
-        printf ("1");
-      else
-        printf ("0");
-    }
-  printf ("\n");
-  
-  for (i=0; i<64; i++)
-    if ((6654654654654654654ll >> i) & 1)
-      ply_bitarray_set (bitarray, i);
-  
-  for (i=0; i<64; i++)
-    {
-      if (ply_bitarray_lookup (bitarray, i))
-        printf ("1");
-      else
-        printf ("0");
-    }
-  printf ("\n");
-    
-  for (i = 63; i > 0; i--)
-    {
-      if ((6654654654654654654ll >> i) & 1)
-        {
-          ply_bitarray_clear (bitarray, i);
-          for (i2 = 0; i2 < 64; i2++)
-            {
-              if (ply_bitarray_lookup (bitarray, i2))
-                printf ("1");
-              else
-                printf ("0"); 
-            }
-          printf ("\n");
-        }
-    }
-    
-  ply_bitarray_free (bitarray);
-  
-  printf ("bitarray test end\n");
-  return 0;
-}
-
-#endif
 /* vim: set ts=4 sw=4 expandtab autoindent cindent cino={.5s,(0: */
diff --git a/src/libply/ply-buffer.c b/src/libply/ply-buffer.c
index c65634f5..0d0406ff 100644
--- a/src/libply/ply-buffer.c
+++ b/src/libply/ply-buffer.c
@@ -263,22 +263,4 @@ ply_buffer_clear (ply_buffer_t *buffer)
   buffer->size = 0;
 }
 
-#ifdef PLY_BUFFER_ENABLE_TEST
-int
-main (int    argc,
-      char **argv)
-{
-  int exit_code;
-  ply_buffer_t *buffer;
-
-  exit_code = 0;
-  buffer = ply_buffer_new ();
-
-  ply_buffer_append (buffer, "yo yo yo\n");
-  ply_buffer_free (buffer);
-
-  return exit_code;
-}
-
-#endif /* PLY_BUFFER_ENABLE_TEST */
 /* vim: set ts=4 sw=4 expandtab autoindent cindent cino={.5s,(0: */
diff --git a/src/libply/ply-command-parser.c b/src/libply/ply-command-parser.c
index 6ab323bc..2768668a 100644
--- a/src/libply/ply-command-parser.c
+++ b/src/libply/ply-command-parser.c
@@ -968,100 +968,4 @@ ply_command_parser_parse_arguments (ply_command_parser_t *parser,
   return parsed_arguments;
 }
 
-#ifdef PLY_COMMAND_PARSER_ENABLE_TEST
-
-#include <stdio.h>
-
-#include "ply-command-parser.h"
-#include "ply-event-loop.h"
-#include "ply-logger.h"
-
-static void
-on_ask_for_password (ply_command_parser_t *parser,
-                     const char *command)
-{
-  char *prompt;
-  char *program;
-
-  prompt = NULL;
-  program = NULL;
-  ply_command_parser_get_command_options (parser, command, "prompt", &prompt, "command", &program, NULL);
-
-  printf ("ask for password with prompt '%s' feed result to '%s'\n", prompt, program);
-  free (prompt);
-  free (program);
-}
-
-static void
-on_show_splash (ply_command_parser_t *parser,
-                const char *command)
-{
-  char *plugin_name;
-
-  plugin_name = NULL;
-  ply_command_parser_get_command_options (parser, command, "plugin-name", &plugin_name, NULL);
-
-  printf ("show splash plugin '%s'\n", plugin_name);
-  free (plugin_name);
-}
-
-int
-main (int    argc,
-      char **argv)
-{
-  ply_event_loop_t *loop;
-  ply_command_parser_t *parser;
-  bool should_help;
-
-  loop = ply_event_loop_new ();
-  parser = ply_command_parser_new (argv[0], "Test Program");
-
-  ply_command_parser_add_options (parser,
-                                  "help", "This help message", PLY_COMMAND_OPTION_TYPE_FLAG,
-                                  NULL);
-
-  ply_command_parser_add_command (parser,
-                                  "ask-for-password",
-                                  "Ask user for password",
-                                  (ply_command_handler_t)
-                                  on_ask_for_password, parser,
-                                  "command", "command to pipe result to", PLY_COMMAND_OPTION_TYPE_STRING,
-                                  "prompt", "string to present to user", PLY_COMMAND_OPTION_TYPE_STRING,
-                                  "output-result", "print result", PLY_COMMAND_OPTION_TYPE_BOOLEAN,
-                                  NULL);
-
-  ply_command_parser_add_command (parser,
-                                  "show-splash",
-                                  "Show splash to user",
-                                  (ply_command_handler_t)
-                                  on_show_splash, parser,
-                                  "plugin-name", "name of the plugin to run", PLY_COMMAND_OPTION_TYPE_STRING,
-                                  NULL);
-
-  if (!ply_command_parser_parse_arguments (parser, loop, argv, argc))
-    {
-      ply_error ("couldn't parse arguments");
-      return 1;
-    }
-
-
-  ply_command_parser_get_options (parser, "help", &should_help, NULL);
-
-  if (should_help)
-    {
-      char *usage;
-      usage = ply_command_parser_get_help_string (parser);
-      printf ("%s\n", usage);
-      free (usage);
-      return 0;
-    }
-
-  ply_event_loop_run (loop);
-
-  ply_command_parser_free (parser);
-
-  return 0;
-}
-
-#endif
 /* vim: set ts=4 sw=4 expandtab autoindent cindent cino={.5s,(0: */
diff --git a/src/libply/ply-event-loop.c b/src/libply/ply-event-loop.c
index 4abf25fc..0c85cb93 100644
--- a/src/libply/ply-event-loop.c
+++ b/src/libply/ply-event-loop.c
@@ -1376,88 +1376,4 @@ ply_event_loop_run (ply_event_loop_t *loop)
   return loop->exit_code;
 }
 
-#ifdef PLY_EVENT_LOOP_ENABLE_TEST
-
-static ply_event_loop_t *loop;
-
-static void
-alrm_signal_handler (void)
-{
-  write (1, "times up!\n", sizeof ("times up!\n") - 1);
-  ply_event_loop_exit (loop, 0);
-}
-
-static void
-usr1_signal_handler (void)
-{
-  write (1, "got sigusr1\n", sizeof ("got sigusr1\n") - 1);
-}
-
-static void
-hangup_signal_handler (void)
-{
-  write (1, "got hangup\n", sizeof ("got hangup\n") - 1);
-}
-
-static void
-terminate_signal_handler (void)
-{
-  write (1, "got terminate\n", sizeof ("got terminate\n") - 1);
-  ply_event_loop_exit (loop, 0);
-}
-
-static void
-line_received_handler (void)
-{
-  char line[512] = { 0 };
-  printf ("Received line: ");
-  fflush (stdout);
-
-  fgets (line, sizeof (line), stdin);
-  printf ("%s", line);
-}
-
-static void
-on_timeout (ply_event_loop_t *loop)
-{
-  printf ("timeout elapsed\n");
-}
-
-int
-main (int    argc,
-      char **argv)
-{
-  int exit_code;
-
-  loop = ply_event_loop_new ();
-
-  ply_event_loop_watch_signal (loop, SIGHUP,
-                             (ply_event_handler_t) hangup_signal_handler,
-                             NULL);
-  ply_event_loop_watch_signal (loop, SIGTERM,
-                             (ply_event_handler_t)
-                             terminate_signal_handler, NULL);
-  ply_event_loop_watch_signal (loop, SIGUSR1,
-                             (ply_event_handler_t)
-                             usr1_signal_handler, NULL);
-  ply_event_loop_watch_signal (loop, SIGALRM,
-                             (ply_event_handler_t)
-                             alrm_signal_handler, NULL);
-
-  ply_event_loop_watch_for_timeout (loop, 2.0,
-                                    (ply_event_loop_timeout_handler_t)
-                                    on_timeout, loop);
-  ply_event_loop_watch_fd (loop, 0, PLY_EVENT_LOOP_FD_STATUS_HAS_DATA,
-                          (ply_event_handler_t) line_received_handler,
-                          (ply_event_handler_t) line_received_handler,
-                          NULL);
-
-  alarm (5);
-  exit_code = ply_event_loop_run (loop);
-
-  ply_event_loop_free (loop);
-
-  return exit_code;
-}
-#endif /* PLY_EVENT_LOOP_ENABLE_TEST */
 /* vim: set ts=4 sw=4 expandtab autoindent cindent cino={.5s,(0: */
diff --git a/src/libply/ply-hashtable.c b/src/libply/ply-hashtable.c
index 7d8d648e..7b03d876 100644
--- a/src/libply/ply-hashtable.c
+++ b/src/libply/ply-hashtable.c
@@ -130,14 +130,6 @@ ply_hashtable_insert_internal (ply_hashtable_t *hashtable,
 {
   unsigned int hash_index;
   int step = 0;
-  
-#ifdef PLY_HASHTABLE_ENABLE_TEST
-    /* Make sure the counts are synchronised with bitmap */
-  assert (ply_bitarray_count (hashtable->dirty_node_bitmap, hashtable->total_node_count) ==
-          (int) hashtable->dirty_node_count);
-  assert (ply_bitarray_count (hashtable->live_node_bitmap, hashtable->total_node_count) ==
-          (int) hashtable->live_node_count);
-#endif /* PLY_HASHTABLE_ENABLE_TEST */
 
   hash_index = hashtable->hash_func (key);
   hash_index &= hashtable->total_node_count - 1;
@@ -281,56 +273,10 @@ ply_hashtable_foreach (ply_hashtable_t              *hashtable,
     }
 }
 
-
-#ifdef PLY_HASHTABLE_ENABLE_TEST
-#include <stdio.h>
-
-static void
-foreach_func (void *key,
-              void *data,
-              void *user_data)
-{
-  printf ("foreach key:%s data:%s\n", (char*) key, (char*) data);
-}
-
-
 int
-main (int    argc,
-      char **argv)
+ply_hashtable_get_size (ply_hashtable_t *hashtable)
 {
-  ply_hashtable_t *hashtable;
-  int i;
-  const char* key[10] =  {"k1", "k2", "k3", "k4", "k5", "k6", "k7", "k8", "k9", "k10"};
-  const char* data[10] = {"d1", "d2", "d3", "d4", "d5", "d6", "d7", "d8", "d9", "d10"};
-  char* reply_key = NULL;
-  char* reply_data = NULL;
-  
-  printf ("hashtable test start\n");
-  hashtable = ply_hashtable_new (ply_hashtable_string_hash, ply_hashtable_string_compare);
-  for (i=0; i<10; i++)
-    {
-      ply_hashtable_insert (hashtable, (void *) key[i], (void *) data[9-i]);
-    }
-  for (i=0; i<10; i++)
-    {
-      reply_data = ply_hashtable_lookup (hashtable, (void *) key[i]);
-      printf ("got:%s\n", reply_data);
-    }
-  for (i=0; i<10; i++)
-    {
-      ply_hashtable_remove (hashtable, (void *) key[i]);
-      ply_hashtable_insert (hashtable, (void *) key[i], (void *) data[i]);
-    }
-  for (i=0; i<10; i++)
-    {
-      if (ply_hashtable_lookup_full (hashtable, (void *) key[i], (void**) &reply_key, (void**) &reply_data))
-        printf ("got key:%s data:%s\n", reply_key, reply_data);
-    }
-  ply_hashtable_foreach (hashtable, foreach_func, NULL);
-  ply_hashtable_free(hashtable);
-  printf ("hashtable test end\n");
-  return 0;
+  return hashtable->live_node_count;
 }
 
-#endif
 /* vim: set ts=4 sw=4 expandtab autoindent cindent cino={.5s,(0: */
diff --git a/src/libply/ply-hashtable.h b/src/libply/ply-hashtable.h
index 016c781e..e7e1a6eb 100644
--- a/src/libply/ply-hashtable.h
+++ b/src/libply/ply-hashtable.h
@@ -57,6 +57,8 @@ int ply_hashtable_lookup_full (ply_hashtable_t *hashtable,
 void ply_hashtable_foreach (ply_hashtable_t              *hashtable,
 							ply_hashtable_foreach_func_t  func,
 							void                         *user_data);
+
+int ply_hashtable_get_size (ply_hashtable_t *hashtable);
 #endif
 
 #endif /* PLY_HASHTABLE_H */
diff --git a/src/libply/ply-list.c b/src/libply/ply-list.c
index 85262ab6..8c589c21 100644
--- a/src/libply/ply-list.c
+++ b/src/libply/ply-list.c
@@ -375,85 +375,4 @@ ply_list_node_get_data (ply_list_node_t *node)
   return node->data;
 }
 
-#ifdef PLY_LIST_ENABLE_TEST
-#include <stdio.h>
-
-static int
-compare_int_ptr (void *element_a,
-                 void *element_b)
-{
-  int *int_a = element_a;
-  int *int_b = element_b;
-  return *int_a - *int_b;
-
-}
-
-int
-main (int    argc,
-      char **argv)
-{
-  ply_list_t *list;
-  ply_list_node_t *node;
-  int i, lastval;
-  int *value;
-  int errors;
-
-  errors = 0;
-
-  list = ply_list_new ();
-
-  ply_list_append_data (list, (void *) "foo");
-  ply_list_append_data (list, (void *) "bar");
-  ply_list_append_data (list, (void *) "baz");
-  ply_list_prepend_data (list, (void *) "qux");
-  ply_list_prepend_data (list, (void *) "quux");
-  ply_list_remove_data (list, (void *) "baz");
-  ply_list_remove_data (list, (void *) "foo");
-
-  node = ply_list_get_first_node (list);
-  i = 0;
-  while (node != NULL)
-    {
-      printf ("node '%d' has data '%s'\n", i,
-              (char *) ply_list_node_get_data (node));
-      node = ply_list_get_next_node (list, node);
-      i++;
-    }
-
-  printf ("\n");
-  ply_list_remove_all_nodes (list);
-  srandom(1);
-
-  for (i = 0; i<100; i++)
-    {
-      value = malloc (sizeof (int));
-      *value = random() % 100;
-      ply_list_append_data (list, (void *) value);
-    }
-
-  ply_list_sort (list, compare_int_ptr);
-
-  node = ply_list_get_first_node (list);
-  i = 0;
-  lastval = 0;
-
-  while (node != NULL)
-    {
-      value = (int *) ply_list_node_get_data (node);
-      if (*value < lastval)
-        {
-          printf ("ERROR: incorrect order\n");
-          errors = 1;
-        }
-      lastval = *value;
-      printf ("node '%d' has data '%d'\n", i, *value);
-      node = ply_list_get_next_node (list, node);
-      i++;
-    }
-
-  ply_list_free (list);
-  return errors;
-}
-
-#endif
 /* vim: set ts=4 sw=4 expandtab autoindent cindent cino={.5s,(0: */
diff --git a/src/libply/ply-logger.c b/src/libply/ply-logger.c
index ec5b6e52..740c30ea 100644
--- a/src/libply/ply-logger.c
+++ b/src/libply/ply-logger.c
@@ -598,26 +598,4 @@ ply_logger_is_tracing_enabled (ply_logger_t *logger)
 }
 #endif /* PLY_ENABLE_TRACING */
 
-#ifdef PLY_LOGGER_ENABLE_TEST
-
-int
-main (int    argc,
-      char **argv)
-{
-  int exit_code;
-  ply_logger_t *logger;
-
-  exit_code = 0;
-  logger = ply_logger_new ();
-
-  ply_logger_inject (logger, "yo yo yo\n");
-  ply_logger_set_output_fd (logger, 1);
-  ply_logger_inject (logger, "yo yo yo yo\n");
-  ply_logger_flush (logger);
-  ply_logger_free (logger);
-
-  return exit_code;
-}
-
-#endif /* PLY_LOGGER_ENABLE_TEST */
 /* vim: set ts=4 sw=4 expandtab autoindent cindent cino={.5s,(0: */
diff --git a/src/libply/ply-progress.c b/src/libply/ply-progress.c
index cf372cdd..a88aa28b 100644
--- a/src/libply/ply-progress.c
+++ b/src/libply/ply-progress.c
@@ -330,75 +330,5 @@ ply_progress_status_update (ply_progress_t* progress,
     }
 }
 
-#ifdef PLY_PROGRESS_ENABLE_TEST
-
-#include <stdio.h>
-
-int
-main (int    argc,
-      char **argv)
-{
-  double percent;
-  int slowness;
-  double time;
-  int i;
-  const char* strings[10]={"foobar", "barfoo", "barbar", "foo", "foo", "bar", "foo", "more", "even more", "even even more"};
-  ply_progress_t* progress = ply_progress_new ();
-  
-  progress->scalar = 1.0/5;  /* Original time estimate is 5 sec*/
-
-  percent = ply_progress_get_percentage (progress);
-  time = ply_progress_get_time (progress);
-  printf("Time:%f   \t Percentage: %f%%\n", time, percent*100);
-  srand ((int) ply_get_timestamp ());
-  
-  slowness = rand () % 500000 + 50000;
-
-  for (i=0; i<2; i++)
-    {
-      usleep ((rand () % slowness+slowness));
-      percent = ply_progress_get_percentage (progress);
-      time = ply_progress_get_time (progress);
-      printf("Time:%f   \t Percentage: %f%%\n", time, percent*100);
-    }
-  printf("Load cache\n");
-  ply_progress_load_cache (progress, PLYMOUTH_TIME_DIRECTORY "/boot-duration");
-
-  for (i=0; i<10; i++)
-    {
-      ply_progress_status_update (progress, strings[i]);
-      usleep ((rand () % slowness+slowness));
-      percent = ply_progress_get_percentage (progress);
-      time = ply_progress_get_time (progress);
-      printf("Time:%f   \t Percentage: %f%% \tScalar:%f\n", time, percent*100, progress->scalar);
-    }
-  printf("Save and free cache\n");
-  ply_progress_save_cache (progress, PLYMOUTH_TIME_DIRECTORY "/boot-duration");
-  ply_progress_free(progress);
-
-  printf("\nManual set percentage run\n\n");
-
-  progress = ply_progress_new ();
-  progress->scalar = 1.0/5;  /* Original time estimate is 5 sec*/
-
-  percent = ply_progress_get_percentage (progress);
-  time = ply_progress_get_time (progress);
-  printf("Time:%f   \t Percentage: %f%%\n", time, percent*100);
-  srand ((int) ply_get_timestamp ());
-
-  for (i=0; i<12; i++)
-    {
-      ply_progress_set_percentage (progress, (double)i/12);
-      usleep ((rand () % slowness+slowness));
-      percent = ply_progress_get_percentage (progress);
-      time = ply_progress_get_time (progress);
-      printf("Time:%f   \t Percentage: %f%% (%f%%)\tScalar:%f\n", time, percent*100, (double)i/12*100, progress->scalar);
-    }
-  ply_progress_free(progress);
-
-  return 0;
-}
-
-#endif /* PLY_PROGRESS_ENABLE_TEST */
 /* vim: set ts=4 sw=4 expandtab autoindent cindent cino={.5s,(0: */
     
diff --git a/src/libply/ply-region.c b/src/libply/ply-region.c
index cbaca403..92d35743 100644
--- a/src/libply/ply-region.c
+++ b/src/libply/ply-region.c
@@ -467,141 +467,4 @@ ply_region_get_sorted_rectangle_list (ply_region_t *region)
   return region->rectangle_list;
 }
 
-#ifdef PLY_REGION_ENABLE_TEST
-#include <stdio.h>
-
-#define COVER_SIZE 100
-#define RECTANGLE_COUNT 1000
-
-static void
-cover_with_rect(char             cover[COVER_SIZE][COVER_SIZE],
-                ply_rectangle_t *rectangle,
-                char             value)
-{      /* is value is not zero, the entry will be set to the value,
-          otherwise entry is incremented*/
-  unsigned long x, y;
-  for (y=0; y<rectangle->height; y++)
-    {
-      for (x=0; x<rectangle->width; x++)
-        {
-          if (rectangle->x + x < COVER_SIZE &&
-              rectangle->y + y < COVER_SIZE)
-            {
-              if (value)
-                cover[rectangle->y + y][rectangle->x + x] = value;
-              else
-                cover[rectangle->y + y][rectangle->x + x]++;
-            }
-        }
-    }
-}
-
-static int
-do_test (void)
-{
-  ply_rectangle_t rectangle;
-  char cover[COVER_SIZE][COVER_SIZE];
-  int i;
-  unsigned long x, y;
-  ply_region_t *region;
-  ply_list_node_t *node;
-
-  region = ply_region_new ();
-
-  for (y = 0; y < COVER_SIZE; y++)
-    {
-      for (x = 0; x < COVER_SIZE; x++)
-        {
-          cover[y][x] = 0;
-        }
-    }
-
-  for (i = 0; i < RECTANGLE_COUNT; i++)
-    {
-      rectangle.x = random() % COVER_SIZE-5;
-      rectangle.y = random() % COVER_SIZE-5;
-      rectangle.width = 1 + random() % 20;
-      rectangle.height = 1 + random() % 20;
-      printf("Adding X=%ld Y=%ld W=%ld H=%ld\n",
-              rectangle.x,
-              rectangle.y,
-              rectangle.width,
-              rectangle.height);
-      cover_with_rect(cover, &rectangle, 100); /* 100 means covered by origial squares */
-      ply_region_add_rectangle (region, &rectangle);
-    }
-
-  printf("Converted to:\n");
-  int count = 0;
-
-  ply_list_t *rectangle_list = ply_region_get_rectangle_list (region);
-  for (node = ply_list_get_first_node (rectangle_list);
-       node;
-       node = ply_list_get_next_node (rectangle_list, node))
-    {
-      ply_rectangle_t *small_rectangle = ply_list_node_get_data (node);
-      printf("Processed X=%ld Y=%ld W=%ld H=%ld\n",
-             small_rectangle->x,
-             small_rectangle->y, 
-             small_rectangle->width, 
-             small_rectangle->height);
-      cover_with_rect(cover, small_rectangle, 0);
-      count++;
-    }
-  printf("Rectangles in:%d out:%d\n", RECTANGLE_COUNT, count);
-
-  count=0;
-
-  for (y = 0; y < COVER_SIZE; y++)
-    {
-      printf("%03ld ", y);
-      for (x = 0; x < COVER_SIZE; x++)
-        {
-          if (cover[y][x] >= 100)
-            {
-              if (cover[y][x] == 100)
-                {
-                  printf("-");  /* "-" means should have been covered but wasn't */
-                  count++;
-                }
-              else
-                {
-                  if (cover[y][x] == 101)
-                    printf("O");  /* "O" means correctly covered */
-                  else
-                    {
-                      printf("%d", cover[y][x] - 101);
-                      count++;  /* 1+ means covered multiple times*/
-                    }
-                }
-            }
-          else
-            {
-              if (cover[y][x] == 0)
-                printf("o");  /* "o" means not involved*/
-              else
-                {
-                  printf("%c", 'A' - 1 + cover[y][x]);
-                  count++;  /* A+ means covered despite being not involved*/
-                }
-            }
-        }
-      printf("\n");
-    }
-  printf("errors:%d\n", count);
-  return count;
-}
-int
-main (int    argc,
-      char **argv)
-{
-  int i;
-  srandom(312);
-  for (i=0; i<100; i++)
-    {
-      if (do_test ()) return 1;
-    }
-  return 0;
-}
-#endif
 /* vim: set ts=4 sw=4 expandtab autoindent cindent cino={.5s,(0: */
diff --git a/src/libply/ply-terminal-session.c b/src/libply/ply-terminal-session.c
index 0bdb985b..379035cc 100644
--- a/src/libply/ply-terminal-session.c
+++ b/src/libply/ply-terminal-session.c
@@ -587,57 +587,4 @@ ply_terminal_session_close_log (ply_terminal_session_t *session)
   return ply_logger_close_file (session->logger);
 }
 
-#ifdef PLY_TERMINAL_SESSION_ENABLE_TEST
-
-#include <stdio.h>
-
-#include "ply-event-loop.h"
-#include "ply-terminal-session.h"
-
-static void
-on_finished (ply_event_loop_t *loop)
-{
-  ply_event_loop_exit (loop, 0);
-}
-
-int
-main (int    argc,
-      char **argv)
-{
-  ply_event_loop_t *loop;
-  ply_terminal_session_t *session;
-  int exit_code;
-  ply_terminal_session_flags_t flags;
-
-  exit_code = 0;
-
-  loop = ply_event_loop_new ();
-
-  session = ply_terminal_session_new ((const char * const *) (argv + 1));
-
-  flags = PLY_TERMINAL_SESSION_FLAGS_RUN_IN_PARENT;
-  flags |= PLY_TERMINAL_SESSION_FLAGS_LOOK_IN_PATH;
-
-  ply_terminal_session_attach_to_event_loop (session, loop);
-
-  if (!ply_terminal_session_run (session, flags, 
-                                 (ply_terminal_session_begin_handler_t) NULL,
-                                 (ply_terminal_session_output_handler_t) NULL,
-                                 (ply_terminal_session_hangup_handler_t) 
-                                 on_finished, loop))
-    {
-      perror ("could not start terminal session");
-      return errno;
-    }
-
-  ply_terminal_session_open_log (session, "foo.log");
-
-  exit_code = ply_event_loop_run (loop);
-
-  ply_terminal_session_free (session);
-
-  return exit_code;
-}
-
-#endif /* PLY_TERMINAL_SESSION_ENABLE_TEST */
 /* vim: set ts=4 sw=4 expandtab autoindent cindent cino={.5s,(0: */
diff --git a/src/libply/tests/Makefile.am b/src/libply/tests/Makefile.am
deleted file mode 100644
index bc4da58f..00000000
--- a/src/libply/tests/Makefile.am
+++ /dev/null
@@ -1,25 +0,0 @@
-INCLUDES =                                                                    \
-           -I$(top_srcdir)                                                    \
-           -I$(srcdir)/..                                                     \
-           -I$(srcdir)
-TESTS = 
-
-if ENABLE_TESTS
-include $(srcdir)/ply-terminal-session-test.am
-include $(srcdir)/ply-logger-test.am
-include $(srcdir)/ply-array-test.am
-include $(srcdir)/ply-bitarray-test.am
-include $(srcdir)/ply-list-test.am
-include $(srcdir)/ply-hashtable-test.am
-include $(srcdir)/ply-event-loop-test.am
-include $(srcdir)/ply-command-parser-test.am
-include $(srcdir)/ply-progress-test.am
-include $(srcdir)/ply-region.am
-endif
-
-noinst_PROGRAMS = $(TESTS)
-
-# Our tests aren't unit tests so clear for now
-TESTS =
-
-MAINTAINERCLEANFILES = Makefile.in
diff --git a/src/libply/tests/ply-array-test.am b/src/libply/tests/ply-array-test.am
deleted file mode 100644
index 4f8ecc4e..00000000
--- a/src/libply/tests/ply-array-test.am
+++ /dev/null
@@ -1,16 +0,0 @@
-TESTS += ply-array-test
-
-ply_array_test_CFLAGS = $(PLYMOUTH_CFLAGS) -DPLY_ARRAY_ENABLE_TEST
-ply_array_test_LDADD = $(PLYMOUTH_LIBS)
-
-ply_array_test_SOURCES =                                                     \
-                          $(srcdir)/../ply-buffer.h                          \
-                          $(srcdir)/../ply-buffer.c                          \
-                          $(srcdir)/../ply-list.h                            \
-                          $(srcdir)/../ply-list.c                            \
-                          $(srcdir)/../ply-logger.h                          \
-                          $(srcdir)/../ply-logger.c                          \
-                          $(srcdir)/../ply-utils.h                           \
-                          $(srcdir)/../ply-utils.c                           \
-                          $(srcdir)/../ply-array.h                           \
-                          $(srcdir)/../ply-array.c
diff --git a/src/libply/tests/ply-bitarray-test.am b/src/libply/tests/ply-bitarray-test.am
deleted file mode 100644
index 85c36089..00000000
--- a/src/libply/tests/ply-bitarray-test.am
+++ /dev/null
@@ -1,8 +0,0 @@
-TESTS += ply-bitarray-test
-
-ply_bitarray_test_CFLAGS = $(PLYMOUTH_CFLAGS) -DPLY_BITARRAY_ENABLE_TEST
-ply_bitarray_test_LDADD = $(PLYMOUTH_LIBS)
-
-ply_bitarray_test_SOURCES =                                                     \
-                          $(srcdir)/../ply-bitarray.h                           \
-                          $(srcdir)/../ply-bitarray.c
diff --git a/src/libply/tests/ply-command-parser-test.am b/src/libply/tests/ply-command-parser-test.am
deleted file mode 100644
index 91649d5b..00000000
--- a/src/libply/tests/ply-command-parser-test.am
+++ /dev/null
@@ -1,18 +0,0 @@
-TESTS += ply-command-parser-test
-
-ply_command_parser_test_CFLAGS = $(PLYMOUTH_CFLAGS) -DPLY_COMMAND_PARSER_ENABLE_TEST
-ply_command_parser_test_LDADD = $(PLYMOUTH_LIBS)
-
-ply_command_parser_test_SOURCES =                                            \
-                          $(srcdir)/../ply-buffer.h                          \
-                          $(srcdir)/../ply-buffer.c                          \
-                          $(srcdir)/../ply-event-loop.h                      \
-                          $(srcdir)/../ply-event-loop.c                      \
-                          $(srcdir)/../ply-list.h                            \
-                          $(srcdir)/../ply-list.c                            \
-                          $(srcdir)/../ply-logger.h                          \
-                          $(srcdir)/../ply-logger.c                          \
-                          $(srcdir)/../ply-utils.h                           \
-                          $(srcdir)/../ply-utils.c                           \
-                          $(srcdir)/../ply-command-parser.h                  \
-                          $(srcdir)/../ply-command-parser.c
diff --git a/src/libply/tests/ply-event-loop-test.am b/src/libply/tests/ply-event-loop-test.am
deleted file mode 100644
index c666ea6a..00000000
--- a/src/libply/tests/ply-event-loop-test.am
+++ /dev/null
@@ -1,14 +0,0 @@
-TESTS += ply-event-loop-test
-
-ply_event_loop_test_CFLAGS = $(PLYMOUTH_CFLAGS) -DPLY_EVENT_LOOP_ENABLE_TEST
-ply_event_loop_test_LDADD = $(PLYMOUTH_LIBS)
-
-ply_event_loop_test_SOURCES =                                               \
-                          $(srcdir)/../ply-utils.h                          \
-                          $(srcdir)/../ply-utils.c                          \
-                          $(srcdir)/../ply-list.h                           \
-                          $(srcdir)/../ply-list.c                           \
-                          $(srcdir)/../ply-logger.h                         \
-                          $(srcdir)/../ply-logger.c                         \
-                          $(srcdir)/../ply-event-loop.h                     \
-                          $(srcdir)/../ply-event-loop.c
diff --git a/src/libply/tests/ply-hashtable-test.am b/src/libply/tests/ply-hashtable-test.am
deleted file mode 100644
index d3410fcd..00000000
--- a/src/libply/tests/ply-hashtable-test.am
+++ /dev/null
@@ -1,10 +0,0 @@
-TESTS += ply-hashtable-test
-
-ply_hashtable_test_CFLAGS = $(PLYMOUTH_CFLAGS) -DPLY_HASHTABLE_ENABLE_TEST
-ply_hashtable_test_LDADD = $(PLYMOUTH_LIBS)
-
-ply_hashtable_test_SOURCES =                                                     \
-                          $(srcdir)/../ply-hashtable.h                           \
-                          $(srcdir)/../ply-hashtable.c                           \
-                          $(srcdir)/../ply-bitarray.h                            \
-                          $(srcdir)/../ply-bitarray.c
diff --git a/src/libply/tests/ply-list-test.am b/src/libply/tests/ply-list-test.am
deleted file mode 100644
index 8beb5786..00000000
--- a/src/libply/tests/ply-list-test.am
+++ /dev/null
@@ -1,8 +0,0 @@
-TESTS += ply-list-test
-
-ply_list_test_CFLAGS = $(PLYMOUTH_CFLAGS) -DPLY_LIST_ENABLE_TEST
-ply_list_test_LDADD = $(PLYMOUTH_LIBS)
-
-ply_list_test_SOURCES =                                                     \
-                          $(srcdir)/../ply-list.h                           \
-                          $(srcdir)/../ply-list.c
diff --git a/src/libply/tests/ply-logger-test.am b/src/libply/tests/ply-logger-test.am
deleted file mode 100644
index a589fb92..00000000
--- a/src/libply/tests/ply-logger-test.am
+++ /dev/null
@@ -1,12 +0,0 @@
-TESTS += ply-logger-test
-
-ply_logger_test_CFLAGS = $(PLYMOUTH_CFLAGS) -DPLY_LOGGER_ENABLE_TEST
-ply_logger_test_LDADD = $(PLYMOUTH_LIBS)
-
-ply_logger_test_SOURCES =                                                     \
-                          $(srcdir)/../ply-list.h                             \
-                          $(srcdir)/../ply-list.c                             \
-                          $(srcdir)/../ply-utils.h                            \
-                          $(srcdir)/../ply-utils.c                            \
-                          $(srcdir)/../ply-logger.h                           \
-                          $(srcdir)/../ply-logger.c
diff --git a/src/libply/tests/ply-progress-test.am b/src/libply/tests/ply-progress-test.am
deleted file mode 100644
index 6279facf..00000000
--- a/src/libply/tests/ply-progress-test.am
+++ /dev/null
@@ -1,15 +0,0 @@
-TESTS += ply-progress-test
-
-ply_progress_test_CFLAGS = $(PLYMOUTH_CFLAGS) -DPLY_PROGRESS_ENABLE_TEST      \
-           -DPLYMOUTH_TIME_DIRECTORY=\"$(localstatedir)/lib/plymouth/\"
-ply_progress_test_LDADD = $(PLYMOUTH_LIBS)
-
-ply_progress_test_SOURCES =                                     \
-                          $(srcdir)/../ply-progress.h           \
-                          $(srcdir)/../ply-progress.c           \
-                          $(srcdir)/../ply-list.h               \
-                          $(srcdir)/../ply-list.c               \
-                          $(srcdir)/../ply-logger.h             \
-                          $(srcdir)/../ply-logger.c             \
-                          $(srcdir)/../ply-utils.h              \
-                          $(srcdir)/../ply-utils.c
diff --git a/src/libply/tests/ply-region.am b/src/libply/tests/ply-region.am
deleted file mode 100644
index 18838336..00000000
--- a/src/libply/tests/ply-region.am
+++ /dev/null
@@ -1,12 +0,0 @@
-TESTS += ply-region-test
-
-ply_region_test_CFLAGS = $(PLYMOUTH_CFLAGS) -DPLY_REGION_ENABLE_TEST
-ply_region_test_LDADD = $(PLYMOUTH_LIBS)
-
-ply_region_test_SOURCES =                                                   \
-                          $(srcdir)/../ply-region.h                         \
-                          $(srcdir)/../ply-region.c                         \
-                          $(srcdir)/../ply-rectangle.h                      \
-                          $(srcdir)/../ply-rectangle.c                      \
-                          $(srcdir)/../ply-list.h                           \
-                          $(srcdir)/../ply-list.c                           
diff --git a/src/libply/tests/ply-terminal-session-test.am b/src/libply/tests/ply-terminal-session-test.am
deleted file mode 100644
index decb531b..00000000
--- a/src/libply/tests/ply-terminal-session-test.am
+++ /dev/null
@@ -1,18 +0,0 @@
-TESTS += ply-terminal-session-test
-
-ply_terminal_session_test_CFLAGS = $(PLYMOUTH_CFLAGS) -DPLY_TERMINAL_SESSION_ENABLE_TEST
-ply_terminal_session_test_LDADD = $(PLYMOUTH_LIBS)
-
-ply_terminal_session_test_SOURCES =                                                   \
-                          $(srcdir)/../ply-utils.h                                    \
-                          $(srcdir)/../ply-utils.c                                    \
-                          $(srcdir)/../ply-buffer.h                                   \
-                          $(srcdir)/../ply-buffer.c                                   \
-                          $(srcdir)/../ply-logger.h                                   \
-                          $(srcdir)/../ply-logger.c                                   \
-                          $(srcdir)/../ply-list.h                                     \
-                          $(srcdir)/../ply-list.c                                     \
-                          $(srcdir)/../ply-event-loop.h                               \
-                          $(srcdir)/../ply-event-loop.c                               \
-                          $(srcdir)/../ply-terminal-session.h                         \
-                          $(srcdir)/../ply-terminal-session.c
diff --git a/src/main.c b/src/main.c
index 9c450c0c..50062951 100644
--- a/src/main.c
+++ b/src/main.c
@@ -43,10 +43,12 @@
 #include "ply-command-parser.h"
 #include "ply-boot-server.h"
 #include "ply-boot-splash.h"
+#include "ply-device-manager.h"
 #include "ply-event-loop.h"
 #include "ply-hashtable.h"
 #include "ply-list.h"
 #include "ply-logger.h"
+#include "ply-renderer.h"
 #include "ply-terminal-session.h"
 #include "ply-trigger.h"
 #include "ply-utils.h"
@@ -84,9 +86,6 @@ typedef struct
 {
   ply_event_loop_t *loop;
   ply_boot_server_t *boot_server;
-  ply_list_t *pixel_displays;
-  ply_list_t *text_displays;
-  ply_keyboard_t *keyboard;
   ply_boot_splash_t *boot_splash;
   ply_terminal_session_t *session;
   ply_buffer_t *boot_buffer;
@@ -97,8 +96,8 @@ typedef struct
   ply_list_t *messages;
   ply_command_parser_t *command_parser;
   ply_mode_t mode;
-  ply_renderer_t *renderer;
   ply_terminal_t *local_console_terminal;
+  ply_device_manager_t *device_manager;
 
   ply_trigger_t *deactivate_trigger;
   ply_trigger_t *quit_trigger;
@@ -116,7 +115,6 @@ typedef struct
   uint32_t is_shown : 1;
   uint32_t should_force_details : 1;
 
-  char *kernel_console_tty;
   char *override_splash_path;
   char *system_default_splash_path;
   char *distribution_default_splash_path;
@@ -125,15 +123,14 @@ typedef struct
   int number_of_errors;
 } state_t;
 
-static ply_boot_splash_t *start_boot_splash (state_t    *state,
-                                             const char *theme_path,
-                                             bool        fall_back_if_neccessary);
-
-static void add_display_and_keyboard_for_terminal (state_t        *state,
-                                                   ply_terminal_t *terminal);
-
-static void add_default_displays_and_keyboard (state_t *state);
+static void load_splash (state_t *state);
+static ply_boot_splash_t *load_built_in_theme (state_t *state);
+static ply_boot_splash_t *load_theme (state_t    *state,
+                                      const char *theme_path);
+static void show_theme (state_t           *state,
+                        ply_boot_splash_t *splash);
 
+static void attach_splash_to_seats (state_t *state);
 static bool attach_to_running_session (state_t *state);
 static void detach_from_running_session (state_t *state);
 static void on_escape_pressed (state_t *state);
@@ -146,15 +143,19 @@ static void on_error_message (ply_buffer_t *debug_buffer,
 static ply_buffer_t *debug_buffer;
 static char *debug_buffer_path = NULL;
 static char *pid_file = NULL;
-static void check_for_consoles (state_t    *state,
-                                const char *default_tty,
-                                bool        should_add_displays);
 static void toggle_between_splash_and_details (state_t *state);
 #ifdef PLY_ENABLE_SYSTEMD_INTEGRATION
 static void tell_systemd_to_print_details (state_t *state);
 static void tell_systemd_to_stop_printing_details (state_t *state);
 #endif
 static const char * get_cache_file_for_mode (ply_mode_t mode);
+static void on_escape_pressed (state_t *state);
+static void on_enter (state_t    *state,
+                      const char *line);
+static void on_keyboard_input (state_t    *state,
+                               const char *keyboard_input,
+                               size_t      character_size);
+static void on_backspace (state_t *state);
 
 static void
 on_session_output (state_t    *state,
@@ -254,20 +255,23 @@ show_messages (state_t *state)
 }
 
 static void
-show_detailed_splash (state_t *state)
+load_detailed_splash (state_t *state)
 {
+  ply_boot_splash_t *splash;
+
   if (state->boot_splash != NULL)
     return;
 
   ply_trace ("Showing detailed splash screen");
-  state->boot_splash = start_boot_splash (state,
-                                          PLYMOUTH_THEME_PATH "details/details.plymouth",
-                                          true);
+  splash = load_built_in_theme (state);
 
-  if (state->boot_splash == NULL)
+  if (splash == NULL)
     {
       ply_trace ("Could not start detailed splash screen, this could be a problem.");
+      return;
     }
+
+  state->boot_splash = splash;
 }
 
 static const char *
@@ -392,7 +396,7 @@ find_distribution_default_splash (state_t *state)
 }
 
 static void
-show_default_splash (state_t *state)
+load_default_splash (state_t *state)
 {
   if (state->boot_splash != NULL)
     return;
@@ -402,9 +406,7 @@ show_default_splash (state_t *state)
   if (state->override_splash_path != NULL)
     {
       ply_trace ("Trying override splash at '%s'", state->override_splash_path);
-      state->boot_splash = start_boot_splash (state,
-                                              state->override_splash_path,
-                                              false);
+      state->boot_splash = load_theme (state, state->override_splash_path);
     }
 
   find_system_default_splash (state);
@@ -412,9 +414,7 @@ show_default_splash (state_t *state)
       state->system_default_splash_path != NULL)
     {
       ply_trace ("Trying system default splash");
-      state->boot_splash = start_boot_splash (state,
-                                              state->system_default_splash_path,
-                                              false);
+      state->boot_splash = load_theme (state, state->system_default_splash_path);
     }
 
   find_distribution_default_splash (state);
@@ -422,39 +422,34 @@ show_default_splash (state_t *state)
       state->distribution_default_splash_path != NULL)
     {
       ply_trace ("Trying distribution default splash");
-      state->boot_splash = start_boot_splash (state,
-                                              state->distribution_default_splash_path,
-                                              false);
+      state->boot_splash = load_theme (state, state->distribution_default_splash_path);
     }
 
   if (state->boot_splash == NULL)
     {
       ply_trace ("Trying old scheme for default splash");
-      state->boot_splash = start_boot_splash (state,
-                                              PLYMOUTH_THEME_PATH "default.plymouth",
-                                              false);
+      state->boot_splash = load_theme (state, PLYMOUTH_THEME_PATH "default.plymouth");
     }
 
   if (state->boot_splash == NULL)
     {
       ply_trace ("Could not start default splash screen,"
                  "showing text splash screen");
-      state->boot_splash = start_boot_splash (state,
-                                              PLYMOUTH_THEME_PATH "text/text.plymouth",
-                                              false);
+      state->boot_splash = load_theme (state, PLYMOUTH_THEME_PATH "text/text.plymouth");
     }
 
   if (state->boot_splash == NULL)
     {
       ply_trace ("Could not start text splash screen,"
-                 "showing built-in fallback");
-      state->boot_splash = start_boot_splash (state,
-                                              PLYMOUTH_THEME_PATH "text/text.plymouth",
-                                              true);
+                 "showing built-in splash screen");
+      state->boot_splash = load_built_in_theme (state);
     }
 
   if (state->boot_splash == NULL)
-    ply_error ("plymouthd: could not start boot splash: %m");
+    {
+      ply_error ("plymouthd: could not start boot splash: %m");
+      return;
+    }
 }
 
 static void
@@ -820,55 +815,9 @@ plymouth_should_show_default_splash (state_t *state)
 }
 
 static void
-remove_displays_and_keyboard (state_t *state)
-{
-  ply_list_node_t *node;
-  ply_trace ("removing displays and keyboard");
-
-  node = ply_list_get_first_node (state->pixel_displays);
-  while (node != NULL)
-    {
-      ply_list_node_t *next_node;
-      ply_pixel_display_t *display;
-
-      ply_trace ("removing pixel display");
-      next_node = ply_list_get_next_node (state->pixel_displays, node);
-      display = ply_list_node_get_data (node);
-      ply_pixel_display_free (display);
-
-      ply_list_remove_node (state->pixel_displays, node);
-
-      node = next_node;
-    }
-
-  node = ply_list_get_first_node (state->text_displays);
-  while (node != NULL)
-    {
-      ply_list_node_t *next_node;
-      ply_text_display_t *display;
-
-      ply_trace ("removing text display");
-      next_node = ply_list_get_next_node (state->text_displays, node);
-      display = ply_list_node_get_data (node);
-      ply_text_display_free (display);
-
-      ply_list_remove_node (state->text_displays, node);
-
-      node = next_node;
-    }
-
-  if (state->keyboard != NULL)
-    {
-      ply_trace ("removing keyboard");
-      ply_keyboard_free (state->keyboard);
-      state->keyboard = NULL;
-    }
-}
-
-static void
 on_show_splash (state_t *state)
 {
-  bool has_display;
+  bool has_open_seats;
 
   if (state->is_shown)
     {
@@ -890,90 +839,127 @@ on_show_splash (state_t *state)
     }
 
   state->is_shown = true;
+  has_open_seats = ply_device_manager_has_open_seats (state->device_manager);
 
-  check_for_consoles (state, state->default_tty, true);
-
-  has_display = ply_list_get_length (state->pixel_displays) > 0 ||
-                ply_list_get_length (state->text_displays) > 0;
-
-  if (!state->is_attached && state->should_be_attached && has_display)
+  if (!state->is_attached && state->should_be_attached && has_open_seats)
     attach_to_running_session (state);
 
-  if (!has_display)
+  if (has_open_seats)
+    {
+      ply_trace ("at least one seat already open, so loading splash");
+      load_splash (state);
+      show_theme (state, state->boot_splash);
+    }
+  else
     {
-      ply_trace ("no open seats");
-      detach_from_running_session (state);
+      ply_trace ("no seats available to show splash on, waiting...");
     }
+}
+
+static void
+on_seat_removed (state_t    *state,
+                 ply_seat_t *seat)
+{
+  ply_keyboard_t *keyboard;
+
+  keyboard = ply_seat_get_keyboard (seat);
+
+  ply_trace ("no longer listening for keystrokes");
+  ply_keyboard_remove_input_handler (keyboard,
+                                     (ply_keyboard_input_handler_t)
+                                     on_keyboard_input);
+  ply_trace ("no longer listening for escape");
+  ply_keyboard_remove_escape_handler (keyboard,
+                                      (ply_keyboard_escape_handler_t)
+                                      on_escape_pressed);
+  ply_trace ("no longer listening for backspace");
+  ply_keyboard_remove_backspace_handler (keyboard,
+                                         (ply_keyboard_backspace_handler_t)
+                                         on_backspace);
+  ply_trace ("no longer listening for enter");
+  ply_keyboard_remove_enter_handler (keyboard,
+                                     (ply_keyboard_enter_handler_t)
+                                     on_enter);
+
+  if (state->boot_splash != NULL)
+   ply_boot_splash_detach_from_seat (state->boot_splash, seat);
+}
+
+static void
+load_splash (state_t *state)
+{
+  if (state->boot_splash != NULL)
+    return;
 
   if (plymouth_should_show_default_splash (state))
     {
-      show_default_splash (state);
+      load_default_splash (state);
       state->showing_details = false;
     }
   else
     {
-      show_detailed_splash (state);
+      load_detailed_splash (state);
       state->showing_details = true;
     }
-  show_messages (state);
 }
 
-static ply_list_t *
-get_tracked_terminals (state_t *state)
+static void
+on_seat_added (state_t    *state,
+               ply_seat_t *seat)
 {
-  ply_list_t *terminals;
-  ply_list_node_t *node;
-
-  terminals = ply_list_new ();
+  ply_keyboard_t *keyboard;
 
-  node = ply_list_get_first_node (state->text_displays);
-  while (node != NULL)
+  if (state->boot_splash == NULL)
     {
-      ply_list_node_t *next_node;
-      ply_text_display_t *display;
-      ply_terminal_t *terminal;
+      ply_trace ("seat added before splash loaded, so loading splash now");
+      load_splash (state);
+    }
 
-      next_node = ply_list_get_next_node (state->text_displays, node);
-      display = ply_list_node_get_data (node);
-      terminal = ply_text_display_get_terminal (display);
+  if (state->boot_splash != NULL && state->is_shown)
+    {
+      ply_trace ("show-splash already requested, so showing splash now");
+      show_theme (state, state->boot_splash);
+    }
 
-      ply_list_append_data (terminals, terminal);
+  keyboard = ply_seat_get_keyboard (seat);
 
-      node = next_node;
-    }
+  ply_trace ("listening for keystrokes");
+  ply_keyboard_add_input_handler (keyboard,
+                                  (ply_keyboard_input_handler_t)
+                                  on_keyboard_input, state);
+  ply_trace ("listening for escape");
+  ply_keyboard_add_escape_handler (keyboard,
+                                   (ply_keyboard_escape_handler_t)
+                                   on_escape_pressed, state);
+  ply_trace ("listening for backspace");
+  ply_keyboard_add_backspace_handler (keyboard,
+                                      (ply_keyboard_backspace_handler_t)
+                                      on_backspace, state);
+  ply_trace ("listening for enter");
+  ply_keyboard_add_enter_handler (keyboard,
+                                  (ply_keyboard_enter_handler_t)
+                                  on_enter, state);
 
-  return terminals;
 }
 
 static void
-free_terminals (state_t    *state,
-                ply_list_t *terminals)
+load_devices (state_t                    *state,
+              ply_device_manager_flags_t  flags)
 {
-  ply_list_node_t *node;
-  node = ply_list_get_first_node (terminals);
-  while (node != NULL)
-    {
-      ply_list_node_t *next_node;
-      ply_terminal_t *terminal;
+  state->device_manager = ply_device_manager_new (state->default_tty, flags);
+  state->local_console_terminal = ply_device_manager_get_default_terminal (state->device_manager);
 
-      next_node = ply_list_get_next_node (state->text_displays, node);
-      terminal = ply_list_node_get_data (node);
-
-      ply_terminal_close (terminal);
-      ply_terminal_free (terminal);
-      ply_list_remove_node (terminals, node);
-
-      node = next_node;
-    }
-
-  ply_list_free (terminals);
+  ply_device_manager_watch_seats (state->device_manager,
+                                  (ply_seat_added_handler_t)
+                                  on_seat_added,
+                                  (ply_seat_removed_handler_t)
+                                  on_seat_removed,
+                                  state);
 }
 
 static void
 quit_splash (state_t *state)
 {
-  ply_list_t *terminals;
-
   ply_trace ("quiting splash");
   if (state->boot_splash != NULL)
     {
@@ -982,18 +968,6 @@ quit_splash (state_t *state)
       state->boot_splash = NULL;
     }
 
-  terminals = get_tracked_terminals (state);
-
-  ply_trace ("removing displays and keyboard");
-  remove_displays_and_keyboard (state);
-
-  if (state->renderer != NULL)
-    {
-      ply_renderer_close (state->renderer);
-      ply_renderer_free (state->renderer);
-      state->renderer = NULL;
-    }
-
   if (state->local_console_terminal != NULL)
     {
       if (!state->should_retain_splash)
@@ -1003,21 +977,30 @@ quit_splash (state_t *state)
         }
       state->local_console_terminal = NULL;
     }
-  free_terminals (state, terminals);
 
   detach_from_running_session (state);
 }
 
 static void
+hide_splash (state_t *state)
+{
+  if (state->boot_splash == NULL)
+    return;
+
+  ply_boot_splash_hide (state->boot_splash);
+
+  if (state->local_console_terminal != NULL)
+    ply_terminal_set_mode (state->local_console_terminal, PLY_TERMINAL_MODE_TEXT);
+}
+
+static void
 dump_details_and_quit_splash (state_t *state)
 {
   state->showing_details = false;
   toggle_between_splash_and_details (state);
 
-  if (state->renderer != NULL)
-    ply_renderer_deactivate (state->renderer);
-  if (state->boot_splash != NULL)
-    ply_boot_splash_hide (state->boot_splash);
+  ply_device_manager_deactivate_renderers (state->device_manager);
+  hide_splash (state);
 
   state->is_shown = false;
 
@@ -1051,6 +1034,9 @@ tell_gdm_to_transition (void)
 static void
 quit_program (state_t *state)
 {
+  ply_trace ("cleaning up devices");
+  ply_device_manager_free (state->device_manager);
+
   ply_trace ("exiting event loop");
   ply_event_loop_exit (state->loop, 0);
 
@@ -1086,11 +1072,7 @@ deactivate_splash (state_t *state)
 {
   assert (!state->is_inactive);
 
-  if (state->renderer != NULL)
-    {
-      ply_trace ("deactivating renderer");
-      ply_renderer_deactivate (state->renderer);
-    }
+  ply_device_manager_deactivate_renderers (state->device_manager);
 
   detach_from_running_session (state);
 
@@ -1128,10 +1110,8 @@ on_boot_splash_idle (state_t *state)
       if (!state->should_retain_splash)
         {
           ply_trace ("hiding splash");
-          if (state->renderer != NULL)
-            ply_renderer_deactivate (state->renderer);
-          if (state->boot_splash != NULL)
-            ply_boot_splash_hide (state->boot_splash);
+          ply_device_manager_deactivate_renderers (state->device_manager);
+          hide_splash (state);
 
           state->is_shown = false;
         }
@@ -1148,7 +1128,6 @@ on_boot_splash_idle (state_t *state)
     }
 }
 
-
 static void
 on_deactivate (state_t       *state,
                ply_trigger_t *deactivate_trigger)
@@ -1171,12 +1150,7 @@ on_deactivate (state_t       *state,
   state->deactivate_trigger = deactivate_trigger;
 
   ply_trace ("deactivating");
-
-  if (state->keyboard != NULL)
-    {
-      ply_trace ("deactivating keyboard");
-      ply_keyboard_stop_watching_for_input (state->keyboard);
-    }
+  ply_device_manager_deactivate_keyboards (state->device_manager);
 
   if (state->boot_splash != NULL)
     {
@@ -1212,17 +1186,8 @@ on_reactivate (state_t *state)
       attach_to_running_session (state);
     }
 
-  if (state->keyboard != NULL)
-    {
-      ply_trace ("activating keyboard");
-      ply_keyboard_watch_for_input (state->keyboard);
-    }
-
-  if (state->renderer != NULL)
-    {
-      ply_trace ("activating renderer");
-      ply_renderer_activate (state->renderer);
-    }
+  ply_device_manager_activate_keyboards (state->device_manager);
+  ply_device_manager_activate_renderers (state->device_manager);
 
   state->is_inactive = false;
 
@@ -1258,11 +1223,7 @@ on_quit (state_t       *state,
   if (state->session != NULL)
     ply_terminal_session_close_log (state->session);
 
-  if (state->keyboard != NULL)
-    {
-      ply_trace ("deactivating keyboard");
-      ply_keyboard_stop_watching_for_input (state->keyboard);
-    }
+  ply_device_manager_deactivate_keyboards (state->device_manager);
 
   ply_trace ("unloading splash");
   if (state->is_inactive && !retain_splash)
@@ -1376,23 +1337,22 @@ toggle_between_splash_and_details (state_t *state)
   if (state->boot_splash != NULL)
     {
       ply_trace ("hiding and freeing current splash");
-      ply_boot_splash_hide (state->boot_splash);
+      hide_splash (state);
       ply_boot_splash_free (state->boot_splash);
       state->boot_splash = NULL;
     }
 
   if (!state->showing_details)
     {
-      show_detailed_splash (state);
+      load_detailed_splash (state);
       state->showing_details = true;
     }
   else
     {
-      show_default_splash (state);
+      load_default_splash (state);
       state->showing_details = false;
     }
-  update_display (state);
-  show_messages (state);
+  show_theme (state, state->boot_splash);
 }
 
 static void
@@ -1504,140 +1464,23 @@ on_enter (state_t                  *state,
 }
 
 static void
-set_keyboard (state_t        *state,
-              ply_keyboard_t *keyboard)
-{
-  state->keyboard = keyboard;
-
-  ply_keyboard_add_escape_handler (keyboard, (ply_keyboard_escape_handler_t)
-                                   on_escape_pressed, state);
-  ply_trace ("listening for keystrokes");
-  ply_keyboard_add_input_handler (keyboard,
-                                  (ply_keyboard_input_handler_t)
-                                  on_keyboard_input, state);
-  ply_trace ("listening for backspace");
-  ply_keyboard_add_backspace_handler (keyboard,
-                                      (ply_keyboard_backspace_handler_t)
-                                      on_backspace, state);
-  ply_trace ("listening for enter");
-  ply_keyboard_add_enter_handler (keyboard,
-                                  (ply_keyboard_enter_handler_t)
-                                  on_enter, state);
-}
-static void
-add_display_and_keyboard_for_terminal (state_t        *state,
-                                       ply_terminal_t *terminal)
-{
-  ply_text_display_t *display;
-  ply_keyboard_t *keyboard;
-
-  keyboard = ply_keyboard_new_for_terminal (terminal);
-  display = ply_text_display_new (terminal);
-
-  ply_list_append_data (state->text_displays, display);
-  set_keyboard (state, keyboard);
-}
-
-static void
-add_pixel_displays_from_renderer (state_t        *state,
-                                  ply_renderer_t *renderer)
-{
-  ply_list_t *heads;
-  ply_list_node_t *node;
-
-  heads = ply_renderer_get_heads (renderer);
-
-  ply_trace ("Adding displays for %d heads",
-             ply_list_get_length (heads));
-
-  node = ply_list_get_first_node (heads);
-  while (node != NULL)
-    {
-      ply_list_node_t *next_node;
-      ply_renderer_head_t *head;
-      ply_pixel_display_t *display;
-
-      head = ply_list_node_get_data (node);
-      next_node = ply_list_get_next_node (heads, node);
-
-      display = ply_pixel_display_new (renderer, head);
-
-      ply_list_append_data (state->pixel_displays, display);
-
-      node = next_node;
-    }
-
-}
-
-static void
-add_default_displays_and_keyboard (state_t *state)
+attach_splash_to_seats (state_t *state)
 {
-  ply_renderer_t *renderer;
-  ply_keyboard_t *keyboard;
-  ply_text_display_t *text_display;
-
-  ply_trace ("adding default displays and keyboard");
 
-  state->local_console_terminal = ply_terminal_new (state->default_tty);
-
-  renderer = ply_renderer_new (NULL, NULL, state->local_console_terminal);
-
-  if (!ply_renderer_open (renderer))
-    {
-      ply_trace ("could not open renderer /dev/fb");
-      ply_renderer_free (renderer);
-
-      ply_trace ("adding text display and keyboard for %s", state->default_tty);
-      add_display_and_keyboard_for_terminal (state, state->local_console_terminal);
-      return;
-    }
-
-  keyboard = ply_keyboard_new_for_renderer (renderer);
-  set_keyboard (state, keyboard);
-
-  add_pixel_displays_from_renderer (state, renderer);
-
-  text_display = ply_text_display_new (state->local_console_terminal);
-  ply_list_append_data (state->text_displays, text_display);
-
-  state->renderer = renderer;
-}
-
-static void
-add_displays_and_keyboard_to_boot_splash (state_t           *state,
-                                          ply_boot_splash_t *splash)
-{
+  ply_list_t *seats;
   ply_list_node_t *node;
 
-  ply_trace ("setting keyboard on boot splash");
-  if (state->keyboard != NULL)
-    ply_boot_splash_set_keyboard (splash, state->keyboard);
-
-  node = ply_list_get_first_node (state->pixel_displays);
-  while (node != NULL)
-    {
-      ply_pixel_display_t *display;
-      ply_list_node_t *next_node;
-
-      display = ply_list_node_get_data (node);
-      next_node = ply_list_get_next_node (state->pixel_displays, node);
-      ply_trace ("adding pixel display on boot splash");
-      ply_boot_splash_add_pixel_display (splash, display);
-
-      node = next_node;
-    }
-
-  node = ply_list_get_first_node (state->text_displays);
+  seats = ply_device_manager_get_seats (state->device_manager);
+  node = ply_list_get_first_node (seats);
   while (node != NULL)
     {
-      ply_text_display_t *display;
+      ply_seat_t *seat;
       ply_list_node_t *next_node;
 
-      display = ply_list_node_get_data (node);
-      next_node = ply_list_get_next_node (state->text_displays, node);
+      seat = ply_list_node_get_data (node);
+      next_node = ply_list_get_next_node (seats, node);
 
-      ply_trace ("adding text display on boot splash");
-      ply_boot_splash_add_text_display (splash, display);
+      ply_boot_splash_attach_to_seat (state->boot_splash, seat);
 
       node = next_node;
     }
@@ -1662,12 +1505,41 @@ tell_systemd_to_stop_printing_details (state_t *state)
 #endif
 
 static ply_boot_splash_t *
-start_boot_splash (state_t    *state,
-                   const char *theme_path,
-                   bool        fall_back_if_neccessary)
+load_built_in_theme (state_t *state)
+{
+  ply_boot_splash_t *splash;
+  bool is_loaded;
+
+  ply_trace ("Loading built-in theme");
+
+  splash = ply_boot_splash_new ("",
+                                PLYMOUTH_PLUGIN_PATH,
+                                state->boot_buffer);
+
+  is_loaded = ply_boot_splash_load_built_in (splash);
+
+  if (!is_loaded)
+    {
+      ply_save_errno ();
+      ply_boot_splash_free (splash);
+      ply_restore_errno ();
+      return NULL;
+    }
+
+  ply_trace ("attaching plugin to event loop");
+  ply_boot_splash_attach_to_event_loop (splash, state->loop);
+
+  ply_trace ("attaching progress to plugin");
+  ply_boot_splash_attach_progress (splash, state->progress);
+
+  return splash;
+}
+
+static ply_boot_splash_t *
+load_theme (state_t    *state,
+            const char *theme_path)
 {
   ply_boot_splash_t *splash;
-  ply_boot_splash_mode_t splash_mode;
   bool is_loaded;
 
   ply_trace ("Loading boot splash theme '%s'",
@@ -1678,13 +1550,6 @@ start_boot_splash (state_t    *state,
                                 state->boot_buffer);
 
   is_loaded = ply_boot_splash_load (splash);
-  if (!is_loaded && fall_back_if_neccessary)
-    {
-      ply_trace ("Splash couldn't be loaded: %m");
-
-      ply_trace ("Loading built in splash");
-      is_loaded = ply_boot_splash_load_built_in (splash);
-    }
 
   if (!is_loaded)
     {
@@ -1700,7 +1565,17 @@ start_boot_splash (state_t    *state,
   ply_trace ("attaching progress to plugin");
   ply_boot_splash_attach_progress (splash, state->progress);
 
-  add_displays_and_keyboard_to_boot_splash (state, splash);
+  return splash;
+}
+
+static void
+show_theme (state_t           *state,
+            ply_boot_splash_t *splash)
+{
+  ply_boot_splash_mode_t splash_mode;
+
+  attach_splash_to_seats (state);
+  ply_device_manager_activate_renderers (state->device_manager);
 
   ply_trace ("showing plugin");
   if (state->mode == PLY_MODE_SHUTDOWN)
@@ -1711,10 +1586,9 @@ start_boot_splash (state_t    *state,
   if (!ply_boot_splash_show (splash, splash_mode))
     {
       ply_save_errno ();
-      ply_boot_splash_unset_keyboard (splash);
       ply_boot_splash_free (splash);
       ply_restore_errno ();
-      return NULL;
+      return;
     }
 
 #ifdef PLY_ENABLE_SYSTEMD_INTEGRATION
@@ -1722,11 +1596,9 @@ start_boot_splash (state_t    *state,
     tell_systemd_to_print_details (state);
 #endif
 
-  if (state->keyboard != NULL)
-    ply_keyboard_watch_for_input (state->keyboard);
-
+  ply_device_manager_activate_keyboards (state->device_manager);
+  show_messages (state);
   update_display (state);
-  return splash;
 }
 
 static bool
@@ -1904,10 +1776,7 @@ check_verbosity (state_t *state)
             const char* device;
             char *file;
 
-            if (state->kernel_console_tty != NULL)
-                device = state->kernel_console_tty;
-            else
-                device = state->default_tty;
+            device = state->default_tty;
 
             ply_trace ("redirecting debug output to %s", device);
 
@@ -1962,237 +1831,6 @@ check_logging (state_t *state)
     }
 }
 
-static void
-add_display_and_keyboard_for_console (const char *console,
-                                      const char *null,
-                                      state_t    *state)
-{
-  ply_terminal_t *terminal;
-
-  terminal = ply_terminal_new (console);
-
-  if (strcmp (console, state->default_tty) == 0)
-    state->local_console_terminal = terminal;
-
-  ply_trace ("adding display and keyboard for console %s", console);
-  add_display_and_keyboard_for_terminal (state, terminal);
-}
-
-static int
-add_consoles_from_file (state_t         *state,
-                        ply_hashtable_t *consoles,
-                        const char      *path)
-{
-  int fd;
-  char contents[512] = "";
-  ssize_t contents_length;
-  int num_consoles;
-  const char *remaining_file_contents;
-
-  ply_trace ("opening %s", path);
-  fd = open (path, O_RDONLY);
-
-  if (fd < 0)
-    {
-      ply_trace ("couldn't open it: %m");
-      return 0;
-    }
-
-  ply_trace ("reading file");
-  contents_length = read (fd, contents, sizeof (contents) - 1);
-
-  if (contents_length <= 0)
-    {
-      ply_trace ("couldn't read it: %m");
-      close (fd);
-      return 0;
-    }
-  close (fd);
-
-  remaining_file_contents = contents;
-  num_consoles = 0;
-
-  while (remaining_file_contents < contents + contents_length)
-    {
-      char *console;
-      size_t console_length;
-      char *console_device;
-
-      /* Advance past any leading whitespace */
-      remaining_file_contents += strspn (remaining_file_contents, " \n\t\v");
-
-      if (*remaining_file_contents == '\0')
-        {
-          /* There's nothing left after the whitespace, we're done */
-          break;
-        }
-
-      /* Find trailing whitespace and NUL terminate.  If strcspn
-       * doesn't find whitespace, it gives us the length of the string
-       * until the next NUL byte, which we'll just overwrite with
-       * another NUL byte anyway. */
-      console_length = strcspn (remaining_file_contents, " \n\t\v");
-      console = strndup (remaining_file_contents, console_length);
-
-      /* If this console is anything besides tty0, then the user is sort
-       * of a weird case (uses a serial console or whatever) and they
-       * most likely don't want a graphical splash, so force details.
-       */
-      if (strcmp (console, "tty0") != 0)
-        state->should_force_details = true;
-
-      asprintf (&console_device, "/dev/%s", console);
-
-      free (console);
-
-      ply_trace ("console %s found!", console_device);
-      ply_hashtable_insert (consoles, console_device, console_device);
-      num_consoles++;
-
-      /* Move past the parsed console string, and the whitespace we
-       * may have found above.  If we found a NUL above and not whitespace,
-       * then we're going to jump past the end of the buffer and the loop
-       * will terminate
-       */
-      remaining_file_contents += console_length + 1;
-    }
-
-  return num_consoles;
-}
-
-static int
-add_consoles_from_kernel_command_line (state_t         *state,
-                                       ply_hashtable_t *consoles)
-{
-  const char *console_string;
-  const char *remaining_command_line;
-  char *console;
-  int num_consoles;
-
-  remaining_command_line = state->kernel_command_line;
-
-  num_consoles = 0;
-  console = NULL;
-  while ((console_string = command_line_get_string_after_prefix (remaining_command_line,
-                                                                 "console=")) != NULL)
-    {
-      char *end;
-      size_t console_length;
-      char *console_device;
-
-      remaining_command_line = console_string;
-
-      state->should_force_details = true;
-
-      console = strdup (console_string);
-
-      end = strpbrk (console, " \n\t\v,");
-
-      if (end != NULL)
-        *end = '\0';
-
-      console_length = strlen (console);
-
-      if (strncmp (console, "/dev/", strlen ("/dev/")) == 0)
-        {
-          console_device = console;
-          console = NULL;
-        }
-      else
-        {
-          asprintf (&console_device, "/dev/%s", console);
-          free (console);
-          console = NULL;
-        }
-
-      ply_trace ("console %s found!", console_device);
-      ply_hashtable_insert (consoles, console_device, console_device);
-      num_consoles++;
-      remaining_command_line += console_length;
-    }
-
-  return num_consoles;
-}
-
-static void
-check_for_consoles (state_t    *state,
-                    const char *default_tty,
-                    bool        should_add_displays)
-{
-  char *console;
-  ply_hashtable_t *consoles;
-  int num_consoles;
-  bool ignore_serial_consoles;
-
-  ply_trace ("checking for consoles%s",
-             should_add_displays? " and adding displays": "");
-
-  consoles = ply_hashtable_new (ply_hashtable_string_hash,
-                                ply_hashtable_string_compare);
-  ignore_serial_consoles = command_line_has_argument (state->kernel_command_line, "plymouth.ignore-serial-consoles");
-
-  num_consoles = 0;
-
-  if (!ignore_serial_consoles)
-    {
-      num_consoles = add_consoles_from_file (state, consoles, "/sys/class/tty/console/active");
-
-      if (num_consoles == 0)
-        {
-          ply_trace ("falling back to kernel command line");
-          num_consoles = add_consoles_from_kernel_command_line (state, consoles);
-        }
-    }
-  else
-    {
-      ply_trace ("ignoring all consoles but default console because of plymouth.ignore-serial-consoles");
-    }
-
-  console = ply_hashtable_remove (consoles, (void *) "/dev/tty0");
-  if (console != NULL)
-    {
-      free (console);
-      console = strdup (default_tty);
-      ply_hashtable_insert (consoles, console, console);
-    }
-
-  console = ply_hashtable_remove (consoles, (void *) "/dev/tty");
-  if (console != NULL)
-    {
-      free (console);
-      console = strdup (default_tty);
-      ply_hashtable_insert (consoles, console, console);
-    }
-
-  free (state->kernel_console_tty);
-  state->kernel_console_tty = NULL;
-
-  if (console != NULL)
-    state->kernel_console_tty = strdup (console);
-
-  if (should_add_displays)
-    {
-      /* Do a full graphical splash if there's no weird serial console
-       * stuff going on, otherwise just prepare text splashes
-       */
-      if ((num_consoles == 0) ||
-          ((num_consoles == 1) &&
-           (ply_hashtable_lookup (consoles, (void *) default_tty) != NULL)))
-        add_default_displays_and_keyboard (state);
-      else
-        ply_hashtable_foreach (consoles,
-                               (ply_hashtable_foreach_func_t *)
-                               add_display_and_keyboard_for_console,
-                               state);
-    }
-
-  ply_hashtable_foreach (consoles, (ply_hashtable_foreach_func_t *) free, NULL);
-  ply_hashtable_free (consoles);
-
-  ply_trace ("After processing serial consoles there are now %d text displays",
-             ply_list_get_length (state->text_displays));
-}
-
 static bool
 redirect_standard_io_to_dev_null (void)
 {
@@ -2274,13 +1912,7 @@ initialize_environment (state_t *state)
   state->keystroke_triggers = ply_list_new ();
   state->entry_triggers = ply_list_new ();
   state->entry_buffer = ply_buffer_new();
-  state->pixel_displays = ply_list_new ();
-  state->text_displays = ply_list_new ();
   state->messages = ply_list_new ();
-  state->keyboard = NULL;
-
-
-  check_for_consoles (state, state->default_tty, false);
 
   redirect_standard_io_to_dev_null ();
 
@@ -2390,6 +2022,7 @@ main (int    argc,
   char *mode_string = NULL;
   char *kernel_command_line = NULL;
   char *tty = NULL;
+  ply_device_manager_flags_t device_manager_flags = PLY_DEVICE_MANAGER_FLAGS_NONE;
 
   state.command_parser = ply_command_parser_new ("plymouthd", "Splash server");
 
@@ -2564,6 +2197,15 @@ main (int    argc,
       return EX_UNAVAILABLE;
     }
 
+  if (command_line_has_argument (state.kernel_command_line, "plymouth.ignore-serial-consoles"))
+    device_manager_flags |= PLY_DEVICE_MANAGER_FLAGS_IGNORE_SERIAL_CONSOLES;
+
+  if (command_line_has_argument (state.kernel_command_line, "plymouth.ignore-udev") ||
+      (getenv ("DISPLAY") != NULL))
+    device_manager_flags |= PLY_DEVICE_MANAGER_FLAGS_IGNORE_UDEV;
+
+  load_devices (&state, device_manager_flags);
+
   ply_trace ("entering event loop");
   exit_code = ply_event_loop_run (state.loop);
   ply_trace ("exited event loop");
diff --git a/src/plugins/renderers/drm/plugin.c b/src/plugins/renderers/drm/plugin.c
index 945f15e6..6677279d 100644
--- a/src/plugins/renderers/drm/plugin.c
+++ b/src/plugins/renderers/drm/plugin.c
@@ -522,6 +522,9 @@ open_device (ply_renderer_backend_t *backend)
   if (!load_driver (backend))
     return false;
 
+  if (backend->terminal == NULL)
+    return true;
+
   if (!ply_terminal_open (backend->terminal))
     {
       ply_trace ("could not open terminal: %m");
@@ -550,10 +553,11 @@ close_device (ply_renderer_backend_t *backend)
 
   free_heads (backend);
 
-  ply_terminal_stop_watching_for_active_vt_change (backend->terminal,
-                                                   (ply_terminal_active_vt_changed_handler_t)
-                                                   on_active_vt_changed,
-                                                   backend);
+  if (backend->terminal != NULL)
+    ply_terminal_stop_watching_for_active_vt_change (backend->terminal,
+                                                     (ply_terminal_active_vt_changed_handler_t)
+                                                     on_active_vt_changed,
+                                                     backend);
 
   unload_driver (backend);
 }
@@ -888,10 +892,17 @@ map_to_device (ply_renderer_backend_t *backend)
       node = next_node;
     }
 
-  if (ply_terminal_is_active (backend->terminal))
-    activate (backend);
+  if (backend->terminal != NULL)
+    {
+      if (ply_terminal_is_active (backend->terminal))
+        activate (backend);
+      else
+        ply_terminal_activate_vt (backend->terminal);
+    }
   else
-    ply_terminal_activate_vt (backend->terminal);
+    {
+      activate (backend);
+    }
 
   return head_mapped;
 }
@@ -1019,8 +1030,11 @@ reset_scan_out_buffer_if_needed (ply_renderer_backend_t *backend,
   drmModeCrtc *controller;
   bool did_reset = false;
 
-  if (!ply_terminal_is_active (backend->terminal))
-    return false;
+  if (backend->terminal != NULL)
+    {
+      if (!ply_terminal_is_active (backend->terminal))
+        return false;
+    }
 
   controller = drmModeGetCrtc (backend->device_fd, head->controller_id);
 
@@ -1054,8 +1068,11 @@ flush_head (ply_renderer_backend_t *backend,
   if (!backend->is_active)
     return;
 
-  ply_terminal_set_mode (backend->terminal, PLY_TERMINAL_MODE_GRAPHICS);
-  ply_terminal_set_unbuffered_input (backend->terminal);
+  if (backend->terminal != NULL)
+    {
+      ply_terminal_set_mode (backend->terminal, PLY_TERMINAL_MODE_GRAPHICS);
+      ply_terminal_set_unbuffered_input (backend->terminal);
+    }
   pixel_buffer = head->pixel_buffer;
   updated_region = ply_pixel_buffer_get_updated_areas (pixel_buffer);
   areas_to_flush = ply_region_get_sorted_rectangle_list (updated_region);
@@ -1163,6 +1180,9 @@ open_input_source (ply_renderer_backend_t      *backend,
   assert (backend != NULL);
   assert (has_input_source (backend, input_source));
 
+  if (backend->terminal == NULL)
+    return false;
+
   terminal_fd = ply_terminal_get_fd (backend->terminal);
 
   input_source->backend = backend;
@@ -1193,6 +1213,9 @@ close_input_source (ply_renderer_backend_t      *backend,
   assert (backend != NULL);
   assert (has_input_source (backend, input_source));
 
+  if (backend->terminal == NULL)
+    return;
+
   ply_event_loop_stop_watching_fd (backend->loop, input_source->terminal_input_watch);
   input_source->terminal_input_watch = NULL;
   input_source->backend = NULL;
diff --git a/src/plugins/renderers/frame-buffer/plugin.c b/src/plugins/renderers/frame-buffer/plugin.c
index 0e079431..dd73a0f7 100644
--- a/src/plugins/renderers/frame-buffer/plugin.c
+++ b/src/plugins/renderers/frame-buffer/plugin.c
@@ -351,6 +351,9 @@ open_device (ply_renderer_backend_t *backend)
       return false;
     }
 
+  if (backend->terminal == NULL)
+    return true;
+
   if (!ply_terminal_open (backend->terminal))
     {
       ply_trace ("could not open terminal: %m");
@@ -376,10 +379,11 @@ static void
 close_device (ply_renderer_backend_t *backend)
 {
 
-  ply_terminal_stop_watching_for_active_vt_change (backend->terminal,
-                                                   (ply_terminal_active_vt_changed_handler_t)
-                                                   on_active_vt_changed,
-                                                   backend);
+  if (backend->terminal != NULL)
+    ply_terminal_stop_watching_for_active_vt_change (backend->terminal,
+                                                     (ply_terminal_active_vt_changed_handler_t)
+                                                     on_active_vt_changed,
+                                                     backend);
   uninitialize_head (backend, &backend->head);
 
   close (backend->device_fd);
@@ -546,15 +550,22 @@ map_to_device (ply_renderer_backend_t *backend)
       return false;
     }
 
-  if (ply_terminal_is_active (backend->terminal))
+  if (backend->terminal != NULL)
     {
-      ply_trace ("already on right vt, activating");
-      activate (backend);
+      if (ply_terminal_is_active (backend->terminal))
+        {
+          ply_trace ("already on right vt, activating");
+          activate (backend);
+        }
+      else
+        {
+          ply_trace ("on wrong vt, changing vts");
+          ply_terminal_activate_vt (backend->terminal);
+        }
     }
   else
     {
-      ply_trace ("on wrong vt, changing vts");
-      ply_terminal_activate_vt (backend->terminal);
+      activate (backend);
     }
 
   return true;
@@ -590,8 +601,11 @@ flush_head (ply_renderer_backend_t *backend,
   if (!backend->is_active)
     return;
 
-  ply_terminal_set_mode (backend->terminal, PLY_TERMINAL_MODE_GRAPHICS);
-  ply_terminal_set_unbuffered_input (backend->terminal);
+  if (backend->terminal != NULL)
+    {
+      ply_terminal_set_mode (backend->terminal, PLY_TERMINAL_MODE_GRAPHICS);
+      ply_terminal_set_unbuffered_input (backend->terminal);
+    }
   pixel_buffer = head->pixel_buffer;
   updated_region = ply_pixel_buffer_get_updated_areas (pixel_buffer);
   areas_to_flush = ply_region_get_sorted_rectangle_list (updated_region);
@@ -685,6 +699,9 @@ open_input_source (ply_renderer_backend_t      *backend,
   assert (backend != NULL);
   assert (has_input_source (backend, input_source));
 
+  if (backend->terminal == NULL)
+    return false;
+
   terminal_fd = ply_terminal_get_fd (backend->terminal);
 
   input_source->backend = backend;
@@ -715,6 +732,9 @@ close_input_source (ply_renderer_backend_t      *backend,
   assert (backend != NULL);
   assert (has_input_source (backend, input_source));
 
+  if (backend->terminal == NULL)
+    return;
+
   ply_event_loop_stop_watching_fd (backend->loop, input_source->terminal_input_watch);
   input_source->terminal_input_watch = NULL;
   input_source->backend = NULL;
diff --git a/src/ply-boot-server.c b/src/ply-boot-server.c
index 2d2a5b85..3e67bfbf 100644
--- a/src/ply-boot-server.c
+++ b/src/ply-boot-server.c
@@ -831,183 +831,4 @@ ply_boot_server_attach_to_event_loop (ply_boot_server_t *server,
                                  server); 
 }
 
-#ifdef PLY_BOOT_SERVER_ENABLE_TEST
-
-#include <stdio.h>
-
-#include "ply-event-loop.h"
-#include "ply-boot-server.h"
-
-static void 
-on_update (ply_event_loop_t  *loop,
-           const char        *status)
-{
-  printf ("new status is '%s'\n", status);
-}
-
-static void
-on_newroot (ply_event_loop_t *loop)
-{
-  printf ("got newroot request\n");
-}
-
-static void
-on_system_initialized (ply_event_loop_t *loop)
-{
-  printf ("got sysinit done request\n");
-}
-
-static void
-on_show_splash (ply_event_loop_t *loop)
-{
-  printf ("got show splash request\n");
-}
-
-static void
-on_hide_splash (ply_event_loop_t *loop)
-{
-  printf ("got hide splash request\n");
-}
-
-static void
-on_deactivate (ply_event_loop_t *loop)
-{
-  printf ("got deactivate request\n");
-}
-
-static void
-on_reactivate (ply_event_loop_t *loop)
-{
-  printf ("got reactivate request\n");
-}
-
-static void
-on_quit (ply_event_loop_t *loop)
-{
-  printf ("got quit request, quiting...\n");
-  ply_event_loop_exit (loop, 0);
-}
-
-static void
-on_error (ply_event_loop_t *loop)
-{
-  printf ("got error starting service\n");
-}
-
-static char *
-on_ask_for_password (ply_event_loop_t *loop)
-{
-  printf ("got password request, returning 'password'...\n");
-
-  return strdup ("password");
-}
-
-static void
-on_ask_question (ply_event_loop_t *loop)
-{
-  printf ("got question request\n");
-  return;
-}
-
-static void
-on_display_message (ply_event_loop_t *loop)
-{
-  printf ("got display message request\n");
-  return;
-}
-
-static void
-on_hide_message (ply_event_loop_t *loop)
-{
-  printf ("got hide message request\n");
-  return;
-}
-
-static void
-on_watch_for_keystroke (ply_event_loop_t *loop)
-{
-  printf ("got keystroke request\n");
-
-  return;
-}
-
-static void
-on_progress_pause (ply_event_loop_t *loop)
-{
-  printf ("got progress pause request\n");
-
-  return;
-}
-
-static void
-on_progress_unpause (ply_event_loop_t *loop)
-{
-  printf ("got progress unpause request\n");
-
-  return;
-}
-
-static void
-on_ignore_keystroke (ply_event_loop_t *loop)
-{
-  printf ("got keystroke ignore request\n");
-
-  return;
-}
-
-static bool
-on_has_active_vt (ply_event_loop_t *loop)
-{
-  printf ("got has_active vt? request\n");
-  return true;
-}
-
-int
-main (int    argc,
-      char **argv)
-{
-  ply_event_loop_t *loop;
-  ply_boot_server_t *server;
-  int exit_code;
-
-  exit_code = 0;
-
-  loop = ply_event_loop_new ();
-
-  server = ply_boot_server_new ((ply_boot_server_update_handler_t) on_update,
-                                (ply_boot_server_change_mode_handler_t) on_change_mode,
-                                (ply_boot_server_system_update_handler_t) on_system_update,
-                                (ply_boot_server_ask_for_password_handler_t) on_ask_for_password,
-                                (ply_boot_server_ask_question_handler_t) on_ask_question,
-                                (ply_boot_server_display_message_handler_t) on_display_message,
-                                (ply_boot_server_hide_message_handler_t) on_hide_message,
-                                (ply_boot_server_watch_for_keystroke_handler_t) on_watch_for_keystroke,
-                                (ply_boot_server_ignore_keystroke_handler_t) on_ignore_keystroke,
-                                (ply_boot_server_progress_pause_handler_t) on_progress_pause,
-                                (ply_boot_server_progress_unpause_handler_t) on_progress_unpause,
-                                (ply_boot_server_show_splash_handler_t) on_show_splash,
-                                (ply_boot_server_hide_splash_handler_t) on_hide_splash,
-                                (ply_boot_server_newroot_handler_t) on_newroot,
-                                (ply_boot_server_system_initialized_handler_t) on_system_initialized,
-                                (ply_boot_server_error_handler_t) on_error,
-                                (ply_boot_server_deactivate_handler_t) on_deactivate,
-                                (ply_boot_server_reactivate_handler_t) on_reactivate,
-                                (ply_boot_server_quit_handler_t) on_quit,
-                                (ply_boot_server_has_active_vt_handler_t) on_has_active_vt,
-                                loop);
-
-  if (!ply_boot_server_listen (server))
-    {
-      perror ("could not start boot status daemon");
-      return errno;
-    }
-
-  ply_boot_server_attach_to_event_loop (server, loop);
-  exit_code = ply_event_loop_run (loop);
-  ply_boot_server_free (server);
-
-  return exit_code;
-}
-
-#endif /* PLY_BOOT_SERVER_ENABLE_TEST */
 /* vim: set ts=4 sw=4 expandtab autoindent cindent cino={.5s,(0: */
diff --git a/src/tests/Makefile.am b/src/tests/Makefile.am
deleted file mode 100644
index 86a8ea61..00000000
--- a/src/tests/Makefile.am
+++ /dev/null
@@ -1,18 +0,0 @@
-INCLUDES =                                                                    \
-           -I$(top_srcdir)                                                    \
-           -I$(srcdir)/..                                                     \
-           -I$(srcdir)/../libply                                              \
-           -I$(srcdir)/../libply-splash-core                                  \
-           -I$(srcdir)
-TESTS =
-
-if ENABLE_TESTS
-include $(srcdir)/ply-boot-server-test.am
-include $(srcdir)/ply-boot-splash-test.am
-endif
-
-noinst_PROGRAMS = $(TESTS)
-
-# our tests aren't unit tests, so clear for now
-TESTS =
-MAINTAINERCLEANFILES = Makefile.in
diff --git a/src/tests/ply-boot-server-test.am b/src/tests/ply-boot-server-test.am
deleted file mode 100644
index cc283487..00000000
--- a/src/tests/ply-boot-server-test.am
+++ /dev/null
@@ -1,8 +0,0 @@
-TESTS += ply-boot-server-test
-
-ply_boot_server_test_CFLAGS = $(PLYMOUTH_CFLAGS) -DPLY_BOOT_SERVER_ENABLE_TEST
-ply_boot_server_test_LDADD = $(PLYMOUTH_LIBS) ../libply/libply.la
-
-ply_boot_server_test_SOURCES =                                                \
-                          $(srcdir)/../ply-boot-server.h                      \
-                          $(srcdir)/../ply-boot-server.c
diff --git a/src/tests/ply-boot-splash-test.am b/src/tests/ply-boot-splash-test.am
deleted file mode 100644
index 9dd15989..00000000
--- a/src/tests/ply-boot-splash-test.am
+++ /dev/null
@@ -1,25 +0,0 @@
-TESTS += ply-boot-splash-test
-
-ply_boot_splash_test_CFLAGS = $(PLYMOUTH_CFLAGS) -DPLY_BOOT_SPLASH_ENABLE_TEST  \
-                        -DPLYMOUTH_TIME_DIRECTORY=\"/var/lib/plymouth\"         \
-                        -DPLYMOUTH_PLUGIN_PATH=\"$(PLYMOUTH_PLUGIN_PATH)\"      \
-                        -DPLYMOUTH_THEME_PATH=\"$(PLYMOUTH_THEME_PATH)/\"
-
-ply_boot_splash_test_LDADD = $(PLYMOUTH_LIBS) ../libply/libply.la
-
-ply_boot_splash_test_SOURCES =                                                   \
-                          $(srcdir)/../libply-splash-core/ply-boot-splash-plugin.h \
-                          $(srcdir)/../libply-splash-core/ply-keyboard.h           \
-                          $(srcdir)/../libply-splash-core/ply-keyboard.c           \
-                          $(srcdir)/../libply-splash-core/ply-pixel-buffer.h       \
-                          $(srcdir)/../libply-splash-core/ply-pixel-buffer.c       \
-                          $(srcdir)/../libply-splash-core/ply-pixel-display.h      \
-                          $(srcdir)/../libply-splash-core/ply-pixel-display.c      \
-                          $(srcdir)/../libply-splash-core/ply-renderer.h           \
-                          $(srcdir)/../libply-splash-core/ply-renderer.c           \
-                          $(srcdir)/../libply-splash-core/ply-terminal.h           \
-                          $(srcdir)/../libply-splash-core/ply-terminal.c           \
-                          $(srcdir)/../libply-splash-core/ply-text-display.h       \
-                          $(srcdir)/../libply-splash-core/ply-text-display.c       \
-                          $(srcdir)/../libply-splash-core/ply-boot-splash.h        \
-                          $(srcdir)/../libply-splash-core/ply-boot-splash.c
diff --git a/systemd-units/plymouth-start.service.in b/systemd-units/plymouth-start.service.in
index 446fb32b..078840c7 100644
--- a/systemd-units/plymouth-start.service.in
+++ b/systemd-units/plymouth-start.service.in
@@ -8,7 +8,7 @@ ConditionKernelCommandLine=!plymouth.enable=0
 
 [Service]
 ExecStart=@PLYMOUTH_DAEMON_DIR@/plymouthd --mode=boot --pid-file=@plymouthruntimedir@/pid --attach-to-session
-ExecStartPost=-@UDEVADM@ settle --timeout=30 --exit-if-exists=/sys/class/drm/card0/dev ; -@UDEVADM@ settle --timeout=30 --exit-if-exists=/sys/class/graphics/fb0/dev ; -@PLYMOUTH_CLIENT_DIR@/plymouth show-splash
+ExecStartPost=-@PLYMOUTH_CLIENT_DIR@/plymouth show-splash
 Type=forking
 KillMode=none
 SendSIGKILL=no