diff --git a/src/app_data/container_state.rs b/src/app_data/container_state.rs
index 3734b34..b8b32b9 100644
--- a/src/app_data/container_state.rs
+++ b/src/app_data/container_state.rs
@@ -11,6 +11,45 @@ const ONE_KB: f64 = 1000.0;
 const ONE_MB: f64 = ONE_KB * 1000.0;
 const ONE_GB: f64 = ONE_MB * 1000.0;
 
+#[derive(Debug, Clone, Eq, Hash, PartialEq)]
+pub struct ContainerId(String);
+
+impl From<String> for ContainerId {
+    fn from(x: String) -> Self {
+        Self(x)
+    }
+}
+
+impl From<&String> for ContainerId {
+    fn from(x: &String) -> Self {
+        Self(x.clone())
+    }
+}
+
+impl From<&str> for ContainerId {
+    fn from(x: &str) -> Self {
+        Self(x.to_owned())
+    }
+}
+
+impl ContainerId {
+    pub fn get(&self) -> &str {
+        self.0.as_str()
+    }
+}
+
+impl Ord for ContainerId {
+    fn cmp(&self, other: &Self) -> Ordering {
+        self.0.cmp(&other.0)
+    }
+}
+
+impl PartialOrd for ContainerId {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
 #[derive(Debug, Clone)]
 pub struct StatefulList<T> {
     pub state: ListState,
@@ -70,7 +109,7 @@ impl<T> StatefulList<T> {
 
     pub fn get_state_title(&self) -> String {
         if self.items.is_empty() {
-            String::from("")
+            String::new()
         } else {
             let len = self.items.len();
             let c = self
@@ -97,10 +136,10 @@ pub enum State {
 impl State {
     pub const fn get_color(self) -> Color {
         match self {
-            Self::Running => Color::Green,
+            Self::Paused => Color::Yellow,
             Self::Removing => Color::LightRed,
             Self::Restarting => Color::LightGreen,
-            Self::Paused => Color::Yellow,
+            Self::Running => Color::Green,
             _ => Color::Red,
         }
     }
@@ -165,19 +204,19 @@ impl fmt::Display for State {
 #[derive(Debug, Clone, Copy)]
 pub enum DockerControls {
     Pause,
-    Unpause,
     Restart,
-    Stop,
     Start,
+    Stop,
+    Unpause,
 }
 
 impl DockerControls {
     pub const fn get_color(self) -> Color {
         match self {
+            Self::Pause => Color::Yellow,
+            Self::Restart => Color::Magenta,
             Self::Start => Color::Green,
             Self::Stop => Color::Red,
-            Self::Restart => Color::Magenta,
-            Self::Pause => Color::Yellow,
             Self::Unpause => Color::Blue,
         }
     }
@@ -198,10 +237,10 @@ impl fmt::Display for DockerControls {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let disp = match self {
             Self::Pause => "pause",
-            Self::Unpause => "unpause",
             Self::Restart => "restart",
-            Self::Stop => "stop",
             Self::Start => "start",
+            Self::Stop => "stop",
+            Self::Unpause => "unpause",
         };
         write!(f, "{}", disp)
     }
@@ -214,7 +253,7 @@ pub trait Stats {
 /// Struct for frequently updated CPU stats
 /// So can use custom display formatter
 /// Use trait Stats for use as generic in draw_chart function
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Default, Clone, Copy)]
 pub struct CpuStats {
     value: f64,
 }
@@ -267,7 +306,7 @@ impl fmt::Display for CpuStats {
 /// Struct for frequently updated memory usage stats
 /// So can use custom display formatter
 /// Use trait Stats for use as generic in draw_chart function
-#[derive(Debug, Clone, Copy, Eq)]
+#[derive(Debug, Default, Clone, Copy, Eq)]
 pub struct ByteStats {
     value: u64,
 }
@@ -298,6 +337,8 @@ impl ByteStats {
         self.value = value;
     }
 }
+
+#[allow(clippy::cast_precision_loss)]
 impl Stats for ByteStats {
     fn get_value(&self) -> f64 {
         self.value as f64
@@ -307,7 +348,7 @@ impl Stats for ByteStats {
 /// convert from bytes to kB, MB, GB etc
 impl fmt::Display for ByteStats {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let as_f64 = self.value as f64;
+        let as_f64 = self.get_value();
         let p = match as_f64 {
             x if x >= ONE_GB => format!("{y:.2} GB", y = as_f64 / ONE_GB),
             x if x >= ONE_MB => format!("{y:.2} MB", y = as_f64 / ONE_MB),
@@ -326,7 +367,7 @@ pub type CpuTuple = (Vec<(f64, f64)>, CpuStats, State);
 pub struct ContainerItem {
     pub cpu_stats: VecDeque<CpuStats>,
     pub docker_controls: StatefulList<DockerControls>,
-    pub id: String,
+    pub id: ContainerId,
     pub image: String,
     pub last_updated: u64,
     pub logs: StatefulList<ListItem<'static>>,
@@ -341,21 +382,23 @@ pub struct ContainerItem {
 
 impl ContainerItem {
     /// Create a new container item
-    pub fn new(id: String, status: String, image: String, state: State, name: String) -> Self {
+    pub fn new(id: ContainerId, status: String, image: String, state: State, name: String) -> Self {
         let mut docker_controls = StatefulList::new(DockerControls::gen_vec(state));
         docker_controls.start();
+        let mut logs = StatefulList::new(vec![]);
+        logs.end();
         Self {
             cpu_stats: VecDeque::with_capacity(60),
             docker_controls,
             id,
             image,
             last_updated: 0,
-            logs: StatefulList::new(vec![]),
-            mem_limit: ByteStats::new(0),
+            logs,
+            mem_limit: ByteStats::default(),
             mem_stats: VecDeque::with_capacity(60),
             name,
-            rx: ByteStats::new(0),
-            tx: ByteStats::new(0),
+            rx: ByteStats::default(),
+            tx: ByteStats::default(),
             state,
             status,
         }
@@ -365,7 +408,7 @@ impl ContainerItem {
     fn max_cpu_stats(&self) -> CpuStats {
         match self.cpu_stats.iter().max() {
             Some(value) => *value,
-            None => CpuStats::new(0.0),
+            None => CpuStats::default(),
         }
     }
 
@@ -373,11 +416,12 @@ impl ContainerItem {
     fn max_mem_stats(&self) -> ByteStats {
         match self.mem_stats.iter().max() {
             Some(value) => *value,
-            None => ByteStats::new(0),
+            None => ByteStats::default(),
         }
     }
 
     /// Convert cpu stats into a vec for the charts function
+    #[allow(clippy::cast_precision_loss)]
     fn get_cpu_dataset(&self) -> Vec<(f64, f64)> {
         self.cpu_stats
             .iter()
@@ -387,6 +431,7 @@ impl ContainerItem {
     }
 
     /// Convert mem stats into a Vec for the charts function
+    #[allow(clippy::cast_precision_loss)]
     fn get_mem_dataset(&self) -> Vec<(f64, f64)> {
         self.mem_stats
             .iter()
diff --git a/src/app_data/mod.rs b/src/app_data/mod.rs
index a0ba4d9..c137fbf 100644
--- a/src/app_data/mod.rs
+++ b/src/app_data/mod.rs
@@ -66,12 +66,12 @@ impl AppData {
     pub fn set_sorted(&mut self, x: Option<(Header, SortedOrder)>) {
         self.sorted_by = x;
         self.sort_containers();
-        self.containers.state.select(
-            self.containers
-                .items
-                .iter()
-                .position(|i| Some(i.id.clone()) == self.get_selected_container_id()),
-        );
+        self.containers
+            .state
+            .select(self.containers.items.iter().position(|i| {
+                self.get_selected_container_id()
+                    .map_or(false, |id| i.id == id)
+            }));
     }
     /// Generate a default app_state
     pub fn default(args: CliArgs) -> Self {
@@ -163,20 +163,14 @@ impl AppData {
     }
 
     /// Find the id of the currently selected container.
-    /// If any containers on system, will always return a string.
+    /// If any containers on system, will always return a ContainerId
     /// Only returns None when no containers found.
-    pub fn get_selected_container_id(&self) -> Option<String> {
+    pub fn get_selected_container_id(&self) -> Option<ContainerId> {
         let mut output = None;
         if let Some(index) = self.containers.state.selected() {
-            let id = self
-                .containers
-                .items
-                .iter()
-                .skip(index)
-                .take(1)
-                .map(|i| i.id.clone())
-                .collect::<String>();
-            output = Some(id);
+            if let Some(x) = self.containers.items.get(index) {
+                output = Some(x.id.clone());
+            }
         }
         output
     }
@@ -265,10 +259,10 @@ impl AppData {
     /// Get the title for log panel for selected container
     /// will be "logs x/x"
     pub fn get_log_title(&self) -> String {
-        self.get_selected_log_index().map_or_else(
-            || String::from(""),
-            |index| self.containers.items[index].logs.get_state_title(),
-        )
+        self.get_selected_log_index()
+            .map_or("".to_owned(), |index| {
+                self.containers.items[index].logs.get_state_title()
+            })
     }
 
     /// select next selected log line
@@ -307,7 +301,9 @@ impl AppData {
         }
     }
 
-    pub fn initialised(&mut self, all_ids: &[(bool, String)]) -> bool {
+
+	/// Check if the initial parsing has been completed, by making sure that all ids given (which are running) have a non empty cpu_stats vecdec
+    pub fn initialised(&mut self, all_ids: &[(bool, ContainerId)]) -> bool {
         let count_is_running = all_ids.iter().filter(|i| i.0).count();
         let number_with_cpu_status = self
             .containers
@@ -329,17 +325,18 @@ impl AppData {
         let mut output = Columns::new();
         let count = |x: &String| x.chars().count();
 
+        // Should probably find a refactor here somewhere
         for container in &self.containers.items {
             let cpu_count = count(
                 &container
                     .cpu_stats
                     .back()
-                    .unwrap_or(&CpuStats::new(0.0))
+                    .unwrap_or(&CpuStats::default())
                     .to_string(),
             );
             let mem_count = count(&format!(
                 "{} / {}",
-                container.mem_stats.back().unwrap_or(&ByteStats::new(0)),
+                container.mem_stats.back().unwrap_or(&ByteStats::default()),
                 container.mem_limit
             ));
 
@@ -379,7 +376,7 @@ impl AppData {
     }
 
     /// Get all containers ids
-    pub fn get_all_ids(&self) -> Vec<String> {
+    pub fn get_all_ids(&self) -> Vec<ContainerId> {
         self.containers
             .items
             .iter()
@@ -387,15 +384,15 @@ impl AppData {
             .collect::<Vec<_>>()
     }
 
-    /// find container given id
-    fn get_container_by_id(&mut self, id: &str) -> Option<&mut ContainerItem> {
-        self.containers.items.iter_mut().find(|i| i.id == id)
+    /// return a mutable container by given id
+    fn get_container_by_id(&mut self, id: &ContainerId) -> Option<&mut ContainerItem> {
+        self.containers.items.iter_mut().find(|i| &i.id == id)
     }
 
     /// Update container mem, cpu, & network stats, in single function so only need to call .lock() once
     pub fn update_stats(
         &mut self,
-        id: &str,
+        id: &ContainerId,
         cpu_stat: Option<f64>,
         mem_stat: Option<u64>,
         mem_limit: u64,
@@ -424,18 +421,18 @@ impl AppData {
     }
 
     /// Update, or insert, containers
-    pub fn update_containers(&mut self, containers: &mut [ContainerSummary]) {
+    pub fn update_containers(&mut self, all_containers: &mut [ContainerSummary]) {
         let all_ids = self.get_all_ids();
 
-        if !containers.is_empty() && self.containers.state.selected().is_none() {
+        if !all_containers.is_empty() && self.containers.state.selected().is_none() {
             self.containers.start();
         }
 
         for (index, id) in all_ids.iter().enumerate() {
-            if !containers
+            if !all_containers
                 .iter()
                 .filter_map(|i| i.id.as_ref())
-                .any(|x| x == id)
+                .any(|x| x == id.get())
             {
                 // If removed container is currently selected, then change selected to previous
                 // This will default to 0 in any edge cases
@@ -448,63 +445,61 @@ impl AppData {
                 }
             }
         }
+		// Trim a &String and return String
+		let trim_owned = |x: &String| x.trim().to_owned();
 
-        for i in containers.iter_mut() {
+        for i in all_containers {
             if let Some(id) = i.id.as_ref() {
-                // maybe if no name then continue?
-                let name = i.names.as_mut().map_or("".to_owned(), |n| {
-                    n.get_mut(0).map_or("".to_owned(), |f| {
+                let name = i.names.as_mut().map_or("".to_owned(), |names| {
+                    names.first_mut().map_or("".to_owned(), |f| {
                         if f.starts_with('/') {
                             f.remove(0);
                         }
-                        f.clone()
+                        (*f).to_string()
                     })
                 });
 
                 let state = State::from(
                     i.state
                         .as_ref()
-                        .map_or("dead".to_owned(), |f| f.trim().to_owned()),
+                        .map_or("dead".to_owned(), trim_owned),
                 );
                 let status = i
                     .status
                     .as_ref()
-                    .map_or("".to_owned(), |f| f.trim().to_owned());
+                    .map_or("".to_owned(), trim_owned);
 
                 let image = i
                     .image
                     .as_ref()
                     .map_or("".to_owned(), std::clone::Clone::clone);
 
-                if let Some(current_container) = self.get_container_by_id(id) {
-                    if current_container.name != name {
-                        current_container.name = name;
+                let id = ContainerId::from(id);
+                // If container info already in containers Vec, then just update details
+                if let Some(item) = self.get_container_by_id(&id) {
+                    if item.name != name {
+                        item.name = name;
                     };
-                    if current_container.status != status {
-                        current_container.status = status;
+                    if item.status != status {
+                        item.status = status;
                     };
-                    if current_container.state != state {
-                        current_container.docker_controls.items = DockerControls::gen_vec(state);
-
+                    if item.state != state {
+                        item.docker_controls.items = DockerControls::gen_vec(state);
                         // Update the list state, needs to be None if the gen_vec returns an empty vec
                         match state {
                             State::Removing | State::Restarting | State::Unknown => {
-                                current_container.docker_controls.state.select(None);
+                                item.docker_controls.state.select(None);
                             }
-                            _ => current_container.docker_controls.start(),
+                            _ => item.docker_controls.start(),
                         };
-                        current_container.state = state;
+                        item.state = state;
                     };
-                    if current_container.image != image {
-                        // limit image name to 64 chars?
-                        // current_container.image = image.chars().into_iter().take(64).collect();
-                        current_container.image = image;
+                    if item.image != image {
+                        item.image = image;
                     };
+                // else container not known, so make new ContainerItem and push into containers Vec
                 } else {
-                    // limit image name to 64 chars?
-                    // let mut container = ContainerItem::new(id.clone(), status, image.chars().into_iter().take(64).collect(), state, name);
-                    let mut container = ContainerItem::new(id.clone(), status, image, state, name);
-                    container.logs.end();
+                    let container = ContainerItem::new(id, status, image, state, name);
                     self.containers.items.push(container);
                 }
             }
@@ -512,7 +507,7 @@ impl AppData {
     }
 
     /// update logs of a given container, based on id
-    pub fn update_log_by_id(&mut self, output: &[String], id: &str) {
+    pub fn update_log_by_id(&mut self, output: &[String], id: &ContainerId) {
         let tz = Self::get_systemtime();
         let color = self.args.color;
         let raw = self.args.raw;
@@ -521,7 +516,7 @@ impl AppData {
             container.last_updated = tz;
             let current_len = container.logs.items.len();
 
-            for i in output.iter() {
+            for i in output {
                 let lines = if color {
                     log_sanitizer::colorize_logs(i)
                 } else if raw {
@@ -532,6 +527,8 @@ impl AppData {
                 container.logs.items.push(ListItem::new(lines));
             }
 
+			// Set the logs selected row for each container
+			// Either when no long currently selected, or currently selected (before updated) is already at end
             if container.logs.state.selected().is_none()
                 || container.logs.state.selected().map_or(1, |f| f + 1) == current_len
             {
diff --git a/src/app_error.rs b/src/app_error.rs
index 385b227..1f90db6 100644
--- a/src/app_error.rs
+++ b/src/app_error.rs
@@ -5,10 +5,10 @@ use std::fmt;
 #[allow(unused)]
 #[derive(Debug, Clone, Copy)]
 pub enum AppError {
+    DockerCommand(DockerControls),
     DockerConnect,
     DockerInterval,
     InputPoll,
-    DockerCommand(DockerControls),
     MouseCapture(bool),
     Terminal,
 }
@@ -17,15 +17,15 @@ pub enum AppError {
 impl fmt::Display for AppError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
+            Self::DockerCommand(s) => write!(f, "Unable to {} container", s),
             Self::DockerConnect => write!(f, "Unable to access docker daemon"),
             Self::DockerInterval => write!(f, "Docker update interval needs to be greater than 0"),
             Self::InputPoll => write!(f, "Unable to poll user input"),
-            Self::Terminal => write!(f, "Unable to draw to terminal"),
-            Self::DockerCommand(s) => write!(f, "Unable to {} container", s),
             Self::MouseCapture(x) => {
                 let reason = if *x { "en" } else { "dis" };
                 write!(f, "Unbale to {}able mouse capture", reason)
             }
+            Self::Terminal => write!(f, "Unable to draw to terminal"),
         }
     }
 }
diff --git a/src/docker_data/message.rs b/src/docker_data/message.rs
index a730830..f7de6f5 100644
--- a/src/docker_data/message.rs
+++ b/src/docker_data/message.rs
@@ -1,10 +1,12 @@
+use crate::app_data::ContainerId;
+
 #[derive(Debug, Clone)]
 pub enum DockerMessage {
     Update,
-    Start(String),
-    Restart(String),
-    Pause(String),
-    Unpause(String),
-    Stop(String),
+    Start(ContainerId),
+    Restart(ContainerId),
+    Pause(ContainerId),
+    Unpause(ContainerId),
+    Stop(ContainerId),
     Quit,
 }
diff --git a/src/docker_data/mod.rs b/src/docker_data/mod.rs
index c0fcd41..d0a3e47 100644
--- a/src/docker_data/mod.rs
+++ b/src/docker_data/mod.rs
@@ -16,7 +16,7 @@ use tokio::{sync::mpsc::Receiver, task::JoinHandle};
 use uuid::Uuid;
 
 use crate::{
-    app_data::{AppData, DockerControls},
+    app_data::{AppData, ContainerId, DockerControls},
     app_error::AppError,
     parse_args::CliArgs,
     ui::GuiState,
@@ -26,8 +26,8 @@ pub use message::DockerMessage;
 
 #[derive(Debug, Clone, Eq, Hash, PartialEq)]
 enum SpawnId {
-    Stats((String, Binate)),
-    Log(String),
+    Stats((ContainerId, Binate)),
+    Log(ContainerId),
 }
 
 /// Cpu & Mem stats take twice as long as the update interval to get a value, so will have two being executed at the same time
@@ -63,6 +63,7 @@ pub struct DockerData {
 
 impl DockerData {
     /// Use docker stats to caluclate current cpu usage
+    #[allow(clippy::cast_precision_loss)]
     fn calculate_usage(stats: &Stats) -> f64 {
         let mut cpu_percentage = 0.0;
         let previous_cpu = stats.precpu_stats.cpu_usage.total_usage;
@@ -78,9 +79,8 @@ impl DockerData {
                     .cpu_stats
                     .cpu_usage
                     .percpu_usage
-                    .clone()
-                    .unwrap_or_default()
-                    .len() as u64
+                    .as_ref()
+                    .map_or(0, std::vec::Vec::len) as u64
             }) as f64;
             if system_delta > 0.0 && cpu_delta > 0.0 {
                 cpu_percentage = (cpu_delta / system_delta) * online_cpus * 100.0;
@@ -94,7 +94,7 @@ impl DockerData {
     /// remove if from spawns hashmap when complete
     async fn update_container_stat(
         docker: Arc<Docker>,
-        id: String,
+        id: ContainerId,
         app_data: Arc<Mutex<AppData>>,
         is_running: bool,
         spawns: Arc<Mutex<HashMap<SpawnId, JoinHandle<()>>>>,
@@ -102,7 +102,7 @@ impl DockerData {
     ) {
         let mut stream = docker
             .stats(
-                &id,
+                id.get(),
                 Some(StatsOptions {
                     stream: false,
                     one_shot: !is_running,
@@ -122,10 +122,11 @@ impl DockerData {
             let cpu_stats = Self::calculate_usage(&stats);
 
             let (rx, tx) = if let Some(key) = op_key {
-                match stats.networks.unwrap_or_default().get(&key) {
-                    Some(data) => (data.rx_bytes, data.tx_bytes),
-                    None => (0, 0),
-                }
+                stats
+                    .networks
+                    .unwrap_or_default()
+                    .get(&key)
+                    .map_or((0, 0), |f| (f.rx_bytes, f.tx_bytes))
             } else {
                 (0, 0)
             };
@@ -149,13 +150,12 @@ impl DockerData {
     }
 
     /// Update all stats, spawn each container into own tokio::spawn thread
-    fn update_all_container_stats(&mut self, all_ids: &[(bool, String)]) {
-        for (is_running, id) in all_ids.iter() {
+    fn update_all_container_stats(&mut self, all_ids: &[(bool, ContainerId)]) {
+        for (is_running, id) in all_ids {
             let docker = Arc::clone(&self.docker);
             let app_data = Arc::clone(&self.app_data);
             let spawns = Arc::clone(&self.spawns);
             let key = SpawnId::Stats((id.clone(), self.binate));
-
             let spawn_key = key.clone();
             self.spawns.lock().entry(key).or_insert_with(|| {
                 tokio::spawn(Self::update_container_stat(
@@ -174,7 +174,7 @@ impl DockerData {
     /// Get all current containers, handle into ContainerItem in the app_data struct rather than here
     /// Just make sure that items sent are guaranteed to have an id
     /// Will ignore any container that contains `oxker` as an entry point
-    pub async fn update_all_containers(&mut self) -> Vec<(bool, String)> {
+    pub async fn update_all_containers(&mut self) -> Vec<(bool, ContainerId)> {
         let containers = self
             .docker
             .list_containers(Some(ListContainersOptions::<String> {
@@ -185,13 +185,13 @@ impl DockerData {
             .unwrap_or_default();
 
         let mut output = containers
-            .iter()
+            .into_iter()
             .filter_map(|f| match f.id {
                 Some(_) => {
                     if f.command.as_ref().map_or(false, |c| c.contains("oxker")) {
                         None
                     } else {
-                        Some(f.clone())
+                        Some(f)
                     }
                 }
                 None => None,
@@ -205,13 +205,13 @@ impl DockerData {
 
         // Just get the containers that are currently running, or being restarted, no point updating info on paused or dead containers
         output
-            .iter()
+            .into_iter()
             .filter_map(|i| {
-                i.id.as_ref().map(|id| {
+                i.id.map(|id| {
                     (
                         i.state == Some("running".to_owned())
                             || i.state == Some("restarting".to_owned()),
-                        id.clone(),
+                        ContainerId::from(id),
                     )
                 })
             })
@@ -223,7 +223,7 @@ impl DockerData {
     /// remove if from spawns hashmap when complete
     async fn update_log(
         docker: Arc<Docker>,
-        id: String,
+        id: ContainerId,
         timestamps: bool,
         since: u64,
         app_data: Arc<Mutex<AppData>>,
@@ -232,11 +232,11 @@ impl DockerData {
         let options = Some(LogsOptions::<String> {
             stdout: true,
             timestamps,
-            since: since as i64,
+            since: i64::try_from(since).unwrap_or_default(),
             ..Default::default()
         });
 
-        let mut logs = docker.logs(&id, options);
+        let mut logs = docker.logs(id.get(), options);
         let mut output = vec![];
 
         while let Some(value) = logs.next().await {
@@ -252,8 +252,8 @@ impl DockerData {
     }
 
     /// Update all logs, spawn each container into own tokio::spawn thread
-    fn init_all_logs(&mut self, all_ids: &[(bool, String)]) {
-        for (_, id) in all_ids.iter() {
+    fn init_all_logs(&mut self, all_ids: &[(bool, ContainerId)]) {
+        for (_, id) in all_ids {
             let docker = Arc::clone(&self.docker);
             let app_data = Arc::clone(&self.app_data);
             let spawns = Arc::clone(&self.spawns);
@@ -349,7 +349,7 @@ impl DockerData {
             match message {
                 DockerMessage::Pause(id) => {
                     let loading_spin = self.loading_spin(loading_uuid).await;
-                    if docker.pause_container(&id).await.is_err() {
+                    if docker.pause_container(id.get()).await.is_err() {
                         app_data
                             .lock()
                             .set_error(AppError::DockerCommand(DockerControls::Pause));
@@ -358,7 +358,7 @@ impl DockerData {
                 }
                 DockerMessage::Restart(id) => {
                     let loading_spin = self.loading_spin(loading_uuid).await;
-                    if docker.restart_container(&id, None).await.is_err() {
+                    if docker.restart_container(id.get(), None).await.is_err() {
                         app_data
                             .lock()
                             .set_error(AppError::DockerCommand(DockerControls::Restart));
@@ -368,7 +368,7 @@ impl DockerData {
                 DockerMessage::Start(id) => {
                     let loading_spin = self.loading_spin(loading_uuid).await;
                     if docker
-                        .start_container(&id, None::<StartContainerOptions<String>>)
+                        .start_container(id.get(), None::<StartContainerOptions<String>>)
                         .await
                         .is_err()
                     {
@@ -380,7 +380,7 @@ impl DockerData {
                 }
                 DockerMessage::Stop(id) => {
                     let loading_spin = self.loading_spin(loading_uuid).await;
-                    if docker.stop_container(&id, None).await.is_err() {
+                    if docker.stop_container(id.get(), None).await.is_err() {
                         app_data
                             .lock()
                             .set_error(AppError::DockerCommand(DockerControls::Stop));
@@ -389,7 +389,7 @@ impl DockerData {
                 }
                 DockerMessage::Unpause(id) => {
                     let loading_spin = self.loading_spin(loading_uuid).await;
-                    if docker.unpause_container(&id).await.is_err() {
+                    if docker.unpause_container(id.get()).await.is_err() {
                         app_data
                             .lock()
                             .set_error(AppError::DockerCommand(DockerControls::Unpause));
diff --git a/src/input_handler/mod.rs b/src/input_handler/mod.rs
index b253beb..91f2418 100644
--- a/src/input_handler/mod.rs
+++ b/src/input_handler/mod.rs
@@ -137,6 +137,7 @@ impl InputHandler {
     }
 
     /// Handle any keyboard button events
+    #[allow(clippy::too_many_lines)]
     async fn button_press(&mut self, key_code: KeyCode) {
         let show_error = self.app_data.lock().show_error;
         let show_info = self.gui_state.lock().show_help;
diff --git a/src/parse_args/mod.rs b/src/parse_args/mod.rs
index 6a4e13f..5c70ce9 100644
--- a/src/parse_args/mod.rs
+++ b/src/parse_args/mod.rs
@@ -4,7 +4,7 @@ use clap::Parser;
 use tracing::error;
 
 #[derive(Parser, Debug, Clone, Copy)]
-// #[command(help_template = FULL_TEMPLATE)]
+#[allow(clippy::struct_excessive_bools)]
 #[command(version, about)]
 pub struct CliArgs {
     /// Docker update interval in ms, minimum effectively 1000
@@ -15,11 +15,11 @@ pub struct CliArgs {
     #[clap(short = 't')]
     pub timestamp: bool,
 
-    /// Attempt to colorize the logs
+    /// Attempt to colorize the logs, conflicts with "-r"
     #[clap(short = 'c', conflicts_with = "raw")]
     pub color: bool,
 
-    /// Show raw logs, default is to remove ansi formatting
+    /// Show raw logs, default is to remove ansi formatting, conflicts with "-c"
     #[clap(short = 'r', conflicts_with = "color")]
     pub raw: bool,
 
diff --git a/src/ui/color_match.rs b/src/ui/color_match.rs
index 5c423f9..8ad3112 100644
--- a/src/ui/color_match.rs
+++ b/src/ui/color_match.rs
@@ -10,11 +10,11 @@ pub mod log_sanitizer {
     pub fn colorize_logs<'a>(input: &str) -> Vec<Spans<'a>> {
         vec![Spans::from(
             categorise_text(input)
-                .into_iter()
+                .iter()
                 .map(|i| {
-                    let fg_color = color_ansi_to_tui(i.fg.unwrap_or(CansiColor::White));
-                    let bg_color = color_ansi_to_tui(i.bg.unwrap_or(CansiColor::Black));
-                    let style = Style::default().bg(bg_color).fg(fg_color);
+                    let style = Style::default()
+                        .bg(color_ansi_to_tui(i.bg.unwrap_or(CansiColor::Black)))
+                        .fg(color_ansi_to_tui(i.fg.unwrap_or(CansiColor::White)));
                     if i.blink.is_some() {
                         style.add_modifier(Modifier::SLOW_BLINK);
                     }
@@ -41,7 +41,7 @@ pub mod log_sanitizer {
 
     /// Remove all ansi formatting from a given string and create tui-rs spans
     pub fn remove_ansi<'a>(input: &str) -> Vec<Spans<'a>> {
-        let mut output = String::from("");
+        let mut output = String::new();
         for i in categorise_text(input) {
             output.push_str(i.text);
         }
diff --git a/src/ui/draw_blocks.rs b/src/ui/draw_blocks.rs
index 2f1a847..50c4177 100644
--- a/src/ui/draw_blocks.rs
+++ b/src/ui/draw_blocks.rs
@@ -51,9 +51,6 @@ fn generate_block<'a>(
     panel: SelectablePanel,
 ) -> Block<'a> {
     gui_state.lock().update_map(Region::Panel(panel), area);
-    let mut block = Block::default()
-        .borders(Borders::ALL)
-        .border_type(BorderType::Rounded);
     let current_selected_panel = gui_state.lock().selected_panel;
     let title = match panel {
         SelectablePanel::Containers => {
@@ -66,9 +63,12 @@ fn generate_block<'a>(
         SelectablePanel::Logs => {
             format!(" {} {} ", panel.title(), app_data.lock().get_log_title())
         }
-        SelectablePanel::Commands => String::from(""),
+        SelectablePanel::Commands => String::new(),
     };
-    block = block.title(title);
+    let mut block = Block::default()
+        .borders(Borders::ALL)
+        .border_type(BorderType::Rounded)
+        .title(title);
     if current_selected_panel == panel {
         block = block.border_style(Style::default().fg(Color::LightCyan));
     }
@@ -109,10 +109,7 @@ pub fn commands<B: Backend>(
             &mut app_data.lock().containers.items[i].docker_controls.state,
         );
     } else {
-        let debug_text = String::from("");
-        let paragraph = Paragraph::new(debug_text)
-            .block(block)
-            .alignment(Alignment::Center);
+        let paragraph = Paragraph::new("").block(block).alignment(Alignment::Center);
         f.render_widget(paragraph, area);
     }
 }
@@ -138,7 +135,7 @@ pub fn containers<B: Backend>(
 
             let mems = format!(
                 "{:>1} / {:>1}",
-                i.mem_stats.back().unwrap_or(&ByteStats::new(0)),
+                i.mem_stats.back().unwrap_or(&ByteStats::default()),
                 i.mem_limit
             );
 
@@ -155,7 +152,7 @@ pub fn containers<B: Backend>(
                     format!(
                         "{}{:>width$}",
                         MARGIN,
-                        i.cpu_stats.back().unwrap_or(&CpuStats::new(0.0)),
+                        i.cpu_stats.back().unwrap_or(&CpuStats::default()),
                         width = &widths.cpu.1
                     ),
                     state_style,
@@ -168,7 +165,7 @@ pub fn containers<B: Backend>(
                     format!(
                         "{}{:>width$}",
                         MARGIN,
-                        i.id.chars().take(8).collect::<String>(),
+                        i.id.get().chars().take(8).collect::<String>(),
                         width = &widths.id.1
                     ),
                     blue,
@@ -194,8 +191,7 @@ pub fn containers<B: Backend>(
         })
         .collect::<Vec<_>>();
     if items.is_empty() {
-        let debug_text = String::from("no containers running");
-        let paragraph = Paragraph::new(debug_text)
+        let paragraph = Paragraph::new("no containers running")
             .block(block)
             .alignment(Alignment::Center);
         f.render_widget(paragraph, area);
@@ -222,8 +218,7 @@ pub fn logs<B: Backend>(
 
     let init = app_data.lock().init;
     if !init {
-        let parsing_logs = format!("parsing logs {}", loading_icon);
-        let paragraph = Paragraph::new(parsing_logs)
+        let paragraph = Paragraph::new(format!("parsing logs {}", loading_icon))
             .style(Style::default())
             .block(block)
             .alignment(Alignment::Center);
@@ -247,8 +242,7 @@ pub fn logs<B: Backend>(
             &mut app_data.lock().containers.items[index].logs.state,
         );
     } else {
-        let debug_text = String::from("no logs found");
-        let paragraph = Paragraph::new(debug_text)
+        let paragraph = Paragraph::new("no logs found")
             .block(block)
             .alignment(Alignment::Center);
         f.render_widget(paragraph, area);
@@ -343,6 +337,7 @@ fn make_chart<'a, T: Stats + Display>(
 }
 
 /// Draw heading bar at top of program, always visible
+#[allow(clippy::too_many_lines)]
 pub fn heading_bar<B: Backend>(
     area: Rect,
     columns: &Columns,
@@ -407,7 +402,7 @@ pub fn heading_bar<B: Backend>(
                 width = width - block.2
             ),
         };
-        let count = text.chars().count() as u16;
+        let count = u16::try_from(text.chars().count()).unwrap_or_default();
         let status = Paragraph::new(text)
             .block(block.0)
             .alignment(Alignment::Left);
@@ -437,12 +432,15 @@ pub fn heading_bar<B: Backend>(
 
     let suffix = if info_visible { "exit" } else { "show" };
     let info_text = format!("( h ) {} help {}", suffix, MARGIN);
-    let info_width = info_text.chars().count() as u16;
+    let info_width = info_text.chars().count();
 
-    let column_width = area.width - info_width;
+    let column_width = usize::from(area.width) - info_width;
     let column_width = if column_width > 0 { column_width } else { 1 };
     let splits = if has_containers {
-        vec![Constraint::Min(column_width), Constraint::Min(info_width)]
+        vec![
+            Constraint::Min(column_width.try_into().unwrap_or_default()),
+            Constraint::Min(info_width.try_into().unwrap_or_default()),
+        ]
     } else {
         vec![Constraint::Percentage(100)]
     };
@@ -540,20 +538,21 @@ pub fn help_box<B: Backend>(f: &mut Frame<'_, B>) {
         .border_type(BorderType::Rounded)
         .border_style(Style::default().fg(Color::Black));
 
-    let area = popup(
-        lines as u16,
-        max_line_width as u16,
-        f.size(),
-        BoxLocation::MiddleCentre,
-    );
+    let area = popup(lines, max_line_width, f.size(), BoxLocation::MiddleCentre);
 
     let split_popup = Layout::default()
         .direction(Direction::Vertical)
         .constraints(
             [
-                Constraint::Max(NAME_TEXT.lines().count() as u16),
-                Constraint::Max(description_text.lines().count() as u16),
-                Constraint::Max(help_text.lines().count() as u16),
+                Constraint::Max(NAME_TEXT.lines().count().try_into().unwrap_or_default()),
+                Constraint::Max(
+                    description_text
+                        .lines()
+                        .count()
+                        .try_into()
+                        .unwrap_or_default(),
+                ),
+                Constraint::Max(help_text.lines().count().try_into().unwrap_or_default()),
             ]
             .as_ref(),
         )
@@ -604,12 +603,7 @@ pub fn error<B: Backend>(f: &mut Frame<'_, B>, error: AppError, seconds: Option<
         .block(block)
         .alignment(Alignment::Center);
 
-    let area = popup(
-        lines as u16,
-        max_line_width as u16,
-        f.size(),
-        BoxLocation::MiddleCentre,
-    );
+    let area = popup(lines, max_line_width, f.size(), BoxLocation::MiddleCentre);
     f.render_widget(Clear, area);
     f.render_widget(paragraph, area);
 }
@@ -633,32 +627,33 @@ pub fn info<B: Backend>(f: &mut Frame<'_, B>, text: String) {
         .block(block)
         .alignment(Alignment::Center);
 
-    let area = popup(
-        lines as u16,
-        max_line_width as u16,
-        f.size(),
-        BoxLocation::BottomRight,
-    );
+    let area = popup(lines, max_line_width, f.size(), BoxLocation::BottomRight);
     f.render_widget(Clear, area);
     f.render_widget(paragraph, area);
 }
 
 /// draw a box in the one of the BoxLocations, based on max line width + number of lines
-fn popup(text_lines: u16, text_width: u16, r: Rect, box_location: BoxLocation) -> Rect {
+fn popup(text_lines: usize, text_width: usize, r: Rect, box_location: BoxLocation) -> Rect {
     // Make sure blank_space can't be an negative, as will crash
-    let blank_vertical = if r.height > text_lines {
-        (r.height - text_lines) / 2
+    let blank_vertical = if usize::from(r.height) > text_lines {
+        (usize::from(r.height) - text_lines) / 2
     } else {
         1
     };
-    let blank_horizontal = if r.width > text_width {
-        (r.width - text_width) / 2
+    let blank_horizontal = if usize::from(r.width) > text_width {
+        (usize::from(r.width) - text_width) / 2
     } else {
         1
     };
 
-    let v_constraints = box_location.get_vertical_constraints(blank_vertical, text_lines);
-    let h_constraints = box_location.get_horizontal_constraints(blank_horizontal, text_width);
+    let v_constraints = box_location.get_vertical_constraints(
+        blank_vertical.try_into().unwrap_or_default(),
+        text_lines.try_into().unwrap_or_default(),
+    );
+    let h_constraints = box_location.get_horizontal_constraints(
+        blank_horizontal.try_into().unwrap_or_default(),
+        text_width.try_into().unwrap_or_default(),
+    );
 
     let indexes = box_location.get_indexes();
 
diff --git a/src/ui/gui_state.rs b/src/ui/gui_state.rs
index b4c586f..f98b990 100644
--- a/src/ui/gui_state.rs
+++ b/src/ui/gui_state.rs
@@ -251,22 +251,22 @@ impl GuiState {
         self.selected_panel = self.selected_panel.prev();
     }
 
-    /// Advance loading animation
+    /// Insert a new loading_uuid into hashset, and advance the animation by one frame
     pub fn next_loading(&mut self, uuid: Uuid) {
         self.loading_icon = self.loading_icon.next();
         self.is_loading.insert(uuid);
     }
 
-    /// if is_loading, return loading animation frame, else single space
+    /// If is_loading has any entries, return the current loading_icon, else an emtpy string
     pub fn get_loading(&mut self) -> String {
         if self.is_loading.is_empty() {
-            String::from(" ")
+            String::new()
         } else {
             self.loading_icon.to_string()
         }
     }
 
-    /// set is_loading to false, but keep animation frame at same state
+    /// Remove a loading_uuid from the is_loading hashset
     pub fn remove_loading(&mut self, uuid: Uuid) {
         self.is_loading.remove(&uuid);
     }
diff --git a/src/ui/mod.rs b/src/ui/mod.rs
index e2dc511..b126dbd 100644
--- a/src/ui/mod.rs
+++ b/src/ui/mod.rs
@@ -148,7 +148,7 @@ fn ui<B: Backend>(
 ) {
     // set max height for container section, needs +4 to deal with docker commands list and borders
     let height = app_data.lock().get_container_len();
-    let height = if height < 12 { (height + 4) as u16 } else { 12 };
+    let height = if height < 12 { height + 4 } else { 12 };
 
     let column_widths = app_data.lock().get_width();
     let has_containers = !app_data.lock().containers.items.is_empty();
@@ -168,7 +168,13 @@ fn ui<B: Backend>(
     // Split into 3, containers+controls, logs, then graphs
     let upper_main = Layout::default()
         .direction(Direction::Vertical)
-        .constraints([Constraint::Max(height as u16), Constraint::Percentage(50)].as_ref())
+        .constraints(
+            [
+                Constraint::Max(height.try_into().unwrap_or_default()),
+                Constraint::Percentage(50),
+            ]
+            .as_ref(),
+        )
         .split(whole_layout[1]);
 
     let top_split = if has_containers {