diff --git a/core/audio.c b/core/audio.c
index 731995d5..9bdc58a8 100644
--- a/core/audio.c
+++ b/core/audio.c
@@ -54,8 +54,8 @@ static struct track *__audio_load_basic(struct track *track, GstState state)
 	__audio_change_state(state);
 
 	tempq_updated(prev);
-	queue_updated(playlist_get_queue("Collection"), prev);
-	queue_updated(playlist_get_queue("Collection"), audio_track);
+	queue_updated(playlist_get_queue(PL_SYSTEM, "Collection"), prev);
+	queue_updated(playlist_get_queue(PL_SYSTEM, "Collection"), audio_track);
 
 	__audio_save();
 	g_free(uri);
@@ -66,7 +66,7 @@ static struct track *__audio_load_basic(struct track *track, GstState state)
 static struct track *__audio_load(struct track *track, GstState state)
 {
 	if (__audio_load_basic(track, state))
-		playlist_add("History", track);
+		playlist_add(PL_SYSTEM, "History", track);
 	return track;
 }
 
@@ -216,9 +216,9 @@ struct track *audio_eos()
 	/* Mark current track as played */
 	if (audio_track) {
 		track_played(audio_track);
-		playlist_update("Unplayed");
-		playlist_update("Most Played");
-		playlist_update("Least Played");
+		playlist_update(PL_SYSTEM, "Unplayed");
+		playlist_update(PL_SYSTEM, "Most Played");
+		playlist_update(PL_SYSTEM, "Least Played");
 	}
 
 	/* Check pause count and pick the next track */
diff --git a/core/collection.c b/core/collection.c
index b4a51154..04acbccd 100644
--- a/core/collection.c
+++ b/core/collection.c
@@ -52,8 +52,8 @@ static void __scan_path(struct scan_data *scan, const gchar *name)
 	else {
 		track = track_add(scan->sd_lib, path);
 		if (track) {
-			playlist_add("Collection", track);
-			playlist_add("Unplayed", track);
+			playlist_add(PL_SYSTEM, "Collection", track);
+			playlist_add(PL_SYSTEM, "Unplayed", track);
 		}
 	}
 
@@ -106,12 +106,12 @@ static bool __validate_library(void *data)
 		if (access < 0) {
 			if (collection_check_library(library) < 0)
 				return true;
-			playlist_remove("Collection", track);
-			playlist_remove("Favorites", track);
-			playlist_remove("Hidden", track);
-			playlist_remove("Least Played", track);
-			playlist_remove("Most Played", track);
-			playlist_remove("Unplayed", track);
+			playlist_remove(PL_SYSTEM, "Collection", track);
+			playlist_remove(PL_SYSTEM, "Favorites", track);
+			playlist_remove(PL_SYSTEM, "Hidden", track);
+			playlist_remove(PL_SYSTEM, "Least Played", track);
+			playlist_remove(PL_SYSTEM, "Most Played", track);
+			playlist_remove(PL_SYSTEM, "Unplayed", track);
 			track_remove(track);
 		}
 	}
@@ -194,9 +194,9 @@ void collection_set_enabled(struct library *library, bool enabled)
 		track = TRACK(dbe);
 		if (track->tr_library == library) {
 			if (enabled)
-				playlist_add("Collection", track);
+				playlist_add(PL_SYSTEM, "Collection", track);
 			else
-				playlist_remove("Collection", track);
+				playlist_remove(PL_SYSTEM, "Collection", track);
 		}
 	}
 }
diff --git a/core/playlist.c b/core/playlist.c
index 29ade58a..f410149a 100644
--- a/core/playlist.c
+++ b/core/playlist.c
@@ -4,6 +4,10 @@
 #include <core/playlist.h>
 #include <core/playlists/system.h>
 
+struct playlist_type *playlist_types[] = {
+	[PL_SYSTEM]  = &pl_system,
+};
+
 
 void playlist_init(struct queue_ops *ops)
 {
@@ -15,65 +19,70 @@ void playlist_deinit()
 	pl_system_deinit();
 }
 
-bool playlist_add(const gchar *name, struct track *track)
+bool playlist_add(enum playlist_type_t type, const gchar *name,
+		  struct track *track)
 {
 	if (!track)
 		return false;
-	return pl_system.pl_add_track(name, track);
+	return playlist_types[type]->pl_add_track(name, track);
 }
 
-bool playlist_remove(const gchar *name, struct track *track)
+bool playlist_remove(enum playlist_type_t type, const gchar *name,
+		     struct track *track)
 {
 	if (!track)
 		return false;
-	return pl_system.pl_remove_track(name, track);
+	return playlist_types[type]->pl_remove_track(name, track);
 }
 
-void playlist_update(const gchar *name)
+void playlist_update(enum playlist_type_t type, const gchar *name)
 {
-	pl_system.pl_update(name);
+	playlist_types[type]->pl_update(name);
 }
 
-bool playlist_has(const gchar *name, struct track *track)
+bool playlist_has(enum playlist_type_t type, const gchar *name,
+		  struct track *track)
 {
-	struct queue *queue = pl_system.pl_get_queue(name);
+	struct queue *queue = playlist_get_queue(type, name);
 	if (!track || !queue)
 		return false;
 	return queue_has(queue, track);
 }
 
-unsigned int playlist_size(const gchar *name)
+unsigned int playlist_size(enum playlist_type_t type, const gchar *name)
 {
-	struct queue *queue = pl_system.pl_get_queue(name);
+	struct queue *queue = playlist_get_queue(type, name);
 	return queue ? queue_size(queue) : 0;
 }
 
-void playlist_set_random(const gchar *name, bool enabled)
+void playlist_set_random(enum playlist_type_t type, const gchar *name,
+			 bool enabled)
 {
-	pl_system.pl_set_flag(name, Q_RANDOM, enabled);
+	playlist_types[type]->pl_set_flag(name, Q_RANDOM, enabled);
 }
 
-bool playlist_get_random(const gchar *name)
+bool playlist_get_random(enum playlist_type_t type, const gchar *name)
 {
-	return queue_has_flag(playlist_get_queue(name), Q_RANDOM);
+	return queue_has_flag(playlist_get_queue(type, name), Q_RANDOM);
 }
 
-void playlist_sort(const gchar *name, enum compare_t sort, bool reset)
+void playlist_sort(enum playlist_type_t type, const gchar *name,
+		   enum compare_t sort, bool reset)
 {
-	pl_system.pl_sort(name, sort, reset);
+	playlist_types[type]->pl_sort(name, sort, reset);
 }
 
 struct track *playlist_next(void)
 {
-	return queue_next(playlist_get_queue("Collection"));
+	return queue_next(playlist_get_queue(PL_SYSTEM, "Collection"));
 }
 
 struct track *playlist_prev(void)
 {
-	return queue_next(playlist_get_queue("History"));
+	return queue_next(playlist_get_queue(PL_SYSTEM, "History"));
 }
 
-struct queue *playlist_get_queue(const gchar *name)
+struct queue *playlist_get_queue(enum playlist_type_t type, const gchar *name)
 {
-	return pl_system.pl_get_queue(name);
+	return playlist_types[type]->pl_get_queue(name);
 }
diff --git a/core/playlists/system.c b/core/playlists/system.c
index 2cbbe4eb..a3842148 100644
--- a/core/playlists/system.c
+++ b/core/playlists/system.c
@@ -10,13 +10,13 @@ static bool __sys_pl_remove(enum sys_playlist_t, struct track *);
 static struct file     sys_file       = FILE_INIT("playlist.db", 0, 0);
 static struct file     sys_collection = FILE_INIT("library.q",   0, 0);
 static struct playlist sys_playlists[SYS_PL_NUM_PLAYLISTS] = {
-	[SYS_PL_FAVORITES]    = DEFINE_PLAYLIST("Favorites"),
-	[SYS_PL_HIDDEN]       = DEFINE_PLAYLIST("Hidden"),
-	[SYS_PL_COLLECTION]   = DEFINE_PLAYLIST("Collection"),
-	[SYS_PL_HISTORY]      = DEFINE_PLAYLIST("History"),
-	[SYS_PL_UNPLAYED]     = DEFINE_PLAYLIST("Unplayed"),
-	[SYS_PL_MOST_PLAYED]  = DEFINE_PLAYLIST("Most Played"),
-	[SYS_PL_LEAST_PLAYED] = DEFINE_PLAYLIST("Least Played"),
+	[SYS_PL_FAVORITES]    = DEFINE_PLAYLIST(PL_SYSTEM, "Favorites"),
+	[SYS_PL_HIDDEN]       = DEFINE_PLAYLIST(PL_SYSTEM, "Hidden"),
+	[SYS_PL_COLLECTION]   = DEFINE_PLAYLIST(PL_SYSTEM, "Collection"),
+	[SYS_PL_HISTORY]      = DEFINE_PLAYLIST(PL_SYSTEM, "History"),
+	[SYS_PL_UNPLAYED]     = DEFINE_PLAYLIST(PL_SYSTEM, "Unplayed"),
+	[SYS_PL_MOST_PLAYED]  = DEFINE_PLAYLIST(PL_SYSTEM, "Most Played"),
+	[SYS_PL_LEAST_PLAYED] = DEFINE_PLAYLIST(PL_SYSTEM, "Least Played"),
 };
 
 
diff --git a/gui/audio.c b/gui/audio.c
index a3d769c7..27e1fad4 100644
--- a/gui/audio.c
+++ b/gui/audio.c
@@ -35,9 +35,9 @@ static void __audio_load(struct track *track)
 	__audio_set_time_label("o_duration", track->tr_length);
 
 	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(gui_builder_widget("o_hide")),
-				     playlist_has("Hidden", track));
+				     playlist_has(PL_SYSTEM, "Hidden", track));
 	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(gui_builder_widget("o_favorite")),
-				     playlist_has("Favorites", track));
+				     playlist_has(PL_SYSTEM, "Favorites", track));
 
 	gui_view_scroll();
 	gui_artwork_set_cover();
@@ -74,18 +74,18 @@ void __audio_seek(GtkRange *range, GtkScrollType type, double value, gpointer da
 void __audio_favorite(GtkToggleButton *toggle, gpointer data)
 {
 	if (gtk_toggle_button_get_active(toggle))
-		playlist_add("Favorites", audio_cur_track());
+		playlist_add(PL_SYSTEM, "Favorites", audio_cur_track());
 	else
-		playlist_remove("Favorites", audio_cur_track());
+		playlist_remove(PL_SYSTEM, "Favorites", audio_cur_track());
 }
 
 void __audio_hide(GtkToggleButton *toggle, gpointer data)
 {
 	if (gtk_toggle_button_get_active(toggle)) {
-		if (playlist_add("Hidden", audio_cur_track()))
+		if (playlist_add(PL_SYSTEM, "Hidden", audio_cur_track()))
 			audio_next();
 	} else
-		playlist_remove("Hidden", audio_cur_track());
+		playlist_remove(PL_SYSTEM, "Hidden", audio_cur_track());
 }
 
 static int __audio_timeout(gpointer data)
diff --git a/gui/playlist.c b/gui/playlist.c
index 89a1ecf2..42cb29a1 100644
--- a/gui/playlist.c
+++ b/gui/playlist.c
@@ -25,7 +25,7 @@ static void __playlist_set(GtkTreeIter *iter,  const gchar *name,
 static void __playlist_set_size(GtkTreeIter *iter, const gchar *name)
 {
 	GtkTreePath *path = gtk_tree_model_get_path(GTK_TREE_MODEL(p_store), iter);
-	unsigned int size = playlist_size(name);
+	unsigned int size = playlist_size(PL_SYSTEM, name);
 	const gchar *fmt = "%s\n%d track%s";
 	gchar *text;
 
@@ -79,7 +79,7 @@ void __playlist_selection_changed(GtkTreeSelection *selection, gpointer data)
 
 		gtk_stack_set_visible_child_name(stack, "queues");
 		gui_sidebar_selected(SB_PLAYLIST,
-				     gui_queue(playlist_get_queue(p_name)));
+				     gui_queue(playlist_get_queue(PL_SYSTEM, p_name)));
 	}
 }
 
@@ -93,7 +93,7 @@ gboolean __playlist_on_select(GtkTreeSelection *selection, GtkTreeModel *model,
 	gtk_tree_model_get_iter(model, &iter, path);
 
 	name  = __playlist_name(&iter);
-	queue = playlist_get_queue(name);
+	queue = playlist_get_queue(PL_SYSTEM, name);
 	g_free(name);
 
 	return queue != NULL;
@@ -156,10 +156,10 @@ static void __playlist_removed(struct queue *queue, unsigned int row)
 static bool __playlist_erase(struct queue *queue, struct track *track)
 {
 	if (string_match(gui_playlist_cur(), "Collection"))
-		playlist_add("Hidden", track);
+		playlist_add(PL_SYSTEM, "Hidden", track);
 	else if (string_match(gui_playlist_cur(), "Favorites") ||
 		 string_match(gui_playlist_cur(), "Hidden"))
-		playlist_remove(gui_playlist_cur(), track);
+		playlist_remove(PL_SYSTEM, gui_playlist_cur(), track);
 	return false;
 }
 
diff --git a/gui/view.c b/gui/view.c
index 2607a8d4..db7e6085 100644
--- a/gui/view.c
+++ b/gui/view.c
@@ -174,8 +174,8 @@ void __view_column_clicked(GtkTreeViewColumn *col, gpointer data)
 	if (!queue || queue_has_flag(queue, Q_NO_SORT))
 		return;
 
-	if (playlist_get_queue(gui_queue(queue)->gq_text))
-		playlist_sort(gui_queue(queue)->gq_text, QUEUE_SORT[index], reset);
+	if (playlist_get_queue(PL_SYSTEM, gui_queue(queue)->gq_text))
+		playlist_sort(PL_SYSTEM, gui_queue(queue)->gq_text, QUEUE_SORT[index], reset);
 	else
 		queue_sort(queue, QUEUE_SORT[index], reset);
 
@@ -201,7 +201,7 @@ static void __view_add_to_queue(GtkTreeModel *model, GtkTreePath *path,
 static void __view_add_to_playlist(GtkTreeModel *model, GtkTreePath *path,
 				   GtkTreeIter  *iter,  gpointer data)
 {
-	playlist_add((gchar *)data, __view_filter_get_track(path));
+	playlist_add(PL_SYSTEM, (gchar *)data, __view_filter_get_track(path));
 }
 
 static void __view_delete_selection(GtkTreeSelection *selection)
@@ -286,7 +286,7 @@ void __view_rc_add_hidden(GtkMenuItem *item, gpointer data)
 	GList *cur  = g_list_reverse(rows);
 
 	while (cur) {
-		playlist_add("Hidden", __view_filter_get_track(cur->data));
+		playlist_add(PL_SYSTEM, "Hidden", __view_filter_get_track(cur->data));
 		cur = g_list_next(cur);
 	}
 
diff --git a/include/core/playlist.h b/include/core/playlist.h
index 7b6d7d05..36f92c42 100644
--- a/include/core/playlist.h
+++ b/include/core/playlist.h
@@ -20,30 +20,30 @@ void playlist_deinit();
 
 
 /* Called to add a track to a playlist. */
-bool playlist_add(const gchar *, struct track *);
+bool playlist_add(enum playlist_type_t, const gchar *, struct track *);
 
 /* Called to remove a track from a playlist. */
-bool playlist_remove(const gchar *, struct track *);
+bool playlist_remove(enum playlist_type_t, const gchar *, struct track *);
 
 /* Called to update tracks on a playlist. */
-void playlist_update(const gchar *);
+void playlist_update(enum playlist_type_t, const gchar *);
 
 
 /* Called to check if a specific track is in the playlist. */
-bool playlist_has(const gchar *, struct track *);
+bool playlist_has(enum playlist_type_t, const gchar *, struct track *);
 
 /* Called to find the number of tracks in the playlist. */
-unsigned int playlist_size(const gchar *);
+unsigned int playlist_size(enum playlist_type_t, const gchar *);
 
 
 /* Called to set the playlist's random flag. */
-void playlist_set_random(const gchar *, bool);
+void playlist_set_random(enum playlist_type_t, const gchar *, bool);
 
 /* Called to check the playlist's random flag. */
-bool playlist_get_random(const gchar *);
+bool playlist_get_random(enum playlist_type_t, const gchar *);
 
 /* Called to change the sort order of the playlist. */
-void playlist_sort(const gchar *, enum compare_t, bool);
+void playlist_sort(enum playlist_type_t, const gchar *, enum compare_t, bool);
 
 
 /* Called to get the next track from the default playlist. */
@@ -54,6 +54,6 @@ struct track *playlist_prev(void);
 
 
 /* Called to access the playlist queue. */
-struct queue *playlist_get_queue(const gchar *);
+struct queue *playlist_get_queue(enum playlist_type_t, const gchar *);
 
 #endif /* OCARINA_CORE_PLAYLIST_H */
diff --git a/include/core/playlists/type.h b/include/core/playlists/type.h
index 2d07ba16..2f2192f8 100644
--- a/include/core/playlists/type.h
+++ b/include/core/playlists/type.h
@@ -9,13 +9,20 @@
 #include <stdbool.h>
 
 
-struct playlist {
-	const  gchar *pl_name;  /* This playlist's name.            */
-	struct queue  pl_queue; /* This playlist's queue of tracks. */
+enum playlist_type_t {
+	PL_SYSTEM,
+	PL_MAX_TYPE,
 };
 
 
-#define DEFINE_PLAYLIST(name) { .pl_name = name, }
+struct playlist {
+	enum   playlist_type_t  pl_type;  /* This playlist's type.            */
+	const  gchar           *pl_name;  /* This playlist's name.            */
+	struct queue            pl_queue; /* This playlist's queue of tracks. */
+};
+
+
+#define DEFINE_PLAYLIST(type, name) { .pl_type = type, .pl_name = name }
 
 
 struct playlist_type {
diff --git a/tests/core/audio.c b/tests/core/audio.c
index a0e13b54..5f13469f 100644
--- a/tests/core/audio.c
+++ b/tests/core/audio.c
@@ -91,7 +91,7 @@ static void test_playback()
 
 	for (i = 0; i < 3; i++) {
 		test_loop_equal(audio_load(tracks[i]), (bool)(i == 0), i);
-		test_loop_equal(playlist_size("History"), 1, i);
+		test_loop_equal(playlist_size(PL_SYSTEM, "History"), 1, i);
 		test_loop_equal(load_count,  1, i);
 		test_loop_equal(state_count, 1, i);
 		test_loop_equal(audio_cur_state(), GST_STATE_PLAYING, i);
@@ -123,7 +123,7 @@ static void test_playback()
 
 static void test_next()
 {
-	struct queue *history_q = playlist_get_queue("History");
+	struct queue *history_q = playlist_get_queue(PL_SYSTEM, "History");
 	struct queue *temp_q = tempq_alloc(0);
 	int i;
 
@@ -163,7 +163,7 @@ static void test_next()
 
 static void test_prev()
 {
-	struct queue *history_q = playlist_get_queue("History");
+	struct queue *history_q = playlist_get_queue(PL_SYSTEM, "History");
 	struct track *track = queue_at(history_q, 0);
 
 	state_count = 0;
@@ -201,7 +201,7 @@ static void test_prev()
 
 void test_autopause()
 {
-	struct queue *history_q = playlist_get_queue("History");
+	struct queue *history_q = playlist_get_queue(PL_SYSTEM, "History");
 	int i;
 
 	audio_pause_after(3);
diff --git a/tests/core/collection.c b/tests/core/collection.c
index 38c39257..1a26d1aa 100644
--- a/tests/core/collection.c
+++ b/tests/core/collection.c
@@ -11,7 +11,7 @@
 
 static void test_init()
 {
-	struct queue *q = playlist_get_queue("Collection");
+	struct queue *q = playlist_get_queue(PL_SYSTEM, "Collection");
 	GSList *list;
 
 	idle_init_sync();
@@ -44,7 +44,7 @@ static void test_init()
 
 static void test_add()
 {
-	struct queue *q = playlist_get_queue("Collection");
+	struct queue *q = playlist_get_queue(PL_SYSTEM, "Collection");
 	struct library *lib;
 
 	test_equal((void *)collection_add("tests/Invalid"), NULL);
@@ -64,7 +64,7 @@ static void test_add()
 
 static void test_update()
 {
-	struct queue *q = playlist_get_queue("Collection");
+	struct queue *q = playlist_get_queue(PL_SYSTEM, "Collection");
 	struct library *lib = library_get(0);
 
 	collection_update(NULL);
@@ -123,7 +123,7 @@ static void test_update()
 
 static void test_enable()
 {
-	struct queue *q = playlist_get_queue("Collection");
+	struct queue *q = playlist_get_queue(PL_SYSTEM, "Collection");
 	struct library *lib = library_get(0);
 	struct db_entry *dbe, *next;
 
@@ -138,7 +138,7 @@ static void test_enable()
 
 	/* Banned tracks should not be re-added to the queue. */
 	db_for_each(dbe, next, track_db_get()) {
-		playlist_add("Hidden", TRACK(dbe));
+		playlist_add(PL_SYSTEM, "Hidden", TRACK(dbe));
 		next = db_next(track_db_get(), next);
 	}
 
@@ -149,7 +149,7 @@ static void test_enable()
 	test_equal(queue_size(q), 24);
 
 	db_for_each(dbe, next, track_db_get()) {
-		playlist_remove("Hidden", TRACK(dbe));
+		playlist_remove(PL_SYSTEM, "Hidden", TRACK(dbe));
 		next = db_next(track_db_get(), next);
 	}
 	test_equal(queue_size(q), 48);
@@ -157,7 +157,7 @@ static void test_enable()
 
 static void test_eio()
 {
-	struct queue *q = playlist_get_queue("Collection");
+	struct queue *q = playlist_get_queue(PL_SYSTEM, "Collection");
 	struct library *lib = library_get(0);
 
 	test_equal(queue_size(q), 48);
@@ -193,7 +193,7 @@ static void test_eio()
 
 static void test_remove()
 {
-	struct queue *q = playlist_get_queue("Collection");
+	struct queue *q = playlist_get_queue(PL_SYSTEM, "Collection");
 
 	collection_remove(NULL);
 	test_equal(track_db_get()->db_size, 48);
diff --git a/tests/core/playlist.c b/tests/core/playlist.c
index b40025e0..d34fbf43 100644
--- a/tests/core/playlist.c
+++ b/tests/core/playlist.c
@@ -9,7 +9,7 @@
 
 static void test_init()
 {
-	struct queue *q = playlist_get_queue("Most Played");
+	struct queue *q = playlist_get_queue(PL_SYSTEM, "Most Played");
 	struct library *library;
 	GSList *list;
 
@@ -19,11 +19,11 @@ static void test_init()
 	playlist_init(NULL);
 	while (idle_run_task()) {};
 
-	test_not_equal((void *)playlist_get_queue("Favorites"),    NULL);
-	test_not_equal((void *)playlist_get_queue("Hidden"),       NULL);
-	test_not_equal((void *)playlist_get_queue("Unplayed"),     NULL);
-	test_not_equal((void *)playlist_get_queue("Most Played"),  NULL);
-	test_not_equal((void *)playlist_get_queue("Least Played"), NULL);
+	test_not_equal((void *)playlist_get_queue(PL_SYSTEM, "Favorites"),    NULL);
+	test_not_equal((void *)playlist_get_queue(PL_SYSTEM, "Hidden"),       NULL);
+	test_not_equal((void *)playlist_get_queue(PL_SYSTEM, "Unplayed"),     NULL);
+	test_not_equal((void *)playlist_get_queue(PL_SYSTEM, "Most Played"),  NULL);
+	test_not_equal((void *)playlist_get_queue(PL_SYSTEM, "Least Played"), NULL);
 
 	test_not_equal((void *)q, NULL);
 	test_equal(queue_has_flag(q, Q_ENABLED), (bool)true);
@@ -61,23 +61,23 @@ static void test_add()
 {
 	struct track *track = track_get(0);
 
-	test_equal(playlist_add("Favorites", NULL), (bool)false);
-	test_equal(playlist_has("Favorites", NULL), (bool)false);
+	test_equal(playlist_add(PL_SYSTEM, "Favorites", NULL), (bool)false);
+	test_equal(playlist_has(PL_SYSTEM, "Favorites", NULL), (bool)false);
 
-	test_equal(playlist_has("Favorites", track), (bool)false);
-	test_equal(playlist_add("Favorites", track), (bool)true);
-	test_equal(playlist_has("Favorites", track), (bool)true);
-	test_equal(playlist_size("Favorites"), 1);
-	test_equal(playlist_add("Favorites", track), (bool)false);
-	test_equal(playlist_size("Favorites"), 1);
-	test_equal(playlist_add("Favorites", track_get(1)), (bool)true);
-	test_equal(playlist_size("Favorites"), 2);
+	test_equal(playlist_has(PL_SYSTEM, "Favorites", track), (bool)false);
+	test_equal(playlist_add(PL_SYSTEM, "Favorites", track), (bool)true);
+	test_equal(playlist_has(PL_SYSTEM, "Favorites", track), (bool)true);
+	test_equal(playlist_size(PL_SYSTEM, "Favorites"), 1);
+	test_equal(playlist_add(PL_SYSTEM, "Favorites", track), (bool)false);
+	test_equal(playlist_size(PL_SYSTEM, "Favorites"), 1);
+	test_equal(playlist_add(PL_SYSTEM, "Favorites", track_get(1)), (bool)true);
+	test_equal(playlist_size(PL_SYSTEM, "Favorites"), 2);
 
 	track = track_get(2);
-	test_equal(playlist_has("Hidden", track), (bool)false);
-	test_equal(playlist_add("Hidden", track), (bool)true);
-	test_equal(playlist_has("Hidden", track), (bool)true);
-	test_equal(playlist_size("Hidden"), 1);
+	test_equal(playlist_has(PL_SYSTEM, "Hidden", track), (bool)false);
+	test_equal(playlist_add(PL_SYSTEM, "Hidden", track), (bool)true);
+	test_equal(playlist_has(PL_SYSTEM, "Hidden", track), (bool)true);
+	test_equal(playlist_size(PL_SYSTEM, "Hidden"), 1);
 }
 
 static void test_remove()
@@ -85,36 +85,31 @@ static void test_remove()
 	struct track *track = track_get(0);
 
 	/* The important thing here is that we don't crash */
-	test_equal(playlist_remove("Favorites", NULL), (bool)false);
+	test_equal(playlist_remove(PL_SYSTEM, "Favorites", NULL), (bool)false);
 
-	test_equal(playlist_size("Favorites"), 2);
-	test_equal(playlist_has("Favorites", track),    (bool)true);
-	test_equal(playlist_remove("Favorites", track), (bool)true);
-	test_equal(playlist_has("Favorites", track),    (bool)false);
-	test_equal(playlist_size("Favorites"), 1);
-	test_equal(playlist_remove("Favorites", track), (bool)false);
-	test_equal(playlist_size("Favorites"), 1);
-	test_equal(playlist_remove("Favorites", track_get(1)), (bool)true);
-	test_equal(playlist_size("Favorites"), 0);
+	test_equal(playlist_size(PL_SYSTEM, "Favorites"), 2);
+	test_equal(playlist_has(PL_SYSTEM, "Favorites", track),    (bool)true);
+	test_equal(playlist_remove(PL_SYSTEM, "Favorites", track), (bool)true);
+	test_equal(playlist_has(PL_SYSTEM, "Favorites", track),    (bool)false);
+	test_equal(playlist_size(PL_SYSTEM, "Favorites"), 1);
+	test_equal(playlist_remove(PL_SYSTEM, "Favorites", track), (bool)false);
+	test_equal(playlist_size(PL_SYSTEM, "Favorites"), 1);
+	test_equal(playlist_remove(PL_SYSTEM, "Favorites", track_get(1)), (bool)true);
+	test_equal(playlist_size(PL_SYSTEM, "Favorites"), 0);
 
 	track = track_get(2);
-	test_equal(playlist_size("Hidden"), 1);
-	test_equal(playlist_has("Hidden", track),    (bool)true);
-	test_equal(playlist_remove("Hidden", track), (bool)true);
-	test_equal(playlist_has("Hidden", track),    (bool)false);
-	test_equal(playlist_size("Hidden"), 0);
+	test_equal(playlist_size(PL_SYSTEM, "Hidden"), 1);
+	test_equal(playlist_has(PL_SYSTEM, "Hidden", track),    (bool)true);
+	test_equal(playlist_remove(PL_SYSTEM, "Hidden", track), (bool)true);
+	test_equal(playlist_has(PL_SYSTEM, "Hidden", track),    (bool)false);
+	test_equal(playlist_size(PL_SYSTEM, "Hidden"), 0);
 }
 
 static void test_deinit()
 {
-	struct queue *q = playlist_get_queue("Unplayed");
-
 	playlist_deinit();
 	tags_deinit();
 	filter_deinit();
-
-	test_equal(queue_size(q), 0);
-	test_equal((void *)q->q_sort, NULL);
 }
 
 DECLARE_UNIT_TESTS(
diff --git a/tests/gui/audio.c b/tests/gui/audio.c
index ba369c3f..29e48940 100644
--- a/tests/gui/audio.c
+++ b/tests/gui/audio.c
@@ -80,9 +80,9 @@ static void test_audio()
 		}
 	}
 
-	playlist_add("Favorites", track);
-	playlist_add("Hidden", track);
-	test_equal(playlist_has("Collection", track), (bool)false);
+	playlist_add(PL_SYSTEM, "Favorites", track);
+	playlist_add(PL_SYSTEM, "Hidden", track);
+	test_equal(playlist_has(PL_SYSTEM, "Collection", track), (bool)false);
 	audio_load(track);
 	test_equal(audio_cur_track()->tr_track, track->tr_track);
 
diff --git a/tests/gui/model.c b/tests/gui/model.c
index 4aed59e3..2098581a 100644
--- a/tests/gui/model.c
+++ b/tests/gui/model.c
@@ -69,10 +69,10 @@ static void test_init()
 	GuiQueueModel *model;
 	GType type;
 
-	model = gui_queue_model_new(playlist_get_queue("Collection"));
+	model = gui_queue_model_new(playlist_get_queue(PL_SYSTEM, "Collection"));
 	test_not_equal((void *)model, NULL);
 	test_equal(GTK_IS_TREE_MODEL(model), true);
-	test_equal((void *)model->gqm_queue, (void *)playlist_get_queue("Collection"));
+	test_equal((void *)model->gqm_queue, (void *)playlist_get_queue(PL_SYSTEM, "Collection"));
 
 	treemodel = GTK_TREE_MODEL(model);
 	test_equal(gtk_tree_model_get_flags(treemodel), GTK_TREE_MODEL_LIST_ONLY);
@@ -115,7 +115,7 @@ static void test_empty()
 	GtkTreeIter iter;
 	GValue value;
 
-	model = GTK_TREE_MODEL(gui_queue_model_new(playlist_get_queue("Collection")));
+	model = GTK_TREE_MODEL(gui_queue_model_new(playlist_get_queue(PL_SYSTEM, "Collection")));
 	memset(&value, 0, sizeof(GValue));
 
 	test_equal(gtk_tree_model_get_iter_first(model, &iter), false);
@@ -171,7 +171,7 @@ static void test_model()
 	core_init(&argc, NULL, &init_data);
 	while (idle_run_task() == true) {}
 
-	model = GTK_TREE_MODEL(gui_queue_model_new(playlist_get_queue("Collection")));
+	model = GTK_TREE_MODEL(gui_queue_model_new(playlist_get_queue(PL_SYSTEM, "Collection")));
 	memset(&value, 0, sizeof(GValue));
 
 	g_signal_connect(model, "row-inserted", (GCallback)on_row_inserted, NULL);
@@ -179,12 +179,12 @@ static void test_model()
 	g_signal_connect(model, "row-changed",  (GCallback)on_row_changed,  NULL);
 
 	/* Okay, now scan a directory ... */
-	playlist_get_queue("Collection")->q_private = model;
+	playlist_get_queue(PL_SYSTEM, "Collection")->q_private = model;
 	collection_add("tests/Music/Hyrule Symphony");
 	while (idle_run_task() == true) {}
-	test_equal(playlist_size("Collection"), 13);
+	test_equal(playlist_size(PL_SYSTEM, "Collection"), 13);
 	test_equal(count_insert, 13);
-	queue_resort(playlist_get_queue("Collection"));
+	queue_resort(playlist_get_queue(PL_SYSTEM, "Collection"));
 	test_equal(count_update, 13);
 
 	/* ... and test again */
@@ -257,7 +257,7 @@ static void test_model()
 	test_equal(gtk_tree_model_iter_parent(model, &iter, &iter), false);
 
 	db_for_each(dbe, next, track_db_get())
-		playlist_remove("Collection", TRACK(dbe));
+		playlist_remove(PL_SYSTEM, "Collection", TRACK(dbe));
 	test_equal(count_delete, 13);
 
 	core_deinit();
diff --git a/tests/gui/queue.c b/tests/gui/queue.c
index 152532d7..a31ee045 100644
--- a/tests/gui/queue.c
+++ b/tests/gui/queue.c
@@ -162,7 +162,7 @@ static void test_tracks()
 	search  = GTK_ENTRY(gui_builder_widget("o_search"));
 
 	core_init(&argc, NULL, &init_data);
-	gq = gui_queue(playlist_get_queue("Collection"));
+	gq = gui_queue(playlist_get_queue(PL_SYSTEM, "Collection"));
 
 	gui_queue_show(gq);
 	test_equal(gtk_label_get_text(runtime), "");
@@ -185,7 +185,7 @@ static void test_tracks()
 
 	db_for_each(dbe, next, track_db_get()) {
 		if (TRACK(dbe)->tr_track == 4) {
-			playlist_remove("Collection", TRACK(dbe));
+			playlist_remove(PL_SYSTEM, "Collection", TRACK(dbe));
 			break;
 		}
 	}
diff --git a/tests/gui/view.c b/tests/gui/view.c
index 7a449299..cfff200c 100644
--- a/tests/gui/view.c
+++ b/tests/gui/view.c
@@ -75,7 +75,7 @@ static void test_treeview()
 
 	collection_add("tests/Music/Hyrule Symphony");
 	while (idle_run_task() == true) {}
-	model  = GTK_TREE_MODEL(gui_queue_model_new(playlist_get_queue("Collection")));
+	model  = GTK_TREE_MODEL(gui_queue_model_new(playlist_get_queue(PL_SYSTEM, "Collection")));
 	filter = gtk_tree_model_filter_new(model, NULL);
 
 	treeview  = GTK_TREE_VIEW(gui_builder_widget("o_treeview"));