diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index eb68a0e1d..2a635ef9c 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -53,7 +53,7 @@ pub fn module<'a>(context: &'a Context) -> Option<Module<'a>> {
 To run a external command (e.g. to get the version of a tool) and to allow for mocking use the `context.exec_cmd` function. Here's a quick example:
 
 ```rust
-use super::{Context, Module, RootModuleConfig};
+use super::{Context, Module, ModuleConfig};
 
 use crate::configs::php::PhpConfig;
 use crate::formatter::StringFormatter;
@@ -163,7 +163,7 @@ Unit tests are written using the built-in Rust testing library in the same file
 All tests that test the rendered output of a module should use `ModuleRenderer`. For Example:
 
 ```rust
-use super::{Context, Module, RootModuleConfig};
+use super::{Context, Module, ModuleConfig};
 
 use crate::configs::php::PhpConfig;
 use crate::formatter::StringFormatter;
diff --git a/Cargo.lock b/Cargo.lock
index 1aedb44d1..9cd299eee 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1583,7 +1583,6 @@ dependencies = [
  "shadow-rs",
  "shell-words",
  "starship-battery",
- "starship_module_config_derive",
  "strsim",
  "sys-info",
  "tempfile",
@@ -1617,15 +1616,6 @@ dependencies = [
  "winapi",
 ]
 
-[[package]]
-name = "starship_module_config_derive"
-version = "0.2.1"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
 [[package]]
 name = "static_assertions"
 version = "1.1.0"
diff --git a/Cargo.toml b/Cargo.toml
index fde4eb2cd..a85762885 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -65,7 +65,6 @@ shadow-rs = "0.11.0"
 # battery is optional (on by default) because the crate doesn't currently build for Termux
 # see: https://github.com/svartalf/rust-battery/issues/33
 starship-battery = { version = "0.7.9", optional = true }
-starship_module_config_derive = { version = "0.2.1", path = "starship_module_config_derive" }
 strsim = "0.10.0"
 sys-info = "0.9.1"
 terminal_size = "0.1.17"
diff --git a/src/config.rs b/src/config.rs
index bd2eae4ff..982fe688c 100644
--- a/src/config.rs
+++ b/src/config.rs
@@ -1,199 +1,59 @@
+use crate::serde_utils::ValueDeserializer;
 use crate::utils;
-use ansi_term::{Color, Style};
-use indexmap::IndexMap;
-use serde::Serialize;
+use ansi_term::Color;
+use serde::{
+    de::value::Error as ValueError, de::Error as SerdeError, Deserialize, Deserializer, Serialize,
+};
 
+use std::borrow::Cow;
 use std::clone::Clone;
-use std::collections::HashMap;
 use std::io::ErrorKind;
-use std::marker::Sized;
 
 use std::env;
 use toml::Value;
 
 /// Root config of a module.
-pub trait RootModuleConfig<'a>
+pub trait ModuleConfig<'a, E>
 where
-    Self: ModuleConfig<'a> + Default,
-{
-    /// Load root module config from given Value and fill unset variables with default
-    /// values.
-    fn load(config: &'a Value) -> Self {
-        let mut out = Self::default();
-        out.load_config(config);
-        out
-    }
-
-    /// Helper function that will call RootModuleConfig::load(config) if config is Some,
-    /// or RootModuleConfig::new() if config is None.
-    fn try_load(config: Option<&'a Value>) -> Self {
-        if let Some(config) = config {
-            Self::load(config)
-        } else {
-            Self::default()
-        }
-    }
-}
-
-impl<'a, T: ModuleConfig<'a> + Default> RootModuleConfig<'a> for T {}
-
-/// Parsable config.
-pub trait ModuleConfig<'a>
-where
-    Self: Sized + Clone,
+    Self: Default,
+    E: SerdeError,
 {
     /// Construct a `ModuleConfig` from a toml value.
-    fn from_config(_config: &'a Value) -> Option<Self> {
-        None
-    }
+    fn from_config(config: &'a Value) -> Result<Self, E>;
 
-    /// Merge `self` with config from a toml table.
-    fn load_config(&mut self, config: &'a Value) {
-        if let Some(value) = Self::from_config(config) {
-            let _ = std::mem::replace(self, value);
-        }
-    }
-}
-
-// TODO: Add logging to default implementations
-impl<'a> ModuleConfig<'a> for &'a str {
-    fn from_config(config: &'a Value) -> Option<Self> {
-        config.as_str()
-    }
-}
-
-impl<'a> ModuleConfig<'a> for String {
-    fn from_config(config: &'a Value) -> Option<Self> {
-        config.as_str().map(std::borrow::ToOwned::to_owned)
-    }
-}
-
-impl<'a> ModuleConfig<'a> for Style {
-    fn from_config(config: &Value) -> Option<Self> {
-        parse_style_string(config.as_str()?)
-    }
-}
-
-impl<'a> ModuleConfig<'a> for bool {
-    fn from_config(config: &Value) -> Option<Self> {
-        config.as_bool()
-    }
-}
-
-impl<'a> ModuleConfig<'a> for i64 {
-    fn from_config(config: &Value) -> Option<Self> {
-        config.as_integer()
-    }
-}
-
-impl<'a> ModuleConfig<'a> for u64 {
-    fn from_config(config: &Value) -> Option<Self> {
-        match config {
-            Value::Integer(value) => {
-                // Converting i64 to u64
-                if *value > 0 {
-                    Some(*value as Self)
-                } else {
-                    None
-                }
+    /// Loads the TOML value into the config.
+    /// Missing values are set to their default values.
+    /// On error, logs an error message.
+    fn load(config: &'a Value) -> Self {
+        match Self::from_config(config) {
+            Ok(config) => config,
+            Err(e) => {
+                log::warn!("Failed to load config value: {}", e);
+                Self::default()
             }
-            Value::String(value) => value.parse::<Self>().ok(),
-            _ => None,
         }
     }
-}
 
-impl<'a> ModuleConfig<'a> for f64 {
-    fn from_config(config: &Value) -> Option<Self> {
-        config.as_float()
+    /// Helper function that will call ModuleConfig::from_config(config) if config is Some,
+    /// or ModuleConfig::default() if config is None.
+    fn try_load(config: Option<&'a Value>) -> Self {
+        config.map(Self::load).unwrap_or_default()
     }
 }
 
-impl<'a> ModuleConfig<'a> for u32 {
-    fn from_config(config: &Value) -> Option<Self> {
-        match config {
-            Value::Integer(value) => {
-                // Converting i64 to u32
-                if *value > 0 && *value <= u32::MAX.into() {
-                    Some(*value as Self)
-                } else {
-                    None
-                }
-            }
-            Value::String(value) => value.parse::<Self>().ok(),
-            _ => None,
-        }
+impl<'a, T: Deserialize<'a> + Default> ModuleConfig<'a, ValueError> for T {
+    /// Create ValueDeserializer wrapper and use it to call Deserialize::deserialize on it.
+    fn from_config(config: &'a Value) -> Result<Self, ValueError> {
+        let deserializer = ValueDeserializer::new(config);
+        T::deserialize(deserializer)
     }
 }
 
-impl<'a> ModuleConfig<'a> for usize {
-    fn from_config(config: &Value) -> Option<Self> {
-        match config {
-            Value::Integer(value) => {
-                if *value > 0 {
-                    Some(*value as Self)
-                } else {
-                    None
-                }
-            }
-            Value::String(value) => value.parse::<Self>().ok(),
-            _ => None,
-        }
-    }
-}
-
-impl<'a, T> ModuleConfig<'a> for Vec<T>
-where
-    T: ModuleConfig<'a>,
-{
-    fn from_config(config: &'a Value) -> Option<Self> {
-        config
-            .as_array()?
-            .iter()
-            .map(|value| T::from_config(value))
-            .collect()
-    }
-}
-
-impl<'a, T, S: ::std::hash::BuildHasher + Default> ModuleConfig<'a> for HashMap<String, T, S>
-where
-    T: ModuleConfig<'a>,
-    S: Clone,
-{
-    fn from_config(config: &'a Value) -> Option<Self> {
-        let mut hm = Self::default();
-
-        for (x, y) in config.as_table()? {
-            hm.insert(x.clone(), T::from_config(y)?);
-        }
-
-        Some(hm)
-    }
-}
-
-impl<'a, T, S: ::std::hash::BuildHasher + Default> ModuleConfig<'a> for IndexMap<String, T, S>
-where
-    T: ModuleConfig<'a>,
-    S: Clone,
-{
-    fn from_config(config: &'a Value) -> Option<Self> {
-        let mut im = Self::default();
-
-        for (x, y) in config.as_table()? {
-            im.insert(x.clone(), T::from_config(y)?);
-        }
-
-        Some(im)
-    }
-}
-
-impl<'a, T> ModuleConfig<'a> for Option<T>
-where
-    T: ModuleConfig<'a> + Sized,
-{
-    fn from_config(config: &'a Value) -> Option<Self> {
-        Some(T::from_config(config))
-    }
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(untagged)]
+pub enum Either<A, B> {
+    First(A),
+    Second(B),
 }
 
 /// A wrapper around `Vec<T>` that implements `ModuleConfig`, and either
@@ -201,22 +61,19 @@ where
 #[derive(Clone, Default, Serialize)]
 pub struct VecOr<T>(pub Vec<T>);
 
-impl<'a, T> ModuleConfig<'a> for VecOr<T>
+impl<'de, T> Deserialize<'de> for VecOr<T>
 where
-    T: ModuleConfig<'a> + Sized,
+    T: Deserialize<'de>,
 {
-    fn from_config(config: &'a Value) -> Option<Self> {
-        if let Some(item) = T::from_config(config) {
-            return Some(Self(vec![item]));
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let either = Either::<Vec<T>, T>::deserialize(deserializer)?;
+        match either {
+            Either::First(v) => Ok(VecOr(v)),
+            Either::Second(s) => Ok(VecOr(vec![s])),
         }
-
-        let vec = config
-            .as_array()?
-            .iter()
-            .map(|value| T::from_config(value))
-            .collect::<Option<Vec<T>>>()?;
-
-        Some(Self(vec))
     }
 }
 
@@ -374,6 +231,16 @@ impl StarshipConfig {
     }
 }
 
+/// Deserialize a style string in the starship format with serde
+pub fn deserialize_style<'de, D>(de: D) -> Result<ansi_term::Style, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    Cow::<'_, str>::deserialize(de).and_then(|s| {
+        parse_style_string(s.as_ref()).ok_or_else(|| D::Error::custom("Invalid style string"))
+    })
+}
+
 /** Parse a style string which represents an ansi style. Valid tokens in the style
  string include the following:
  - 'fg:<color>'    (specifies that the color read should be a foreground color)
@@ -501,11 +368,24 @@ fn parse_color_string(color_string: &str) -> Option<ansi_term::Color> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use starship_module_config_derive::ModuleConfig;
+    use ansi_term::Style;
+
+    // Small wrapper to allow deserializing Style without a struct with #[serde(deserialize_with=)]
+    #[derive(Default, Clone, Debug, PartialEq)]
+    struct StyleWrapper(Style);
+
+    impl<'de> Deserialize<'de> for StyleWrapper {
+        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+        where
+            D: Deserializer<'de>,
+        {
+            deserialize_style(deserializer).map(Self)
+        }
+    }
 
     #[test]
     fn test_load_config() {
-        #[derive(Clone, Default, ModuleConfig)]
+        #[derive(Clone, Default, Deserialize)]
         struct TestConfig<'a> {
             pub symbol: &'a str,
             pub disabled: bool,
@@ -517,12 +397,7 @@ mod tests {
             disabled = true
             some_array = ["A"]
         };
-        let mut rust_config = TestConfig {
-            symbol: "S ",
-            disabled: false,
-            some_array: vec!["A", "B", "C"],
-        };
-        rust_config.load_config(&config);
+        let rust_config = TestConfig::from_config(&config).unwrap();
 
         assert_eq!(rust_config.symbol, "T ");
         assert!(rust_config.disabled);
@@ -531,15 +406,20 @@ mod tests {
 
     #[test]
     fn test_load_nested_config() {
-        #[derive(Clone, Default, ModuleConfig)]
+        #[derive(Clone, Default, Deserialize)]
+        #[serde(default)]
         struct TestConfig<'a> {
+            #[serde(borrow)]
             pub untracked: SegmentDisplayConfig<'a>,
+            #[serde(borrow)]
             pub modified: SegmentDisplayConfig<'a>,
         }
 
-        #[derive(PartialEq, Debug, Clone, Default, ModuleConfig)]
+        #[derive(PartialEq, Debug, Clone, Default, Deserialize)]
+        #[serde(default)]
         struct SegmentDisplayConfig<'a> {
             pub value: &'a str,
+            #[serde(deserialize_with = "deserialize_style")]
             pub style: Style,
         }
 
@@ -548,23 +428,13 @@ mod tests {
             modified = { value = "∙", style = "red" }
         };
 
-        let mut git_status_config = TestConfig {
-            untracked: SegmentDisplayConfig {
-                value: "?",
-                style: Color::Red.bold(),
-            },
-            modified: SegmentDisplayConfig {
-                value: "!",
-                style: Color::Red.bold(),
-            },
-        };
-        git_status_config.load_config(&config);
+        let git_status_config = TestConfig::from_config(&config).unwrap();
 
         assert_eq!(
             git_status_config.untracked,
             SegmentDisplayConfig {
                 value: "x",
-                style: Color::Red.bold(),
+                style: Style::default(),
             }
         );
         assert_eq!(
@@ -578,7 +448,8 @@ mod tests {
 
     #[test]
     fn test_load_optional_config() {
-        #[derive(Clone, Default, ModuleConfig)]
+        #[derive(Clone, Default, Deserialize)]
+        #[serde(default)]
         struct TestConfig<'a> {
             pub optional: Option<&'a str>,
             pub hidden: Option<&'a str>,
@@ -587,11 +458,7 @@ mod tests {
         let config = toml::toml! {
             optional = "test"
         };
-        let mut rust_config = TestConfig {
-            optional: None,
-            hidden: None,
-        };
-        rust_config.load_config(&config);
+        let rust_config = TestConfig::from_config(&config).unwrap();
 
         assert_eq!(rust_config.optional, Some("test"));
         assert_eq!(rust_config.hidden, None);
@@ -599,7 +466,8 @@ mod tests {
 
     #[test]
     fn test_load_enum_config() {
-        #[derive(Clone, Default, ModuleConfig)]
+        #[derive(Clone, Default, Deserialize)]
+        #[serde(default)]
         struct TestConfig {
             pub switch_a: Switch,
             pub switch_b: Switch,
@@ -612,19 +480,22 @@ mod tests {
             Off,
         }
 
-        impl Default for Switch {
-            fn default() -> Self {
-                Self::Off
+        impl<'de> Deserialize<'de> for Switch {
+            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+            where
+                D: Deserializer<'de>,
+            {
+                let s = String::deserialize(deserializer)?;
+                match s.to_ascii_lowercase().as_str() {
+                    "on" => Ok(Switch::On),
+                    _ => Ok(Switch::Off),
+                }
             }
         }
 
-        impl<'a> ModuleConfig<'a> for Switch {
-            fn from_config(config: &'a Value) -> Option<Self> {
-                match config.as_str()? {
-                    "on" => Some(Self::On),
-                    "off" => Some(Self::Off),
-                    _ => None,
-                }
+        impl Default for Switch {
+            fn default() -> Self {
+                Self::Off
             }
         }
 
@@ -632,12 +503,7 @@ mod tests {
             switch_a = "on"
             switch_b = "any"
         };
-        let mut rust_config = TestConfig {
-            switch_a: Switch::Off,
-            switch_b: Switch::Off,
-            switch_c: Switch::Off,
-        };
-        rust_config.load_config(&config);
+        let rust_config = TestConfig::from_config(&config).unwrap();
 
         assert_eq!(rust_config.switch_a, Switch::On);
         assert_eq!(rust_config.switch_b, Switch::Off);
@@ -665,23 +531,26 @@ mod tests {
     #[test]
     fn test_from_style() {
         let config = Value::from("red bold");
-        assert_eq!(<Style>::from_config(&config).unwrap(), Color::Red.bold());
+        assert_eq!(
+            <StyleWrapper>::from_config(&config).unwrap().0,
+            Color::Red.bold()
+        );
     }
 
     #[test]
     fn test_from_hex_color_style() {
         let config = Value::from("#00000");
-        assert_eq!(<Style>::from_config(&config), None);
+        assert!(<StyleWrapper>::from_config(&config).is_err());
 
         let config = Value::from("#0000000");
-        assert_eq!(<Style>::from_config(&config), None);
+        assert!(<StyleWrapper>::from_config(&config).is_err());
 
         let config = Value::from("#NOTHEX");
-        assert_eq!(<Style>::from_config(&config), None);
+        assert!(<StyleWrapper>::from_config(&config).is_err());
 
         let config = Value::from("#a12BcD");
         assert_eq!(
-            <Style>::from_config(&config).unwrap(),
+            <StyleWrapper>::from_config(&config).unwrap().0,
             Color::RGB(0xA1, 0x2B, 0xCD).into()
         );
     }
@@ -701,7 +570,7 @@ mod tests {
     #[test]
     fn table_get_styles_bold_italic_underline_green_dimmed_silly_caps() {
         let config = Value::from("bOlD ItAlIc uNdErLiNe GrEeN diMMeD");
-        let mystyle = <Style>::from_config(&config).unwrap();
+        let mystyle = <StyleWrapper>::from_config(&config).unwrap().0;
         assert!(mystyle.is_bold);
         assert!(mystyle.is_italic);
         assert!(mystyle.is_underline);
@@ -720,7 +589,7 @@ mod tests {
     #[test]
     fn table_get_styles_bold_italic_underline_green_dimmed_inverted_silly_caps() {
         let config = Value::from("bOlD ItAlIc uNdErLiNe GrEeN diMMeD InVeRTed");
-        let mystyle = <Style>::from_config(&config).unwrap();
+        let mystyle = <StyleWrapper>::from_config(&config).unwrap().0;
         assert!(mystyle.is_bold);
         assert!(mystyle.is_italic);
         assert!(mystyle.is_underline);
@@ -742,58 +611,67 @@ mod tests {
     fn table_get_styles_plain_and_broken_styles() {
         // Test a "plain" style with no formatting
         let config = Value::from("");
-        let plain_style = <Style>::from_config(&config).unwrap();
+        let plain_style = <StyleWrapper>::from_config(&config).unwrap().0;
         assert_eq!(plain_style, ansi_term::Style::new());
 
         // Test a string that's clearly broken
         let config = Value::from("djklgfhjkldhlhk;j");
-        assert!(<Style>::from_config(&config).is_none());
+        assert!(<StyleWrapper>::from_config(&config).is_err());
 
         // Test a string that's nullified by `none`
         let config = Value::from("fg:red bg:green bold none");
-        assert!(<Style>::from_config(&config).is_none());
+        assert!(<StyleWrapper>::from_config(&config).is_err());
 
         // Test a string that's nullified by `none` at the start
         let config = Value::from("none fg:red bg:green bold");
-        assert!(<Style>::from_config(&config).is_none());
+        assert!(<StyleWrapper>::from_config(&config).is_err());
     }
 
     #[test]
     fn table_get_styles_with_none() {
         // Test that none on the end will result in None, overriding bg:none
         let config = Value::from("fg:red bg:none none");
-        assert!(<Style>::from_config(&config).is_none());
+        assert!(<StyleWrapper>::from_config(&config).is_err());
 
         // Test that none in front will result in None, overriding bg:none
         let config = Value::from("none fg:red bg:none");
-        assert!(<Style>::from_config(&config).is_none());
+        assert!(<StyleWrapper>::from_config(&config).is_err());
 
         // Test that none in the middle will result in None, overriding bg:none
         let config = Value::from("fg:red none bg:none");
-        assert!(<Style>::from_config(&config).is_none());
+        assert!(<StyleWrapper>::from_config(&config).is_err());
 
         // Test that fg:none will result in None
         let config = Value::from("fg:none bg:black");
-        assert!(<Style>::from_config(&config).is_none());
+        assert!(<StyleWrapper>::from_config(&config).is_err());
 
         // Test that bg:none will yield a style
         let config = Value::from("fg:red bg:none");
-        assert_eq!(<Style>::from_config(&config).unwrap(), Color::Red.normal());
+        assert_eq!(
+            <StyleWrapper>::from_config(&config).unwrap().0,
+            Color::Red.normal()
+        );
 
         // Test that bg:none will yield a style
         let config = Value::from("fg:red bg:none bold");
-        assert_eq!(<Style>::from_config(&config).unwrap(), Color::Red.bold());
+        assert_eq!(
+            <StyleWrapper>::from_config(&config).unwrap().0,
+            Color::Red.bold()
+        );
 
         // Test that bg:none will overwrite the previous background colour
         let config = Value::from("fg:red bg:green bold bg:none");
-        assert_eq!(<Style>::from_config(&config).unwrap(), Color::Red.bold());
+        assert_eq!(
+            <StyleWrapper>::from_config(&config).unwrap().0,
+            Color::Red.bold()
+        );
     }
 
     #[test]
     fn table_get_styles_ordered() {
         // Test a background style with inverted order (also test hex + ANSI)
         let config = Value::from("bg:#050505 underline fg:120");
-        let flipped_style = <Style>::from_config(&config).unwrap();
+        let flipped_style = <StyleWrapper>::from_config(&config).unwrap().0;
         assert_eq!(
             flipped_style,
             Style::new()
@@ -804,7 +682,7 @@ mod tests {
 
         // Test that the last color style is always the one used
         let config = Value::from("bg:120 bg:125 bg:127 fg:127 122 125");
-        let multi_style = <Style>::from_config(&config).unwrap();
+        let multi_style = <StyleWrapper>::from_config(&config).unwrap().0;
         assert_eq!(
             multi_style,
             Style::new().fg(Color::Fixed(125)).on(Color::Fixed(127))
diff --git a/src/configs/aws.rs b/src/configs/aws.rs
index 69092abb6..5e492d394 100644
--- a/src/configs/aws.rs
+++ b/src/configs/aws.rs
@@ -1,9 +1,8 @@
-use crate::config::ModuleConfig;
-use serde::Serialize;
-use starship_module_config_derive::ModuleConfig;
+use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 
-#[derive(Clone, ModuleConfig, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(default)]
 pub struct AwsConfig<'a> {
     pub format: &'a str,
     pub symbol: &'a str,
diff --git a/src/configs/azure.rs b/src/configs/azure.rs
index c22fad981..bc4fadde2 100644
--- a/src/configs/azure.rs
+++ b/src/configs/azure.rs
@@ -1,8 +1,7 @@
-use crate::config::ModuleConfig;
-use serde::Serialize;
-use starship_module_config_derive::ModuleConfig;
+use serde::{Deserialize, Serialize};
 
-#[derive(Clone, ModuleConfig, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(default)]
 pub struct AzureConfig<'a> {
     pub format: &'a str,
     pub symbol: &'a str,
diff --git a/src/configs/battery.rs b/src/configs/battery.rs
index 817c2afe7..9058aadb9 100644
--- a/src/configs/battery.rs
+++ b/src/configs/battery.rs
@@ -1,15 +1,14 @@
-use crate::config::ModuleConfig;
+use serde::{Deserialize, Serialize};
 
-use serde::Serialize;
-use starship_module_config_derive::ModuleConfig;
-
-#[derive(Clone, ModuleConfig, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(default)]
 pub struct BatteryConfig<'a> {
     pub full_symbol: &'a str,
     pub charging_symbol: &'a str,
     pub discharging_symbol: &'a str,
     pub unknown_symbol: &'a str,
     pub empty_symbol: &'a str,
+    #[serde(borrow)]
     pub display: Vec<BatteryDisplayConfig<'a>>,
     pub disabled: bool,
     pub format: &'a str,
@@ -30,7 +29,8 @@ impl<'a> Default for BatteryConfig<'a> {
     }
 }
 
-#[derive(Clone, ModuleConfig, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(default)]
 pub struct BatteryDisplayConfig<'a> {
     pub threshold: i64,
     pub style: &'a str,
diff --git a/src/configs/buf.rs b/src/configs/buf.rs
index f4fd0a18f..531ce4dfc 100644
--- a/src/configs/buf.rs
+++ b/src/configs/buf.rs
@@ -1,9 +1,7 @@
-use crate::config::ModuleConfig;
+use serde::{Deserialize, Serialize};
 
-use serde::Serialize;
-use starship_module_config_derive::ModuleConfig;
-
-#[derive(Clone, ModuleConfig, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(default)]
 pub struct BufConfig<'a> {
     pub format: &'a str,
     pub version_format: &'a str,
diff --git a/src/configs/c.rs b/src/configs/c.rs
index 14a230ff9..fda0a17ab 100644
--- a/src/configs/c.rs
+++ b/src/configs/c.rs
@@ -1,9 +1,7 @@
-use crate::config::ModuleConfig;
+use serde::{Deserialize, Serialize};
 
-use serde::Serialize;
-use starship_module_config_derive::ModuleConfig;
-
-#[derive(Clone, ModuleConfig, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(default)]
 pub struct CConfig<'a> {
     pub format: &'a str,
     pub version_format: &'a str,
diff --git a/src/configs/character.rs b/src/configs/character.rs
index 19204fe3c..91bba8c23 100644
--- a/src/configs/character.rs
+++ b/src/configs/character.rs
@@ -1,9 +1,7 @@
-use crate::config::ModuleConfig;
+use serde::{Deserialize, Serialize};
 
-use serde::Serialize;
-use starship_module_config_derive::ModuleConfig;
-
-#[derive(Clone, ModuleConfig, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(default)]
 pub struct CharacterConfig<'a> {
     pub format: &'a str,
     pub success_symbol: &'a str,
diff --git a/src/configs/cmake.rs b/src/configs/cmake.rs
index 8ba2c6a94..51140c8f3 100644
--- a/src/configs/cmake.rs
+++ b/src/configs/cmake.rs
@@ -1,9 +1,7 @@
-use crate::config::ModuleConfig;
+use serde::{Deserialize, Serialize};
 
-use serde::Serialize;
-use starship_module_config_derive::ModuleConfig;
-
-#[derive(Clone, ModuleConfig, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(default)]
 pub struct CMakeConfig<'a> {
     pub format: &'a str,
     pub version_format: &'a str,
diff --git a/src/configs/cmd_duration.rs b/src/configs/cmd_duration.rs
index 44c0c6994..ace907305 100644
--- a/src/configs/cmd_duration.rs
+++ b/src/configs/cmd_duration.rs
@@ -1,9 +1,7 @@
-use crate::config::ModuleConfig;
+use serde::{Deserialize, Serialize};
 
-use serde::Serialize;
-use starship_module_config_derive::ModuleConfig;
-
-#[derive(Clone, ModuleConfig, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(default)]
 pub struct CmdDurationConfig<'a> {
     pub min_time: i64,
     pub format: &'a str,
diff --git a/src/configs/cobol.rs b/src/configs/cobol.rs
index b56123987..da41b96f3 100644
--- a/src/configs/cobol.rs
+++ b/src/configs/cobol.rs
@@ -1,9 +1,7 @@
-use crate::config::ModuleConfig;
+use serde::{Deserialize, Serialize};
 
-use serde::Serialize;
-use starship_module_config_derive::ModuleConfig;
-
-#[derive(Clone, ModuleConfig, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(default)]
 pub struct CobolConfig<'a> {
     pub format: &'a str,
     pub version_format: &'a str,
diff --git a/src/configs/conda.rs b/src/configs/conda.rs
index 623b4fc67..df88312d1 100644
--- a/src/configs/conda.rs
+++ b/src/configs/conda.rs
@@ -1,9 +1,7 @@
-use crate::config::ModuleConfig;
+use serde::{Deserialize, Serialize};
 
-use serde::Serialize;
-use starship_module_config_derive::ModuleConfig;
-
-#[derive(Clone, ModuleConfig, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(default)]
 pub struct CondaConfig<'a> {
     pub truncation_length: usize,
     pub format: &'a str,
diff --git a/src/configs/container.rs b/src/configs/container.rs
index 107fdd28f..dd777b48a 100644
--- a/src/configs/container.rs
+++ b/src/configs/container.rs
@@ -1,9 +1,7 @@
-use crate::config::ModuleConfig;
+use serde::{Deserialize, Serialize};
 
-use serde::Serialize;
-use starship_module_config_derive::ModuleConfig;
-
-#[derive(Clone, ModuleConfig, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(default)]
 pub struct ContainerConfig<'a> {
     pub format: &'a str,
     pub symbol: &'a str,
diff --git a/src/configs/crystal.rs b/src/configs/crystal.rs
index ec90b773e..7c7ece703 100644
--- a/src/configs/crystal.rs
+++ b/src/configs/crystal.rs
@@ -1,9 +1,7 @@
-use crate::config::ModuleConfig;
+use serde::{Deserialize, Serialize};
 
-use serde::Serialize;
-use starship_module_config_derive::ModuleConfig;
-
-#[derive(Clone, ModuleConfig, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(default)]
 pub struct CrystalConfig<'a> {
     pub format: &'a str,
     pub version_format: &'a str,
diff --git a/src/configs/custom.rs b/src/configs/custom.rs
index d1f758aa4..a38d60a75 100644
--- a/src/configs/custom.rs
+++ b/src/configs/custom.rs
@@ -1,9 +1,9 @@
-use crate::config::{ModuleConfig, VecOr};
+use crate::config::VecOr;
 
-use serde::{self, Serialize};
-use starship_module_config_derive::ModuleConfig;
+use serde::{self, Deserialize, Serialize};
 
-#[derive(Clone, ModuleConfig, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(default)]
 pub struct CustomConfig<'a> {
     pub format: &'a str,
     pub symbol: &'a str,
diff --git a/src/configs/dart.rs b/src/configs/dart.rs
index 8edb214bd..cc235d488 100644
--- a/src/configs/dart.rs
+++ b/src/configs/dart.rs
@@ -1,9 +1,7 @@
-use crate::config::ModuleConfig;
+use serde::{Deserialize, Serialize};
 
-use serde::Serialize;
-use starship_module_config_derive::ModuleConfig;
-
-#[derive(Clone, ModuleConfig, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(default)]
 pub struct DartConfig<'a> {
     pub format: &'a str,
     pub version_format: &'a str,
diff --git a/src/configs/deno.rs b/src/configs/deno.rs
index c7b3e45b4..f3f955ec3 100644
--- a/src/configs/deno.rs
+++ b/src/configs/deno.rs
@@ -1,9 +1,7 @@
-use crate::config::ModuleConfig;
+use serde::{Deserialize, Serialize};
 
-use serde::Serialize;
-use starship_module_config_derive::ModuleConfig;
-
-#[derive(Clone, ModuleConfig, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(default)]
 pub struct DenoConfig<'a> {
     pub format: &'a str,
     pub version_format: &'a str,
diff --git a/src/configs/directory.rs b/src/configs/directory.rs
index 0d1d9217e..89c98518a 100644
--- a/src/configs/directory.rs
+++ b/src/configs/directory.rs
@@ -1,10 +1,9 @@
-use crate::config::ModuleConfig;
 use indexmap::IndexMap;
 
-use serde::Serialize;
-use starship_module_config_derive::ModuleConfig;
+use serde::{Deserialize, Serialize};
 
-#[derive(Clone, ModuleConfig, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(default)]
 pub struct DirectoryConfig<'a> {
     pub truncation_length: i64,
     pub truncate_to_repo: bool,
diff --git a/src/configs/docker_context.rs b/src/configs/docker_context.rs
index b026acda9..73603ac34 100644
--- a/src/configs/docker_context.rs
+++ b/src/configs/docker_context.rs
@@ -1,9 +1,7 @@
-use crate::config::ModuleConfig;
+use serde::{Deserialize, Serialize};
 
-use serde::Serialize;
-use starship_module_config_derive::ModuleConfig;
-
-#[derive(Clone, ModuleConfig, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(default)]
 pub struct DockerContextConfig<'a> {
     pub symbol: &'a str,
     pub style: &'a str,
diff --git a/src/configs/dotnet.rs b/src/configs/dotnet.rs
index 0d29e178e..da2137655 100644
--- a/src/configs/dotnet.rs
+++ b/src/configs/dotnet.rs
@@ -1,9 +1,7 @@
-use crate::config::ModuleConfig;
+use serde::{Deserialize, Serialize};
 
-use serde::Serialize;
-use starship_module_config_derive::ModuleConfig;
-
-#[derive(Clone, ModuleConfig, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(default)]
 pub struct DotnetConfig<'a> {
     pub format: &'a str,
     pub version_format: &'a str,
diff --git a/src/configs/elixir.rs b/src/configs/elixir.rs
index d4ed7161e..fac7983c2 100644
--- a/src/configs/elixir.rs
+++ b/src/configs/elixir.rs
@@ -1,9 +1,7 @@
-use crate::config::ModuleConfig;
+use serde::{Deserialize, Serialize};
 
-use serde::Serialize;
-use starship_module_config_derive::ModuleConfig;
-
-#[derive(Clone, ModuleConfig, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(default)]
 pub struct ElixirConfig<'a> {
     pub format: &'a str,
     pub version_format: &'a str,
diff --git a/src/configs/elm.rs b/src/configs/elm.rs
index 34d6b6260..1b5357d43 100644
--- a/src/configs/elm.rs
+++ b/src/configs/elm.rs
@@ -1,9 +1,7 @@
-use crate::config::ModuleConfig;
+use serde::{Deserialize, Serialize};
 
-use serde::Serialize;
-use starship_module_config_derive::ModuleConfig;
-
-#[derive(Clone, ModuleConfig, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(default)]
 pub struct ElmConfig<'a> {
     pub format: &'a str,
     pub version_format: &'a str,
diff --git a/src/configs/env_var.rs b/src/configs/env_var.rs
index 30ab72e95..0b5c663b7 100644
--- a/src/configs/env_var.rs
+++ b/src/configs/env_var.rs
@@ -1,9 +1,7 @@
-use crate::config::ModuleConfig;
+use serde::{Deserialize, Serialize};
 
-use serde::Serialize;
-use starship_module_config_derive::ModuleConfig;
-
-#[derive(Clone, ModuleConfig, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(default)]
 pub struct EnvVarConfig<'a> {
     pub symbol: &'a str,
     pub style: &'a str,
diff --git a/src/configs/erlang.rs b/src/configs/erlang.rs
index 8ab6f0764..06888b88a 100644
--- a/src/configs/erlang.rs
+++ b/src/configs/erlang.rs
@@ -1,9 +1,7 @@
-use crate::config::ModuleConfig;
+use serde::{Deserialize, Serialize};
 
-use serde::Serialize;
-use starship_module_config_derive::ModuleConfig;
-
-#[derive(Clone, ModuleConfig, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(default)]
 pub struct ErlangConfig<'a> {
     pub format: &'a str,
     pub version_format: &'a str,
diff --git a/src/configs/fill.rs b/src/configs/fill.rs
index fc0af31fa..63cd4424c 100644
--- a/src/configs/fill.rs
+++ b/src/configs/fill.rs
@@ -1,9 +1,7 @@
-use crate::config::ModuleConfig;
+use serde::{Deserialize, Serialize};
 
-use serde::Serialize;
-use starship_module_config_derive::ModuleConfig;
-
-#[derive(Clone, ModuleConfig, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(default)]
 pub struct FillConfig<'a> {
     pub style: &'a str,
     pub symbol: &'a str,
diff --git a/src/configs/gcloud.rs b/src/configs/gcloud.rs
index 853cd0148..e298a0446 100644
--- a/src/configs/gcloud.rs
+++ b/src/configs/gcloud.rs
@@ -1,9 +1,8 @@
-use crate::config::ModuleConfig;
-use serde::Serialize;
-use starship_module_config_derive::ModuleConfig;
+use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 
-#[derive(Clone, ModuleConfig, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(default)]
 pub struct GcloudConfig<'a> {
     pub format: &'a str,
     pub symbol: &'a str,
diff --git a/src/configs/git_branch.rs b/src/configs/git_branch.rs
index c20321592..1123df330 100644
--- a/src/configs/git_branch.rs
+++ b/src/configs/git_branch.rs
@@ -1,9 +1,7 @@
-use crate::config::ModuleConfig;
+use serde::{Deserialize, Serialize};
 
-use serde::Serialize;
-use starship_module_config_derive::ModuleConfig;
-
-#[derive(Clone, ModuleConfig, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(default)]
 pub struct GitBranchConfig<'a> {
     pub format: &'a str,
     pub symbol: &'a str,
diff --git a/src/configs/git_commit.rs b/src/configs/git_commit.rs
index bab6d2ae7..3044d0e7c 100644
--- a/src/configs/git_commit.rs
+++ b/src/configs/git_commit.rs
@@ -1,9 +1,7 @@
-use crate::config::ModuleConfig;
+use serde::{Deserialize, Serialize};
 
-use serde::Serialize;
-use starship_module_config_derive::ModuleConfig;
-
-#[derive(Clone, ModuleConfig, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(default)]
 pub struct GitCommitConfig<'a> {
     pub commit_hash_length: usize,
     pub format: &'a str,
diff --git a/src/configs/git_metrics.rs b/src/configs/git_metrics.rs
index ed3e499a2..d4cac7d13 100644
--- a/src/configs/git_metrics.rs
+++ b/src/configs/git_metrics.rs
@@ -1,9 +1,7 @@
-use crate::config::ModuleConfig;
+use serde::{Deserialize, Serialize};
 
-use serde::Serialize;
-use starship_module_config_derive::ModuleConfig;
-
-#[derive(Clone, ModuleConfig, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(default)]
 pub struct GitMetricsConfig<'a> {
     pub added_style: &'a str,
     pub deleted_style: &'a str,
diff --git a/src/configs/git_state.rs b/src/configs/git_state.rs
index d0773dcdd..d02a2ed74 100644
--- a/src/configs/git_state.rs
+++ b/src/configs/git_state.rs
@@ -1,9 +1,7 @@
-use crate::config::ModuleConfig;
+use serde::{Deserialize, Serialize};
 
-use serde::Serialize;
-use starship_module_config_derive::ModuleConfig;
-
-#[derive(Clone, ModuleConfig, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(default)]
 pub struct GitStateConfig<'a> {
     pub rebase: &'a str,
     pub merge: &'a str,
diff --git a/src/configs/git_status.rs b/src/configs/git_status.rs
index 78186db3d..d965875ed 100644
--- a/src/configs/git_status.rs
+++ b/src/configs/git_status.rs
@@ -1,9 +1,7 @@
-use crate::config::ModuleConfig;
+use serde::{Deserialize, Serialize};
 
-use serde::Serialize;
-use starship_module_config_derive::ModuleConfig;
-
-#[derive(Clone, ModuleConfig, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(default)]
 pub struct GitStatusConfig<'a> {
     pub format: &'a str,
     pub style: &'a str,
diff --git a/src/configs/go.rs b/src/configs/go.rs
index 0e9f2effb..5ea9b225a 100644
--- a/src/configs/go.rs
+++ b/src/configs/go.rs
@@ -1,9 +1,7 @@
-use crate::config::ModuleConfig;
+use serde::{Deserialize, Serialize};
 
-use serde::Serialize;
-use starship_module_config_derive::ModuleConfig;
-
-#[derive(Clone, ModuleConfig, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(default)]
 pub struct GoConfig<'a> {
     pub format: &'a str,
     pub version_format: &'a str,
diff --git a/src/configs/haskell.rs b/src/configs/haskell.rs
index 40319461e..720f7a386 100644
--- a/src/configs/haskell.rs
+++ b/src/configs/haskell.rs
@@ -1,9 +1,7 @@
-use crate::config::ModuleConfig;
+use serde::{Deserialize, Serialize};
 
-use serde::Serialize;
-use starship_module_config_derive::ModuleConfig;
-
-#[derive(Clone, ModuleConfig, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(default)]
 pub struct HaskellConfig<'a> {
     pub format: &'a str,
     pub version_format: &'a str,
diff --git a/src/configs/helm.rs b/src/configs/helm.rs
index 91c38efab..df7e75a92 100644
--- a/src/configs/helm.rs
+++ b/src/configs/helm.rs
@@ -1,9 +1,7 @@
-use crate::config::ModuleConfig;
+use serde::{Deserialize, Serialize};
 
-use serde::Serialize;
-use starship_module_config_derive::ModuleConfig;
-
-#[derive(Clone, ModuleConfig, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(default)]
 pub struct HelmConfig<'a> {
     pub format: &'a str,
     pub version_format: &'a str,
diff --git a/src/configs/hg_branch.rs b/src/configs/hg_branch.rs
index cb50afc52..ef954f429 100644
--- a/src/configs/hg_branch.rs
+++ b/src/configs/hg_branch.rs
@@ -1,9 +1,7 @@
-use crate::config::ModuleConfig;
+use serde::{Deserialize, Serialize};
 
-use serde::Serialize;
-use starship_module_config_derive::ModuleConfig;
-
-#[derive(Clone, ModuleConfig, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(default)]
 pub struct HgBranchConfig<'a> {
     pub symbol: &'a str,
     pub style: &'a str,
diff --git a/src/configs/hostname.rs b/src/configs/hostname.rs
index 074fabcaf..4090f9daa 100644
--- a/src/configs/hostname.rs
+++ b/src/configs/hostname.rs
@@ -1,9 +1,7 @@
-use crate::config::ModuleConfig;
+use serde::{Deserialize, Serialize};
 
-use serde::Serialize;
-use starship_module_config_derive::ModuleConfig;
-
-#[derive(Clone, ModuleConfig, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(default)]
 pub struct HostnameConfig<'a> {
     pub ssh_only: bool,
     pub trim_at: &'a str,
diff --git a/src/configs/java.rs b/src/configs/java.rs
index 20c28fd3d..2944360f5 100644
--- a/src/configs/java.rs
+++ b/src/configs/java.rs
@@ -1,9 +1,7 @@
-use crate::config::ModuleConfig;
+use serde::{Deserialize, Serialize};
 
-use serde::Serialize;
-use starship_module_config_derive::ModuleConfig;
-
-#[derive(Clone, ModuleConfig, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(default)]
 pub struct JavaConfig<'a> {
     pub disabled: bool,
     pub format: &'a str,
diff --git a/src/configs/jobs.rs b/src/configs/jobs.rs
index 9f01f4a5f..a9f51dc88 100644
--- a/src/configs/jobs.rs
+++ b/src/configs/jobs.rs
@@ -1,9 +1,7 @@
-use crate::config::ModuleConfig;
+use serde::{Deserialize, Serialize};
 
-use serde::Serialize;
-use starship_module_config_derive::ModuleConfig;
-
-#[derive(Clone, ModuleConfig, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(default)]
 pub struct JobsConfig<'a> {
     pub threshold: i64,
     pub symbol_threshold: i64,
diff --git a/src/configs/julia.rs b/src/configs/julia.rs
index 785d229dd..bef950ed5 100644
--- a/src/configs/julia.rs
+++ b/src/configs/julia.rs
@@ -1,9 +1,7 @@
-use crate::config::ModuleConfig;
+use serde::{Deserialize, Serialize};
 
-use serde::Serialize;
-use starship_module_config_derive::ModuleConfig;
-
-#[derive(Clone, ModuleConfig, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(default)]
 pub struct JuliaConfig<'a> {
     pub format: &'a str,
     pub version_format: &'a str,
diff --git a/src/configs/kotlin.rs b/src/configs/kotlin.rs
index 35bbafa50..e1cd9bd1c 100644
--- a/src/configs/kotlin.rs
+++ b/src/configs/kotlin.rs
@@ -1,9 +1,7 @@
-use crate::config::ModuleConfig;
+use serde::{Deserialize, Serialize};
 
-use serde::Serialize;
-use starship_module_config_derive::ModuleConfig;
-
-#[derive(Clone, ModuleConfig, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(default)]
 pub struct KotlinConfig<'a> {
     pub format: &'a str,
     pub version_format: &'a str,
diff --git a/src/configs/kubernetes.rs b/src/configs/kubernetes.rs
index 04740c4f2..60b3bb2e7 100644
--- a/src/configs/kubernetes.rs
+++ b/src/configs/kubernetes.rs
@@ -1,10 +1,8 @@
-use crate::config::ModuleConfig;
-
-use serde::Serialize;
-use starship_module_config_derive::ModuleConfig;
+use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 
-#[derive(Clone, ModuleConfig, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(default)]
 pub struct KubernetesConfig<'a> {
     pub symbol: &'a str,
     pub format: &'a str,
diff --git a/src/configs/line_break.rs b/src/configs/line_break.rs
index c3d3669f9..ddc975530 100644
--- a/src/configs/line_break.rs
+++ b/src/configs/line_break.rs
@@ -1,9 +1,6 @@
-use crate::config::ModuleConfig;
+use serde::{Deserialize, Serialize};
 
-use serde::Serialize;
-use starship_module_config_derive::ModuleConfig;
-
-#[derive(Clone, ModuleConfig, Serialize, Default)]
+#[derive(Clone, Deserialize, Serialize, Default)]
 pub struct LineBreakConfig {
     pub disabled: bool,
 }
diff --git a/src/configs/localip.rs b/src/configs/localip.rs
index 98655afe7..a9bb0bb26 100644
--- a/src/configs/localip.rs
+++ b/src/configs/localip.rs
@@ -1,9 +1,7 @@
-use crate::config::ModuleConfig;
+use serde::{Deserialize, Serialize};
 
-use serde::Serialize;
-use starship_module_config_derive::ModuleConfig;
-
-#[derive(Clone, ModuleConfig, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(default)]
 pub struct LocalipConfig<'a> {
     pub ssh_only: bool,
     pub format: &'a str,
diff --git a/src/configs/lua.rs b/src/configs/lua.rs
index 2b8e0898c..a155ee179 100644
--- a/src/configs/lua.rs
+++ b/src/configs/lua.rs
@@ -1,9 +1,7 @@
-use crate::config::ModuleConfig;
+use serde::{Deserialize, Serialize};
 
-use serde::Serialize;
-use starship_module_config_derive::ModuleConfig;
-
-#[derive(Clone, ModuleConfig, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(default)]
 pub struct LuaConfig<'a> {
     pub format: &'a str,
     pub version_format: &'a str,
diff --git a/src/configs/memory_usage.rs b/src/configs/memory_usage.rs
index d89283e0b..49952c06e 100644
--- a/src/configs/memory_usage.rs
+++ b/src/configs/memory_usage.rs
@@ -1,9 +1,7 @@
-use crate::config::ModuleConfig;
+use serde::{Deserialize, Serialize};
 
-use serde::Serialize;
-use starship_module_config_derive::ModuleConfig;
-
-#[derive(Clone, ModuleConfig, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(default)]
 pub struct MemoryConfig<'a> {
     pub threshold: i64,
     pub format: &'a str,
diff --git a/src/configs/mod.rs b/src/configs/mod.rs
index 9a36d7481..0e596e387 100644
--- a/src/configs/mod.rs
+++ b/src/configs/mod.rs
@@ -1,7 +1,5 @@
-use crate::config::ModuleConfig;
 use indexmap::IndexMap;
-use serde::{self, Serialize};
-use starship_module_config_derive::ModuleConfig;
+use serde::{self, Deserialize, Serialize};
 
 pub mod aws;
 pub mod azure;
@@ -79,177 +77,158 @@ pub mod zig;
 
 pub use starship_root::*;
 
-#[derive(Serialize, ModuleConfig, Clone)]
+#[derive(Serialize, Deserialize, Clone, Default)]
 #[serde(default)]
 pub struct FullConfig<'a> {
     // Root config
-    pub format: String,
-    pub right_format: String,
-    pub continuation_prompt: String,
-    pub scan_timeout: u64,
-    pub command_timeout: u64,
-    pub add_newline: bool,
+    #[serde(flatten)]
+    root: StarshipRootConfig,
     // modules
+    #[serde(borrow)]
     aws: aws::AwsConfig<'a>,
+    #[serde(borrow)]
     azure: azure::AzureConfig<'a>,
+    #[serde(borrow)]
     battery: battery::BatteryConfig<'a>,
+    #[serde(borrow)]
     buf: buf::BufConfig<'a>,
+    #[serde(borrow)]
     c: c::CConfig<'a>,
+    #[serde(borrow)]
     character: character::CharacterConfig<'a>,
+    #[serde(borrow)]
     cmake: cmake::CMakeConfig<'a>,
+    #[serde(borrow)]
     cmd_duration: cmd_duration::CmdDurationConfig<'a>,
+    #[serde(borrow)]
     cobol: cobol::CobolConfig<'a>,
+    #[serde(borrow)]
     conda: conda::CondaConfig<'a>,
+    #[serde(borrow)]
     container: container::ContainerConfig<'a>,
+    #[serde(borrow)]
     crystal: crystal::CrystalConfig<'a>,
+    #[serde(borrow)]
     dart: dart::DartConfig<'a>,
+    #[serde(borrow)]
     deno: deno::DenoConfig<'a>,
+    #[serde(borrow)]
     directory: directory::DirectoryConfig<'a>,
+    #[serde(borrow)]
     docker_context: docker_context::DockerContextConfig<'a>,
+    #[serde(borrow)]
     dotnet: dotnet::DotnetConfig<'a>,
+    #[serde(borrow)]
     elixir: elixir::ElixirConfig<'a>,
+    #[serde(borrow)]
     elm: elm::ElmConfig<'a>,
+    #[serde(borrow)]
     env_var: IndexMap<String, env_var::EnvVarConfig<'a>>,
+    #[serde(borrow)]
     erlang: erlang::ErlangConfig<'a>,
+    #[serde(borrow)]
     fill: fill::FillConfig<'a>,
+    #[serde(borrow)]
     gcloud: gcloud::GcloudConfig<'a>,
+    #[serde(borrow)]
     git_branch: git_branch::GitBranchConfig<'a>,
+    #[serde(borrow)]
     git_commit: git_commit::GitCommitConfig<'a>,
+    #[serde(borrow)]
     git_metrics: git_metrics::GitMetricsConfig<'a>,
+    #[serde(borrow)]
     git_state: git_state::GitStateConfig<'a>,
+    #[serde(borrow)]
     git_status: git_status::GitStatusConfig<'a>,
+    #[serde(borrow)]
     golang: go::GoConfig<'a>,
+    #[serde(borrow)]
     haskell: haskell::HaskellConfig<'a>,
+    #[serde(borrow)]
     helm: helm::HelmConfig<'a>,
+    #[serde(borrow)]
     hg_branch: hg_branch::HgBranchConfig<'a>,
+    #[serde(borrow)]
     hostname: hostname::HostnameConfig<'a>,
+    #[serde(borrow)]
     java: java::JavaConfig<'a>,
+    #[serde(borrow)]
     jobs: jobs::JobsConfig<'a>,
+    #[serde(borrow)]
     julia: julia::JuliaConfig<'a>,
+    #[serde(borrow)]
     kotlin: kotlin::KotlinConfig<'a>,
+    #[serde(borrow)]
     kubernetes: kubernetes::KubernetesConfig<'a>,
     line_break: line_break::LineBreakConfig,
+    #[serde(borrow)]
     localip: localip::LocalipConfig<'a>,
+    #[serde(borrow)]
     lua: lua::LuaConfig<'a>,
+    #[serde(borrow)]
     memory_usage: memory_usage::MemoryConfig<'a>,
+    #[serde(borrow)]
     nim: nim::NimConfig<'a>,
+    #[serde(borrow)]
     nix_shell: nix_shell::NixShellConfig<'a>,
+    #[serde(borrow)]
     nodejs: nodejs::NodejsConfig<'a>,
+    #[serde(borrow)]
     ocaml: ocaml::OCamlConfig<'a>,
+    #[serde(borrow)]
     openstack: openstack::OspConfig<'a>,
+    #[serde(borrow)]
     package: package::PackageConfig<'a>,
+    #[serde(borrow)]
     perl: perl::PerlConfig<'a>,
+    #[serde(borrow)]
     php: php::PhpConfig<'a>,
+    #[serde(borrow)]
     pulumi: pulumi::PulumiConfig<'a>,
+    #[serde(borrow)]
     purescript: purescript::PureScriptConfig<'a>,
+    #[serde(borrow)]
     python: python::PythonConfig<'a>,
+    #[serde(borrow)]
     red: red::RedConfig<'a>,
+    #[serde(borrow)]
     rlang: rlang::RLangConfig<'a>,
+    #[serde(borrow)]
     ruby: ruby::RubyConfig<'a>,
+    #[serde(borrow)]
     rust: rust::RustConfig<'a>,
+    #[serde(borrow)]
     scala: scala::ScalaConfig<'a>,
+    #[serde(borrow)]
     shell: shell::ShellConfig<'a>,
+    #[serde(borrow)]
     shlvl: shlvl::ShLvlConfig<'a>,
+    #[serde(borrow)]
     singularity: singularity::SingularityConfig<'a>,
+    #[serde(borrow)]
     status: status::StatusConfig<'a>,
+    #[serde(borrow)]
     sudo: sudo::SudoConfig<'a>,
+    #[serde(borrow)]
     swift: swift::SwiftConfig<'a>,
+    #[serde(borrow)]
     terraform: terraform::TerraformConfig<'a>,
+    #[serde(borrow)]
     time: time::TimeConfig<'a>,
+    #[serde(borrow)]
     username: username::UsernameConfig<'a>,
+    #[serde(borrow)]
     vagrant: vagrant::VagrantConfig<'a>,
+    #[serde(borrow)]
     vcsh: vcsh::VcshConfig<'a>,
+    #[serde(borrow)]
     vlang: v::VConfig<'a>,
+    #[serde(borrow)]
     zig: zig::ZigConfig<'a>,
+    #[serde(borrow)]
     custom: IndexMap<String, custom::CustomConfig<'a>>,
 }
 
-impl<'a> Default for FullConfig<'a> {
-    fn default() -> Self {
-        Self {
-            format: "$all".to_string(),
-            right_format: "".to_string(),
-            continuation_prompt: "[∙](bright-black) ".to_string(),
-            scan_timeout: 30,
-            command_timeout: 500,
-            add_newline: true,
-
-            aws: Default::default(),
-            azure: Default::default(),
-            battery: Default::default(),
-            buf: Default::default(),
-            c: Default::default(),
-            character: Default::default(),
-            cmake: Default::default(),
-            cmd_duration: Default::default(),
-            cobol: Default::default(),
-            conda: Default::default(),
-            container: Default::default(),
-            crystal: Default::default(),
-            dart: Default::default(),
-            deno: Default::default(),
-            directory: Default::default(),
-            docker_context: Default::default(),
-            dotnet: Default::default(),
-            elixir: Default::default(),
-            elm: Default::default(),
-            env_var: Default::default(),
-            erlang: Default::default(),
-            fill: Default::default(),
-            gcloud: Default::default(),
-            git_branch: Default::default(),
-            git_commit: Default::default(),
-            git_metrics: Default::default(),
-            git_state: Default::default(),
-            git_status: Default::default(),
-            golang: Default::default(),
-            haskell: Default::default(),
-            helm: Default::default(),
-            hg_branch: Default::default(),
-            hostname: Default::default(),
-            java: Default::default(),
-            jobs: Default::default(),
-            julia: Default::default(),
-            kotlin: Default::default(),
-            kubernetes: Default::default(),
-            line_break: Default::default(),
-            localip: Default::default(),
-            lua: Default::default(),
-            memory_usage: Default::default(),
-            nim: Default::default(),
-            nix_shell: Default::default(),
-            nodejs: Default::default(),
-            ocaml: Default::default(),
-            openstack: Default::default(),
-            package: Default::default(),
-            perl: Default::default(),
-            php: Default::default(),
-            pulumi: Default::default(),
-            purescript: Default::default(),
-            python: Default::default(),
-            red: Default::default(),
-            rlang: Default::default(),
-            ruby: Default::default(),
-            rust: Default::default(),
-            scala: Default::default(),
-            shell: Default::default(),
-            shlvl: Default::default(),
-            singularity: Default::default(),
-            status: Default::default(),
-            sudo: Default::default(),
-            swift: Default::default(),
-            terraform: Default::default(),
-            time: Default::default(),
-            username: Default::default(),
-            vagrant: Default::default(),
-            vcsh: Default::default(),
-            vlang: Default::default(),
-            zig: Default::default(),
-            custom: Default::default(),
-        }
-    }
-}
-
 #[cfg(test)]
 mod test {
     use super::*;
@@ -264,17 +243,4 @@ mod test {
             assert!(cfg_table.contains_key(*module));
         }
     }
-
-    #[test]
-    fn root_in_full_config() {
-        let full_cfg = Value::try_from(FullConfig::default()).unwrap();
-        let cfg_table = full_cfg.as_table().unwrap();
-
-        let root_cfg = Value::try_from(StarshipRootConfig::default()).unwrap();
-        let root_table = root_cfg.as_table().unwrap();
-        for (option, default_value) in root_table.iter() {
-            assert!(cfg_table.contains_key(option));
-            assert_eq!(&cfg_table[option], default_value);
-        }
-    }
 }
diff --git a/src/configs/nim.rs b/src/configs/nim.rs
index 936045f5c..be1fe9de1 100644
--- a/src/configs/nim.rs
+++ b/src/configs/nim.rs
@@ -1,9 +1,7 @@
-use crate::config::ModuleConfig;
+use serde::{Deserialize, Serialize};
 
-use serde::Serialize;
-use starship_module_config_derive::ModuleConfig;
-
-#[derive(Clone, ModuleConfig, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(default)]
 pub struct NimConfig<'a> {
     pub format: &'a str,
     pub version_format: &'a str,
diff --git a/src/configs/nix_shell.rs b/src/configs/nix_shell.rs
index e2f07ed3b..bd7b7ad88 100644
--- a/src/configs/nix_shell.rs
+++ b/src/configs/nix_shell.rs
@@ -1,9 +1,7 @@
-use crate::config::ModuleConfig;
+use serde::{Deserialize, Serialize};
 
-use serde::Serialize;
-use starship_module_config_derive::ModuleConfig;
-
-#[derive(Clone, ModuleConfig, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(default)]
 pub struct NixShellConfig<'a> {
     pub format: &'a str,
     pub symbol: &'a str,
diff --git a/src/configs/nodejs.rs b/src/configs/nodejs.rs
index a026a4598..d7e8721c2 100644
--- a/src/configs/nodejs.rs
+++ b/src/configs/nodejs.rs
@@ -1,9 +1,7 @@
-use crate::config::ModuleConfig;
+use serde::{Deserialize, Serialize};
 
-use serde::Serialize;
-use starship_module_config_derive::ModuleConfig;
-
-#[derive(Clone, ModuleConfig, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(default)]
 pub struct NodejsConfig<'a> {
     pub format: &'a str,
     pub version_format: &'a str,
diff --git a/src/configs/ocaml.rs b/src/configs/ocaml.rs
index 4675b59bc..145c2f284 100644
--- a/src/configs/ocaml.rs
+++ b/src/configs/ocaml.rs
@@ -1,9 +1,7 @@
-use crate::config::ModuleConfig;
+use serde::{Deserialize, Serialize};
 
-use serde::Serialize;
-use starship_module_config_derive::ModuleConfig;
-
-#[derive(Clone, ModuleConfig, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(default)]
 pub struct OCamlConfig<'a> {
     pub format: &'a str,
     pub version_format: &'a str,
diff --git a/src/configs/openstack.rs b/src/configs/openstack.rs
index 2525466af..a969a4f8f 100644
--- a/src/configs/openstack.rs
+++ b/src/configs/openstack.rs
@@ -1,8 +1,7 @@
-use crate::config::ModuleConfig;
-use serde::Serialize;
-use starship_module_config_derive::ModuleConfig;
+use serde::{Deserialize, Serialize};
 
-#[derive(Clone, ModuleConfig, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(default)]
 pub struct OspConfig<'a> {
     pub format: &'a str,
     pub symbol: &'a str,
diff --git a/src/configs/package.rs b/src/configs/package.rs
index 887cda0d0..3c21ca3a0 100644
--- a/src/configs/package.rs
+++ b/src/configs/package.rs
@@ -1,9 +1,7 @@
-use crate::config::ModuleConfig;
+use serde::{Deserialize, Serialize};
 
-use serde::Serialize;
-use starship_module_config_derive::ModuleConfig;
-
-#[derive(Clone, ModuleConfig, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(default)]
 pub struct PackageConfig<'a> {
     pub format: &'a str,
     pub symbol: &'a str,
diff --git a/src/configs/perl.rs b/src/configs/perl.rs
index ca7aed454..11edc3feb 100644
--- a/src/configs/perl.rs
+++ b/src/configs/perl.rs
@@ -1,9 +1,7 @@
-use crate::config::ModuleConfig;
+use serde::{Deserialize, Serialize};
 
-use serde::Serialize;
-use starship_module_config_derive::ModuleConfig;
-
-#[derive(Clone, ModuleConfig, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(default)]
 pub struct PerlConfig<'a> {
     pub format: &'a str,
     pub version_format: &'a str,
diff --git a/src/configs/php.rs b/src/configs/php.rs
index bb2b8d7c3..cd2af165e 100644
--- a/src/configs/php.rs
+++ b/src/configs/php.rs
@@ -1,9 +1,7 @@
-use crate::config::ModuleConfig;
+use serde::{Deserialize, Serialize};
 
-use serde::Serialize;
-use starship_module_config_derive::ModuleConfig;
-
-#[derive(Clone, ModuleConfig, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(default)]
 pub struct PhpConfig<'a> {
     pub format: &'a str,
     pub version_format: &'a str,
diff --git a/src/configs/pulumi.rs b/src/configs/pulumi.rs
index 2941bc1c4..5df9530fe 100644
--- a/src/configs/pulumi.rs
+++ b/src/configs/pulumi.rs
@@ -1,9 +1,7 @@
-use crate::config::ModuleConfig;
+use serde::{Deserialize, Serialize};
 
-use serde::Serialize;
-use starship_module_config_derive::ModuleConfig;
-
-#[derive(Clone, ModuleConfig, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(default)]
 pub struct PulumiConfig<'a> {
     pub format: &'a str,
     pub version_format: &'a str,
diff --git a/src/configs/purescript.rs b/src/configs/purescript.rs
index 3d1625794..a3dead384 100644
--- a/src/configs/purescript.rs
+++ b/src/configs/purescript.rs
@@ -1,9 +1,7 @@
-use crate::config::ModuleConfig;
+use serde::{Deserialize, Serialize};
 
-use serde::Serialize;
-use starship_module_config_derive::ModuleConfig;
-
-#[derive(Clone, ModuleConfig, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(default)]
 pub struct PureScriptConfig<'a> {
     pub format: &'a str,
     pub version_format: &'a str,
diff --git a/src/configs/python.rs b/src/configs/python.rs
index 1be75deae..e36792fce 100644
--- a/src/configs/python.rs
+++ b/src/configs/python.rs
@@ -1,9 +1,9 @@
-use crate::config::{ModuleConfig, VecOr};
+use crate::config::VecOr;
 
-use serde::Serialize;
-use starship_module_config_derive::ModuleConfig;
+use serde::{Deserialize, Serialize};
 
-#[derive(Clone, ModuleConfig, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(default)]
 pub struct PythonConfig<'a> {
     pub pyenv_version_name: bool,
     pub pyenv_prefix: &'a str,
diff --git a/src/configs/red.rs b/src/configs/red.rs
index ba2a9bca6..d3cb302bc 100644
--- a/src/configs/red.rs
+++ b/src/configs/red.rs
@@ -1,9 +1,7 @@
-use crate::config::ModuleConfig;
+use serde::{Deserialize, Serialize};
 
-use serde::Serialize;
-use starship_module_config_derive::ModuleConfig;
-
-#[derive(Clone, ModuleConfig, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(default)]
 pub struct RedConfig<'a> {
     pub format: &'a str,
     pub version_format: &'a str,
diff --git a/src/configs/rlang.rs b/src/configs/rlang.rs
index e08852829..58ff295bc 100644
--- a/src/configs/rlang.rs
+++ b/src/configs/rlang.rs
@@ -1,9 +1,7 @@
-use crate::config::ModuleConfig;
+use serde::{Deserialize, Serialize};
 
-use serde::Serialize;
-use starship_module_config_derive::ModuleConfig;
-
-#[derive(Clone, ModuleConfig, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(default)]
 pub struct RLangConfig<'a> {
     pub format: &'a str,
     pub version_format: &'a str,
diff --git a/src/configs/ruby.rs b/src/configs/ruby.rs
index ed6520eda..8accebf69 100644
--- a/src/configs/ruby.rs
+++ b/src/configs/ruby.rs
@@ -1,9 +1,7 @@
-use crate::config::ModuleConfig;
+use serde::{Deserialize, Serialize};
 
-use serde::Serialize;
-use starship_module_config_derive::ModuleConfig;
-
-#[derive(Clone, ModuleConfig, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(default)]
 pub struct RubyConfig<'a> {
     pub format: &'a str,
     pub version_format: &'a str,
diff --git a/src/configs/rust.rs b/src/configs/rust.rs
index a007fc5de..52b6d2093 100644
--- a/src/configs/rust.rs
+++ b/src/configs/rust.rs
@@ -1,9 +1,7 @@
-use crate::config::ModuleConfig;
+use serde::{Deserialize, Serialize};
 
-use serde::Serialize;
-use starship_module_config_derive::ModuleConfig;
-
-#[derive(Clone, ModuleConfig, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(default)]
 pub struct RustConfig<'a> {
     pub format: &'a str,
     pub version_format: &'a str,
diff --git a/src/configs/scala.rs b/src/configs/scala.rs
index 90adad15e..4d7e5f061 100644
--- a/src/configs/scala.rs
+++ b/src/configs/scala.rs
@@ -1,9 +1,7 @@
-use crate::config::ModuleConfig;
+use serde::{Deserialize, Serialize};
 
-use serde::Serialize;
-use starship_module_config_derive::ModuleConfig;
-
-#[derive(Clone, ModuleConfig, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(default)]
 pub struct ScalaConfig<'a> {
     pub format: &'a str,
     pub version_format: &'a str,
diff --git a/src/configs/shell.rs b/src/configs/shell.rs
index 087e202e7..52d1a5154 100644
--- a/src/configs/shell.rs
+++ b/src/configs/shell.rs
@@ -1,9 +1,7 @@
-use crate::config::ModuleConfig;
+use serde::{Deserialize, Serialize};
 
-use serde::Serialize;
-use starship_module_config_derive::ModuleConfig;
-
-#[derive(Clone, ModuleConfig, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(default)]
 pub struct ShellConfig<'a> {
     pub format: &'a str,
     pub bash_indicator: &'a str,
diff --git a/src/configs/shlvl.rs b/src/configs/shlvl.rs
index 48c348a93..bbbb74183 100644
--- a/src/configs/shlvl.rs
+++ b/src/configs/shlvl.rs
@@ -1,9 +1,7 @@
-use crate::config::ModuleConfig;
+use serde::{Deserialize, Serialize};
 
-use serde::Serialize;
-use starship_module_config_derive::ModuleConfig;
-
-#[derive(Clone, ModuleConfig, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(default)]
 pub struct ShLvlConfig<'a> {
     pub threshold: i64,
     pub format: &'a str,
diff --git a/src/configs/singularity.rs b/src/configs/singularity.rs
index ade5901f5..e54dee929 100644
--- a/src/configs/singularity.rs
+++ b/src/configs/singularity.rs
@@ -1,9 +1,7 @@
-use crate::config::ModuleConfig;
+use serde::{Deserialize, Serialize};
 
-use serde::Serialize;
-use starship_module_config_derive::ModuleConfig;
-
-#[derive(Clone, ModuleConfig, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(default)]
 pub struct SingularityConfig<'a> {
     pub symbol: &'a str,
     pub format: &'a str,
diff --git a/src/configs/starship_root.rs b/src/configs/starship_root.rs
index b977d620d..143d345eb 100644
--- a/src/configs/starship_root.rs
+++ b/src/configs/starship_root.rs
@@ -1,10 +1,7 @@
-use crate::{config::ModuleConfig, module::ALL_MODULES};
+use serde::{Deserialize, Serialize};
 
-use serde::Serialize;
-use std::cmp::Ordering;
-
-// On changes please also update the `FullConfig` struct in `mod.rs`
-#[derive(Clone, Serialize)]
+#[derive(Clone, Serialize, Deserialize, Debug)]
+#[serde(default)]
 pub struct StarshipRootConfig {
     pub format: String,
     pub right_format: String,
@@ -108,60 +105,3 @@ impl<'a> Default for StarshipRootConfig {
         }
     }
 }
-
-impl<'a> ModuleConfig<'a> for StarshipRootConfig {
-    fn load_config(&mut self, config: &'a toml::Value) {
-        if let toml::Value::Table(config) = config {
-            config.iter().for_each(|(k, v)| match k.as_str() {
-                "format" => self.format.load_config(v),
-                "right_format" => self.right_format.load_config(v),
-                "continuation_prompt" => self.continuation_prompt.load_config(v),
-                "scan_timeout" => self.scan_timeout.load_config(v),
-                "command_timeout" => self.command_timeout.load_config(v),
-                "add_newline" => self.add_newline.load_config(v),
-                unknown => {
-                    if !ALL_MODULES.contains(&unknown)
-                        && unknown != "custom"
-                        && unknown != "env_var"
-                    {
-                        log::warn!("Unknown config key '{}'", unknown);
-
-                        let did_you_mean = &[
-                            // Root options
-                            "format",
-                            "right_format",
-                            "continuation_prompt",
-                            "scan_timeout",
-                            "command_timeout",
-                            "add_newline",
-                            // Modules
-                            "custom",
-                            "env_var",
-                        ]
-                        .iter()
-                        .chain(ALL_MODULES)
-                        .filter_map(|field| {
-                            let score = strsim::jaro_winkler(unknown, field);
-                            (score > 0.8).then(|| (score, field))
-                        })
-                        .max_by(
-                            |(score_a, _field_a), (score_b, _field_b)| {
-                                score_a.partial_cmp(score_b).unwrap_or(Ordering::Equal)
-                            },
-                        );
-
-                        if let Some((_score, field)) = did_you_mean {
-                            log::warn!("Did you mean '{}'?", field);
-                        }
-                    }
-                }
-            });
-        }
-    }
-
-    fn from_config(config: &'a toml::Value) -> Option<Self> {
-        let mut out = Self::default();
-        out.load_config(config);
-        Some(out)
-    }
-}
diff --git a/src/configs/status.rs b/src/configs/status.rs
index 9d6337eb7..7ec756de2 100644
--- a/src/configs/status.rs
+++ b/src/configs/status.rs
@@ -1,9 +1,7 @@
-use crate::config::ModuleConfig;
+use serde::{Deserialize, Serialize};
 
-use serde::Serialize;
-use starship_module_config_derive::ModuleConfig;
-
-#[derive(Clone, ModuleConfig, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(default)]
 pub struct StatusConfig<'a> {
     pub format: &'a str,
     pub symbol: &'a str,
diff --git a/src/configs/sudo.rs b/src/configs/sudo.rs
index c2a5b6ed7..b7bedcf9d 100644
--- a/src/configs/sudo.rs
+++ b/src/configs/sudo.rs
@@ -1,9 +1,7 @@
-use crate::config::ModuleConfig;
+use serde::{Deserialize, Serialize};
 
-use serde::Serialize;
-use starship_module_config_derive::ModuleConfig;
-
-#[derive(Clone, ModuleConfig, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(default)]
 pub struct SudoConfig<'a> {
     pub format: &'a str,
     pub symbol: &'a str,
diff --git a/src/configs/swift.rs b/src/configs/swift.rs
index c63b1ae67..528f1f574 100644
--- a/src/configs/swift.rs
+++ b/src/configs/swift.rs
@@ -1,9 +1,7 @@
-use crate::config::ModuleConfig;
+use serde::{Deserialize, Serialize};
 
-use serde::Serialize;
-use starship_module_config_derive::ModuleConfig;
-
-#[derive(Clone, ModuleConfig, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(default)]
 pub struct SwiftConfig<'a> {
     pub format: &'a str,
     pub version_format: &'a str,
diff --git a/src/configs/terraform.rs b/src/configs/terraform.rs
index 21f6b705e..24f870dd0 100644
--- a/src/configs/terraform.rs
+++ b/src/configs/terraform.rs
@@ -1,9 +1,7 @@
-use crate::config::ModuleConfig;
+use serde::{Deserialize, Serialize};
 
-use serde::Serialize;
-use starship_module_config_derive::ModuleConfig;
-
-#[derive(Clone, ModuleConfig, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(default)]
 pub struct TerraformConfig<'a> {
     pub format: &'a str,
     pub version_format: &'a str,
diff --git a/src/configs/time.rs b/src/configs/time.rs
index 0ab8996f7..ecff84b15 100644
--- a/src/configs/time.rs
+++ b/src/configs/time.rs
@@ -1,9 +1,7 @@
-use crate::config::ModuleConfig;
+use serde::{Deserialize, Serialize};
 
-use serde::Serialize;
-use starship_module_config_derive::ModuleConfig;
-
-#[derive(Clone, ModuleConfig, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(default)]
 pub struct TimeConfig<'a> {
     pub format: &'a str,
     pub style: &'a str,
diff --git a/src/configs/username.rs b/src/configs/username.rs
index 42c83552f..a5fe25461 100644
--- a/src/configs/username.rs
+++ b/src/configs/username.rs
@@ -1,9 +1,7 @@
-use crate::config::ModuleConfig;
+use serde::{Deserialize, Serialize};
 
-use serde::Serialize;
-use starship_module_config_derive::ModuleConfig;
-
-#[derive(Clone, ModuleConfig, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(default)]
 pub struct UsernameConfig<'a> {
     pub format: &'a str,
     pub style_root: &'a str,
diff --git a/src/configs/v.rs b/src/configs/v.rs
index 87316ef76..ddd1e8fe5 100644
--- a/src/configs/v.rs
+++ b/src/configs/v.rs
@@ -1,9 +1,7 @@
-use crate::config::ModuleConfig;
+use serde::{Deserialize, Serialize};
 
-use serde::Serialize;
-use starship_module_config_derive::ModuleConfig;
-
-#[derive(Clone, ModuleConfig, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(default)]
 pub struct VConfig<'a> {
     pub format: &'a str,
     pub version_format: &'a str,
diff --git a/src/configs/vagrant.rs b/src/configs/vagrant.rs
index cc7df44b1..0cd1ea38a 100644
--- a/src/configs/vagrant.rs
+++ b/src/configs/vagrant.rs
@@ -1,9 +1,7 @@
-use crate::config::ModuleConfig;
+use serde::{Deserialize, Serialize};
 
-use serde::Serialize;
-use starship_module_config_derive::ModuleConfig;
-
-#[derive(Clone, ModuleConfig, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(default)]
 pub struct VagrantConfig<'a> {
     pub format: &'a str,
     pub version_format: &'a str,
diff --git a/src/configs/vcsh.rs b/src/configs/vcsh.rs
index 0bb1a801c..506009136 100644
--- a/src/configs/vcsh.rs
+++ b/src/configs/vcsh.rs
@@ -1,9 +1,7 @@
-use crate::config::ModuleConfig;
+use serde::{Deserialize, Serialize};
 
-use serde::Serialize;
-use starship_module_config_derive::ModuleConfig;
-
-#[derive(Clone, ModuleConfig, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(default)]
 pub struct VcshConfig<'a> {
     pub symbol: &'a str,
     pub style: &'a str,
diff --git a/src/configs/zig.rs b/src/configs/zig.rs
index c26ae5b74..6f8202b64 100644
--- a/src/configs/zig.rs
+++ b/src/configs/zig.rs
@@ -1,9 +1,7 @@
-use crate::config::ModuleConfig;
+use serde::{Deserialize, Serialize};
 
-use serde::Serialize;
-use starship_module_config_derive::ModuleConfig;
-
-#[derive(Clone, ModuleConfig, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(default)]
 pub struct ZigConfig<'a> {
     pub format: &'a str,
     pub version_format: &'a str,
diff --git a/src/configure.rs b/src/configure.rs
index e3de2ada8..816a4fa0f 100644
--- a/src/configure.rs
+++ b/src/configure.rs
@@ -5,7 +5,7 @@ use std::process;
 use std::process::Stdio;
 use std::str::FromStr;
 
-use crate::config::RootModuleConfig;
+use crate::config::ModuleConfig;
 use crate::config::StarshipConfig;
 use crate::configs::PROMPT_ORDER;
 use crate::utils;
@@ -83,7 +83,7 @@ pub fn print_configuration(use_default: bool, paths: &[String]) {
         // Get config as toml::Value
         let user_config = get_configuration();
         // Convert into FullConfig and fill in default values
-        let user_config = crate::configs::FullConfig::try_load(Some(&user_config));
+        let user_config = crate::configs::FullConfig::load(&user_config);
         // Convert back to Value because toml can't serialize FullConfig directly
         toml::value::Value::try_from(user_config).unwrap()
     };
diff --git a/src/context.rs b/src/context.rs
index 2ae65b8fb..f84a07cb3 100644
--- a/src/context.rs
+++ b/src/context.rs
@@ -1,4 +1,4 @@
-use crate::config::{RootModuleConfig, StarshipConfig};
+use crate::config::{ModuleConfig, StarshipConfig};
 use crate::configs::StarshipRootConfig;
 use crate::module::Module;
 use crate::utils::{create_command, exec_timeout, CommandOutput};
diff --git a/src/lib.rs b/src/lib.rs
index 52c719739..cfacfa0a8 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -18,6 +18,7 @@ pub mod module;
 mod modules;
 pub mod print;
 mod segment;
+mod serde_utils;
 mod utils;
 
 #[cfg(test)]
diff --git a/src/modules/aws.rs b/src/modules/aws.rs
index 193cdd133..0a941bfac 100644
--- a/src/modules/aws.rs
+++ b/src/modules/aws.rs
@@ -4,7 +4,7 @@ use std::str::FromStr;
 
 use chrono::DateTime;
 
-use super::{Context, Module, RootModuleConfig};
+use super::{Context, Module, ModuleConfig};
 
 use crate::configs::aws::AwsConfig;
 use crate::formatter::StringFormatter;
@@ -614,10 +614,6 @@ credential_process = /opt/bin/awscreds-retriever
         );
 
         let actual = ModuleRenderer::new("aws")
-            .config(toml::toml! {
-                [aws]
-                show_duration = true
-            })
             .env("AWS_PROFILE", "astronauts")
             .env("AWS_REGION", "ap-northeast-2")
             .env("AWS_ACCESS_KEY_ID", "dummy")
@@ -664,10 +660,6 @@ expiration={}
         )?;
 
         let actual = ModuleRenderer::new("aws")
-            .config(toml::toml! {
-                [aws]
-                show_duration = true
-            })
             .env("AWS_PROFILE", "astronauts")
             .env("AWS_REGION", "ap-northeast-2")
             .env(
@@ -695,10 +687,6 @@ expiration={}
     #[test]
     fn profile_and_region_set_show_duration() {
         let actual = ModuleRenderer::new("aws")
-            .config(toml::toml! {
-                [aws]
-                show_duration = true
-            })
             .env("AWS_PROFILE", "astronauts")
             .env("AWS_REGION", "ap-northeast-2")
             .env("AWS_ACCESS_KEY_ID", "dummy")
@@ -727,7 +715,6 @@ expiration={}
         let actual = ModuleRenderer::new("aws")
             .config(toml::toml! {
                 [aws]
-                show_duration = true
                 expiration_symbol = symbol
             })
             .env("AWS_PROFILE", "astronauts")
diff --git a/src/modules/azure.rs b/src/modules/azure.rs
index 7921ebcb7..87bb351db 100644
--- a/src/modules/azure.rs
+++ b/src/modules/azure.rs
@@ -2,7 +2,7 @@ use std::fs::File;
 use std::io::{BufReader, Read};
 use std::path::{Path, PathBuf};
 
-use super::{Context, Module, RootModuleConfig};
+use super::{Context, Module, ModuleConfig};
 
 type JValue = serde_json::Value;
 
diff --git a/src/modules/battery.rs b/src/modules/battery.rs
index 3942dea52..04bc075b7 100644
--- a/src/modules/battery.rs
+++ b/src/modules/battery.rs
@@ -1,4 +1,4 @@
-use super::{Context, Module, RootModuleConfig};
+use super::{Context, Module, ModuleConfig};
 use crate::configs::battery::BatteryConfig;
 #[cfg(test)]
 use mockall::automock;
diff --git a/src/modules/buf.rs b/src/modules/buf.rs
index 78fccc93f..cae5b9c5d 100644
--- a/src/modules/buf.rs
+++ b/src/modules/buf.rs
@@ -1,4 +1,4 @@
-use super::{Context, Module, RootModuleConfig};
+use super::{Context, Module, ModuleConfig};
 
 use crate::configs::buf::BufConfig;
 use crate::formatter::StringFormatter;
diff --git a/src/modules/c.rs b/src/modules/c.rs
index bbe796c95..49113bd14 100644
--- a/src/modules/c.rs
+++ b/src/modules/c.rs
@@ -1,4 +1,4 @@
-use super::{Context, Module, RootModuleConfig};
+use super::{Context, Module, ModuleConfig};
 
 use crate::configs::c::CConfig;
 use crate::formatter::StringFormatter;
diff --git a/src/modules/character.rs b/src/modules/character.rs
index c6a89daa3..e7b65e2ee 100644
--- a/src/modules/character.rs
+++ b/src/modules/character.rs
@@ -1,4 +1,4 @@
-use super::{Context, Module, RootModuleConfig, Shell};
+use super::{Context, Module, ModuleConfig, Shell};
 use crate::configs::character::CharacterConfig;
 use crate::formatter::StringFormatter;
 
diff --git a/src/modules/cmake.rs b/src/modules/cmake.rs
index c5c58a337..11ad27bdf 100644
--- a/src/modules/cmake.rs
+++ b/src/modules/cmake.rs
@@ -1,4 +1,4 @@
-use super::{Context, Module, RootModuleConfig};
+use super::{Context, Module, ModuleConfig};
 use crate::formatter::VersionFormatter;
 
 use crate::configs::cmake::CMakeConfig;
diff --git a/src/modules/cmd_duration.rs b/src/modules/cmd_duration.rs
index 628714ea0..c35603021 100644
--- a/src/modules/cmd_duration.rs
+++ b/src/modules/cmd_duration.rs
@@ -1,4 +1,4 @@
-use super::{Context, Module, RootModuleConfig};
+use super::{Context, Module, ModuleConfig};
 
 use crate::configs::cmd_duration::CmdDurationConfig;
 use crate::formatter::StringFormatter;
diff --git a/src/modules/cobol.rs b/src/modules/cobol.rs
index a2ebe3e32..d19983f35 100644
--- a/src/modules/cobol.rs
+++ b/src/modules/cobol.rs
@@ -1,4 +1,4 @@
-use super::{Context, Module, RootModuleConfig};
+use super::{Context, Module, ModuleConfig};
 
 use crate::configs::cobol::CobolConfig;
 use crate::formatter::StringFormatter;
diff --git a/src/modules/conda.rs b/src/modules/conda.rs
index 2491420b7..01a7f01fe 100644
--- a/src/modules/conda.rs
+++ b/src/modules/conda.rs
@@ -1,4 +1,4 @@
-use super::{Context, Module, RootModuleConfig};
+use super::{Context, Module, ModuleConfig};
 
 use super::utils::directory::truncate;
 use crate::configs::conda::CondaConfig;
diff --git a/src/modules/container.rs b/src/modules/container.rs
index ffe71ce05..9feba3d2d 100644
--- a/src/modules/container.rs
+++ b/src/modules/container.rs
@@ -7,7 +7,7 @@ pub fn module<'a>(_context: &'a Context) -> Option<Module<'a>> {
 
 #[cfg(target_os = "linux")]
 pub fn module<'a>(context: &'a Context) -> Option<Module<'a>> {
-    use super::RootModuleConfig;
+    use super::ModuleConfig;
     use crate::configs::container::ContainerConfig;
     use crate::formatter::StringFormatter;
     use crate::utils::read_file;
diff --git a/src/modules/crystal.rs b/src/modules/crystal.rs
index ca9e3f344..cb283bb4d 100644
--- a/src/modules/crystal.rs
+++ b/src/modules/crystal.rs
@@ -1,4 +1,4 @@
-use super::{Context, Module, RootModuleConfig};
+use super::{Context, Module, ModuleConfig};
 
 use crate::configs::crystal::CrystalConfig;
 use crate::formatter::StringFormatter;
diff --git a/src/modules/custom.rs b/src/modules/custom.rs
index 309129cdd..66880c3e7 100644
--- a/src/modules/custom.rs
+++ b/src/modules/custom.rs
@@ -3,7 +3,7 @@ use std::io::Write;
 use std::process::{Command, Output, Stdio};
 use std::time::Instant;
 
-use super::{Context, Module, RootModuleConfig, Shell};
+use super::{Context, Module, ModuleConfig, Shell};
 
 use crate::{configs::custom::CustomConfig, formatter::StringFormatter, utils::create_command};
 
diff --git a/src/modules/dart.rs b/src/modules/dart.rs
index 918e43f13..8df6307b2 100644
--- a/src/modules/dart.rs
+++ b/src/modules/dart.rs
@@ -1,4 +1,4 @@
-use super::{Context, Module, RootModuleConfig};
+use super::{Context, Module, ModuleConfig};
 
 use crate::configs::dart::DartConfig;
 use crate::formatter::StringFormatter;
diff --git a/src/modules/deno.rs b/src/modules/deno.rs
index 3ab6cbf4d..a226fbc9e 100644
--- a/src/modules/deno.rs
+++ b/src/modules/deno.rs
@@ -1,4 +1,4 @@
-use super::{Context, Module, RootModuleConfig};
+use super::{Context, Module, ModuleConfig};
 
 use crate::configs::deno::DenoConfig;
 use crate::formatter::StringFormatter;
diff --git a/src/modules/directory.rs b/src/modules/directory.rs
index ddbe8588b..2e6c14336 100644
--- a/src/modules/directory.rs
+++ b/src/modules/directory.rs
@@ -12,7 +12,7 @@ use unicode_segmentation::UnicodeSegmentation;
 use super::{Context, Module};
 
 use super::utils::directory::truncate;
-use crate::config::RootModuleConfig;
+use crate::config::ModuleConfig;
 use crate::configs::directory::DirectoryConfig;
 use crate::formatter::StringFormatter;
 
diff --git a/src/modules/docker_context.rs b/src/modules/docker_context.rs
index 80ed4bfed..bc18d8347 100644
--- a/src/modules/docker_context.rs
+++ b/src/modules/docker_context.rs
@@ -1,6 +1,6 @@
 use std::path::PathBuf;
 
-use super::{Context, Module, RootModuleConfig};
+use super::{Context, Module, ModuleConfig};
 
 use crate::configs::docker_context::DockerContextConfig;
 use crate::formatter::StringFormatter;
diff --git a/src/modules/dotnet.rs b/src/modules/dotnet.rs
index 2483ad243..51a3440b0 100644
--- a/src/modules/dotnet.rs
+++ b/src/modules/dotnet.rs
@@ -5,7 +5,7 @@ use std::iter::Iterator;
 use std::path::{Path, PathBuf};
 use std::str;
 
-use super::{Context, Module, RootModuleConfig};
+use super::{Context, Module, ModuleConfig};
 use crate::configs::dotnet::DotnetConfig;
 use crate::formatter::StringFormatter;
 use crate::utils;
diff --git a/src/modules/elixir.rs b/src/modules/elixir.rs
index eb3ff5847..f6d5c91c7 100644
--- a/src/modules/elixir.rs
+++ b/src/modules/elixir.rs
@@ -1,4 +1,4 @@
-use super::{Context, Module, RootModuleConfig};
+use super::{Context, Module, ModuleConfig};
 
 use crate::configs::elixir::ElixirConfig;
 use crate::formatter::StringFormatter;
diff --git a/src/modules/elm.rs b/src/modules/elm.rs
index 687165bb0..09564ab71 100644
--- a/src/modules/elm.rs
+++ b/src/modules/elm.rs
@@ -1,4 +1,4 @@
-use super::{Context, Module, RootModuleConfig};
+use super::{Context, Module, ModuleConfig};
 
 use crate::configs::elm::ElmConfig;
 use crate::formatter::StringFormatter;
diff --git a/src/modules/env_var.rs b/src/modules/env_var.rs
index 108b90a43..85ff8d0db 100644
--- a/src/modules/env_var.rs
+++ b/src/modules/env_var.rs
@@ -1,6 +1,6 @@
 use super::{Context, Module};
 
-use crate::config::RootModuleConfig;
+use crate::config::ModuleConfig;
 use crate::configs::env_var::EnvVarConfig;
 use crate::formatter::StringFormatter;
 use crate::segment::Segment;
diff --git a/src/modules/erlang.rs b/src/modules/erlang.rs
index e20fd23a0..4d3be6d71 100644
--- a/src/modules/erlang.rs
+++ b/src/modules/erlang.rs
@@ -1,4 +1,4 @@
-use super::{Context, Module, RootModuleConfig};
+use super::{Context, Module, ModuleConfig};
 
 use crate::configs::erlang::ErlangConfig;
 use crate::formatter::StringFormatter;
diff --git a/src/modules/fill.rs b/src/modules/fill.rs
index 1b7127c95..d77eb7ce1 100644
--- a/src/modules/fill.rs
+++ b/src/modules/fill.rs
@@ -1,6 +1,6 @@
 use super::{Context, Module};
 
-use crate::config::{parse_style_string, RootModuleConfig};
+use crate::config::{parse_style_string, ModuleConfig};
 use crate::configs::fill::FillConfig;
 use crate::segment::Segment;
 
diff --git a/src/modules/gcloud.rs b/src/modules/gcloud.rs
index 153aa5ccb..7ba923559 100644
--- a/src/modules/gcloud.rs
+++ b/src/modules/gcloud.rs
@@ -3,7 +3,7 @@ use std::ops::Deref;
 use std::path::Path;
 use std::path::PathBuf;
 
-use super::{Context, Module, RootModuleConfig};
+use super::{Context, Module, ModuleConfig};
 
 use crate::configs::gcloud::GcloudConfig;
 use crate::formatter::StringFormatter;
diff --git a/src/modules/git_branch.rs b/src/modules/git_branch.rs
index 715f342ad..a1b91ea1d 100644
--- a/src/modules/git_branch.rs
+++ b/src/modules/git_branch.rs
@@ -1,6 +1,6 @@
 use unicode_segmentation::UnicodeSegmentation;
 
-use super::{Context, Module, RootModuleConfig};
+use super::{Context, Module, ModuleConfig};
 
 use crate::configs::git_branch::GitBranchConfig;
 use crate::formatter::StringFormatter;
diff --git a/src/modules/git_commit.rs b/src/modules/git_commit.rs
index 3c140c956..71ae94f16 100644
--- a/src/modules/git_commit.rs
+++ b/src/modules/git_commit.rs
@@ -1,4 +1,4 @@
-use super::{Context, Module, RootModuleConfig};
+use super::{Context, Module, ModuleConfig};
 use crate::formatter::string_formatter::StringFormatterError;
 use git2::Time;
 
diff --git a/src/modules/git_metrics.rs b/src/modules/git_metrics.rs
index 78e94e617..bcec04067 100644
--- a/src/modules/git_metrics.rs
+++ b/src/modules/git_metrics.rs
@@ -2,7 +2,7 @@ use regex::Regex;
 use std::ffi::OsStr;
 
 use crate::{
-    config::RootModuleConfig, configs::git_metrics::GitMetricsConfig,
+    config::ModuleConfig, configs::git_metrics::GitMetricsConfig,
     formatter::string_formatter::StringFormatterError, formatter::StringFormatter, module::Module,
 };
 
diff --git a/src/modules/git_state.rs b/src/modules/git_state.rs
index 689a4765d..526e8069d 100644
--- a/src/modules/git_state.rs
+++ b/src/modules/git_state.rs
@@ -1,7 +1,7 @@
 use git2::RepositoryState;
 use std::path::PathBuf;
 
-use super::{Context, Module, RootModuleConfig};
+use super::{Context, Module, ModuleConfig};
 use crate::configs::git_state::GitStateConfig;
 use crate::context::Repo;
 use crate::formatter::StringFormatter;
diff --git a/src/modules/git_status.rs b/src/modules/git_status.rs
index c7291e101..8f5a0e749 100644
--- a/src/modules/git_status.rs
+++ b/src/modules/git_status.rs
@@ -1,7 +1,7 @@
 use once_cell::sync::OnceCell;
 use regex::Regex;
 
-use super::{Context, Module, RootModuleConfig};
+use super::{Context, Module, ModuleConfig};
 
 use crate::configs::git_status::GitStatusConfig;
 use crate::formatter::StringFormatter;
diff --git a/src/modules/golang.rs b/src/modules/golang.rs
index bded55beb..7e2524b73 100644
--- a/src/modules/golang.rs
+++ b/src/modules/golang.rs
@@ -1,4 +1,4 @@
-use super::{Context, Module, RootModuleConfig};
+use super::{Context, Module, ModuleConfig};
 
 use crate::configs::go::GoConfig;
 use crate::formatter::StringFormatter;
diff --git a/src/modules/haskell.rs b/src/modules/haskell.rs
index 93ae25ca9..a913aeb53 100644
--- a/src/modules/haskell.rs
+++ b/src/modules/haskell.rs
@@ -1,4 +1,4 @@
-use super::{Context, Module, RootModuleConfig};
+use super::{Context, Module, ModuleConfig};
 
 use crate::configs::haskell::HaskellConfig;
 use crate::formatter::StringFormatter;
diff --git a/src/modules/helm.rs b/src/modules/helm.rs
index d6181a82c..b09977091 100644
--- a/src/modules/helm.rs
+++ b/src/modules/helm.rs
@@ -1,4 +1,4 @@
-use super::{Context, Module, RootModuleConfig};
+use super::{Context, Module, ModuleConfig};
 
 use crate::configs::helm::HelmConfig;
 use crate::formatter::StringFormatter;
diff --git a/src/modules/hg_branch.rs b/src/modules/hg_branch.rs
index 4cd2fa5c5..ae1ac7377 100644
--- a/src/modules/hg_branch.rs
+++ b/src/modules/hg_branch.rs
@@ -1,6 +1,6 @@
 use unicode_segmentation::UnicodeSegmentation;
 
-use super::{Context, Module, RootModuleConfig};
+use super::{Context, Module, ModuleConfig};
 
 use crate::configs::hg_branch::HgBranchConfig;
 use crate::formatter::StringFormatter;
diff --git a/src/modules/hostname.rs b/src/modules/hostname.rs
index 650919406..e02cf3d3b 100644
--- a/src/modules/hostname.rs
+++ b/src/modules/hostname.rs
@@ -1,7 +1,7 @@
 use super::{Context, Module};
 use std::ffi::OsString;
 
-use crate::config::RootModuleConfig;
+use crate::config::ModuleConfig;
 use crate::configs::hostname::HostnameConfig;
 use crate::formatter::StringFormatter;
 
diff --git a/src/modules/java.rs b/src/modules/java.rs
index a4f86b8d3..36ba777eb 100644
--- a/src/modules/java.rs
+++ b/src/modules/java.rs
@@ -1,4 +1,4 @@
-use super::{Context, Module, RootModuleConfig};
+use super::{Context, Module, ModuleConfig};
 use crate::configs::java::JavaConfig;
 use crate::formatter::{StringFormatter, VersionFormatter};
 use crate::utils::get_command_string_output;
diff --git a/src/modules/jobs.rs b/src/modules/jobs.rs
index 36a051895..acc48b171 100644
--- a/src/modules/jobs.rs
+++ b/src/modules/jobs.rs
@@ -1,4 +1,4 @@
-use super::{Context, Module, RootModuleConfig};
+use super::{Context, Module, ModuleConfig};
 
 use crate::configs::jobs::JobsConfig;
 use crate::formatter::StringFormatter;
diff --git a/src/modules/julia.rs b/src/modules/julia.rs
index 0559b24a5..646ec4561 100644
--- a/src/modules/julia.rs
+++ b/src/modules/julia.rs
@@ -1,4 +1,4 @@
-use super::{Context, Module, RootModuleConfig};
+use super::{Context, Module, ModuleConfig};
 
 use crate::configs::julia::JuliaConfig;
 use crate::formatter::StringFormatter;
diff --git a/src/modules/kotlin.rs b/src/modules/kotlin.rs
index d7c5b80a4..d4c054c65 100644
--- a/src/modules/kotlin.rs
+++ b/src/modules/kotlin.rs
@@ -1,4 +1,4 @@
-use super::{Context, Module, RootModuleConfig};
+use super::{Context, Module, ModuleConfig};
 
 use crate::configs::kotlin::KotlinConfig;
 use crate::formatter::StringFormatter;
diff --git a/src/modules/kubernetes.rs b/src/modules/kubernetes.rs
index e8aab32c7..b581a32f3 100644
--- a/src/modules/kubernetes.rs
+++ b/src/modules/kubernetes.rs
@@ -4,7 +4,7 @@ use std::borrow::Cow;
 use std::env;
 use std::path;
 
-use super::{Context, Module, RootModuleConfig};
+use super::{Context, Module, ModuleConfig};
 
 use crate::configs::kubernetes::KubernetesConfig;
 use crate::formatter::StringFormatter;
diff --git a/src/modules/localip.rs b/src/modules/localip.rs
index de6e51674..db05df6ca 100644
--- a/src/modules/localip.rs
+++ b/src/modules/localip.rs
@@ -1,6 +1,6 @@
 use super::{Context, Module};
 
-use crate::config::RootModuleConfig;
+use crate::config::ModuleConfig;
 use crate::configs::localip::LocalipConfig;
 use crate::formatter::StringFormatter;
 
@@ -121,7 +121,6 @@ mod tests {
             .config(toml::toml! {
                 [localip]
                 ssh_only = true
-                trim_at = ""
                 disabled = false
             })
             .env("SSH_CONNECTION", "something")
diff --git a/src/modules/lua.rs b/src/modules/lua.rs
index 9ef6a09ca..271f5558c 100644
--- a/src/modules/lua.rs
+++ b/src/modules/lua.rs
@@ -1,4 +1,4 @@
-use super::{Context, Module, RootModuleConfig};
+use super::{Context, Module, ModuleConfig};
 
 use crate::configs::lua::LuaConfig;
 use crate::formatter::StringFormatter;
diff --git a/src/modules/memory_usage.rs b/src/modules/memory_usage.rs
index 68c0e932a..9aaee11f5 100644
--- a/src/modules/memory_usage.rs
+++ b/src/modules/memory_usage.rs
@@ -1,6 +1,6 @@
 use byte_unit::{Byte, ByteUnit};
 
-use super::{Context, Module, RootModuleConfig};
+use super::{Context, Module, ModuleConfig};
 
 use crate::configs::memory_usage::MemoryConfig;
 use crate::formatter::StringFormatter;
diff --git a/src/modules/mod.rs b/src/modules/mod.rs
index 67a6df5c3..bc14908ae 100644
--- a/src/modules/mod.rs
+++ b/src/modules/mod.rs
@@ -78,7 +78,7 @@ mod battery;
 #[cfg(feature = "battery")]
 pub use self::battery::{BatteryInfoProvider, BatteryInfoProviderImpl};
 
-use crate::config::RootModuleConfig;
+use crate::config::ModuleConfig;
 use crate::context::{Context, Shell};
 use crate::module::Module;
 use std::time::Instant;
diff --git a/src/modules/nim.rs b/src/modules/nim.rs
index fc1771442..1b6c9fd39 100644
--- a/src/modules/nim.rs
+++ b/src/modules/nim.rs
@@ -1,4 +1,4 @@
-use super::{Context, Module, RootModuleConfig};
+use super::{Context, Module, ModuleConfig};
 
 use crate::configs::nim::NimConfig;
 use crate::formatter::StringFormatter;
diff --git a/src/modules/nix_shell.rs b/src/modules/nix_shell.rs
index 6cde73fbd..77222d649 100644
--- a/src/modules/nix_shell.rs
+++ b/src/modules/nix_shell.rs
@@ -1,4 +1,4 @@
-use super::{Context, Module, RootModuleConfig};
+use super::{Context, Module, ModuleConfig};
 
 use crate::configs::nix_shell::NixShellConfig;
 use crate::formatter::StringFormatter;
diff --git a/src/modules/nodejs.rs b/src/modules/nodejs.rs
index cf77a8fd3..07a5790a5 100644
--- a/src/modules/nodejs.rs
+++ b/src/modules/nodejs.rs
@@ -1,4 +1,4 @@
-use super::{Context, Module, RootModuleConfig};
+use super::{Context, Module, ModuleConfig};
 
 use crate::configs::nodejs::NodejsConfig;
 use crate::formatter::{StringFormatter, VersionFormatter};
diff --git a/src/modules/ocaml.rs b/src/modules/ocaml.rs
index b88fd8d84..512d7b73d 100644
--- a/src/modules/ocaml.rs
+++ b/src/modules/ocaml.rs
@@ -1,4 +1,4 @@
-use super::{Context, Module, RootModuleConfig};
+use super::{Context, Module, ModuleConfig};
 use once_cell::sync::Lazy;
 use std::ops::Deref;
 use std::path::Path;
diff --git a/src/modules/openstack.rs b/src/modules/openstack.rs
index e665f73be..400874421 100644
--- a/src/modules/openstack.rs
+++ b/src/modules/openstack.rs
@@ -1,6 +1,6 @@
 use yaml_rust::YamlLoader;
 
-use super::{Context, Module, RootModuleConfig};
+use super::{Context, Module, ModuleConfig};
 
 use crate::configs::openstack::OspConfig;
 use crate::formatter::StringFormatter;
diff --git a/src/modules/package.rs b/src/modules/package.rs
index acfcf3897..31f167b01 100644
--- a/src/modules/package.rs
+++ b/src/modules/package.rs
@@ -1,4 +1,4 @@
-use super::{Context, Module, RootModuleConfig};
+use super::{Context, Module, ModuleConfig};
 use crate::configs::package::PackageConfig;
 use crate::formatter::{StringFormatter, VersionFormatter};
 use crate::utils;
diff --git a/src/modules/perl.rs b/src/modules/perl.rs
index 1d0489d20..5051fda33 100644
--- a/src/modules/perl.rs
+++ b/src/modules/perl.rs
@@ -1,4 +1,4 @@
-use super::{Context, Module, RootModuleConfig};
+use super::{Context, Module, ModuleConfig};
 
 use crate::configs::perl::PerlConfig;
 use crate::formatter::StringFormatter;
diff --git a/src/modules/php.rs b/src/modules/php.rs
index 641b1970f..81ab232ff 100644
--- a/src/modules/php.rs
+++ b/src/modules/php.rs
@@ -1,4 +1,4 @@
-use super::{Context, Module, RootModuleConfig};
+use super::{Context, Module, ModuleConfig};
 
 use crate::configs::php::PhpConfig;
 use crate::formatter::StringFormatter;
diff --git a/src/modules/pulumi.rs b/src/modules/pulumi.rs
index 7cbf3ccb6..b1ed6d233 100644
--- a/src/modules/pulumi.rs
+++ b/src/modules/pulumi.rs
@@ -9,7 +9,7 @@ use std::path::{Path, PathBuf};
 use std::str::FromStr;
 use yaml_rust::{Yaml, YamlLoader};
 
-use super::{Context, Module, RootModuleConfig};
+use super::{Context, Module, ModuleConfig};
 use crate::configs::pulumi::PulumiConfig;
 use crate::formatter::{StringFormatter, VersionFormatter};
 
diff --git a/src/modules/purescript.rs b/src/modules/purescript.rs
index 500218668..f2b8a4d07 100644
--- a/src/modules/purescript.rs
+++ b/src/modules/purescript.rs
@@ -1,4 +1,4 @@
-use super::{Context, Module, RootModuleConfig};
+use super::{Context, Module, ModuleConfig};
 
 use crate::configs::purescript::PureScriptConfig;
 use crate::formatter::StringFormatter;
diff --git a/src/modules/python.rs b/src/modules/python.rs
index 4576db949..6def18212 100644
--- a/src/modules/python.rs
+++ b/src/modules/python.rs
@@ -1,7 +1,7 @@
 use ini::Ini;
 use std::path::Path;
 
-use super::{Context, Module, RootModuleConfig};
+use super::{Context, Module, ModuleConfig};
 use crate::configs::python::PythonConfig;
 use crate::formatter::StringFormatter;
 use crate::formatter::VersionFormatter;
diff --git a/src/modules/red.rs b/src/modules/red.rs
index 2954423a7..9b9a611e1 100644
--- a/src/modules/red.rs
+++ b/src/modules/red.rs
@@ -1,4 +1,4 @@
-use super::{Context, Module, RootModuleConfig};
+use super::{Context, Module, ModuleConfig};
 
 use crate::configs::red::RedConfig;
 use crate::formatter::{StringFormatter, VersionFormatter};
diff --git a/src/modules/rlang.rs b/src/modules/rlang.rs
index 6e96c774c..ee8c5d443 100644
--- a/src/modules/rlang.rs
+++ b/src/modules/rlang.rs
@@ -1,4 +1,4 @@
-use super::{Context, Module, RootModuleConfig};
+use super::{Context, Module, ModuleConfig};
 use crate::formatter::VersionFormatter;
 
 use crate::configs::rlang::RLangConfig;
diff --git a/src/modules/ruby.rs b/src/modules/ruby.rs
index e045a8fd2..e9245ae74 100644
--- a/src/modules/ruby.rs
+++ b/src/modules/ruby.rs
@@ -1,4 +1,4 @@
-use super::{Context, Module, RootModuleConfig};
+use super::{Context, Module, ModuleConfig};
 
 use crate::configs::ruby::RubyConfig;
 use crate::formatter::{StringFormatter, VersionFormatter};
diff --git a/src/modules/rust.rs b/src/modules/rust.rs
index c3b251610..dddf3075e 100644
--- a/src/modules/rust.rs
+++ b/src/modules/rust.rs
@@ -6,7 +6,7 @@ use std::process::Output;
 
 use serde::Deserialize;
 
-use super::{Context, Module, RootModuleConfig};
+use super::{Context, Module, ModuleConfig};
 
 use crate::configs::rust::RustConfig;
 use crate::formatter::{StringFormatter, VersionFormatter};
diff --git a/src/modules/scala.rs b/src/modules/scala.rs
index df410fb88..f0ce3a924 100644
--- a/src/modules/scala.rs
+++ b/src/modules/scala.rs
@@ -1,7 +1,7 @@
 use crate::configs::scala::ScalaConfig;
 use crate::formatter::StringFormatter;
 
-use super::{Context, Module, RootModuleConfig};
+use super::{Context, Module, ModuleConfig};
 use crate::formatter::VersionFormatter;
 use crate::utils::get_command_string_output;
 
diff --git a/src/modules/shell.rs b/src/modules/shell.rs
index 6eeafdbb1..3bc2929a5 100644
--- a/src/modules/shell.rs
+++ b/src/modules/shell.rs
@@ -1,4 +1,4 @@
-use super::{Context, Module, RootModuleConfig, Shell};
+use super::{Context, Module, ModuleConfig, Shell};
 
 use crate::configs::shell::ShellConfig;
 use crate::formatter::StringFormatter;
diff --git a/src/modules/shlvl.rs b/src/modules/shlvl.rs
index 889914112..e095d6359 100644
--- a/src/modules/shlvl.rs
+++ b/src/modules/shlvl.rs
@@ -1,6 +1,6 @@
 use super::{Context, Module};
 
-use crate::config::RootModuleConfig;
+use crate::config::ModuleConfig;
 use crate::configs::shlvl::ShLvlConfig;
 use crate::formatter::StringFormatter;
 use std::borrow::Cow;
diff --git a/src/modules/singularity.rs b/src/modules/singularity.rs
index ee6046c09..1f7685a22 100644
--- a/src/modules/singularity.rs
+++ b/src/modules/singularity.rs
@@ -1,4 +1,4 @@
-use super::{Context, Module, RootModuleConfig};
+use super::{Context, Module, ModuleConfig};
 
 use crate::configs::singularity::SingularityConfig;
 use crate::formatter::StringFormatter;
diff --git a/src/modules/status.rs b/src/modules/status.rs
index 43d21bfbb..0566db6b4 100644
--- a/src/modules/status.rs
+++ b/src/modules/status.rs
@@ -1,6 +1,6 @@
 use std::string::ToString;
 
-use super::{Context, Module, RootModuleConfig};
+use super::{Context, Module, ModuleConfig};
 
 use crate::configs::status::StatusConfig;
 use crate::formatter::{string_formatter::StringFormatterError, StringFormatter};
diff --git a/src/modules/sudo.rs b/src/modules/sudo.rs
index 32daf8710..044487dc2 100644
--- a/src/modules/sudo.rs
+++ b/src/modules/sudo.rs
@@ -1,6 +1,6 @@
 use std::env;
 
-use super::{Context, Module, RootModuleConfig};
+use super::{Context, Module, ModuleConfig};
 
 use crate::configs::sudo::SudoConfig;
 use crate::formatter::StringFormatter;
diff --git a/src/modules/swift.rs b/src/modules/swift.rs
index 72aa069cf..470dac163 100644
--- a/src/modules/swift.rs
+++ b/src/modules/swift.rs
@@ -1,4 +1,4 @@
-use super::{Context, Module, RootModuleConfig};
+use super::{Context, Module, ModuleConfig};
 
 use crate::configs::swift::SwiftConfig;
 use crate::formatter::StringFormatter;
diff --git a/src/modules/terraform.rs b/src/modules/terraform.rs
index c69a10306..2c0bda04c 100644
--- a/src/modules/terraform.rs
+++ b/src/modules/terraform.rs
@@ -1,4 +1,4 @@
-use super::{Context, Module, RootModuleConfig};
+use super::{Context, Module, ModuleConfig};
 
 use crate::configs::terraform::TerraformConfig;
 use crate::formatter::StringFormatter;
diff --git a/src/modules/time.rs b/src/modules/time.rs
index c6606e4c6..f66d18256 100644
--- a/src/modules/time.rs
+++ b/src/modules/time.rs
@@ -1,6 +1,6 @@
 use chrono::{DateTime, FixedOffset, Local, NaiveTime, Utc};
 
-use super::{Context, Module, RootModuleConfig};
+use super::{Context, Module, ModuleConfig};
 use crate::configs::time::TimeConfig;
 use crate::formatter::StringFormatter;
 
diff --git a/src/modules/username.rs b/src/modules/username.rs
index 2f01c0b93..30e062b73 100644
--- a/src/modules/username.rs
+++ b/src/modules/username.rs
@@ -1,4 +1,4 @@
-use super::{Context, Module, RootModuleConfig};
+use super::{Context, Module, ModuleConfig};
 
 use crate::configs::username::UsernameConfig;
 use crate::formatter::StringFormatter;
diff --git a/src/modules/vagrant.rs b/src/modules/vagrant.rs
index 566519d29..158137d01 100644
--- a/src/modules/vagrant.rs
+++ b/src/modules/vagrant.rs
@@ -1,4 +1,4 @@
-use super::{Context, Module, RootModuleConfig};
+use super::{Context, Module, ModuleConfig};
 
 use crate::configs::vagrant::VagrantConfig;
 use crate::formatter::StringFormatter;
diff --git a/src/modules/vcsh.rs b/src/modules/vcsh.rs
index 440e7063d..8d0a445de 100644
--- a/src/modules/vcsh.rs
+++ b/src/modules/vcsh.rs
@@ -1,6 +1,6 @@
 use super::{Context, Module};
 
-use crate::config::RootModuleConfig;
+use crate::config::ModuleConfig;
 use crate::configs::vcsh::VcshConfig;
 use crate::formatter::StringFormatter;
 
diff --git a/src/modules/vlang.rs b/src/modules/vlang.rs
index 9279f5d7e..6ca6dd5f8 100644
--- a/src/modules/vlang.rs
+++ b/src/modules/vlang.rs
@@ -1,4 +1,4 @@
-use super::{Context, Module, RootModuleConfig};
+use super::{Context, Module, ModuleConfig};
 
 use crate::configs::v::VConfig;
 use crate::formatter::{StringFormatter, VersionFormatter};
diff --git a/src/modules/zig.rs b/src/modules/zig.rs
index e9e5a3ffc..4b46a5d4b 100644
--- a/src/modules/zig.rs
+++ b/src/modules/zig.rs
@@ -1,4 +1,4 @@
-use super::{Context, Module, RootModuleConfig};
+use super::{Context, Module, ModuleConfig};
 
 use crate::configs::zig::ZigConfig;
 use crate::formatter::StringFormatter;
diff --git a/src/serde_utils.rs b/src/serde_utils.rs
new file mode 100644
index 000000000..62b9ab6f1
--- /dev/null
+++ b/src/serde_utils.rs
@@ -0,0 +1,385 @@
+use crate::module::ALL_MODULES;
+use serde::de::{
+    value::{Error as ValueError, MapDeserializer, SeqDeserializer},
+    Deserializer, Error, IntoDeserializer, Visitor,
+};
+use std::{cmp::Ordering, fmt};
+use toml::Value;
+
+/// A helper struct for deserializing a TOML value references with serde.
+/// This also prints a warning and suggestions if a key is unknown.
+#[derive(Debug)]
+pub struct ValueDeserializer<'de> {
+    value: &'de Value,
+    info: Option<StructInfo>,
+    current_key: Option<&'de str>,
+}
+
+/// When deserializing a struct, this struct stores information about the struct.
+#[derive(Debug, Clone, Copy)]
+struct StructInfo {
+    fields: &'static [&'static str],
+    name: &'static str,
+}
+
+impl<'de> ValueDeserializer<'de> {
+    pub fn new(value: &'de Value) -> Self {
+        ValueDeserializer {
+            value,
+            info: None,
+            current_key: None,
+        }
+    }
+
+    fn with_info(value: &'de Value, info: Option<StructInfo>, current_key: &'de str) -> Self {
+        ValueDeserializer {
+            value,
+            info,
+            current_key: Some(current_key),
+        }
+    }
+}
+
+impl ValueDeserializer<'_> {
+    /// Prettify an error message by adding the current key and struct name to it.
+    fn error<T: fmt::Display>(&self, msg: T) -> ValueError {
+        match (self.current_key, self.info) {
+            (Some(key), Some(StructInfo { name, .. })) => {
+                // Prettify name of struct
+                let display_name = name.strip_suffix("Config").unwrap_or(name);
+                ValueError::custom(format!("Error in '{display_name}' at '{key}': {msg}",))
+            }
+            // Handling other cases leads to duplicates in the error message.
+            _ => ValueError::custom(msg),
+        }
+    }
+}
+
+impl<'de> IntoDeserializer<'de> for ValueDeserializer<'de> {
+    type Deserializer = ValueDeserializer<'de>;
+
+    fn into_deserializer(self) -> ValueDeserializer<'de> {
+        self
+    }
+}
+
+impl<'de> Deserializer<'de> for ValueDeserializer<'de> {
+    type Error = ValueError;
+
+    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        match self.value {
+            Value::Boolean(b) => visitor.visit_bool(*b),
+            Value::Integer(i) => visitor.visit_i64(*i),
+            Value::Float(f) => visitor.visit_f64(*f),
+            Value::String(s) => visitor.visit_borrowed_str(s),
+            Value::Array(a) => {
+                let seq = SeqDeserializer::new(a.iter().map(ValueDeserializer::new));
+                seq.deserialize_seq(visitor)
+            }
+            Value::Table(t) => {
+                let map = MapDeserializer::new(t.iter().map(|(k, v)| {
+                    (
+                        k.as_str(),
+                        ValueDeserializer::with_info(v, self.info, k.as_str()),
+                    )
+                }));
+                map.deserialize_map(visitor)
+            }
+            Value::Datetime(d) => visitor.visit_string(d.to_string()),
+        }
+        .map_err(|e| self.error(e))
+    }
+
+    // Save a reference to the struct fields and name for later use in error messages.
+    fn deserialize_struct<V>(
+        mut self,
+        name: &'static str,
+        fields: &'static [&'static str],
+        visitor: V,
+    ) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        self.info = Some(StructInfo { fields, name });
+        self.deserialize_any(visitor)
+    }
+
+    // Always `Some` because TOML doesn't have a null type.
+    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_some(self)
+    }
+
+    // Handle ignored Values. (Values at unkown keys in TOML)
+    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        if self
+            .info
+            .filter(|StructInfo { name, .. }| name == &"StarshipRootConfig")
+            .and(self.current_key)
+            .map_or(false, |key| {
+                ALL_MODULES.contains(&key) || key == "custom" || key == "env_var"
+            })
+        {
+            return visitor.visit_none();
+        }
+
+        let did_you_mean = match (self.current_key, self.info) {
+            (Some(key), Some(StructInfo { fields, .. })) => fields
+                .iter()
+                .filter_map(|field| {
+                    let score = strsim::jaro_winkler(key, field);
+                    (score > 0.8).then(|| (score, field))
+                })
+                .max_by(|(score_a, _field_a), (score_b, _field_b)| {
+                    score_a.partial_cmp(score_b).unwrap_or(Ordering::Equal)
+                }),
+            _ => None,
+        };
+        let did_you_mean = did_you_mean
+            .map(|(_score, field)| format!(" (Did you mean '{}'?)", field))
+            .unwrap_or_default();
+
+        Err(self.error(format!("Unknown key{did_you_mean}")))
+    }
+
+    fn deserialize_newtype_struct<V>(
+        self,
+        _name: &'static str,
+        visitor: V,
+    ) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_newtype_struct(self)
+    }
+
+    // Handle most deserialization cases by deferring to `deserialize_any`.
+    serde::forward_to_deserialize_any! {
+        bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string unit seq
+        bytes byte_buf map unit_struct tuple_struct enum tuple identifier
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use crate::configs::StarshipRootConfig;
+
+    use super::*;
+    use serde::Deserialize;
+
+    #[test]
+    fn test_deserialize_bool() {
+        let value = Value::Boolean(true);
+        let deserializer = ValueDeserializer::new(&value);
+        let result: bool = bool::deserialize(deserializer).unwrap();
+        assert!(result);
+    }
+
+    #[test]
+    fn test_deserialize_i64() {
+        let value = Value::Integer(42);
+        let deserializer = ValueDeserializer::new(&value);
+        let result: i64 = i64::deserialize(deserializer).unwrap();
+        assert_eq!(result, 42);
+    }
+
+    #[test]
+    #[allow(clippy::approx_constant)]
+    fn test_deserialize_f64() {
+        let value = Value::Float(3.14);
+        let deserializer = ValueDeserializer::new(&value);
+        let result: f64 = f64::deserialize(deserializer).unwrap();
+        assert_eq!(result, 3.14);
+    }
+
+    #[test]
+    fn test_deserialize_string() {
+        let value = Value::String("hello".to_string());
+        let deserializer = ValueDeserializer::new(&value);
+        let result: String = String::deserialize(deserializer).unwrap();
+        assert_eq!(result, "hello");
+    }
+
+    #[test]
+    fn test_deserialize_str() {
+        let value = toml::toml! {
+            foo = "bar"
+        };
+        let deserializer = ValueDeserializer::new(&value);
+
+        #[derive(Deserialize)]
+        struct StrWrapper<'a> {
+            foo: &'a str,
+        }
+
+        let result = StrWrapper::deserialize(deserializer).unwrap();
+        assert_eq!(result.foo, "bar");
+    }
+
+    #[test]
+    fn test_deserialize_datetime() {
+        let value = toml::toml! {
+            foo = 2018-01-01T00:00:00Z
+        };
+        let deserializer = ValueDeserializer::new(&value);
+
+        #[derive(Deserialize)]
+        struct DateWrapper {
+            foo: String,
+        }
+
+        let result = DateWrapper::deserialize(deserializer).unwrap();
+        assert_eq!(result.foo, "2018-01-01T00:00:00Z");
+    }
+
+    #[test]
+    fn test_deserialize_array() {
+        let value = toml::toml! {
+            foo = [1, 2, 3]
+        };
+        let deserializer = ValueDeserializer::new(&value);
+
+        #[derive(Deserialize)]
+        struct ArrayWrapper {
+            foo: Vec<i32>,
+        }
+
+        let result = ArrayWrapper::deserialize(deserializer).unwrap();
+        assert_eq!(result.foo, vec![1, 2, 3]);
+    }
+
+    #[test]
+    fn test_deserialize_map() {
+        let value = toml::toml! {
+            [foo]
+            a = 1
+            b = 2
+        };
+        let deserializer = ValueDeserializer::new(&value);
+
+        #[derive(Deserialize)]
+        struct MapWrapper {
+            foo: std::collections::HashMap<String, i32>,
+        }
+
+        let result = MapWrapper::deserialize(deserializer).unwrap();
+        assert_eq!(
+            result.foo,
+            std::collections::HashMap::from_iter(vec![("a".to_string(), 1), ("b".to_string(), 2)])
+        );
+    }
+
+    #[test]
+    fn test_deserialize_newtype_struct() {
+        let value = toml::toml! {
+            foo = "bar"
+        };
+
+        #[derive(Deserialize)]
+        struct NewtypeWrapper(String);
+        #[derive(Deserialize)]
+        struct Sample {
+            foo: NewtypeWrapper,
+        }
+
+        let deserializer = ValueDeserializer::new(&value);
+
+        let result = Sample::deserialize(deserializer).unwrap();
+        assert_eq!(result.foo.0, "bar".to_owned());
+    }
+
+    #[test]
+    fn test_deserialize_unknown() {
+        let value = toml::toml! {
+            foo = "bar"
+            unknown_key = 1
+        };
+        let deserializer = ValueDeserializer::new(&value);
+
+        #[derive(Debug, Deserialize)]
+        #[allow(dead_code)]
+        struct Sample {
+            foo: String,
+        }
+
+        let result = Sample::deserialize(deserializer).unwrap_err();
+        assert_eq!(
+            format!("{}", result),
+            "Error in 'Sample' at 'unknown_key': Unknown key"
+        );
+    }
+
+    #[test]
+    fn test_deserialize_unknown_root_config() {
+        let value = toml::toml! {
+            unknown_key = "foo"
+        };
+        let deserializer = ValueDeserializer::new(&value);
+
+        let result = StarshipRootConfig::deserialize(deserializer).unwrap_err();
+        assert_eq!(
+            format!("{}", result),
+            "Error in 'StarshipRoot' at 'unknown_key': Unknown key"
+        );
+    }
+
+    #[test]
+    fn test_deserialize_unknown_root_module() {
+        let value = toml::toml! {
+            [rust]
+            disabled = true
+        };
+        let deserializer = ValueDeserializer::new(&value);
+
+        let result = StarshipRootConfig::deserialize(deserializer);
+        assert!(result.is_ok())
+    }
+
+    #[test]
+    fn test_deserialize_unknown_typo() {
+        let value = toml::toml! {
+            food = "bar"
+        };
+        let deserializer = ValueDeserializer::new(&value);
+
+        #[derive(Debug, Deserialize)]
+        #[allow(dead_code)]
+        struct Sample {
+            foo: String,
+        }
+
+        let result = Sample::deserialize(deserializer).unwrap_err();
+        assert_eq!(
+            format!("{}", result),
+            "Error in 'Sample' at 'food': Unknown key (Did you mean 'foo'?)"
+        );
+    }
+
+    #[test]
+    fn test_deserialize_wrong_type() {
+        let value = toml::toml! {
+            foo = 1
+        };
+        let deserializer = ValueDeserializer::new(&value);
+
+        #[derive(Debug, Deserialize)]
+        #[allow(dead_code)]
+        struct Sample {
+            foo: String,
+        }
+
+        let result = Sample::deserialize(deserializer).unwrap_err();
+        assert_eq!(
+            format!("{}", result),
+            "Error in 'Sample' at 'foo': invalid type: integer `1`, expected a string"
+        );
+    }
+}
diff --git a/src/test/mod.rs b/src/test/mod.rs
index af8775e61..fda44e4f8 100644
--- a/src/test/mod.rs
+++ b/src/test/mod.rs
@@ -1,7 +1,7 @@
 use crate::context::{Context, Shell, Target};
 use crate::logger::StarshipLogger;
 use crate::{
-    config::{RootModuleConfig, StarshipConfig},
+    config::{ModuleConfig, StarshipConfig},
     configs::StarshipRootConfig,
     utils::{create_command, CommandOutput},
 };
diff --git a/starship_module_config_derive/Cargo.toml b/starship_module_config_derive/Cargo.toml
deleted file mode 100644
index caf5ac42b..000000000
--- a/starship_module_config_derive/Cargo.toml
+++ /dev/null
@@ -1,25 +0,0 @@
-[package]
-name = "starship_module_config_derive"
-version = "0.2.1"
-authors = ["Matan Kushner <hello@matchai.me>"]
-categories = ["command-line-utilities"]
-documentation = "https://starship.rs/guide/"
-edition = "2021"
-homepage = "https://starship.rs"
-include = ["src/**/*", "LICENSE", "README.md"]
-keywords = ["prompt", "shell", "bash", "fish", "zsh"]
-license = "ISC"
-readme = "README.md"
-repository = "https://github.com/starship/starship"
-description = """
-The minimal, blazing-fast, and infinitely customizable prompt for any shell! ☄🌌️
-"""
-
-[lib]
-name = "starship_module_config_derive"
-proc-macro = true
-
-[dependencies]
-proc-macro2 = "~1"
-quote = "~1"
-syn = "~1"
diff --git a/starship_module_config_derive/LICENSE b/starship_module_config_derive/LICENSE
deleted file mode 100644
index 1ce6f8232..000000000
--- a/starship_module_config_derive/LICENSE
+++ /dev/null
@@ -1,15 +0,0 @@
-ISC License
-
-Copyright (c) 2019, Starship Contributors
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted, provided that the above
-copyright notice and this permission notice appear in all copies.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
diff --git a/starship_module_config_derive/README.md b/starship_module_config_derive/README.md
deleted file mode 100644
index b1a0ca9ee..000000000
--- a/starship_module_config_derive/README.md
+++ /dev/null
@@ -1 +0,0 @@
-# starship_module_config_derive
diff --git a/starship_module_config_derive/src/lib.rs b/starship_module_config_derive/src/lib.rs
deleted file mode 100644
index 03b32a5ed..000000000
--- a/starship_module_config_derive/src/lib.rs
+++ /dev/null
@@ -1,90 +0,0 @@
-use proc_macro::TokenStream;
-use quote::quote;
-use syn::{parse_macro_input, DeriveInput};
-
-#[proc_macro_derive(ModuleConfig)]
-pub fn derive_module_config(input: TokenStream) -> TokenStream {
-    let dinput = parse_macro_input!(input as DeriveInput);
-    impl_module_config(dinput)
-}
-
-fn impl_module_config(dinput: DeriveInput) -> proc_macro::TokenStream {
-    let struct_ident = &dinput.ident;
-    let (_impl_generics, ty_generics, where_clause) = dinput.generics.split_for_impl();
-
-    let mut from_config = quote! {};
-    let mut load_config = quote! {};
-
-    if let syn::Data::Struct(data) = dinput.data {
-        if let syn::Fields::Named(fields_named) = data.fields {
-            let mut load_tokens = quote! {};
-            let mut fields = quote! {};
-
-            for field in &fields_named.named {
-                let ident = field.ident.as_ref().unwrap();
-
-                let new_load_tokens = quote! {
-                    stringify!(#ident) => self.#ident.load_config(v),
-                };
-
-                let new_field = quote! {
-                    stringify!(#ident),
-                };
-
-                load_tokens = quote! {
-                    #load_tokens
-                    #new_load_tokens
-                };
-
-                fields = quote! {
-                    #fields
-                    #new_field
-                };
-            }
-
-            load_config = quote! {
-                fn load_config(&mut self, config: &'a toml::Value) {
-                    if let toml::Value::Table(config) = config {
-                        config.iter().for_each(|(k, v)| {
-                            match k.as_str() {
-                                #load_tokens
-                                unknown => {
-                                    ::log::warn!("Unknown config key '{}'", unknown);
-
-                                    let did_you_mean = ::std::array::IntoIter::new([#fields])
-                                    .filter_map(|field| {
-                                        let score = ::strsim::jaro_winkler(unknown, field);
-                                        (score > 0.8).then(|| (score, field))
-                                    })
-                                    .max_by(
-                                        |(score_a, _field_a), (score_b, _field_b)| {
-                                            score_a.partial_cmp(score_b).unwrap_or(::std::cmp::Ordering::Equal)
-                                        },
-                                    );
-
-                                    if let Some((_score, field)) = did_you_mean {
-                                        ::log::warn!("Did you mean '{}'?", field);
-                                    }
-                                },
-                            }
-                        });
-                    }
-                }
-            };
-            from_config = quote! {
-                fn from_config(config: &'a toml::Value) -> Option<Self> {
-                    let mut out = Self::default();
-                    out.load_config(config);
-                    Some(out)
-                }
-            };
-        }
-    }
-
-    TokenStream::from(quote! {
-        impl<'a> ModuleConfig<'a> for #struct_ident #ty_generics #where_clause {
-            #from_config
-            #load_config
-        }
-    })
-}