diff --git a/musicdb-client/src/gui.rs b/musicdb-client/src/gui.rs
index d26bc03..8647423 100755
--- a/musicdb-client/src/gui.rs
+++ b/musicdb-client/src/gui.rs
@@ -33,6 +33,7 @@ use crate::{
     gui_edit_song::EditorForSongs,
     gui_notif::{NotifInfo, NotifOverlay},
     gui_screen::GuiScreen,
+    gui_song_adder::SongAdder,
     gui_text::Label,
     textcfg,
 };
@@ -1127,6 +1128,8 @@ pub enum GuiAction {
     EditSongs(Vec<Song>),
     // EditAlbums(Vec<Album>),
     // EditArtists(Vec<Artist>),
+    OpenAddSongsMenu,
+    CloseAddSongsMenu,
 }
 pub enum Dragging {
     Artist(ArtistId),
@@ -1307,6 +1310,19 @@ impl Gui {
             GuiAction::EditSongs(songs) => {
                 self.gui.c_editing_songs = Some(EditorForSongs::new(songs));
             }
+            GuiAction::OpenAddSongsMenu => {
+                if self.gui.c_song_adder.is_none() {
+                    self.gui.c_song_adder = Some(SongAdder::new(
+                        GuiElemCfg::default(),
+                        self.high_performance,
+                        self.line_height,
+                        self.scroll_pixels_multiplier,
+                        self.scroll_lines_multiplier,
+                        self.scroll_pages_multiplier,
+                    ));
+                }
+            }
+            GuiAction::CloseAddSongsMenu => self.gui.c_song_adder = None,
         }
     }
 }
diff --git a/musicdb-client/src/gui_screen.rs b/musicdb-client/src/gui_screen.rs
index c4c9795..d5832c1 100755
--- a/musicdb-client/src/gui_screen.rs
+++ b/musicdb-client/src/gui_screen.rs
@@ -19,6 +19,7 @@ use crate::{
     gui_notif::NotifOverlay,
     gui_queue::QueueViewer,
     gui_settings::Settings,
+    gui_song_adder::SongAdder,
     gui_statusbar::StatusBar,
     gui_text::Label,
     gui_wrappers::Hotkey,
@@ -49,6 +50,7 @@ pub struct GuiScreen {
     pub c_editing_songs: Option<EditorForSongs>,
     pub c_status_bar: StatusBar,
     pub c_settings: Settings,
+    pub c_song_adder: Option<SongAdder>,
     pub c_main_view: Panel<MainView>,
     pub c_context_menu: Option<Box<dyn GuiElem>>,
     pub idle: AnimationController<f32>,
@@ -110,6 +112,7 @@ impl GuiScreen {
                 scroll_sensitivity_lines,
                 scroll_sensitivity_pages,
             ),
+            c_song_adder: None,
             c_main_view: Panel::new(
                 GuiElemCfg::at(Rectangle::from_tuples((0.0, 0.0), (1.0, 0.9))),
                 MainView {
@@ -248,6 +251,7 @@ impl GuiElem for GuiScreen {
                 ]
                 .into_iter()
                 .chain(self.c_editing_songs.as_mut().map(|v| v.elem_mut()))
+                .chain(self.c_song_adder.as_mut().map(|v| v.elem_mut()).into_iter())
                 .chain([
                     self.c_status_bar.elem_mut(),
                     self.c_settings.elem_mut(),
diff --git a/musicdb-client/src/gui_settings.rs b/musicdb-client/src/gui_settings.rs
index f0ef684..ceb4c0c 100755
--- a/musicdb-client/src/gui_settings.rs
+++ b/musicdb-client/src/gui_settings.rs
@@ -68,6 +68,7 @@ pub struct SettingsContent {
     pub scroll_sensitivity: Panel<(Label, Slider)>,
     pub idle_time: Panel<(Label, Slider)>,
     pub save_button: Button<[Label; 1]>,
+    pub add_new_songs_button: Button<[Label; 1]>,
     pub keybinds: Vec<Panel<(AdvancedLabel, KeybindInput)>>,
     pub keybinds_should_be_updated: Arc<AtomicBool>,
     pub keybinds_updated: bool,
@@ -84,13 +85,14 @@ impl GuiElemChildren for SettingsContent {
                 self.scroll_sensitivity.elem_mut(),
                 self.idle_time.elem_mut(),
                 self.save_button.elem_mut(),
+                self.add_new_songs_button.elem_mut(),
             ]
             .into_iter()
             .chain(self.keybinds.iter_mut().map(|v| v.elem_mut())),
         )
     }
     fn len(&self) -> usize {
-        7 + self.keybinds.len()
+        8 + self.keybinds.len()
     }
 }
 pub struct KeybindInput {
@@ -455,6 +457,17 @@ impl SettingsContent {
                     Vec2::new(0.5, 0.5),
                 )],
             ),
+            add_new_songs_button: Button::new(
+                GuiElemCfg::default(),
+                |_| vec![GuiAction::OpenAddSongsMenu],
+                [Label::new(
+                    GuiElemCfg::default(),
+                    "search for new songs".to_string(),
+                    Color::WHITE,
+                    None,
+                    Vec2::new(0.5, 0.5),
+                )],
+            ),
             keybinds: vec![],
             keybinds_should_be_updated: Arc::new(AtomicBool::new(true)),
             keybinds_updated: false,
@@ -537,7 +550,7 @@ impl GuiElem for Settings {
             scrollbox.config_mut().redraw = true;
             if scrollbox.children_heights.len() == scrollbox.children.len() {
                 for (i, h) in scrollbox.children_heights.iter_mut().enumerate() {
-                    *h = if i == 0 || i >= 7 {
+                    *h = if i == 0 || i >= 8 {
                         info.line_height * 2.0
                     } else {
                         info.line_height
diff --git a/musicdb-client/src/gui_song_adder.rs b/musicdb-client/src/gui_song_adder.rs
new file mode 100644
index 0000000..2cdf176
--- /dev/null
+++ b/musicdb-client/src/gui_song_adder.rs
@@ -0,0 +1,187 @@
+use musicdb_lib::data::{AlbumId, ArtistId};
+use speedy2d::{color::Color, dimen::Vec2, Graphics2D};
+
+use crate::{
+    gui::{DrawInfo, GuiElem, GuiElemCfg},
+    gui_base::{Button, Panel, ScrollBox},
+    gui_text::Label,
+};
+
+pub struct SongAdder {
+    pub config: GuiElemCfg,
+    state: u8,
+    c_loading: Option<Label>,
+    c_scroll_box: ScrollBox<Vec<AddableSong>>,
+    c_background: Panel<()>,
+    data: Option<Vec<AddSong>>,
+}
+struct AddSong {
+    path: String,
+    path_broken: bool,
+    artist: Option<ArtistId>,
+    album: Option<AlbumId>,
+}
+impl SongAdder {
+    pub fn new(
+        mut config: GuiElemCfg,
+        no_animations: bool,
+        line_height: f32,
+        scroll_sensitivity_pixels: f64,
+        scroll_sensitivity_lines: f64,
+        scroll_sensitivity_pages: f64,
+    ) -> Self {
+        config.redraw = true;
+        Self {
+            config,
+            state: 0,
+            c_loading: Some(Label::new(
+                GuiElemCfg::default(),
+                format!("Loading..."),
+                Color::GRAY,
+                None,
+                Vec2::new(0.5, 0.5),
+            )),
+            c_scroll_box: ScrollBox::new(
+                GuiElemCfg::default(),
+                crate::gui_base::ScrollBoxSizeUnit::Pixels,
+                vec![],
+                vec![],
+                line_height,
+            ),
+            c_background: Panel::with_background(GuiElemCfg::default().w_mouse(), (), Color::BLACK),
+            data: None,
+        }
+    }
+}
+
+impl GuiElem for SongAdder {
+    fn config(&self) -> &GuiElemCfg {
+        &self.config
+    }
+    fn config_mut(&mut self) -> &mut GuiElemCfg {
+        &mut self.config
+    }
+    fn children(&mut self) -> Box<dyn Iterator<Item = &mut dyn GuiElem> + '_> {
+        Box::new(
+            [
+                self.c_loading.as_mut().map(|v| v.elem_mut()),
+                Some(self.c_scroll_box.elem_mut()),
+                Some(self.c_background.elem_mut()),
+            ]
+            .into_iter()
+            .flatten(),
+        )
+    }
+    fn any(&self) -> &dyn std::any::Any {
+        self
+    }
+    fn any_mut(&mut self) -> &mut dyn std::any::Any {
+        self
+    }
+    fn elem(&self) -> &dyn GuiElem {
+        self
+    }
+    fn elem_mut(&mut self) -> &mut dyn GuiElem {
+        self
+    }
+    fn draw(&mut self, info: &mut DrawInfo, _g: &mut Graphics2D) {
+        if self.state < 10 {
+            self.state += 1;
+            if self.state == 2 {
+                self.c_loading = None;
+                eprintln!("Locking GetCon...");
+                let mut get_con = info.get_con.lock().unwrap();
+                eprintln!("Requesting list of unused songs...");
+                match get_con.find_unused_song_files(None).unwrap() {
+                    Ok(data) => {
+                        eprintln!("Got list of songs.");
+                        self.c_scroll_box.children = data
+                            .iter()
+                            .map(|(path, is_bad)| AddableSong::new(path.to_owned(), *is_bad))
+                            .collect();
+                        self.c_scroll_box.config_mut().redraw = true;
+                        self.data = Some(
+                            data.into_iter()
+                                .map(|(p, b)| AddSong {
+                                    path: p,
+                                    path_broken: b,
+                                    artist: None,
+                                    album: None,
+                                })
+                                .collect(),
+                        );
+                    }
+                    Err(e) => {
+                        eprintln!("Got error: {e}");
+                        self.c_loading = Some(Label::new(
+                            GuiElemCfg::default(),
+                            format!("Error:\n{e}"),
+                            Color::RED,
+                            None,
+                            Vec2::new(0.5, 0.5),
+                        ));
+                    }
+                }
+            }
+        }
+
+        if self.config.redraw {
+            self.config.redraw = false;
+            self.c_scroll_box.config_mut().redraw = true;
+        }
+    }
+}
+
+struct AddableSong {
+    pub config: GuiElemCfg,
+    pub c_button: Button<[Label; 1]>,
+    pub path: String,
+    pub is_bad: bool,
+}
+impl AddableSong {
+    pub fn new(path: String, is_bad: bool) -> Self {
+        Self {
+            config: GuiElemCfg::default(),
+            c_button: Button::new(
+                GuiElemCfg::default(),
+                |_| vec![],
+                [Label::new(
+                    GuiElemCfg::default(),
+                    format!("{path}"),
+                    if is_bad {
+                        Color::LIGHT_GRAY
+                    } else {
+                        Color::WHITE
+                    },
+                    None,
+                    Vec2::new(0.0, 0.5),
+                )],
+            ),
+            path,
+            is_bad,
+        }
+    }
+}
+impl GuiElem for AddableSong {
+    fn config(&self) -> &GuiElemCfg {
+        &self.config
+    }
+    fn config_mut(&mut self) -> &mut GuiElemCfg {
+        &mut self.config
+    }
+    fn children(&mut self) -> Box<dyn Iterator<Item = &mut dyn GuiElem> + '_> {
+        Box::new([self.c_button.elem_mut()].into_iter())
+    }
+    fn any(&self) -> &dyn std::any::Any {
+        self
+    }
+    fn any_mut(&mut self) -> &mut dyn std::any::Any {
+        self
+    }
+    fn elem(&self) -> &dyn GuiElem {
+        self
+    }
+    fn elem_mut(&mut self) -> &mut dyn GuiElem {
+        self
+    }
+}
diff --git a/musicdb-client/src/main.rs b/musicdb-client/src/main.rs
index b806612..1b13546 100755
--- a/musicdb-client/src/main.rs
+++ b/musicdb-client/src/main.rs
@@ -46,6 +46,8 @@ mod gui_screen;
 #[cfg(feature = "speedy2d")]
 mod gui_settings;
 #[cfg(feature = "speedy2d")]
+mod gui_song_adder;
+#[cfg(feature = "speedy2d")]
 mod gui_statusbar;
 #[cfg(feature = "speedy2d")]
 mod gui_text;
diff --git a/musicdb-server/Cargo.toml b/musicdb-server/Cargo.toml
old mode 100755
new mode 100644
index eadcb17..192258a
--- a/musicdb-server/Cargo.toml
+++ b/musicdb-server/Cargo.toml
@@ -7,14 +7,14 @@ edition = "2021"
 
 [dependencies]
 musicdb-lib = { path = "../musicdb-lib", features = ["playback"] }
-axum = { version = "0.6.19", features = ["headers"] }
 clap = { version = "4.4.6", features = ["derive"] }
-futures = "0.3.28"
 headers = "0.3.8"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
-tokio = { version = "1.0", features = ["full"] }
-tokio-stream = "0.1.14"
-tower = { version = "0.4", features = ["util"] }
-tower-http = { version = "0.4.0", features = ["fs", "trace"] }
-trace = "0.1.7"
+tokio = { version = "1.37.0", optional = true, features = ["rt"] }
+rocket = { version = "0.5.0", optional = true }
+html-escape = { version = "0.2.13", optional = true }
+
+[features]
+default = ["website"]
+website = ["dep:tokio", "dep:rocket", "dep:html-escape"]
diff --git a/musicdb-server/Cross.toml b/musicdb-server/Cross.toml
new file mode 100644
index 0000000..d222800
--- /dev/null
+++ b/musicdb-server/Cross.toml
@@ -0,0 +1,6 @@
+[build]
+pre-build = [
+    "dpkg --add-architecture $CROSS_DEB_ARCH",
+    "apt-get update && apt-get --assume-yes install libasound2-dev libasound2-dev:$CROSS_DEB_ARCH"
+]                 
+default-target = "aarch64-unknown-linux-gnu"
diff --git a/musicdb-server/assets/album-view.html b/musicdb-server/assets/album-view.html
deleted file mode 100755
index bc92477..0000000
--- a/musicdb-server/assets/album-view.html
+++ /dev/null
@@ -1,3 +0,0 @@
-<h3>\:name</h3>
-<button hx-post="/queue/add-album/\:id" hx-swap="none">Queue</button>
-\:songs
diff --git a/musicdb-server/assets/albums_one.html b/musicdb-server/assets/albums_one.html
deleted file mode 100755
index e0673be..0000000
--- a/musicdb-server/assets/albums_one.html
+++ /dev/null
@@ -1 +0,0 @@
-<button hx-get="/album-view/\:id" hx-target="#album-view">\:name</button>
diff --git a/musicdb-server/assets/artist-view.html b/musicdb-server/assets/artist-view.html
deleted file mode 100755
index eba4b7b..0000000
--- a/musicdb-server/assets/artist-view.html
+++ /dev/null
@@ -1,2 +0,0 @@
-<h3>\:name</h3>
-\:albums
diff --git a/musicdb-server/assets/artists.html b/musicdb-server/assets/artists.html
deleted file mode 100755
index bbae565..0000000
--- a/musicdb-server/assets/artists.html
+++ /dev/null
@@ -1,2 +0,0 @@
-<h3>Artists</h3>
-\:artists
\ No newline at end of file
diff --git a/musicdb-server/assets/artists_one.html b/musicdb-server/assets/artists_one.html
deleted file mode 100755
index 77fa93a..0000000
--- a/musicdb-server/assets/artists_one.html
+++ /dev/null
@@ -1 +0,0 @@
-<button hx-get="/artist-view/\:id" hx-target="#artist-view">\:name</button>
diff --git a/musicdb-server/assets/queue.html b/musicdb-server/assets/queue.html
deleted file mode 100755
index 1ec447d..0000000
--- a/musicdb-server/assets/queue.html
+++ /dev/null
@@ -1,3 +0,0 @@
-<h2>Queue</h2>
-<div>Now Playing: <b>\:currentTitle</b></div>
-\:content
diff --git a/musicdb-server/assets/queue_folder.html b/musicdb-server/assets/queue_folder.html
deleted file mode 100755
index d01126d..0000000
--- a/musicdb-server/assets/queue_folder.html
+++ /dev/null
@@ -1,11 +0,0 @@
-<div>
-  <small>&gt;&gt;</small>
-  <button hx-post="/queue/goto/\:path" hx-swap="none">&#x23F5;</button>
-  <small>\:name</small>
-  \?shuffled? (shuffled)\;\;
-</div>
-\:content
-<div>
-  <small>&lt;&lt;</small>
-  <button hx-post="/queue/remove/\:path" hx-swap="none">x</button>
-</div>
diff --git a/musicdb-server/assets/queue_folder_current.html b/musicdb-server/assets/queue_folder_current.html
deleted file mode 100755
index 739c48d..0000000
--- a/musicdb-server/assets/queue_folder_current.html
+++ /dev/null
@@ -1,11 +0,0 @@
-<div>
-  <small>&gt;&gt;</small>
-  <button hx-post="/queue/goto/\:path" hx-swap="none">&#x23F5;</button>
-  <small><b>\:name</b></small>
-  \?shuffled? (shuffled)\;\;
-</div>
-\:content
-<div>
-  <small>&lt;&lt;</small>
-  <button hx-post="/queue/remove/\:path" hx-swap="none">x</button>
-</div>
diff --git a/musicdb-server/assets/queue_loop.html b/musicdb-server/assets/queue_loop.html
deleted file mode 100755
index d64827f..0000000
--- a/musicdb-server/assets/queue_loop.html
+++ /dev/null
@@ -1,10 +0,0 @@
-<div>
-  <small>&gt;&gt;</small>
-  <button hx-post="/queue/goto/\:path" hx-swap="none">&#x23F5;</button>
-  <small>repeat \:total times</small>
-</div>
-\:inner
-<div>
-  <small>&lt;&lt;</small>
-  <button hx-post="/queue/remove/\:path" hx-swap="none">x</button>
-</div>
diff --git a/musicdb-server/assets/queue_loop_current.html b/musicdb-server/assets/queue_loop_current.html
deleted file mode 100755
index f4a4657..0000000
--- a/musicdb-server/assets/queue_loop_current.html
+++ /dev/null
@@ -1,10 +0,0 @@
-<div>
-  <small>&gt;&gt;</small>
-  <button hx-post="/queue/goto/\:path" hx-swap="none">&#x23F5;</button>
-  <small><b>repeat \:total times</b></small>
-</div>
-\:inner
-<div>
-  <small>&lt;&lt;</small>
-  <button hx-post="/queue/remove/\:path" hx-swap="none">x</button>
-</div>
diff --git a/musicdb-server/assets/queue_loopinf.html b/musicdb-server/assets/queue_loopinf.html
deleted file mode 100755
index 6bc1ecf..0000000
--- a/musicdb-server/assets/queue_loopinf.html
+++ /dev/null
@@ -1,10 +0,0 @@
-<div>
-  <small>&gt;&gt;</small>
-  <button hx-post="/queue/goto/\:path" hx-swap="none">&#x23F5;</button>
-  <small>repeat forever</small>
-</div>
-\:inner
-<div>
-  <small>&lt;&lt;</small>
-  <button hx-post="/queue/remove/\:path" hx-swap="none">x</button>
-</div>
diff --git a/musicdb-server/assets/queue_loopinf_current.html b/musicdb-server/assets/queue_loopinf_current.html
deleted file mode 100755
index ee389e7..0000000
--- a/musicdb-server/assets/queue_loopinf_current.html
+++ /dev/null
@@ -1,10 +0,0 @@
-<div>
-  <small>&gt;&gt;</small>
-  <button hx-post="/queue/goto/\:path" hx-swap="none">&#x23F5;</button>
-  <small><b>repeat forever</b></small>
-</div>
-\:inner
-<div>
-  <small>&lt;&lt;</small>
-  <button hx-post="/queue/remove/\:path" hx-swap="none">x</button>
-</div>
diff --git a/musicdb-server/assets/queue_random.html b/musicdb-server/assets/queue_random.html
deleted file mode 100755
index 85066ce..0000000
--- a/musicdb-server/assets/queue_random.html
+++ /dev/null
@@ -1,10 +0,0 @@
-<div>
-  <small>&gt;&gt;</small>
-  <button hx-post="/queue/goto/\:path" hx-swap="none">&#x23F5;</button>
-  <small>random</small>
-</div>
-\:content
-<div>
-  <small>&lt;&lt;</small>
-  <button hx-post="/queue/remove/\:path" hx-swap="none">x</button>
-</div>
diff --git a/musicdb-server/assets/queue_random_current.html b/musicdb-server/assets/queue_random_current.html
deleted file mode 100755
index a108899..0000000
--- a/musicdb-server/assets/queue_random_current.html
+++ /dev/null
@@ -1,10 +0,0 @@
-<div>
-  <small>&gt;&gt;</small>
-  <button hx-post="/queue/goto/\:path" hx-swap="none">&#x23F5;</button>
-  <small><b>random</b></small>
-</div>
-\:content
-<div>
-  <small>&lt;&lt;</small>
-  <button hx-post="/queue/remove/\:path" hx-swap="none">x</button>
-</div>
diff --git a/musicdb-server/assets/queue_shuffle.html b/musicdb-server/assets/queue_shuffle.html
deleted file mode 100755
index a59f5cb..0000000
--- a/musicdb-server/assets/queue_shuffle.html
+++ /dev/null
@@ -1,10 +0,0 @@
-<div>
-  <small>&gt;&gt;</small>
-  <button hx-post="/queue/goto/\:path" hx-swap="none">&#x23F5;</button>
-  <small>shuffle</small>
-</div>
-\:content
-<div>
-  <small>&lt;&lt;</small>
-  <button hx-post="/queue/remove/\:path" hx-swap="none">x</button>
-</div>
diff --git a/musicdb-server/assets/queue_shuffle_current.html b/musicdb-server/assets/queue_shuffle_current.html
deleted file mode 100755
index 0ae331c..0000000
--- a/musicdb-server/assets/queue_shuffle_current.html
+++ /dev/null
@@ -1,10 +0,0 @@
-<div>
-  <small>&gt;&gt;</small>
-  <button hx-post="/queue/goto/\:path" hx-swap="none">&#x23F5;</button>
-  <small><b>shuffle</b></small>
-</div>
-\:content
-<div>
-  <small>&lt;&lt;</small>
-  <button hx-post="/queue/remove/\:path" hx-swap="none">x</button>
-</div>
diff --git a/musicdb-server/assets/queue_song.html b/musicdb-server/assets/queue_song.html
deleted file mode 100755
index 886e3dd..0000000
--- a/musicdb-server/assets/queue_song.html
+++ /dev/null
@@ -1,5 +0,0 @@
-<div>
-  <button hx-post="/queue/remove/\:path" hx-swap="none">x</button>
-  <button hx-post="/queue/goto/\:path" hx-swap="none">&#x23F5;</button>
-  \:title
-</div>
diff --git a/musicdb-server/assets/queue_song_current.html b/musicdb-server/assets/queue_song_current.html
deleted file mode 100755
index 9ce459b..0000000
--- a/musicdb-server/assets/queue_song_current.html
+++ /dev/null
@@ -1,5 +0,0 @@
-<div>
-  <button hx-post="/queue/remove/\:path" hx-swap="none">x</button>
-  <button hx-post="/queue/goto/\:path" hx-swap="none">&#x23F5;</button>
-  <b>\:title</b>
-</div>
diff --git a/musicdb-server/assets/root.html b/musicdb-server/assets/root.html
deleted file mode 100755
index f8cbfc8..0000000
--- a/musicdb-server/assets/root.html
+++ /dev/null
@@ -1,24 +0,0 @@
-<!DOCTYPE HTML>
-<html>
-  <head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <meta name="color-scheme" content="light dark">
-    <script src="https://unpkg.com/htmx.org@1.9.3"></script>
-    <title>MusicDb</title>
-  </head>
-  <body>
-    <div hx-sse="connect:/sse">
-      <div hx-sse="swap:playing">(loading)</div>
-      <button hx-post="/resume" hx-swap="none">&#x23F5;</button>
-      <button hx-post="/pause" hx-swap="none">&#x23F8;</button>
-      <button hx-post="/stop" hx-swap="none">&#x23F9;</button>
-      <button hx-post="/next" hx-swap="none">&#x23ED;</button>
-      <button hx-post="/queue/clear" hx-swap="none">-</button>
-      <div hx-sse="swap:queue">(loading)</div>
-      <div hx-sse="swap:artists">(loading)</div>
-      <div id="artist-view"></div>
-      <div id="album-view"></div>
-    </div>
-  </body>
-</html>
diff --git a/musicdb-server/assets/songs_one.html b/musicdb-server/assets/songs_one.html
deleted file mode 100755
index 70b664c..0000000
--- a/musicdb-server/assets/songs_one.html
+++ /dev/null
@@ -1 +0,0 @@
-<button hx-post="/queue/add-song/\:id" hx-swap="none">\:title</button>
diff --git a/musicdb-server/src/main.rs b/musicdb-server/src/main.rs
index 18b5e4c..933b7d6 100755
--- a/musicdb-server/src/main.rs
+++ b/musicdb-server/src/main.rs
@@ -1,3 +1,4 @@
+#[cfg(feature = "website")]
 mod web;
 
 use std::{
@@ -5,7 +6,6 @@ use std::{
     path::PathBuf,
     process::exit,
     sync::{Arc, Mutex},
-    thread,
 };
 
 use clap::Parser;
@@ -47,8 +47,7 @@ struct Args {
     advanced_cache_song_lookahead_limit: u32,
 }
 
-#[tokio::main]
-async fn main() {
+fn main() {
     // parse args
     let args = Args::parse();
     let mut database = if args.init {
@@ -88,11 +87,25 @@ async fn main() {
             );
         };
         if let Some(addr) = &args.web {
-            let (s, mut r) = tokio::sync::mpsc::channel(2);
-            let db = Arc::clone(&database);
-            thread::spawn(move || run_server(database, Some(s)));
-            if let Some(sender) = r.recv().await {
-                web::main(db, sender, *addr).await;
+            #[cfg(not(feature = "website"))]
+            {
+                let _ = addr;
+                eprintln!("Website support requires the 'website' feature to be enabled when compiling the server!");
+                std::process::exit(80);
+            }
+            #[cfg(feature = "website")]
+            {
+                let (s, r) = std::sync::mpsc::sync_channel(1);
+                let db = Arc::clone(&database);
+                std::thread::spawn(move || {
+                    run_server(database, Some(Box::new(move |c| s.send(c).unwrap())))
+                });
+                let sender = r.recv().unwrap();
+                tokio::runtime::Builder::new_current_thread()
+                    .enable_all()
+                    .build()
+                    .unwrap()
+                    .block_on(web::main(db, sender, *addr));
             }
         } else {
             run_server(database, None);
diff --git a/musicdb-server/src/web.rs b/musicdb-server/src/web.rs
index 2717108..3604cbb 100755
--- a/musicdb-server/src/web.rs
+++ b/musicdb-server/src/web.rs
@@ -1,21 +1,15 @@
-use std::borrow::Cow;
-use std::convert::Infallible;
-use std::mem;
 use std::net::SocketAddr;
 use std::sync::{mpsc, Arc, Mutex};
-use std::task::Poll;
-use std::time::Duration;
 
-use axum::extract::{Path, State};
-use axum::response::sse::Event;
-use axum::response::{Html, Sse};
-use axum::routing::{get, post};
-use axum::{Router, TypedHeader};
-use futures::{stream, Stream};
-use musicdb_lib::data::database::{Database, UpdateEndpoint};
-use musicdb_lib::data::queue::{Queue, QueueContent, QueueFolder};
+use musicdb_lib::data::album::Album;
+use musicdb_lib::data::artist::Artist;
+use musicdb_lib::data::database::Database;
+use musicdb_lib::data::queue::{QueueContent, QueueFolder};
+use musicdb_lib::data::song::Song;
+use musicdb_lib::data::SongId;
 use musicdb_lib::server::Command;
-use tokio_stream::StreamExt as _;
+use rocket::response::content::RawHtml;
+use rocket::{get, routes, Config, State};
 
 /*
 
@@ -39,692 +33,347 @@ use tokio_stream::StreamExt as _;
 
 */
 
-#[derive(Clone)]
-pub struct AppState {
+const HTML_START: &'static str =
+    "<!DOCTYPE html><html><head><meta name=\"color-scheme\" content=\"light dark\">";
+const HTML_SEP: &'static str = "</head><body>";
+const HTML_END: &'static str = "</body></html>";
+
+struct Data {
     db: Arc<Mutex<Database>>,
-    html: Arc<AppHtml>,
+    command_sender: mpsc::Sender<Command>,
 }
-#[derive(Debug)]
-pub struct AppHtml {
-    /// /
-    /// can use:
-    root: Vec<HtmlPart>,
 
-    /// sse:artists
-    /// can use: artists (0+ repeats of artists_one)
-    artists: Vec<HtmlPart>,
-    /// can use: id, name
-    artists_one: Vec<HtmlPart>,
-
-    /// /artist-view/:artist-id
-    /// can use: albums (0+ repeats of albums_one)
-    artist_view: Vec<HtmlPart>,
-    /// can use: name
-    albums_one: Vec<HtmlPart>,
-
-    /// /album-view/:album-id
-    /// can use: id, name, songs (0+ repeats of songs_one)
-    album_view: Vec<HtmlPart>,
-    /// can use: title
-    songs_one: Vec<HtmlPart>,
-
-    /// /queue
-    /// can use: currentTitle, nextTitle, content
-    queue: Vec<HtmlPart>,
-    /// can use: path, title
-    queue_song: Vec<HtmlPart>,
-    /// can use: path, title
-    queue_song_current: Vec<HtmlPart>,
-    /// can use: path, content, name
-    /// can use in `\?key?then\;else\;`: `shuffled`
-    queue_folder: Vec<HtmlPart>,
-    /// can use: path, content, name
-    /// can use in `\?key?then\;else\;`: `shuffled`
-    queue_folder_current: Vec<HtmlPart>,
-    /// can use: path, total, current, inner
-    queue_loop: Vec<HtmlPart>,
-    /// can use: path, total, current, inner
-    queue_loop_current: Vec<HtmlPart>,
-    /// can use: path, current, inner
-    queue_loopinf: Vec<HtmlPart>,
-    /// can use: path, current, inner
-    queue_loopinf_current: Vec<HtmlPart>,
-}
-impl AppHtml {
-    pub fn from_dir<P: AsRef<std::path::Path>>(dir: P) -> std::io::Result<Self> {
-        let dir = dir.as_ref();
-        Ok(Self {
-            root: Self::parse(&std::fs::read_to_string(dir.join("root.html"))?),
-            artists: Self::parse(&std::fs::read_to_string(dir.join("artists.html"))?),
-            artists_one: Self::parse(&std::fs::read_to_string(dir.join("artists_one.html"))?),
-            artist_view: Self::parse(&std::fs::read_to_string(dir.join("artist-view.html"))?),
-            albums_one: Self::parse(&std::fs::read_to_string(dir.join("albums_one.html"))?),
-            album_view: Self::parse(&std::fs::read_to_string(dir.join("album-view.html"))?),
-            songs_one: Self::parse(&std::fs::read_to_string(dir.join("songs_one.html"))?),
-            queue: Self::parse(&std::fs::read_to_string(dir.join("queue.html"))?),
-            queue_song: Self::parse(&std::fs::read_to_string(dir.join("queue_song.html"))?),
-            queue_song_current: Self::parse(&std::fs::read_to_string(
-                dir.join("queue_song_current.html"),
-            )?),
-            queue_folder: Self::parse(&std::fs::read_to_string(dir.join("queue_folder.html"))?),
-            queue_folder_current: Self::parse(&std::fs::read_to_string(
-                dir.join("queue_folder_current.html"),
-            )?),
-            queue_loop: Self::parse(&std::fs::read_to_string(dir.join("queue_loop.html"))?),
-            queue_loop_current: Self::parse(&std::fs::read_to_string(
-                dir.join("queue_loop_current.html"),
-            )?),
-            queue_loopinf: Self::parse(&std::fs::read_to_string(dir.join("queue_loopinf.html"))?),
-            queue_loopinf_current: Self::parse(&std::fs::read_to_string(
-                dir.join("queue_loopinf_current.html"),
-            )?),
-        })
+#[get("/")]
+async fn index(data: &State<Data>) -> RawHtml<String> {
+    let script = r#"<script>
+async function performSearch() {
+    var searchResultDiv = document.getElementById("searchResultDiv");
+    searchResultDiv.innerHTML = "Loading...";
+    var sfArtist = document.getElementById("searchFieldArtist").value;
+    var sfAlbum = document.getElementById("searchFieldAlbum").value;
+    var sfTitle = document.getElementById("searchFieldTitle").value;
+    var query = "";
+    if (sfArtist) {
+        query += "artist=" + encodeURIComponent(sfArtist);
     }
-    pub fn parse(s: &str) -> Vec<HtmlPart> {
-        Self::parsei(&mut s.chars().peekable())
-    }
-    pub fn parsei(chars: &mut std::iter::Peekable<impl Iterator<Item = char>>) -> Vec<HtmlPart> {
-        let mut o = Vec::new();
-        let mut c = String::new();
-        loop {
-            // if there is a char (iter not empty) and it is not `\;`. If it is `\;`, consume both chars.
-            if let Some(ch) = chars.next().filter(|ch| {
-                if *ch == '\\' && chars.peek().copied() == Some(';') {
-                    chars.next();
-                    false
-                } else {
-                    true
-                }
-            }) {
-                if ch == '\\' && chars.peek().is_some_and(|ch| *ch == ':') {
-                    chars.next();
-                    o.push(HtmlPart::Plain(mem::replace(&mut c, String::new())));
-                    loop {
-                        if let Some(ch) = chars.peek() {
-                            if !ch.is_ascii_alphabetic() {
-                                o.push(HtmlPart::Insert(mem::replace(&mut c, String::new())));
-                                break;
-                            } else {
-                                c.push(*ch);
-                                chars.next();
-                            }
-                        } else {
-                            if c.len() > 0 {
-                                o.push(HtmlPart::Insert(c));
-                            }
-                            return o;
-                        }
-                    }
-                } else if ch == '\\' && chars.peek().is_some_and(|ch| *ch == '?') {
-                    chars.next();
-                    o.push(HtmlPart::Plain(mem::replace(&mut c, String::new())));
-                    let mut key = String::new();
-                    while let Some(ch) = chars.next() {
-                        if ch != '?' {
-                            key.push(ch);
-                        }
-                    }
-                    o.push(HtmlPart::IfElse(
-                        key,
-                        Self::parsei(chars),
-                        Self::parsei(chars),
-                    ));
-                } else {
-                    c.push(ch);
-                }
-            } else {
-                if c.len() > 0 {
-                    o.push(HtmlPart::Plain(c));
-                }
-                return o;
-            }
+    if (sfAlbum) {
+        if (query) {
+            query += "&";
         }
+        query += "album=" + encodeURIComponent(sfAlbum);
+    }
+    if (sfTitle) {
+        if (query) {
+            query += "&";
+        }
+        query += "title=" + encodeURIComponent(sfTitle);
+    }
+    if (query || confirm("You didn't search for anything specific. If you continue, the whole library will be loaded, which can take a while and use a lot of bandwidth!")) {
+        console.log("Performing search with query '" + query + "'.");
+        var r1 = await fetch("/search?" + query);
+        var r2 = await r1.text();
+        searchResultDiv.innerHTML = r2;
+    } else {
+        searchResultDiv.innerHTML = "";
     }
 }
-#[derive(Debug)]
-pub enum HtmlPart {
-    /// text as plain html
-    Plain(String),
-    /// insert some value depending on context and key
-    Insert(String),
-    /// If the key exists, use the first one, else use the second one.
-    IfElse(String, Vec<Self>, Vec<Self>),
+async function addSong(id) {
+    await fetch("/add-song/" + id);
+}
+</script>"#;
+    let buttons = "<button onclick=\"fetch('/play').then(() => location.reload())\">play</button><button onclick=\"fetch('/pause').then(() => location.reload())\">pause</button><button onclick=\"fetch('/skip').then(() => location.reload())\">skip</button><button onclick=\"fetch('/clear-queue').then(() => location.reload())\">clear queue</button><button onclick=\"location.reload()\">reload</button>";
+    let search = "<input id=\"searchFieldArtist\" placeholder=\"artist\"><input id=\"searchFieldAlbum\" placeholder=\"album\"><input id=\"searchFieldTitle\" placeholder=\"title\">
+<button onclick=\"performSearch()\">search</button><div id=\"searchResultDiv\"></div>";
+    let db = data.db.lock().unwrap();
+    let now_playing =
+        if let Some(current_song) = db.queue.get_current_song().and_then(|id| db.get_song(id)) {
+            format!(
+                "<h1>Now Playing</h1><h4>{}</h4>",
+                html_escape::encode_safe(&current_song.title),
+            )
+        } else {
+            format!("<h1>Now Playing</h1><p>nothing</p>",)
+        };
+    drop(db);
+    RawHtml(format!(
+        "{HTML_START}<title>MusicDb</title>{script}{HTML_SEP}{now_playing}<div>{buttons}</div><div>{search}</div>{HTML_END}",
+    ))
 }
 
-pub async fn main(db: Arc<Mutex<Database>>, sender: mpsc::Sender<Command>, addr: SocketAddr) {
-    let db1 = Arc::clone(&db);
-    let state = AppState {
-        db,
-        html: Arc::new(AppHtml::from_dir("assets").unwrap()),
-    };
-    let (s1, s2, s3, s4, s5, s6, s7, s8, s9) = (
-        sender.clone(),
-        sender.clone(),
-        sender.clone(),
-        sender.clone(),
-        sender.clone(),
-        sender.clone(),
-        sender.clone(),
-        sender.clone(),
-        sender,
-    );
-    let state1 = state.clone();
-
-    let app = Router::new()
-        // root
-        .nest_service(
-            "/",
-            get(move || async move {
-                Html(
-                    state1
-                        .html
-                        .root
-                        .iter()
-                        .map(|v| match v {
-                            HtmlPart::Plain(v) => v,
-                            HtmlPart::Insert(_) => "",
-                            HtmlPart::IfElse(_, _, _) => "",
-                        })
-                        .collect::<String>(),
-                )
-            }),
-        )
-        // server-sent events
-        .route("/sse", get(sse_handler))
-        // inner views (embedded in root)
-        .route("/artist-view/:artist-id", get(artist_view_handler))
-        .route("/album-view/:album-id", get(album_view_handler))
-        // handle POST requests via the mpsc::Sender instead of locking the db.
-        .route(
-            "/pause",
-            post(move || async move {
-                _ = s1.send(Command::Pause);
-            }),
-        )
-        .route(
-            "/resume",
-            post(move || async move {
-                _ = s2.send(Command::Resume);
-            }),
-        )
-        .route(
-            "/stop",
-            post(move || async move {
-                _ = s3.send(Command::Stop);
-            }),
-        )
-        .route(
-            "/next",
-            post(move || async move {
-                _ = s4.send(Command::NextSong);
-            }),
-        )
-        .route(
-            "/queue/clear",
-            post(move || async move {
-                _ = s5.send(Command::QueueUpdate(
-                    vec![],
-                    QueueContent::Folder(QueueFolder::default()).into(),
-                ));
-            }),
-        )
-        .route(
-            "/queue/remove/:i",
-            post(move |Path(i): Path<String>| async move {
-                let mut ids = vec![];
-                for id in i.split('-') {
-                    if let Ok(n) = id.parse() {
-                        ids.push(n);
-                    } else {
-                        return;
-                    }
-                }
-                _ = s8.send(Command::QueueRemove(ids));
-            }),
-        )
-        .route(
-            "/queue/goto/:i",
-            post(move |Path(i): Path<String>| async move {
-                let mut ids = vec![];
-                for id in i.split('-') {
-                    if let Ok(n) = id.parse() {
-                        ids.push(n);
-                    } else {
-                        return;
-                    }
-                }
-                _ = s9.send(Command::QueueGoto(ids));
-            }),
-        )
-        .route(
-            "/queue/add-song/:song-id",
-            post(move |Path(song_id)| async move {
-                _ = s6.send(Command::QueueAdd(
-                    vec![],
-                    vec![QueueContent::Song(song_id).into()],
-                ));
-            }),
-        )
-        .route(
-            "/queue/add-album/:album-id",
-            post(move |Path(album_id)| async move {
-                if let Some(album) = db1.lock().unwrap().albums().get(&album_id) {
-                    _ = s7.send(Command::QueueAdd(
-                        vec![],
-                        vec![QueueContent::Folder(QueueFolder {
-                            index: 0,
-                            content: album
-                                .songs
-                                .iter()
-                                .map(|id| QueueContent::Song(*id).into())
-                                .collect(),
-                            name: album.name.clone(),
-                            order: None,
-                        })
-                        .into()],
-                    ));
-                }
-            }),
-        )
-        .with_state(state);
-    axum::Server::bind(&addr)
-        .serve(app.into_make_service())
-        .await
+#[get("/play")]
+async fn play(data: &State<Data>) {
+    data.command_sender.send(Command::Resume).unwrap();
+}
+#[get("/pause")]
+async fn pause(data: &State<Data>) {
+    data.command_sender.send(Command::Pause).unwrap();
+}
+#[get("/skip")]
+async fn skip(data: &State<Data>) {
+    data.command_sender.send(Command::NextSong).unwrap();
+}
+#[get("/clear-queue")]
+async fn clear_queue(data: &State<Data>) {
+    data.command_sender
+        .send(Command::QueueUpdate(
+            vec![],
+            QueueContent::Folder(QueueFolder {
+                index: 0,
+                content: vec![],
+                name: String::new(),
+                order: None,
+            })
+            .into(),
+        ))
         .unwrap();
 }
 
-async fn sse_handler(
-    TypedHeader(user_agent): TypedHeader<headers::UserAgent>,
-    State(state): State<AppState>,
-) -> Sse<impl Stream<Item = Result<Event, Infallible>>> {
-    println!("`{}` connected", user_agent.as_str());
+#[get("/add-song/<id>")]
+async fn add_song(data: &State<Data>, id: SongId) {
+    data.command_sender
+        .send(Command::QueueAdd(
+            vec![],
+            vec![QueueContent::Song(id).into()],
+        ))
+        .unwrap();
+}
 
-    let (sender, mut receiver) = tokio::sync::mpsc::unbounded_channel();
-    let mut db = state.db.lock().unwrap();
-    _ = sender.send(Arc::new(Command::SyncDatabase(vec![], vec![], vec![])));
-    _ = sender.send(Arc::new(Command::NextSong));
-    _ = sender.send(Arc::new(if db.playing {
-        Command::Resume
-    } else {
-        Command::Pause
-    }));
-    db.update_endpoints
-        .push(UpdateEndpoint::CmdChannelTokio(sender));
-    drop(db);
-
-    let stream = stream::poll_fn(move |_ctx| {
-        if let Ok(cmd) = receiver.try_recv() {
-            Poll::Ready(Some(match cmd.as_ref() {
-                Command::Resume => Event::default().event("playing").data("playing"),
-                Command::Pause => Event::default().event("playing").data("paused"),
-                Command::Stop => Event::default().event("playing").data("stopped"),
-                Command::SyncDatabase(..)
-                | Command::ModifySong(..)
-                | Command::ModifyAlbum(..)
-                | Command::ModifyArtist(..)
-                | Command::AddSong(..)
-                | Command::AddAlbum(..)
-                | Command::AddArtist(..)
-                | Command::AddCover(..)
-                | Command::RemoveSong(_)
-                | Command::RemoveAlbum(_)
-                | Command::RemoveArtist(_)
-                | Command::TagSongFlagSet(..)
-                | Command::TagSongFlagUnset(..)
-                | Command::TagAlbumFlagSet(..)
-                | Command::TagAlbumFlagUnset(..)
-                | Command::TagArtistFlagSet(..)
-                | Command::TagArtistFlagUnset(..)
-                | Command::TagSongPropertySet(..)
-                | Command::TagSongPropertyUnset(..)
-                | Command::TagAlbumPropertySet(..)
-                | Command::TagAlbumPropertyUnset(..)
-                | Command::TagArtistPropertySet(..)
-                | Command::TagArtistPropertyUnset(..)
-                | Command::SetSongDuration(..) => Event::default().event("artists").data({
-                    let db = state.db.lock().unwrap();
-                    let mut a = db.artists().iter().collect::<Vec<_>>();
-                    a.sort_unstable_by_key(|(_id, artist)| &artist.name);
-                    let mut artists = String::new();
-                    for &(id, artist) in &a {
-                        fn gen(
-                            id: &u64,
-                            artist: &musicdb_lib::data::artist::Artist,
-                            v: &Vec<HtmlPart>,
-                            arts: &mut String,
-                        ) {
-                            for v in v {
-                                match v {
-                                    HtmlPart::Plain(v) => arts.push_str(v),
-                                    HtmlPart::Insert(key) => match key.as_str() {
-                                        "id" => arts.push_str(&id.to_string()),
-                                        "name" => arts.push_str(&artist.name),
-                                        _ => {}
-                                    },
-                                    HtmlPart::IfElse(_, _, e) => gen(id, artist, e, arts),
-                                }
-                            }
-                        }
-                        gen(id, artist, &state.html.artists_one, &mut artists);
-                    }
-                    state
-                        .html
-                        .artists
-                        .iter()
-                        .map(|v| match v {
-                            HtmlPart::Plain(v) => v,
-                            HtmlPart::Insert(key) => match key.as_str() {
-                                "artists" => &artists,
-                                _ => "",
-                            },
-                            HtmlPart::IfElse(_, _, _) => "",
-                        })
-                        .collect::<String>()
-                }),
-                Command::NextSong
-                | Command::QueueUpdate(..)
-                | Command::QueueAdd(..)
-                | Command::QueueInsert(..)
-                | Command::QueueRemove(..)
-                | Command::QueueMove(..)
-                | Command::QueueMoveInto(..)
-                | Command::QueueGoto(..)
-                | Command::QueueShuffle(..)
-                | Command::QueueSetShuffle(..)
-                | Command::QueueUnshuffle(..) => {
-                    let db = state.db.lock().unwrap();
-                    let current = db
-                        .queue
-                        .get_current_song()
-                        .map_or(None, |id| db.songs().get(id));
-                    let next = db
-                        .queue
-                        .get_next_song()
-                        .map_or(None, |id| db.songs().get(id));
-                    let mut content = String::new();
-                    build_queue_content_build(
-                        &db,
-                        &state,
-                        &mut content,
-                        &db.queue,
-                        String::new(),
-                        true,
-                        false,
-                    );
-                    Event::default().event("queue").data({
-                        fn gen(
-                            v: &Vec<HtmlPart>,
-                            current: Option<&musicdb_lib::data::song::Song>,
-                            next: Option<&musicdb_lib::data::song::Song>,
-                            content: &str,
-                        ) -> String {
-                            v.iter()
-                                .map(|v| match v {
-                                    HtmlPart::Plain(v) => Cow::Borrowed(v.as_str()),
-                                    HtmlPart::Insert(key) => match key.as_str() {
-                                        "currentTitle" => {
-                                            if let Some(s) = current {
-                                                Cow::Borrowed(s.title.as_str())
-                                            } else {
-                                                Cow::Borrowed("")
-                                            }
-                                        }
-                                        "nextTitle" => {
-                                            if let Some(s) = next {
-                                                Cow::Borrowed(s.title.as_str())
-                                            } else {
-                                                Cow::Borrowed("")
-                                            }
-                                        }
-                                        "content" => Cow::Borrowed(content),
-                                        _ => Cow::Borrowed(""),
-                                    },
-                                    HtmlPart::IfElse(k, t, e) => {
-                                        if (k == "current" && current.is_some())
-                                            || (k == "next" && next.is_some())
-                                        {
-                                            Cow::Owned(gen(t, current, next, content))
-                                        } else {
-                                            Cow::Owned(gen(e, current, next, content))
-                                        }
-                                    }
-                                })
-                                .collect::<String>()
-                        }
-                        gen(&state.html.queue, current, next, content.as_str())
-                    })
-                }
-                Command::Save | Command::InitComplete | Command::ErrorInfo(..) => {
-                    return Poll::Pending
-                }
-            }))
+#[get("/search?<artist>&<album>&<title>&<artist_tags>&<album_tags>&<song_tags>")]
+async fn search(
+    data: &State<Data>,
+    artist: Option<&str>,
+    album: Option<&str>,
+    title: Option<&str>,
+    artist_tags: Vec<&str>,
+    album_tags: Vec<&str>,
+    song_tags: Vec<&str>,
+) -> RawHtml<String> {
+    let db = data.db.lock().unwrap();
+    let mut out = String::new();
+    let artist = artist.map(|v| v.to_lowercase());
+    let artist = artist.as_ref().map(|v| v.as_str());
+    let album = album.map(|v| v.to_lowercase());
+    let album = album.as_ref().map(|v| v.as_str());
+    let title = title.map(|v| v.to_lowercase());
+    let title = title.as_ref().map(|v| v.as_str());
+    find1(
+        &*db,
+        artist,
+        album,
+        title,
+        &artist_tags,
+        &album_tags,
+        &song_tags,
+        &mut out,
+    );
+    fn find1(
+        db: &Database,
+        artist: Option<&str>,
+        album: Option<&str>,
+        title: Option<&str>,
+        artist_tags: &[&str],
+        album_tags: &[&str],
+        song_tags: &[&str],
+        out: &mut String,
+    ) {
+        if let Some(f) = artist {
+            find2(
+                db,
+                db.artists()
+                    .values()
+                    .filter(|v| v.name.to_lowercase().contains(f)),
+                album,
+                title,
+                artist_tags,
+                album_tags,
+                song_tags,
+                out,
+            )
         } else {
-            return Poll::Pending;
+            find2(
+                db,
+                db.artists().values(),
+                album,
+                title,
+                artist_tags,
+                album_tags,
+                song_tags,
+                out,
+            )
         }
-    })
-    .map(Ok);
-    // .throttle(Duration::from_millis(100));
-
-    Sse::new(stream)
-        .keep_alive(axum::response::sse::KeepAlive::new().interval(Duration::from_millis(250)))
-}
-
-async fn artist_view_handler(
-    State(state): State<AppState>,
-    Path(artist_id): Path<u64>,
-) -> Html<String> {
-    let db = state.db.lock().unwrap();
-    if let Some(artist) = db.artists().get(&artist_id) {
-        let mut albums = String::new();
-        for id in artist.albums.iter() {
-            if let Some(album) = db.albums().get(id) {
-                for v in &state.html.albums_one {
-                    match v {
-                        HtmlPart::Plain(v) => albums.push_str(v),
-                        HtmlPart::Insert(key) => match key.as_str() {
-                            "id" => albums.push_str(&id.to_string()),
-                            "name" => albums.push_str(&album.name),
-                            _ => {}
-                        },
-                        HtmlPart::IfElse(_, _, _) => (),
-                    }
-                }
-            }
-        }
-        let id = artist_id.to_string();
-        Html(
-            state
-                .html
-                .artist_view
-                .iter()
-                .map(|v| match v {
-                    HtmlPart::Plain(v) => v,
-                    HtmlPart::Insert(key) => match key.as_str() {
-                        "id" => &id,
-                        "name" => &artist.name,
-                        "albums" => &albums,
-                        _ => "",
-                    },
-                    HtmlPart::IfElse(_, _, _) => "",
-                })
-                .collect(),
-        )
-    } else {
-        Html(format!(
-            "<h1>Bad ID</h1><p>There is no artist with the id {artist_id} in the database</p>"
-        ))
     }
-}
-
-async fn album_view_handler(
-    State(state): State<AppState>,
-    Path(album_id): Path<u64>,
-) -> Html<String> {
-    let db = state.db.lock().unwrap();
-    if let Some(album) = db.albums().get(&album_id) {
-        let mut songs = String::new();
-        for id in album.songs.iter() {
-            if let Some(song) = db.songs().get(id) {
-                for v in &state.html.songs_one {
-                    match v {
-                        HtmlPart::Plain(v) => songs.push_str(v),
-                        HtmlPart::Insert(key) => match key.as_str() {
-                            "id" => songs.push_str(&id.to_string()),
-                            "title" => songs.push_str(&song.title),
-                            _ => {}
-                        },
-                        HtmlPart::IfElse(_, _, _) => (),
-                    }
-                }
-            }
-        }
-        let id = album_id.to_string();
-        Html(
-            state
-                .html
-                .album_view
+    fn find2<'a>(
+        db: &'a Database,
+        artists: impl IntoIterator<Item = &'a Artist>,
+        album: Option<&str>,
+        title: Option<&str>,
+        artist_tags: &[&str],
+        album_tags: &[&str],
+        song_tags: &[&str],
+        out: &mut String,
+    ) {
+        for artist in artists {
+            if artist_tags
                 .iter()
-                .map(|v| match v {
-                    HtmlPart::Plain(v) => v,
-                    HtmlPart::Insert(key) => match key.as_str() {
-                        "id" => &id,
-                        "name" => &album.name,
-                        "songs" => &songs,
-                        _ => "",
-                    },
-                    HtmlPart::IfElse(_, _, _) => "",
-                })
-                .collect(),
-        )
-    } else {
-        Html(format!(
-            "<h1>Bad ID</h1><p>There is no album with the id {album_id} in the database</p>"
-        ))
-    }
-}
-
-fn build_queue_content_build(
-    db: &Database,
-    state: &AppState,
-    html: &mut String,
-    queue: &Queue,
-    path: String,
-    current: bool,
-    skip_folder: bool,
-) {
-    // TODO: Do something for disabled ones too (they shouldn't just be hidden)
-    if queue.enabled() {
-        match queue.content() {
-            QueueContent::Song(id) => {
-                if let Some(song) = db.songs().get(id) {
-                    for v in if current {
-                        &state.html.queue_song_current
-                    } else {
-                        &state.html.queue_song
-                    } {
-                        match v {
-                            HtmlPart::Plain(v) => html.push_str(v),
-                            HtmlPart::Insert(key) => match key.as_str() {
-                                "path" => html.push_str(&path),
-                                "title" => html.push_str(&song.title),
-                                _ => {}
-                            },
-                            HtmlPart::IfElse(_, _, _) => (),
-                        }
-                    }
+                .all(|t| artist.general.tags.iter().any(|v| v == t))
+            {
+                let mut func_artist = Some(|out: &mut String| {
+                    out.push_str("<h3>");
+                    out.push_str(&artist.name);
+                    out.push_str("</h3>");
+                });
+                let mut func_album = None;
+                if false {
+                    // so they have the same type
+                    std::mem::swap(&mut func_artist, &mut func_album);
                 }
-            }
-            QueueContent::Folder(folder) => {
-                if skip_folder || path.is_empty() {
-                    for (i, c) in folder.iter().enumerate() {
-                        let current = current && folder.index == i;
-                        build_queue_content_build(db, state, html, c, i.to_string(), current, false)
-                    }
-                } else {
-                    fn gen(
-                        v: &Vec<HtmlPart>,
-                        folder: &QueueFolder,
-                        db: &Database,
-                        state: &AppState,
-                        html: &mut String,
-                        path: &str,
-                        current: bool,
-                    ) {
-                        for v in v {
-                            match v {
-                                HtmlPart::Plain(v) => html.push_str(v),
-                                HtmlPart::Insert(key) => match key.as_str() {
-                                    "path" => html.push_str(&path),
-                                    "name" => html.push_str(&folder.name),
-                                    "content" => {
-                                        for (i, c) in folder.iter().enumerate() {
-                                            let current = current && folder.index == i;
-                                            build_queue_content_build(
-                                                db,
-                                                state,
-                                                html,
-                                                c,
-                                                format!("{path}-{i}"),
-                                                current,
-                                                false,
-                                            )
-                                        }
-                                    }
-                                    _ => {}
-                                },
-                                HtmlPart::IfElse(i, t, e) => {
-                                    if i == "shuffled" && folder.order.is_some() {
-                                        gen(t, folder, db, state, html, path, current)
-                                    } else {
-                                        gen(e, folder, db, state, html, path, current)
-                                    }
-                                }
-                            }
-                        }
-                    }
-                    gen(
-                        if current {
-                            &state.html.queue_folder_current
-                        } else {
-                            &state.html.queue_folder
-                        },
-                        folder,
+                if album.is_none() && album_tags.is_empty() {
+                    find4(
                         db,
-                        state,
-                        html,
-                        &path,
-                        current,
+                        artist.singles.iter().filter_map(|v| db.get_song(v)),
+                        title,
+                        song_tags,
+                        out,
+                        &mut func_artist,
+                        &mut func_album,
+                    );
+                }
+                let iter = artist.albums.iter().filter_map(|v| db.albums().get(v));
+                if let Some(f) = album {
+                    find3(
+                        db,
+                        iter.filter(|v| v.name.to_lowercase().contains(f)),
+                        title,
+                        album_tags,
+                        song_tags,
+                        out,
+                        &mut func_artist,
+                    )
+                } else {
+                    find3(
+                        db,
+                        iter,
+                        title,
+                        album_tags,
+                        song_tags,
+                        out,
+                        &mut func_artist,
                     )
                 }
             }
-            QueueContent::Loop(total, cur, inner) => {
-                for v in match (*total, current) {
-                    (0, false) => &state.html.queue_loopinf,
-                    (0, true) => &state.html.queue_loopinf_current,
-                    (_, false) => &state.html.queue_loop,
-                    (_, true) => &state.html.queue_loop_current,
-                } {
-                    match v {
-                        HtmlPart::Plain(v) => html.push_str(v),
-                        HtmlPart::Insert(key) => match key.as_str() {
-                            "path" => html.push_str(&path),
-                            "total" => html.push_str(&format!("{total}")),
-                            "current" => html.push_str(&format!("{cur}")),
-                            "inner" => build_queue_content_build(
-                                db,
-                                state,
-                                html,
-                                &inner,
-                                format!("{path}-0"),
-                                current,
-                                true,
-                            ),
-                            _ => {}
-                        },
-                        HtmlPart::IfElse(_, _, _) => (),
-                    }
-                }
+        }
+    }
+    fn find3<'a>(
+        db: &'a Database,
+        albums: impl IntoIterator<Item = &'a Album>,
+        title: Option<&str>,
+        album_tags: &[&str],
+        song_tags: &[&str],
+        out: &mut String,
+        func_artist: &mut Option<impl FnOnce(&'_ mut String)>,
+    ) {
+        for album in albums {
+            if album_tags
+                .iter()
+                .all(|t| album.general.tags.iter().any(|v| v == t))
+            {
+                let mut func_album = Some(|out: &mut String| {
+                    out.push_str("<h4>");
+                    out.push_str(&album.name);
+                    out.push_str("</h4>");
+                });
+                find4(
+                    db,
+                    album.songs.iter().filter_map(|v| db.get_song(v)),
+                    title,
+                    song_tags,
+                    out,
+                    func_artist,
+                    &mut func_album,
+                )
             }
         }
     }
+    fn find4<'a>(
+        db: &'a Database,
+        songs: impl IntoIterator<Item = &'a Song>,
+        title: Option<&str>,
+        song_tags: &[&str],
+        out: &mut String,
+        func_artist: &mut Option<impl FnOnce(&'_ mut String)>,
+        func_album: &mut Option<impl FnOnce(&'_ mut String)>,
+    ) {
+        if let Some(f) = title {
+            find5(
+                db,
+                songs
+                    .into_iter()
+                    .filter(|v| v.title.to_lowercase().contains(f)),
+                song_tags,
+                out,
+                func_artist,
+                func_album,
+            )
+        } else {
+            find5(db, songs, song_tags, out, func_artist, func_album)
+        }
+    }
+    fn find5<'a>(
+        db: &'a Database,
+        songs: impl IntoIterator<Item = &'a Song>,
+        song_tags: &[&str],
+        out: &mut String,
+        func_artist: &mut Option<impl FnOnce(&'_ mut String)>,
+        func_album: &mut Option<impl FnOnce(&'_ mut String)>,
+    ) {
+        for song in songs {
+            if song_tags
+                .iter()
+                .all(|t| song.general.tags.iter().any(|v| v == t))
+            {
+                find6(db, song, out, func_artist, func_album)
+            }
+        }
+    }
+    fn find6<'a>(
+        _db: &Database,
+        song: &Song,
+        out: &mut String,
+        func_artist: &mut Option<impl FnOnce(&'_ mut String)>,
+        func_album: &mut Option<impl FnOnce(&'_ mut String)>,
+    ) {
+        if let Some(f) = func_artist.take() {
+            f(out)
+        }
+        if let Some(f) = func_album.take() {
+            f(out)
+        }
+        out.push_str("<button onclick=\"addSong('");
+        out.push_str(&format!("{}", song.id));
+        out.push_str("')\">");
+        out.push_str(&song.title);
+        out.push_str("</button><br>");
+    }
+    RawHtml(out)
+}
+
+pub async fn main(
+    db: Arc<Mutex<Database>>,
+    command_sender: mpsc::Sender<Command>,
+    addr: SocketAddr,
+) {
+    rocket::build()
+        .configure(Config {
+            address: addr.ip(),
+            port: addr.port(),
+            ..Default::default()
+        })
+        .manage(Data { db, command_sender })
+        .mount(
+            "/",
+            routes![index, play, pause, skip, clear_queue, add_song, search],
+        )
+        .launch()
+        .await
+        .unwrap();
 }