diff --git a/README.md b/README.md
index 501d316..a246587 100644
--- a/README.md
+++ b/README.md
@@ -46,12 +46,12 @@ If no config file is found, a config file with all options and their default val
 | down_on_mark           | true         | bool | Move pointer one down if a video is marked                                                                                             |
 | app_title              | "TYT"        | str  | The title of the left box                                                                                                              |
 | update_at_start        | true         | bool | Fetch new videos at start                                                                                                              |
-| sort_by_tag            | false        | bool | Sort channels by tag or name                                                                                                           |
+| sort_channels          | AlphaNumeric | enum | One of `AlphaNumeric` or `ByTag`                                                                                                       |
 | video_player           | "mpv"        | str  | Could also be [umpv](https://raw.githubusercontent.com/mpv-player/mpv/master/TOOLS/umpv), vlc, or any other program.                   |
-| default_sorting_method | UneenDate    | enum | Can be one of: `Date, Text, UnseenDate, UnseenText`                                                                                    |
+| sort_videos            | UneenDate    | enum | Can be one of: `Date, Text, UnseenDate, UnseenText`                                                                                    |
 | notify_with            | "notify-send | str  | Could also be `dunstify` for example                                                                                                   |
 
-## How do I "Subscribe" 
+## How do I "Subscribe"
 
 The videos are fetched from a list of urls that have to be provided in the ` ~/.config/tyt/subscriptions.yaml ` file.
 
diff --git a/src/backend/core.rs b/src/backend/core.rs
index fc52e5a..255b581 100644
--- a/src/backend/core.rs
+++ b/src/backend/core.rs
@@ -16,48 +16,30 @@ use std::{
     process::{Command, Stdio},
     sync::mpsc::{channel, Receiver, Sender},
 };
-use tui::{
-    style::{Color, Style},
-    text::{Span, Spans},
-    widgets::ListItem,
-};
 
-#[derive(Debug, Clone)]
-pub(crate) enum Status {
+#[derive(Clone, Debug)]
+pub enum FetchState {
+    DownloadsFailure(usize),
+    Waiting,
     Loading,
     Fetched,
-    // Error
 }
 
-#[derive(Clone)]
-pub(crate) struct StatusUpdate {
-    text: String,
-    status: self::Status,
+impl Default for FetchState {
+    fn default() -> Self {
+        Self::Waiting
+    }
 }
 
-/* impl ToTuiListItem for StatusUpdate { */
-impl StatusUpdate {
-    pub(crate) fn into_list_item(self) -> ListItem<'static> {
-        let status_color = match &self.status {
-            Status::Loading => Style::default().fg(Color::Magenta),
-            Status::Fetched => Style::default().fg(Color::Green),
-            // Status::Error => Style::default().fg(Color::Red),
-        };
-
-        let text_color = Style::default().fg(Color::Yellow);
-
-        let status_text = format!("{:?} ", self.status);
-
-        ListItem::new(Spans::from(vec![
-            Span::styled(status_text, status_color),
-            Span::styled(self.text, text_color),
-        ]))
-    }
+#[derive(Clone)]
+pub(crate) struct StateUpdate {
+    text: String,
+    state: self::FetchState,
 }
 
-impl StatusUpdate {
-    pub(crate) fn new(text: String, status: self::Status) -> Self {
-        Self { text, status }
+impl StateUpdate {
+    pub(crate) fn new(text: String, status: self::FetchState) -> Self {
+        Self { text, state: status }
     }
 }
 
@@ -65,13 +47,11 @@ impl StatusUpdate {
 pub(crate) struct Core {
     pub(crate) terminal: Terminal,
     pub(crate) config: Config,
-    pub(crate) status: Vec<StatusUpdate>,
     pub(crate) current_screen: Screen,
-    pub(crate) current_filter: Filter,
     channel_list: ChannelList,
     pub(crate) playback_history: History,
-    pub(crate) status_sender: Sender<StatusUpdate>,
-    pub(crate) status_receiver: Receiver<StatusUpdate>,
+    pub(crate) status_sender: Sender<StateUpdate>,
+    pub(crate) status_receiver: Receiver<StateUpdate>,
 }
 
 impl Core {
@@ -92,7 +72,7 @@ impl Core {
             ChannelList::default()
         });
         channel_list.select(Some(0));
-        channel_list.filter(current_filter, config.sort_by_tag);
+        channel_list.set_filter(current_filter);
 
         let playback_history = History::load();
 
@@ -103,8 +83,6 @@ impl Core {
             config,
             current_screen: Channels,
             channel_list,
-            status: Vec::new(),
-            current_filter,
             playback_history,
             status_sender,
             status_receiver,
@@ -114,47 +92,23 @@ impl Core {
     }
 
     pub(crate) fn save(&mut self) {
-        let f = self.current_filter;
-        self.set_filter(Filter::NoFilter);
-        let string = serde_json::to_string(self.get_filtered_channel_list()).unwrap();
+        let string = serde_json::to_string(self.channel_list()).unwrap();
         write_config(DbFile, &string);
-        self.set_filter(f);
-    }
-
-    pub(crate) fn status_update(&mut self, msg: StatusUpdate) {
-        self.status_sender.send(msg).unwrap();
     }
 
-    //-------- gettter and setter ----------------------
-
     /// receive all status updates from status channel
     pub(crate) fn update_status_line(&mut self) -> bool {
-        let mut found = false;
+        let mut changed = false;
+
         for item in self.status_receiver.try_iter() {
-            found = true;
-            for i in 0..self.status.len() {
-                if self.status[i].text == item.text {
-                    self.status.remove(i);
-                    break;
-                }
+            changed = true;
+
+            if let Some(mut channel) = self.channel_list.get_unfiltered_mut_by_id(&item.text) {
+                channel.fetch_state = item.state.clone();
             }
-            self.status.push(item);
         }
 
-        found
-    }
-
-    pub(crate) fn get_show_empty(&self) -> bool {
-        self.config.show_empty_channels
-    }
-    pub(crate) fn set_show_empty(&mut self, b: bool) {
-        self.config.show_empty_channels = b;
-
-        let new_filter = match self.current_filter {
-            Filter::NoFilter => Filter::OnlyNew,
-            Filter::OnlyNew => Filter::NoFilter,
-        };
-        self.set_filter(new_filter);
+        changed
     }
 
     pub(crate) fn update_at_start(&self) -> bool {
@@ -173,18 +127,23 @@ impl Core {
             match action {
                 Mark(state) => {
                     if self.current_screen == Videos {
-                        if let Some(video) = self.get_selected_video_mut() {
+
+                        let current_channel = self.get_selected_channel_mut()?;
+                        let selected = current_channel.selected()?;
+
+                        if let Some(video) = current_channel.get_mut(selected) {
                             video.mark(state);
                         }
 
-                        if !self.get_selected_channel_mut()?.has_new()
-                            && self.current_filter == Filter::OnlyNew
-                        {
+                        let has_new = !current_channel.has_new();
+                        let is_only_new = self.channel_list.get_filter() == Filter::OnlyNew;
+                        if has_new && is_only_new {
                             self.action(Leave);
                         } else if self.config.down_on_mark {
                             self.get_selected_channel_mut()?.next();
                         }
 
+
                         // let pos = self.get_selected_channel_index();
                         let pos = self.get_selected_channel()?.selected();
                         self.save();
@@ -192,11 +151,11 @@ impl Core {
                     }
                 }
                 Up => match self.current_screen {
-                    Channels => self.get_filtered_channel_list_mut().prev(),
+                    Channels => self.channel_list.prev(),
                     Videos => self.get_selected_channel_mut()?.prev(),
                 },
                 Down => match self.current_screen {
-                    Channels => self.get_filtered_channel_list_mut().next(),
+                    Channels => self.channel_list.next(),
                     Videos => self.get_selected_channel_mut()?.next(),
                 },
                 Enter => {
@@ -208,7 +167,7 @@ impl Core {
                 Leave => {
                     self.current_screen = Channels;
                     let i = self.get_selected_channel_index();
-                    self.get_filtered_channel_list_mut().select(i);
+                    self.channel_list.select(i);
                 }
                 NextChannel => match self.current_screen {
                     Channels => {}
@@ -233,11 +192,6 @@ impl Core {
                     }
                 }
                 Open => {
-                    /* let video = match self.get_selected_video_mut() {
-                     *     Some(v) => v.clone(),
-                     *     None => return,
-                     * }; */
-
                     // get video
                     let video = self.get_selected_video_mut()?.clone();
 
@@ -264,107 +218,20 @@ impl Core {
                 }
             }
             None
-        }(); // TODO test closure
+        }();
     }
 
     pub(crate) fn draw(&self) {
         draw(self.into());
     }
 
-    /// Set a filter
-    fn set_filter(&mut self, filter: Filter) {
-        self.current_filter = filter;
-        self.set_channel_list(self.channel_list.clone());
+    pub fn toggle_filter(&mut self) {
+        self.channel_list.toggle_filter();
     }
 
-    fn set_channel_list(&mut self, mut new_channel_list: ChannelList) {
-        if new_channel_list.len() == 0 {
-            return;
-        }
-
-        // remember selected screen
-        let on_videos = self.current_screen == Videos;
-
-        let video_pos = || -> Option<usize> {
-            self.action(Leave);
-            let pos = self.get_selected_channel()?.selected();
-            pos
-        }();
-
-        /* let mut video_pos = None;
-         * if on_videos {
-         *     self.action(Leave);
-         *     video_pos = self.get_selected_channel().selected();
-         * } */
-
-        // remember selection
-        let selected_channel_index = self.get_selected_channel_index();
-        /* let selected_channel_id = if self.get_filtered_channel_list().len() > 0 {
-         *     self.get_selected_channel_mut().id().clone()
-         * } else {
-         *     String::new() // will not match later: intended
-         * }; */
-
-        // apply current filter to new list
-        new_channel_list.filter(self.current_filter, self.config.sort_by_tag);
-        self.channel_list = new_channel_list;
-
-        /* let selection = self
-         *     .get_filtered_channel_list()
-         *     .get_position_by_id(&selected_channel_id); */
-
-        /* #[cfg(test)]
-         * println!(
-         *     "{:?}, selection: {}, selected_channel_index: {}",
-         *     position, selection, selected_channel_index
-         * ); */
-
-        self.channel_list.select(selected_channel_index);
-
-        // if on_videos && selected_channel_index.is_some() {
-        if on_videos {
-            self.action(Enter);
-            if let Some(channel) = self.get_selected_channel_mut() {
-                channel.select(video_pos);
-            }
-        } else if selected_channel_index.is_some() {
-            self.channel_list.select(selected_channel_index);
-        } else {
-            // try setting it to the first element
-            self.channel_list.select(Some(0));
-        }
-    }
-
-    /* pub(crate) fn select(&mut self, p: usize) {
-     *     let pos = min(self.channel_list.len() - 1, p);
-     *     self.channel_list.select(Some(pos));
-     * } */
-
     /// Search for the channel in channel_list by id. If found insert videos that are not already in channel.videos; else insert channel to channel_list.
     pub(crate) fn update_channel(&mut self, updated_channel: Channel) {
-        let mut channel_list = self.get_filtered_channel_list().clone();
-
-        self.status_update(StatusUpdate::new(
-            updated_channel.name().clone(),
-            Status::Fetched,
-        ));
-        // self.status_update(format!("Updated: {}", &updated_channel.name()));
-
-        if let Some(channel) = channel_list.get_mut_by_id(updated_channel.id()) {
-            channel.merge_videos(updated_channel.videos); // add video to channel
-        } else {
-            channel_list.push(updated_channel); // insert new channel
-        }
-
-        self.set_channel_list(channel_list);
-    }
-
-    fn get_filtered_channel_list_mut(&mut self) -> &mut ChannelList {
-        &mut self.channel_list
-    }
-
-    pub(crate) fn get_filtered_channel_list(&self) -> &ChannelList {
-        &self.channel_list
+        self.channel_list.update_channel(updated_channel, self.config.sort_channels);
     }
 
     pub(crate) fn get_selected_video_link(&mut self) -> String {
@@ -374,25 +241,24 @@ impl Core {
         }
     }
 
+    pub fn channel_list(&self) -> &ChannelList {
+        &self.channel_list
+    }
+
     pub(crate) fn get_selected_channel_index(&self) -> Option<usize> {
-        self.get_filtered_channel_list().selected()
+        self.channel_list.selected()
     }
 
     pub(crate) fn get_selected_channel(&self) -> Option<&Channel> {
         let i = self.get_selected_channel_index()?;
-        self.get_filtered_channel_list().get(i)
+        self.channel_list.get(i)
     }
 
     pub(crate) fn get_selected_channel_mut(&mut self) -> Option<&mut Channel> {
         let i = self.get_selected_channel_index()?;
-        self.get_filtered_channel_list_mut().get_mut(i)
+        self.channel_list.get_mut(i)
     }
 
-    /* pub(crate) fn get_selected_video(&self) -> Option<&Video> {
-     *     let i = self.get_selected_channel()?.selected()?;
-     *     self.get_selected_channel()?.get(i)
-     * } */
-
     pub(crate) fn get_selected_video_mut(&mut self) -> Option<&mut Video> {
         let i = self.get_selected_channel()?.selected()?;
         self.get_selected_channel_mut()?.get_mut(i)
diff --git a/src/backend/data/channel/builder.rs b/src/backend/data/channel/builder.rs
index a8e9164..40efedf 100644
--- a/src/backend/data/channel/builder.rs
+++ b/src/backend/data/channel/builder.rs
@@ -4,7 +4,7 @@ use crate::backend::{
         feed::Feed,
         video::{builder::VideoBuilder, Video},
     },
-    SortingMethod,
+    SortingMethodVideos,
 };
 
 #[derive(Default)]
@@ -41,7 +41,7 @@ impl ChannelBuilder {
         self
     }
 
-    pub fn with_sorting(mut self, sorting_method: SortingMethod) -> Self {
+    pub fn with_sorting(mut self, sorting_method: SortingMethodVideos) -> Self {
         self.channel.sorting_method = sorting_method;
         self
     }
diff --git a/src/backend/data/channel/mod.rs b/src/backend/data/channel/mod.rs
index 53eb54d..3e4e290 100644
--- a/src/backend/data/channel/mod.rs
+++ b/src/backend/data/channel/mod.rs
@@ -1,9 +1,10 @@
 mod builder;
 
 use crate::backend::{
-    data::{channel::builder::ChannelBuilder, video::Video},
+    data::{channel::builder::ChannelBuilder, video::Video,},
     io::subscriptions::SubscriptionItem,
-    SortingMethod, ToTuiListItem,
+    SortingMethodVideos, ToTuiListItem,
+    core::FetchState,
 };
 use serde::{Deserialize, Serialize};
 use std::cmp::min;
@@ -20,11 +21,14 @@ pub struct Channel {
     pub(crate) videos: Vec<Video>,
 
     #[serde(skip_deserializing)]
-    pub sorting_method: SortingMethod,
+    pub sorting_method: SortingMethodVideos,
     #[serde(skip)]
     pub(super) tag: String,
     #[serde(skip)]
     list_state: ListState,
+
+    #[serde(skip)]
+    pub fetch_state: FetchState,
 }
 
 #[allow(clippy::unnecessary_unwrap)]
@@ -136,22 +140,22 @@ impl Channel {
 
     pub fn sort(&mut self) {
         match self.sorting_method {
-            SortingMethod::Date => {
+            SortingMethodVideos::Date => {
                 self.videos.sort();
                 self.videos.sort_by_key(|video| video.pub_date().clone());
                 self.videos.reverse();
             }
-            SortingMethod::Text => {
+            SortingMethodVideos::Text => {
                 self.videos.sort_by(|video_a, video_b| {
                     alphanumeric_sort::compare_str(video_a.title().clone(), video_b.title().clone())
                 });
             }
-            SortingMethod::UnseenDate => {
+            SortingMethodVideos::UnseenDate => {
                 self.videos.sort_by_key(|video| video.pub_date().clone());
                 self.videos.reverse();
                 self.videos.sort();
             }
-            SortingMethod::UnseenText => {
+            SortingMethodVideos::UnseenText => {
                 self.videos.sort_by(|video_a, video_b| {
                     alphanumeric_sort::compare_str(video_a.title().clone(), video_b.title().clone())
                 });
@@ -193,11 +197,13 @@ impl ToTuiListItem for Channel {
         let tag = if self.tag.is_empty() {
             String::from("")
         } else {
-            format!(" [{}]", &self.tag)
+            format!(" [{}]", &self.tag())
         };
 
         let video_count = format!("{}/{}", num_marked, &self.videos.len());
 
+        let fetch_state = format!(" - {:?}", self.fetch_state);
+
         let new = if has_new {
             " * ".to_string()
         } else {
@@ -214,6 +220,7 @@ impl ToTuiListItem for Channel {
             .fg(Color::DarkGray)
             .add_modifier(Modifier::ITALIC);
 
+        // Combine displayed information to string
         if num_marked > &0 {
             ListItem::new(Spans::from(vec![
                 Span::styled(new, light_green),
@@ -221,6 +228,7 @@ impl ToTuiListItem for Channel {
                 Span::styled(tag, blue),
                 Span::styled(spacer, gray),
                 Span::styled(video_count, gray),
+                Span::styled(fetch_state, gray),
             ]))
         } else {
             ListItem::new(Spans::from(vec![
@@ -229,6 +237,7 @@ impl ToTuiListItem for Channel {
                 Span::styled(tag, gray),
                 Span::styled(spacer, gray),
                 Span::styled(video_count, gray),
+                Span::styled(fetch_state, gray),
             ]))
         }
     }
diff --git a/src/backend/data/channel_list.rs b/src/backend/data/channel_list.rs
index bcee226..b19e31d 100644
--- a/src/backend/data/channel_list.rs
+++ b/src/backend/data/channel_list.rs
@@ -1,9 +1,12 @@
+#![allow(unused)]
+
 use crate::backend::{
     data::channel::Channel,
     io::subscriptions::{SubscriptionItem, Subscriptions},
     io::{read_config, FileType::DbFile},
     Error::ParseDB,
     Filter::{self, *},
+    SortingMethodChannels,
     Result, ToTuiListItem,
 };
 use serde::{Deserialize, Serialize};
@@ -17,7 +20,7 @@ pub(crate) struct ChannelList {
     #[serde(skip)]
     list_state: ListState,
     #[serde(skip)]
-    backup: Vec<Channel>,
+    filter: Filter,
 }
 
 impl Default for ChannelList {
@@ -25,7 +28,7 @@ impl Default for ChannelList {
         Self {
             channels: vec![Channel::default()],
             list_state: ListState::default(),
-            backup: Vec::new(),
+            filter: Filter::NoFilter,
         }
     }
 }
@@ -44,12 +47,11 @@ impl ChannelList {
         }
     }
 
-    #[allow(dead_code)]
     pub(crate) fn next(&mut self) {
         let state = &self.list_state;
         let index = match state.selected() {
             Some(i) => {
-                if i + 1 < self.channels.len() {
+                if i + 1 < self.len() {
                     i + 1
                 } else {
                     i
@@ -60,7 +62,6 @@ impl ChannelList {
         self.list_state.select(Some(index));
     }
 
-    #[allow(dead_code)]
     pub(crate) fn prev(&mut self) {
         let state = &self.list_state;
         let index = match state.selected() {
@@ -79,7 +80,10 @@ impl ChannelList {
     //---------------------------------------------------------------
 
     pub(crate) fn len(&self) -> usize {
-        self.channels.len()
+        match self.filter {
+            NoFilter => self.channels.len(),
+            OnlyNew => self.channels.iter().filter(|c| c.videos.iter().any(|v| !v.marked())).count()
+        }
     }
 
     pub fn select(&mut self, i: Option<usize>) {
@@ -104,32 +108,126 @@ impl ChannelList {
     }
 
     pub(crate) fn get(&self, index: usize) -> Option<&Channel> {
+        match self.filter {
+            NoFilter => self.channels.get(index),
+            OnlyNew => self.channels.iter().filter(|c| c.videos.iter().any(|v| !v.marked())).nth(index)
+        }
+    }
+
+    pub(crate) fn get_unfiltered(&self, index: usize) -> Option<&Channel> {
         self.channels.get(index)
     }
 
     pub(crate) fn get_mut(&mut self, index: usize) -> Option<&mut Channel> {
+        match self.filter {
+            NoFilter => self.channels.get_mut(index),
+            OnlyNew => self.channels.iter_mut().filter(|c| c.videos.iter().any(|v| !v.marked())).nth(index)
+        }
+    }
+
+    pub(crate) fn get_unfiltered_mut(&mut self, index: usize) -> Option<&mut Channel> {
         self.channels.get_mut(index)
     }
 
-    pub(crate) fn get_by_id(&self, id: &str) -> Option<&Channel> {
+    pub fn get_by_id(&self, id: &str) -> Option<&Channel> {
         let p = self.get_position_by_id(id)?;
-        self.channels.get(p)
+        self.get(p)
+    }
+
+    pub fn get_unfiltered_by_id(&self, id: &str) -> Option<&Channel> {
+        let p = self.get_unfiltered_position_by_id(id)?;
+        self.get_unfiltered(p)
     }
 
-    pub(crate) fn get_mut_by_id(&mut self, id: &str) -> Option<&mut Channel> {
+    pub fn get_mut_by_id(&mut self, id: &str) -> Option<&mut Channel> {
         let p = self.get_position_by_id(id)?;
-        self.channels.get_mut(p)
+        self.get_mut(p)
+    }
+
+    pub fn get_unfiltered_mut_by_id(&mut self, id: &str) -> Option<&mut Channel> {
+        let p = self.get_unfiltered_position_by_id(id)?;
+        self.get_unfiltered_mut(p)
+    }
+
+
+    pub fn get_position_by_id(&self, id: &str) -> Option<usize> {
+        match self.filter {
+            NoFilter => self.channels.iter().position(|channel| channel.id() == id),
+            OnlyNew => {
+                self.channels.iter()
+                    .filter(|c| c.videos.iter().any(|v| !v.marked()))
+                    .position(|channel| channel.id() == id)
+            }
+        }
     }
 
-    pub(crate) fn get_position_by_id(&self, id: &str) -> Option<usize> {
+    pub fn get_unfiltered_position_by_id(&self, id: &str) -> Option<usize> {
         self.channels.iter().position(|channel| channel.id() == id)
     }
 
+    pub fn set_filter(&mut self, filter: Filter) {
+        self.filter = filter;
+        self.select(self.selected()); // this resets the selection if it is out of bounds
+    }
+
+    pub fn get_filter(&self) -> Filter {
+        self.filter
+    }
+
+    pub fn toggle_filter(&mut self) {
+        match self.filter {
+            NoFilter => self.set_filter(OnlyNew),
+            OnlyNew => self.set_filter(NoFilter),
+        }
+    }
+
     pub(crate) fn get_spans_list(&self) -> Vec<ListItem> {
-        self.channels
-            .iter()
-            .map(|channel| channel.to_list_item())
-            .collect()
+        match self.filter {
+            NoFilter => {
+                self.channels
+                    .iter()
+                    .map(|channel| channel.to_list_item())
+                    .collect()
+            }
+            OnlyNew => {
+                self.channels
+                    .iter()
+                    .filter(|c| c.videos.iter().any(|v| !v.marked()))
+                    .map(|channel| channel.to_list_item())
+                    .collect()
+            }
+        }
+    }
+
+    /// Add new videos to already known channel
+    pub fn update_channel(&mut self, updated_channel: Channel, sort: SortingMethodChannels) {
+        let filter = self.get_filter();
+        self.set_filter(Filter::NoFilter);
+
+        let old_channel = self.get_mut_by_id(updated_channel.id()); // get old channel
+
+        if let Some(channel) = old_channel {
+            channel.merge_videos(updated_channel.videos); // merge videos of new and old version
+        } else {
+            self.push(updated_channel);
+        }
+
+        match sort {
+            SortingMethodChannels::AlphaNumeric => {
+                self.channels.sort_by_key(|channel| channel.name().clone().to_lowercase());
+            }
+            SortingMethodChannels::ByTag => {
+                self.channels.sort_by_key(|channel| {
+                    if channel.tag().is_empty() {
+                        channel.name().clone().to_lowercase() // lowercase is sorted after uppercase
+                    } else {
+                        format!("{}{}", channel.tag().clone().to_uppercase(), channel.name().clone().to_uppercase())
+                    }
+                });
+            }
+        }
+
+        self.set_filter(filter);
     }
 
     /// Filter all channels that are not in the UrlFile anymore
@@ -201,48 +299,6 @@ impl ChannelList {
             ..Self::default()
         }
     }
-
-    pub(crate) fn filter(&mut self, filter: Filter, sort_by_tag: bool) {
-        // merge changes to backup
-        let tmp = self.backup.clone();
-        self.backup = self.channels.clone();
-        for chan in tmp.iter() {
-            if !self.backup.iter().any(|c| c.id() == chan.id()) {
-                self.backup.push(chan.clone());
-            }
-        }
-
-        // sort
-        if sort_by_tag {
-            self.backup.sort_by_key(|channel|
-                if channel.tag().is_empty() {
-                    channel.name().clone().to_lowercase() // lowercase is sorted after uppercase
-                /* if channel.has_new() {
-                 *     channel.name.clone().to_lowercase() // lowercase is sorted after uppercase */
-                } else {
-                    format!("{}{}", channel.tag().clone().to_uppercase(), channel.name().clone().to_uppercase())
-                }
-            );
-        } else {
-            self.backup
-                .sort_by_key(|channel| channel.name().clone().to_lowercase());
-        }
-
-        // aply new changes
-        match filter {
-            NoFilter => {
-                self.channels = self.backup.clone();
-            }
-            OnlyNew => {
-                self.channels = self
-                    .backup
-                    .iter()
-                    .cloned()
-                    .filter(|c| c.videos.iter().any(|v| !v.marked()))
-                    .collect();
-            }
-        }
-    }
 }
 
 impl PartialEq<ChannelList> for ChannelList {
diff --git a/src/backend/data/mod.rs b/src/backend/data/mod.rs
index 689d1bc..7d53521 100644
--- a/src/backend/data/mod.rs
+++ b/src/backend/data/mod.rs
@@ -6,7 +6,7 @@ pub(crate) mod video;
 use self::channel_list::ChannelList;
 use crate::{
     backend::{
-        core::{Status, StatusUpdate},
+        core::{FetchState, StateUpdate},
         data::channel::Channel,
         data::feed::Feed,
         io::subscriptions::{SubscriptionItem, Subscriptions},
@@ -23,12 +23,12 @@ use threadpool::ThreadPool;
 pub(crate) struct Data {
     sender: Sender<Channel>,
     receiver: Receiver<Channel>,
-    status_sender: Sender<StatusUpdate>,
+    status_sender: Sender<StateUpdate>,
 }
 
 impl Data {
     /// Init
-    pub(crate) fn init(status_sender: Sender<StatusUpdate>) -> Self {
+    pub(crate) fn init(status_sender: Sender<StateUpdate>) -> Self {
         let (sender, receiver) = channel();
 
         Self {
@@ -63,7 +63,7 @@ impl Data {
         };
 
         // prepate threads
-        let worker_num = 4;
+        let worker_num = 10;
         let pool = ThreadPool::new(worker_num);
 
         // load "normal" channels
@@ -99,7 +99,7 @@ fn fetch_channel_updates<T: 'static + SubscriptionItem + std::marker::Send>(
     history: ChannelList,
     item: T,
     urls: Vec<String>,
-    status_sender: Sender<StatusUpdate>,
+    status_sender: Sender<StateUpdate>,
 ) {
     // get videos from history file
     let (history_videos, history_name) = match history.get_by_id(&item.id()) {
@@ -107,18 +107,13 @@ fn fetch_channel_updates<T: 'static + SubscriptionItem + std::marker::Send>(
         None => (Vec::new(), String::new()),
     };
 
-    // download feed (if active)
-    let feed = if item.active() {
-        let n = item.name();
-        if !n.is_empty() {
-            status_sender
-                .send(StatusUpdate::new(n, Status::Loading))
-                .unwrap();
-        }
-        download_feed(&urls)
-    } else {
-        Feed::default()
-    };
+    if !item.id().is_empty() {
+        status_sender
+            .send(StateUpdate::new(item.id(), FetchState::Loading))
+            .unwrap();
+    }
+
+    let (feed, num_failed) = download_feed(&urls);
 
     // choose item name first; if not given take feed name; take history name as last resort
     let name = if !item.name().is_empty() {
@@ -129,36 +124,58 @@ fn fetch_channel_updates<T: 'static + SubscriptionItem + std::marker::Send>(
         history_name
     };
 
-    let channel = Channel::builder()
-        .add_from_feed(feed)
-        .with_old_videos(history_videos)
+    let mut channel_builder = Channel::builder();
+
+    // only add new videos if active
+    if item.active() {
+        channel_builder = channel_builder.add_from_feed(feed)
+    }
+
+    let channel = channel_builder.with_old_videos(history_videos)
         .with_name(name)
         .with_id(item.id())
         .with_tag(item.tag())
         .with_sorting(item.sorting_method())
         .build();
 
+
+    let state = if num_failed > 0 {
+        FetchState::DownloadsFailure(num_failed)
+    } else {
+        FetchState::Fetched
+    };
+    let _ = status_sender.send(StateUpdate::new(item.id(), state));
+
     let _ = channel_sender.send(channel);
 }
 
 // download xml and parse
-fn download_feed(urls: &[String]) -> Feed {
+// returns Feed and number of download/parsing failures
+fn download_feed(urls: &[String]) -> (Feed, usize) {
     let client = Client::builder().build().unwrap();
 
     let mut feed_final = Feed::default();
 
+    let mut num_failed = 0;
+
     // one internal feed can consist of seveal "normal" feeds
     for url in urls.iter() {
         // download feed
         let text = match client.get(url).send() {
             Ok(res) => res.text().unwrap_or_default(),
-            Err(_) => continue,
+            Err(_) => {
+                num_failed += 1;
+                continue;
+            }
         };
 
         // parse feed
         let mut feed = match Feed::parse_text(text) {
             Ok(f) => f,
-            Err(_) => continue, // notify that feed failed
+            Err(_) => {
+                num_failed += 1;
+                continue;
+            }
         };
 
         // set some meta on videos
@@ -172,7 +189,7 @@ fn download_feed(urls: &[String]) -> Feed {
         feed_final.set_name(&feed.name);
     }
 
-    feed_final
+    (feed_final, num_failed)
 }
 
 /* #[cfg(test)]
diff --git a/src/backend/draw.rs b/src/backend/draw.rs
index 3a34d59..74b7f27 100644
--- a/src/backend/draw.rs
+++ b/src/backend/draw.rs
@@ -1,5 +1,5 @@
 use crate::backend::{
-    core::{Core, StatusUpdate},
+    core::Core,
     data::{channel::Channel, channel_list::ChannelList},
     io::{history::History, config::Config},
     Backend, Screen,
@@ -24,7 +24,6 @@ pub struct AppState {
     channel_list: ChannelList,
     history: History,
     screen: Screen,
-    status: Vec<StatusUpdate>,
     terminal: Terminal,
     config: Config,
 }
@@ -32,10 +31,9 @@ pub struct AppState {
 impl From<&Core> for AppState {
     fn from(core: &Core) -> Self {
         let channel = core.get_selected_channel().cloned();
-        let channel_list = core.get_filtered_channel_list().clone();
+        let channel_list = core.channel_list().clone();
         let history = core.playback_history.clone();
         let screen = core.current_screen.clone();
-        let status = core.status.clone();
         let terminal = core.terminal.clone();
         let config = core.config.clone();
 
@@ -44,7 +42,6 @@ impl From<&Core> for AppState {
             channel_list,
             history,
             screen,
-            status,
             terminal,
             config,
         }
@@ -94,7 +91,6 @@ impl<'a> Widget<'a> {
 pub struct AppLayout {
     main: Vec<Rect>,
     content: Vec<Rect>,
-    other: Vec<Rect>,
 }
 
 impl AppLayout {
@@ -106,7 +102,6 @@ impl AppLayout {
 
         let main_split = vec![Percentage(80), Percentage(19), Percentage(1)];
         let content_split = vec![Percentage(100 - video_size), Percentage(video_size)];
-        let other_split = vec![Percentage(50), Percentage(50)];
 
         let main = Layout::default()
             .direction(Direction::Vertical)
@@ -120,29 +115,18 @@ impl AppLayout {
             .constraints(content_split)
             .split(main[0]);
 
-        let other = Layout::default()
-            .direction(Direction::Horizontal)
-            .margin(0)
-            .constraints(other_split)
-            .split(main[1]);
-
         Self {
             main,
             content,
-            other,
         }
     }
 
-    fn status(&self) -> Rect {
-        self.other[1]
-    }
-
     fn info(&self) -> Rect {
         self.main[2]
     }
 
     fn history(&self) -> Rect {
-        self.other[0]
+        self.main[1]
     }
 
     fn channels(&self) -> Rect {
@@ -157,12 +141,8 @@ impl AppLayout {
 #[allow(clippy::unnecessary_unwrap)]
 pub fn draw(app: AppState) {
     thread::spawn(move || {
-        // all channels - left view
         let channels = app.channel_list.clone();
 
-        // all videos - right view
-        /* let current_channel = app.current_selected.clone(); */
-
         let channel_symbol = match app.screen {
             Channels => ">> ",
             Videos => "-",
@@ -194,20 +174,6 @@ pub fn draw(app: AppState) {
                 );
             }
 
-            let mut list = Vec::new();
-            for line in app.status {
-                list.push(line.into_list_item());
-            }
-            let widget_height = layout.status().height as usize - 2; // minus two for the borders
-            list.reverse();
-            list.truncate(widget_height);
-            list.reverse();
-            let status = Widget::builder()
-                .with_title(" Download Status ")
-                .with_list(list);
-
-            f.render_widget(status.render(), layout.status());
-
             let history_widget = Widget::builder()
                 .with_title(" Playback History ")
                 .with_list(app.history.to_list_items());
@@ -216,16 +182,11 @@ pub fn draw(app: AppState) {
 
             //////////////////////////////
 
-            // let par_1 = Paragraph::new(Span::from(app.status.clone()))
-            //     .style(Style::default())
-            //     .alignment(Alignment::Left);
-            // f.render_widget(par_1, layout.status());
-
-            let par_2 = Paragraph::new(Span::from(INFO_LINE))
+            let info = Paragraph::new(Span::from(INFO_LINE))
                 .style(Style::default())
                 .alignment(Alignment::Left);
 
-            f.render_widget(par_2, layout.info());
+            f.render_widget(info, layout.info());
         });
     });
 }
diff --git a/src/backend/io/config.rs b/src/backend/io/config.rs
index e5ca858..1f11db0 100644
--- a/src/backend/io/config.rs
+++ b/src/backend/io/config.rs
@@ -1,7 +1,7 @@
 use crate::backend::{
     io::{read_config, FileType::ConfigFile},
     Error::ParseConfig,
-    Result, SortingMethod,
+    Result, SortingMethodVideos, SortingMethodChannels,
 };
 use serde::{Deserialize, Serialize};
 
@@ -10,7 +10,6 @@ const MARK_ON_OPEN_DEFAULT: bool = true;
 const DOWN_ON_MARK_DEFAULT: bool = true;
 const APP_TITLE_DEFAULT: &str = "TYT";
 const UPDATAE_AT_START_DEFAULT: bool = true;
-const SORT_BY_TAG_DEFAULT: bool = false;
 const MASSAGE_TIMEOUT_DEFAULT: usize = 20;
 const NOTIFY_WITH_DEFAULT: &str = "notify_send";
 const VIDEO_PLAYER_DEFAULT: &str = "mpv";
@@ -18,17 +17,17 @@ const VIDEO_PLAYER_DEFAULT: &str = "mpv";
 
 #[derive(Clone, Deserialize, Serialize)]
 #[serde(default)]
-pub(crate) struct Config {
-    pub(crate) show_empty_channels: bool,
-    pub(crate) mark_on_open: bool,
-    pub(crate) down_on_mark: bool,
-    pub(crate) app_title: String,
-    pub(crate) update_at_start: bool,
-    pub(crate) sort_by_tag: bool,
-    pub(crate) message_timeout: usize,
-    pub(crate) video_player: String,
-    pub(crate) default_sorting_method: SortingMethod,
-    pub(crate) notify_with: String,
+pub struct Config {
+    pub show_empty_channels: bool,
+    pub mark_on_open: bool,
+    pub down_on_mark: bool,
+    pub app_title: String,
+    pub update_at_start: bool,
+    pub sort_channels: SortingMethodChannels,
+    pub message_timeout: usize,
+    pub video_player: String,
+    pub sort_videos: SortingMethodVideos,
+    pub notify_with: String,
 }
 
 impl Default for Config {
@@ -39,11 +38,11 @@ impl Default for Config {
             down_on_mark: DOWN_ON_MARK_DEFAULT,
             app_title: APP_TITLE_DEFAULT.into(),
             update_at_start: UPDATAE_AT_START_DEFAULT,
-            sort_by_tag: SORT_BY_TAG_DEFAULT,
+            sort_channels: SortingMethodChannels::default(),
             message_timeout: MASSAGE_TIMEOUT_DEFAULT,
             notify_with: NOTIFY_WITH_DEFAULT.into(),
             video_player: VIDEO_PLAYER_DEFAULT.into(),
-            default_sorting_method: SortingMethod::default(),
+            sort_videos: SortingMethodVideos::default(),
         }
     }
 }
diff --git a/src/backend/io/subscriptions/channel.rs b/src/backend/io/subscriptions/channel.rs
index d3ee11b..75223fd 100644
--- a/src/backend/io/subscriptions/channel.rs
+++ b/src/backend/io/subscriptions/channel.rs
@@ -1,5 +1,5 @@
 use super::{date_always, Date, SubscriptionItem};
-use crate::backend::SortingMethod;
+use crate::backend::SortingMethodVideos;
 use chrono::prelude::*;
 use serde::{Deserialize, Serialize};
 
@@ -14,7 +14,7 @@ pub struct ChannelSubscription {
     #[serde(default)]
     tag: String,
     #[serde(default)]
-    sort_by: SortingMethod,
+    sort_by: SortingMethodVideos,
 }
 
 impl Default for ChannelSubscription {
@@ -25,7 +25,7 @@ impl Default for ChannelSubscription {
             name: "Tom Scott".to_string(),
             update_on: vec![Date::default()],
             tag: "Interresting".to_string(),
-            sort_by: SortingMethod::default(),
+            sort_by: SortingMethodVideos::default(),
         }
     }
 }
@@ -44,7 +44,7 @@ impl SubscriptionItem for ChannelSubscription {
     fn name(&self) -> String {
         self.name.clone()
     }
-    fn sorting_method(&self) -> SortingMethod {
+    fn sorting_method(&self) -> SortingMethodVideos {
         self.sort_by
     }
 }
diff --git a/src/backend/io/subscriptions/custom_channel.rs b/src/backend/io/subscriptions/custom_channel.rs
index 30058e6..066950a 100644
--- a/src/backend/io/subscriptions/custom_channel.rs
+++ b/src/backend/io/subscriptions/custom_channel.rs
@@ -1,5 +1,5 @@
 use super::{date_always, Date, SubscriptionItem};
-use crate::backend::SortingMethod;
+use crate::backend::SortingMethodVideos;
 use chrono::prelude::*;
 use serde::{Deserialize, Serialize};
 
@@ -12,7 +12,7 @@ pub struct CustomChannelSubscription {
     #[serde(default)]
     tag: String,
     #[serde(default)]
-    sort_by: SortingMethod,
+    sort_by: SortingMethodVideos,
 }
 
 impl SubscriptionItem for CustomChannelSubscription {
@@ -29,7 +29,7 @@ impl SubscriptionItem for CustomChannelSubscription {
     fn name(&self) -> String {
         self.name.clone()
     }
-    fn sorting_method(&self) -> SortingMethod {
+    fn sorting_method(&self) -> SortingMethodVideos {
         self.sort_by
     }
 }
diff --git a/src/backend/io/subscriptions/mod.rs b/src/backend/io/subscriptions/mod.rs
index cce3824..10ed9eb 100644
--- a/src/backend/io/subscriptions/mod.rs
+++ b/src/backend/io/subscriptions/mod.rs
@@ -1,7 +1,7 @@
 use crate::backend::{
     io::{read_config, FileType::SubscriptionsFile},
     Error::ParseSubscription,
-    Result, SortingMethod,
+    Result, SortingMethodVideos,
 };
 use channel::ChannelSubscription;
 use chrono::Weekday;
@@ -17,7 +17,7 @@ pub(crate) trait SubscriptionItem {
     fn active(&self) -> bool;
     fn tag(&self) -> String;
     fn name(&self) -> String;
-    fn sorting_method(&self) -> SortingMethod;
+    fn sorting_method(&self) -> SortingMethodVideos;
 }
 
 /// Default value for date always
diff --git a/src/backend/mod.rs b/src/backend/mod.rs
index 8306533..0aab940 100644
--- a/src/backend/mod.rs
+++ b/src/backend/mod.rs
@@ -73,12 +73,30 @@ impl Terminal {
     }
 }
 
-#[derive(PartialEq, Clone, Copy)]
+#[derive(PartialEq, Clone, Copy, Debug)]
 pub enum Filter {
     NoFilter,
     OnlyNew,
 }
 
+impl Default for Filter {
+    fn default() -> Self {
+        Self::NoFilter
+    }
+}
+
+#[derive(PartialEq, Clone, Copy, Debug, Serialize, Deserialize)]
+pub enum SortingMethodChannels {
+    AlphaNumeric,
+    ByTag,
+}
+
+impl Default for SortingMethodChannels {
+    fn default() -> Self {
+        Self::AlphaNumeric
+    }
+}
+
 #[derive(PartialEq)]
 pub enum Action {
     Mark(bool),
@@ -99,14 +117,14 @@ pub enum Screen {
 }
 
 #[derive(Debug, Clone, Copy, Serialize, Deserialize)]
-pub enum SortingMethod {
+pub enum SortingMethodVideos {
     Date,
     Text,
     UnseenDate,
     UnseenText,
 }
 
-impl Default for SortingMethod {
+impl Default for SortingMethodVideos {
     fn default() -> Self {
         Self::UnseenDate
     }
diff --git a/src/main.rs b/src/main.rs
index 652f415..b08b740 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -108,7 +108,8 @@ fn main() -> Result<(), Error> {
                     core.action(Leave);
                 }
                 Key::Char('t') => {
-                    core.set_show_empty(!core.get_show_empty());
+                    // core.set_show_empty(!core.get_show_empty());
+                    core.toggle_filter();
                     core.draw();
                 }
                 Key::Char('c') => match core.get_current_screen() {