diff --git a/.gitignore b/.gitignore
index bb23b4bd..e49a903b 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,8 @@
 .vscode/settings.json
+.idea/
 target/
 /*.svg
 /*.png
+/*.json
+/*.yml
+
diff --git a/Cargo.lock b/Cargo.lock
index 62b86c04..80e807bd 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1784,6 +1784,8 @@ checksum = "7714e70437a7dc3ac8eb7e6f8df75fd8eb422675fc7678aff7364301092b1017"
 dependencies = [
  "equivalent",
  "hashbrown 0.16.1",
+ "serde",
+ "serde_core",
 ]
 
 [[package]]
@@ -2345,6 +2347,22 @@ version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0676bb32a98c1a483ce53e500a81ad9c3d5b3f7c920c28c24e9cb0980d0b5bc8"
 
+[[package]]
+name = "noyalib"
+version = "0.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8c4d40221dba649ed01664957d3e0248511fa7b01fd2fb77e6b9041593258f6e"
+dependencies = [
+ "indexmap",
+ "itoa",
+ "memchr",
+ "rustc-hash 2.1.1",
+ "ryu",
+ "serde",
+ "serde_ignored",
+ "smallvec",
+]
+
 [[package]]
 name = "num-bigint"
 version = "0.4.6"
@@ -2870,6 +2888,15 @@ dependencies = [
  "libredox",
 ]
 
+[[package]]
+name = "ordered-float"
+version = "2.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68f19d67e5a2795c94e73e0bb1cc1a7edeb2e28efd39e2e1c9b7a40c1108b11c"
+dependencies = [
+ "num-traits",
+]
+
 [[package]]
 name = "ordered-float"
 version = "5.1.0"
@@ -3004,6 +3031,7 @@ checksum = "7edddbd0b52d732b21ad9a5fab5c704c14cd949e5e9a1ec5929a24fded1b904c"
 name = "plotive"
 version = "0.5.0"
 dependencies = [
+ "noyalib",
  "ode_solvers",
  "plotive-base",
  "plotive-dsl",
@@ -3014,12 +3042,17 @@ dependencies = [
  "rand",
  "rand_chacha",
  "rand_distr",
+ "serde",
+ "serde-value",
+ "serde_json",
 ]
 
 [[package]]
 name = "plotive-base"
 version = "0.5.0"
 dependencies = [
+ "serde",
+ "serde_json",
  "strict-num 0.2.0",
  "tiny-skia-path",
 ]
@@ -3079,6 +3112,7 @@ dependencies = [
  "rand",
  "rand_chacha",
  "rand_distr",
+ "serde_json",
  "similar",
  "tiny-skia",
 ]
@@ -3570,9 +3604,9 @@ dependencies = [
 
 [[package]]
 name = "ryu"
-version = "1.0.20"
+version = "1.0.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "28d3b2b1366ec20994f1fd18c3c594f05c5dd4bc44d8bb0c1c632c8d6829481f"
+checksum = "9774ba4a74de5f7b1c1451ed6cd5285a32eddb5cccb8cc655a4e50009e06477f"
 
 [[package]]
 name = "safe_arch"
@@ -3633,6 +3667,16 @@ dependencies = [
  "serde_derive",
 ]
 
+[[package]]
+name = "serde-value"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f3a1a3341211875ef120e117ea7fd5228530ae7e7036a779fdc9117be6b3282c"
+dependencies = [
+ "ordered-float 2.10.1",
+ "serde",
+]
+
 [[package]]
 name = "serde_core"
 version = "1.0.228"
@@ -3653,16 +3697,27 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "serde_ignored"
+version = "0.1.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "115dffd5f3853e06e746965a20dcbae6ee747ae30b543d91b0e089668bb07798"
+dependencies = [
+ "serde",
+ "serde_core",
+]
+
 [[package]]
 name = "serde_json"
-version = "1.0.142"
+version = "1.0.150"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "030fedb782600dcbd6f02d479bf0d817ac3bb40d644745b769d6a96bc3afc5a7"
+checksum = "e8014e44b4736ed0538adeecded0fce2a272f22dc9578a7eb6b2d9993c74cfb9"
 dependencies = [
  "itoa",
  "memchr",
- "ryu",
  "serde",
+ "serde_core",
+ "zmij",
 ]
 
 [[package]]
@@ -4694,7 +4749,7 @@ dependencies = [
  "ndk-sys",
  "objc",
  "once_cell",
- "ordered-float",
+ "ordered-float 5.1.0",
  "parking_lot",
  "portable-atomic",
  "portable-atomic-util",
@@ -5443,6 +5498,12 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "zmij"
+version = "1.0.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8848ee67ecc8aedbaf3e4122217aff892639231befc6a1b58d29fff4c2cabaa"
+
 [[package]]
 name = "zune-core"
 version = "0.4.12"
diff --git a/Cargo.toml b/Cargo.toml
index 9c1f8d69..b50d9103 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -17,6 +17,9 @@ plotive-base.workspace = true
 plotive-text.workspace = true
 # feature dsl
 plotive-dsl = { workspace = true, optional = true }
+# feature serde
+serde = { workspace = true, optional = true }
+serde-value = { version = "0.7", optional = true }
 
 [dev-dependencies]
 plotive-iced = { path = "iced", features = ["clipboard"] }
@@ -26,6 +29,9 @@ rand.workspace = true
 rand_distr.workspace = true
 rand_chacha.workspace = true
 ode_solvers = "0.6.1"
+serde_json.workspace = true
+noyalib = "0.0.6"
+
 
 [features]
 default = ["noto-sans"]
@@ -37,6 +43,7 @@ noto-sans = ["plotive-text/noto-sans"]
 noto-sans-italic = ["plotive-text/noto-sans-italic"]
 noto-serif = ["plotive-text/noto-serif"]
 noto-serif-italic = ["plotive-text/noto-serif-italic"]
+serde = ["plotive-base/serde", "dep:serde", "dep:serde-value"]
 time = []
 utils = []
 
@@ -73,6 +80,9 @@ required-features = ["data-csv"]
 name = "iris_dsl"
 required-features = ["data-csv", "dsl"]
 
+[[example]]
+name = "minimal"
+
 [[example]]
 name = "multiple_axes"
 required-features = ["utils"]
@@ -117,7 +127,6 @@ keywords = ["data", "visualization", "plotting"]
 plotive = { version = "0.5.0", path = "." }
 plotive-base = { version = "0.5.0", path = "base" }
 plotive-dsl = { version = "0.5.0", path = "dsl" }
-plotive-iced = { version = "0.5.0", path = "iced" }
 plotive-pxl = { version = "0.5.0", path = "pxl" }
 plotive-svg = { version = "0.5.0", path = "svg" }
 plotive-text = { version = "0.5.0", path = "text" }
@@ -137,6 +146,8 @@ rand_distr = "0.5.1"
 rand_chacha = "0.9.0"
 rfd = "0.17.1"
 rustybuzz = "0.20.1"
+serde = { version = "1.0.228" }
+serde_json = "1.0.149"
 strict-num = "0.2.0"
 tiny-skia = "0.11.4"
 tiny-skia-path = "0.11.4"
diff --git a/base/Cargo.toml b/base/Cargo.toml
index 8c3377e4..5aa873a8 100644
--- a/base/Cargo.toml
+++ b/base/Cargo.toml
@@ -12,3 +12,10 @@ keywords.workspace = true
 [dependencies]
 tiny-skia-path.workspace = true
 strict-num.workspace = true
+serde = { workspace = true, optional = true }
+
+[dev-dependencies]
+serde_json = { workspace = true }
+
+[features]
+serde = ["dep:serde"]
diff --git a/base/src/color.rs b/base/src/color.rs
index 67a6540a..cafa71ab 100644
--- a/base/src/color.rs
+++ b/base/src/color.rs
@@ -2,8 +2,8 @@
 use std::str::FromStr;
 use std::{error, fmt};
 
-mod css4;
-mod xkcd;
+pub(crate) mod css4;
+pub(crate) mod xkcd;
 
 pub use css4::*;
 
@@ -60,7 +60,7 @@ impl Rgba8 {
     }
 
     /// Get the HTML hex string representation of the color, e.g. `#ff0000` for red.
-    /// If the alpha channel is not 255, the form "rgba(r, g, b, a)" is used.
+    /// If the alpha channel is not 255, the form "rgba(r, g, b, a)" is used instead (with alpha normalized to [0, 1]).
     pub fn html(&self) -> String {
         if self.a() == 255 {
             format!("#{:02x}{:02x}{:02x}", self.r(), self.g(), self.b())
@@ -376,9 +376,10 @@ impl FromStr for Rgb8 {
         }
         // named color
         else {
-            if let Some(col) = css4::lookup_name(raw) {
-                Ok(col.rgb())
-            } else if let Some(col) = xkcd::lookup_name(raw) {
+            if let Some(col) = names::lookup(raw) {
+                if col.a() != 255 {
+                    return Err(ParseError::InvalidAlphaComponent);
+                }
                 Ok(col.rgb())
             } else {
                 Err(ParseError::UnknownName)
@@ -441,9 +442,7 @@ impl FromStr for Rgba8 {
         }
         // named color
         else {
-            if let Some(col) = css4::lookup_name(raw) {
-                Ok(col)
-            } else if let Some(col) = xkcd::lookup_name(raw) {
+            if let Some(col) = names::lookup(raw) {
                 Ok(col)
             } else {
                 Err(ParseError::UnknownName)
@@ -452,6 +451,27 @@ impl FromStr for Rgba8 {
     }
 }
 
+pub(crate) mod names {
+    use std::collections::HashMap;
+    use std::sync::LazyLock;
+
+    use crate::Rgba8;
+    use crate::color::{css4, xkcd};
+
+    static MAP: LazyLock<HashMap<&'static str, Rgba8>> = LazyLock::new(|| {
+        // Start with XKCD colors, then CSS4 so CSS4 names take precedence on collisions.
+        let mut map = HashMap::with_capacity(xkcd::COLORS.len() + css4::COLORS.len());
+        map.extend(xkcd::COLORS.iter().map(|(name, rgba)| (*name, *rgba)));
+        map.extend(css4::COLORS.iter().map(|(name, rgba)| (*name, *rgba)));
+        map
+    });
+
+    pub(crate) fn lookup(name: &str) -> Option<Rgba8> {
+        let key = name.trim().to_lowercase();
+        MAP.get(key.as_str()).copied()
+    }
+}
+
 /// A trait for interpolating between two colors, used for color scales in heatmaps and similar plots.
 pub trait Lerp {
     /// Interpolate between two colors using a parameter t in the range [0.0, 1.0].
diff --git a/base/src/color/css4.rs b/base/src/color/css4.rs
index 4ed312ea..27c9afa3 100644
--- a/base/src/color/css4.rs
+++ b/base/src/color/css4.rs
@@ -1,6 +1,159 @@
 use super::Rgba8;
 
 // standard CSS colors
+pub const COLORS: &[(&str, Rgba8)] = &[
+    ("transparent", Rgba8::new(0, 0, 0, 0)),
+    ("black", Rgba8::from_hex(b"#000000")),
+    ("silver", Rgba8::from_hex(b"#c0c0c0")),
+    ("gray", Rgba8::from_hex(b"#808080")),
+    ("white", Rgba8::from_hex(b"#ffffff")),
+    ("maroon", Rgba8::from_hex(b"#800000")),
+    ("red", Rgba8::from_hex(b"#ff0000")),
+    ("purple", Rgba8::from_hex(b"#800080")),
+    ("fuchsia", Rgba8::from_hex(b"#ff00ff")),
+    ("green", Rgba8::from_hex(b"#008000")),
+    ("lime", Rgba8::from_hex(b"#00ff00")),
+    ("olive", Rgba8::from_hex(b"#808000")),
+    ("yellow", Rgba8::from_hex(b"#ffff00")),
+    ("navy", Rgba8::from_hex(b"#000080")),
+    ("blue", Rgba8::from_hex(b"#0000ff")),
+    ("teal", Rgba8::from_hex(b"#008080")),
+    ("aqua", Rgba8::from_hex(b"#00ffff")),
+    // other named colors
+    ("aliceblue", Rgba8::from_hex(b"#f0f8ff")),
+    ("antiquewhite", Rgba8::from_hex(b"#faebd7")),
+    ("aquamarine", Rgba8::from_hex(b"#7fffd4")),
+    ("azure", Rgba8::from_hex(b"#f0ffff")),
+    ("beige", Rgba8::from_hex(b"#f5f5dc")),
+    ("bisque", Rgba8::from_hex(b"#ffe4c4")),
+    ("blanchedalmond", Rgba8::from_hex(b"#ffebcd")),
+    ("blueviolet", Rgba8::from_hex(b"#8a2be2")),
+    ("brown", Rgba8::from_hex(b"#a52a2a")),
+    ("burlywood", Rgba8::from_hex(b"#deb887")),
+    ("cadetblue", Rgba8::from_hex(b"#5f9ea0")),
+    ("chartreuse", Rgba8::from_hex(b"#7fff00")),
+    ("chocolate", Rgba8::from_hex(b"#d2691e")),
+    ("coral", Rgba8::from_hex(b"#ff7f50")),
+    ("cornflowerblue", Rgba8::from_hex(b"#6495ed")),
+    ("cornsilk", Rgba8::from_hex(b"#fff8dc")),
+    ("crimson", Rgba8::from_hex(b"#dc143c")),
+    ("cyan", Rgba8::from_hex(b"#00ffff")),
+    ("darkblue", Rgba8::from_hex(b"#00008b")),
+    ("darkcyan", Rgba8::from_hex(b"#008b8b")),
+    ("darkgoldenrod", Rgba8::from_hex(b"#b8860b")),
+    ("darkgray", Rgba8::from_hex(b"#a9a9a9")),
+    ("darkgreen", Rgba8::from_hex(b"#006400")),
+    ("darkgrey", Rgba8::from_hex(b"#a9a9a9")),
+    ("darkkhaki", Rgba8::from_hex(b"#bdb76b")),
+    ("darkmagenta", Rgba8::from_hex(b"#8b008b")),
+    ("darkolivegreen", Rgba8::from_hex(b"#556b2f")),
+    ("darkorange", Rgba8::from_hex(b"#ff8c00")),
+    ("darkorchid", Rgba8::from_hex(b"#9932cc")),
+    ("darkred", Rgba8::from_hex(b"#8b0000")),
+    ("darksalmon", Rgba8::from_hex(b"#e9967a")),
+    ("darkseagreen", Rgba8::from_hex(b"#8fbc8f")),
+    ("darkslateblue", Rgba8::from_hex(b"#483d8b")),
+    ("darkslategray", Rgba8::from_hex(b"#2f4f4f")),
+    ("darkslategrey", Rgba8::from_hex(b"#2f4f4f")),
+    ("darkturquoise", Rgba8::from_hex(b"#00ced1")),
+    ("darkviolet", Rgba8::from_hex(b"#9400d3")),
+    ("deeppink", Rgba8::from_hex(b"#ff1493")),
+    ("deepskyblue", Rgba8::from_hex(b"#00bfff")),
+    ("dimgray", Rgba8::from_hex(b"#696969")),
+    ("dimgrey", Rgba8::from_hex(b"#696969")),
+    ("dodgerblue", Rgba8::from_hex(b"#1e90ff")),
+    ("firebrick", Rgba8::from_hex(b"#b22222")),
+    ("floralwhite", Rgba8::from_hex(b"#fffaf0")),
+    ("forestgreen", Rgba8::from_hex(b"#228b22")),
+    ("gainsboro", Rgba8::from_hex(b"#dcdcdc")),
+    ("ghostwhite", Rgba8::from_hex(b"#f8f8ff")),
+    ("gold", Rgba8::from_hex(b"#ffd700")),
+    ("goldenrod", Rgba8::from_hex(b"#daa520")),
+    ("greenyellow", Rgba8::from_hex(b"#adff2f")),
+    ("grey", Rgba8::from_hex(b"#808080")),
+    ("honeydew", Rgba8::from_hex(b"#f0fff0")),
+    ("hotpink", Rgba8::from_hex(b"#ff69b4")),
+    ("indianred", Rgba8::from_hex(b"#cd5c5c")),
+    ("indigo", Rgba8::from_hex(b"#4b0082")),
+    ("ivory", Rgba8::from_hex(b"#fffff0")),
+    ("khaki", Rgba8::from_hex(b"#f0e68c")),
+    ("lavender", Rgba8::from_hex(b"#e6e6fa")),
+    ("lavenderblush", Rgba8::from_hex(b"#fff0f5")),
+    ("lawngreen", Rgba8::from_hex(b"#7cfc00")),
+    ("lemonchiffon", Rgba8::from_hex(b"#fffacd")),
+    ("lightblue", Rgba8::from_hex(b"#add8e6")),
+    ("lightcoral", Rgba8::from_hex(b"#f08080")),
+    ("lightcyan", Rgba8::from_hex(b"#e0ffff")),
+    ("lightgoldenrodyellow", Rgba8::from_hex(b"#fafad2")),
+    ("lightgray", Rgba8::from_hex(b"#d3d3d3")),
+    ("lightgreen", Rgba8::from_hex(b"#90ee90")),
+    ("lightgrey", Rgba8::from_hex(b"#d3d3d3")),
+    ("lightpink", Rgba8::from_hex(b"#ffb6c1")),
+    ("lightsalmon", Rgba8::from_hex(b"#ffa07a")),
+    ("lightseagreen", Rgba8::from_hex(b"#20b2aa")),
+    ("lightskyblue", Rgba8::from_hex(b"#87cefa")),
+    ("lightslategray", Rgba8::from_hex(b"#778899")),
+    ("lightslategrey", Rgba8::from_hex(b"#778899")),
+    ("lightsteelblue", Rgba8::from_hex(b"#b0c4de")),
+    ("lightyellow", Rgba8::from_hex(b"#ffffe0")),
+    ("limegreen", Rgba8::from_hex(b"#32cd32")),
+    ("linen", Rgba8::from_hex(b"#faf0e6")),
+    ("magenta", Rgba8::from_hex(b"#ff00ff")),
+    ("mediumaquamarine", Rgba8::from_hex(b"#66cdaa")),
+    ("mediumblue", Rgba8::from_hex(b"#0000cd")),
+    ("mediumorchid", Rgba8::from_hex(b"#ba55d3")),
+    ("mediumpurple", Rgba8::from_hex(b"#9370db")),
+    ("mediumseagreen", Rgba8::from_hex(b"#3cb371")),
+    ("mediumslateblue", Rgba8::from_hex(b"#7b68ee")),
+    ("mediumspringgreen", Rgba8::from_hex(b"#00fa9a")),
+    ("mediumturquoise", Rgba8::from_hex(b"#48d1cc")),
+    ("mediumvioletred", Rgba8::from_hex(b"#c71585")),
+    ("midnightblue", Rgba8::from_hex(b"#191970")),
+    ("mintcream", Rgba8::from_hex(b"#f5fffa")),
+    ("mistyrose", Rgba8::from_hex(b"#ffe4e1")),
+    ("moccasin", Rgba8::from_hex(b"#ffe4b5")),
+    ("navajowhite", Rgba8::from_hex(b"#ffdead")),
+    ("oldlace", Rgba8::from_hex(b"#fdf5e6")),
+    ("olivedrab", Rgba8::from_hex(b"#6b8e23")),
+    ("orange", Rgba8::from_hex(b"#ffa500")),
+    ("orangered", Rgba8::from_hex(b"#ff4500")),
+    ("orchid", Rgba8::from_hex(b"#da70d6")),
+    ("palegoldenrod", Rgba8::from_hex(b"#eee8aa")),
+    ("palegreen", Rgba8::from_hex(b"#98fb98")),
+    ("paleturquoise", Rgba8::from_hex(b"#afeeee")),
+    ("palevioletred", Rgba8::from_hex(b"#db7093")),
+    ("papayawhip", Rgba8::from_hex(b"#ffefd5")),
+    ("peachpuff", Rgba8::from_hex(b"#ffdab9")),
+    ("peru", Rgba8::from_hex(b"#cd853f")),
+    ("pink", Rgba8::from_hex(b"#ffc0cb")),
+    ("plum", Rgba8::from_hex(b"#dda0dd")),
+    ("powderblue", Rgba8::from_hex(b"#b0e0e6")),
+    ("rebeccapurple", Rgba8::from_hex(b"#663399")),
+    ("rosybrown", Rgba8::from_hex(b"#bc8f8f")),
+    ("royalblue", Rgba8::from_hex(b"#4169e1")),
+    ("saddlebrown", Rgba8::from_hex(b"#8b4513")),
+    ("salmon", Rgba8::from_hex(b"#fa8072")),
+    ("sandybrown", Rgba8::from_hex(b"#f4a460")),
+    ("seagreen", Rgba8::from_hex(b"#2e8b57")),
+    ("seashell", Rgba8::from_hex(b"#fff5ee")),
+    ("sienna", Rgba8::from_hex(b"#a0522d")),
+    ("skyblue", Rgba8::from_hex(b"#87ceeb")),
+    ("slateblue", Rgba8::from_hex(b"#6a5acd")),
+    ("slategray", Rgba8::from_hex(b"#708090")),
+    ("slategrey", Rgba8::from_hex(b"#708090")),
+    ("snow", Rgba8::from_hex(b"#fffafa")),
+    ("springgreen", Rgba8::from_hex(b"#00ff7f")),
+    ("steelblue", Rgba8::from_hex(b"#4682b4")),
+    ("tan", Rgba8::from_hex(b"#d2b48c")),
+    ("thistle", Rgba8::from_hex(b"#d8bfd8")),
+    ("tomato", Rgba8::from_hex(b"#ff6347")),
+    ("turquoise", Rgba8::from_hex(b"#40e0d0")),
+    ("violet", Rgba8::from_hex(b"#ee82ee")),
+    ("wheat", Rgba8::from_hex(b"#f5deb3")),
+    ("whitesmoke", Rgba8::from_hex(b"#f5f5f5")),
+    ("yellowgreen", Rgba8::from_hex(b"#9acd32")),
+];
+
 /// <div style="display: inline-block; width: 3em; height: 1em; border: 1px solid black; background: rgba(0,0,0,0);"></div>
 pub const TRANSPARENT: Rgba8 = Rgba8::new(0, 0, 0, 0);
 
@@ -302,162 +455,3 @@ pub const WHEAT: Rgba8 = Rgba8::from_hex(b"#f5deb3");
 pub const WHITESMOKE: Rgba8 = Rgba8::from_hex(b"#f5f5f5");
 /// <div style="display: inline-block; width: 3em; height: 1em; border: 1px solid black; background: #9acd32;"></div>
 pub const YELLOWGREEN: Rgba8 = Rgba8::from_hex(b"#9acd32");
-
-/// Lookup a named color (case-insensitive).
-/// Return Some(Rgba8) if the name is known
-pub(super) fn lookup_name(name: &str) -> Option<Rgba8> {
-    match name.trim().to_ascii_lowercase().as_str() {
-        "transparent" => Some(TRANSPARENT),
-
-        "black" => Some(BLACK),
-        "silver" => Some(SILVER),
-        "gray" | "grey" => Some(GRAY),
-        "white" => Some(WHITE),
-        "maroon" => Some(MAROON),
-        "red" => Some(RED),
-        "purple" => Some(PURPLE),
-        "fuchsia" => Some(FUCHSIA),
-        "green" => Some(GREEN),
-        "lime" => Some(LIME),
-        "olive" => Some(OLIVE),
-        "yellow" => Some(YELLOW),
-        "navy" => Some(NAVY),
-        "blue" => Some(BLUE),
-        "teal" => Some(TEAL),
-        "aqua" | "cyan" => Some(AQUA),
-
-        "aliceblue" => Some(ALICEBLUE),
-        "antiquewhite" => Some(ANTIQUEWHITE),
-        "aquamarine" => Some(AQUAMARINE),
-        "azure" => Some(AZURE),
-        "beige" => Some(BEIGE),
-        "bisque" => Some(BISQUE),
-        "blanchedalmond" => Some(BLANCHEDALMOND),
-        "blueviolet" => Some(BLUEVIOLET),
-        "brown" => Some(BROWN),
-        "burlywood" => Some(BURLYWOOD),
-        "cadetblue" => Some(CADETBLUE),
-        "chartreuse" => Some(CHARTREUSE),
-        "chocolate" => Some(CHOCOLATE),
-        "coral" => Some(CORAL),
-        "cornflowerblue" => Some(CORNFLOWERBLUE),
-        "cornsilk" => Some(CORNSILK),
-        "crimson" => Some(CRIMSON),
-        "darkblue" => Some(DARKBLUE),
-        "darkcyan" => Some(DARKCYAN),
-        "darkgoldenrod" => Some(DARKGOLDENROD),
-        "darkgray" => Some(DARKGRAY),
-        "darkgreen" => Some(DARKGREEN),
-        "darkgrey" => Some(DARKGREY),
-        "darkkhaki" => Some(DARKKHAKI),
-        "darkmagenta" => Some(DARKMAGENTA),
-        "darkolivegreen" => Some(DARKOLIVEGREEN),
-        "darkorange" => Some(DARKORANGE),
-        "darkorchid" => Some(DARKORCHID),
-        "darkred" => Some(DARKRED),
-        "darksalmon" => Some(DARKSALMON),
-        "darkseagreen" => Some(DARKSEAGREEN),
-        "darkslateblue" => Some(DARKSLATEBLUE),
-        "darkslategray" => Some(DARKSLATEGRAY),
-        "darkslategrey" => Some(DARKSLATEGREY),
-        "darkturquoise" => Some(DARKTURQUOISE),
-        "darkviolet" => Some(DARKVIOLET),
-        "deeppink" => Some(DEEPPINK),
-        "deepskyblue" => Some(DEEPSKYBLUE),
-        "dimgray" => Some(DIMGRAY),
-        "dimgrey" => Some(DIMGREY),
-        "dodgerblue" => Some(DODGERBLUE),
-        "firebrick" => Some(FIREBRICK),
-        "floralwhite" => Some(FLORALWHITE),
-        "forestgreen" => Some(FORESTGREEN),
-        "gainsboro" => Some(GAINSBORO),
-        "ghostwhite" => Some(GHOSTWHITE),
-        "gold" => Some(GOLD),
-        "goldenrod" => Some(GOLDENROD),
-        "greenyellow" => Some(GREENYELLOW),
-        "honeydew" => Some(HONEYDEW),
-        "hotpink" => Some(HOTPINK),
-        "indianred" => Some(INDIANRED),
-        "indigo" => Some(INDIGO),
-        "ivory" => Some(IVORY),
-        "khaki" => Some(KHAKI),
-        "lavender" => Some(LAVENDER),
-        "lavenderblush" => Some(LAVENDERBLUSH),
-        "lawngreen" => Some(LAWNGREEN),
-        "lemonchiffon" => Some(LEMONCHIFFON),
-        "lightblue" => Some(LIGHTBLUE),
-        "lightcoral" => Some(LIGHTCORAL),
-        "lightcyan" => Some(LIGHTCYAN),
-        "lightgoldenrodyellow" => Some(LIGHTGOLDENRODYELLOW),
-        "lightgray" => Some(LIGHTGRAY),
-        "lightgreen" => Some(LIGHTGREEN),
-        "lightgrey" => Some(LIGHTGREY),
-        "lightpink" => Some(LIGHTPINK),
-        "lightsalmon" => Some(LIGHTSALMON),
-        "lightseagreen" => Some(LIGHTSEAGREEN),
-        "lightskyblue" => Some(LIGHTSKYBLUE),
-        "lightslategray" => Some(LIGHTSLATEGRAY),
-        "lightslategrey" => Some(LIGHTSLATEGREY),
-        "lightsteelblue" => Some(LIGHTSTEELBLUE),
-        "lightyellow" => Some(LIGHTYELLOW),
-        "limegreen" => Some(LIMEGREEN),
-        "linen" => Some(LINEN),
-
-        "magenta" => Some(MAGENTA),
-        "mediumaquamarine" => Some(MEDIUMAQUAMARINE),
-        "mediumblue" => Some(MEDIUMBLUE),
-        "mediumorchid" => Some(MEDIUMORCHID),
-        "mediumpurple" => Some(MEDIUMPURPLE),
-        "mediumseagreen" => Some(MEDIUMSEAGREEN),
-        "mediumslateblue" => Some(MEDIUMSLATEBLUE),
-        "mediumspringgreen" => Some(MEDIUMSPRINGGREEN),
-        "mediumturquoise" => Some(MEDIUMTURQUOISE),
-        "mediumvioletred" => Some(MEDIUMVIOLETRED),
-        "midnightblue" => Some(MIDNIGHTBLUE),
-        "mintcream" => Some(MINTCREAM),
-        "mistyrose" => Some(MISTYROSE),
-        "moccasin" => Some(MOCCASIN),
-        "navajowhite" => Some(NAVAJOWHITE),
-        "oldlace" => Some(OLDLACE),
-        "olivedrab" => Some(OLIVEDRAB),
-        "orange" => Some(ORANGE),
-        "orangered" => Some(ORANGERED),
-        "orchid" => Some(ORCHID),
-        "palegoldenrod" => Some(PALEGOLDENROD),
-        "palegreen" => Some(PALEGREEN),
-        "paleturquoise" => Some(PALETURQUOISE),
-        "palevioletred" => Some(PALEVIOLETRED),
-        "papayawhip" => Some(PAPAYAWHIP),
-        "peachpuff" => Some(PEACHPUFF),
-        "peru" => Some(PERU),
-        "pink" => Some(PINK),
-        "plum" => Some(PLUM),
-        "powderblue" => Some(POWDERBLUE),
-        "rebeccapurple" => Some(REBECCAPURPLE),
-        "rosybrown" => Some(ROSYBROWN),
-        "royalblue" => Some(ROYALBLUE),
-        "saddlebrown" => Some(SADDLEBROWN),
-        "salmon" => Some(SALMON),
-        "sandybrown" => Some(SANDYBROWN),
-        "seagreen" => Some(SEAGREEN),
-        "seashell" => Some(SEASHELL),
-        "sienna" => Some(SIENNA),
-        "skyblue" => Some(SKYBLUE),
-        "slateblue" => Some(SLATEBLUE),
-        "slategray" => Some(SLATEGRAY),
-        "slategrey" => Some(SLATEGREY),
-        "snow" => Some(SNOW),
-        "springgreen" => Some(SPRINGGREEN),
-        "steelblue" => Some(STEELBLUE),
-        "tan" => Some(TAN),
-        "thistle" => Some(THISTLE),
-        "tomato" => Some(TOMATO),
-        "turquoise" => Some(TURQUOISE),
-        "violet" => Some(VIOLET),
-        "wheat" => Some(WHEAT),
-        "whitesmoke" => Some(WHITESMOKE),
-        "yellowgreen" => Some(YELLOWGREEN),
-
-        _ => None,
-    }
-}
diff --git a/base/src/color/xkcd.rs b/base/src/color/xkcd.rs
index db2270b2..a0a4e426 100644
--- a/base/src/color/xkcd.rs
+++ b/base/src/color/xkcd.rs
@@ -1,961 +1,908 @@
 use super::Rgba8;
 
-/// Colors from the xkcd color survey.
+/// Colors from the xkcd color survey, minus the colors that are present in the CSS4 color set.
 /// These are not intended to be used directly, but are available for users who want to use them.
 /// https://blog.xkcd.com/2010/05/03/color-survey-results/
 
-pub fn lookup_name(name: &str) -> Option<Rgba8> {
-    // License: https://creativecommons.org/publicdomain/zero/1.0/
-    match name {
-        "cloudy blue" => Some(Rgba8::from_hex(b"#acc2d9")),
-        "dark pastel green" => Some(Rgba8::from_hex(b"#56ae57")),
-        "dust" => Some(Rgba8::from_hex(b"#b2996e")),
-        "electric lime" => Some(Rgba8::from_hex(b"#a8ff04")),
-        "fresh green" => Some(Rgba8::from_hex(b"#69d84f")),
-        "light eggplant" => Some(Rgba8::from_hex(b"#894585")),
-        "nasty green" => Some(Rgba8::from_hex(b"#70b23f")),
-        "really light blue" => Some(Rgba8::from_hex(b"#d4ffff")),
-        "tea" => Some(Rgba8::from_hex(b"#65ab7c")),
-        "warm purple" => Some(Rgba8::from_hex(b"#952e8f")),
-        "yellowish tan" => Some(Rgba8::from_hex(b"#fcfc81")),
-        "cement" => Some(Rgba8::from_hex(b"#a5a391")),
-        "dark grass green" => Some(Rgba8::from_hex(b"#388004")),
-        "dusty teal" => Some(Rgba8::from_hex(b"#4c9085")),
-        "grey teal" => Some(Rgba8::from_hex(b"#5e9b8a")),
-        "macaroni and cheese" => Some(Rgba8::from_hex(b"#efb435")),
-        "pinkish tan" => Some(Rgba8::from_hex(b"#d99b82")),
-        "spruce" => Some(Rgba8::from_hex(b"#0a5f38")),
-        "strong blue" => Some(Rgba8::from_hex(b"#0c06f7")),
-        "toxic green" => Some(Rgba8::from_hex(b"#61de2a")),
-        "windows blue" => Some(Rgba8::from_hex(b"#3778bf")),
-        "blue blue" => Some(Rgba8::from_hex(b"#2242c7")),
-        "blue with a hint of purple" => Some(Rgba8::from_hex(b"#533cc6")),
-        "booger" => Some(Rgba8::from_hex(b"#9bb53c")),
-        "bright sea green" => Some(Rgba8::from_hex(b"#05ffa6")),
-        "dark green blue" => Some(Rgba8::from_hex(b"#1f6357")),
-        "deep turquoise" => Some(Rgba8::from_hex(b"#017374")),
-        "green teal" => Some(Rgba8::from_hex(b"#0cb577")),
-        "strong pink" => Some(Rgba8::from_hex(b"#ff0789")),
-        "bland" => Some(Rgba8::from_hex(b"#afa88b")),
-        "deep aqua" => Some(Rgba8::from_hex(b"#08787f")),
-        "lavender pink" => Some(Rgba8::from_hex(b"#dd85d7")),
-        "light moss green" => Some(Rgba8::from_hex(b"#a6c875")),
-        "light seafoam green" => Some(Rgba8::from_hex(b"#a7ffb5")),
-        "olive yellow" => Some(Rgba8::from_hex(b"#c2b709")),
-        "pig pink" => Some(Rgba8::from_hex(b"#e78ea5")),
-        "deep lilac" => Some(Rgba8::from_hex(b"#966ebd")),
-        "desert" => Some(Rgba8::from_hex(b"#ccad60")),
-        "dusty lavender" => Some(Rgba8::from_hex(b"#ac86a8")),
-        "purpley grey" => Some(Rgba8::from_hex(b"#947e94")),
-        "purply" => Some(Rgba8::from_hex(b"#983fb2")),
-        "candy pink" => Some(Rgba8::from_hex(b"#ff63e9")),
-        "light pastel green" => Some(Rgba8::from_hex(b"#b2fba5")),
-        "boring green" => Some(Rgba8::from_hex(b"#63b365")),
-        "kiwi green" => Some(Rgba8::from_hex(b"#8ee53f")),
-        "light grey green" => Some(Rgba8::from_hex(b"#b7e1a1")),
-        "orange pink" => Some(Rgba8::from_hex(b"#ff6f52")),
-        "tea green" => Some(Rgba8::from_hex(b"#bdf8a3")),
-        "very light brown" => Some(Rgba8::from_hex(b"#d3b683")),
-        "egg shell" => Some(Rgba8::from_hex(b"#fffcc4")),
-        "eggplant purple" => Some(Rgba8::from_hex(b"#430541")),
-        "powder pink" => Some(Rgba8::from_hex(b"#ffb2d0")),
-        "reddish grey" => Some(Rgba8::from_hex(b"#997570")),
-        "baby shit brown" => Some(Rgba8::from_hex(b"#ad900d")),
-        "liliac" => Some(Rgba8::from_hex(b"#c48efd")),
-        "stormy blue" => Some(Rgba8::from_hex(b"#507b9c")),
-        "ugly brown" => Some(Rgba8::from_hex(b"#7d7103")),
-        "custard" => Some(Rgba8::from_hex(b"#fffd78")),
-        "darkish pink" => Some(Rgba8::from_hex(b"#da467d")),
-        "deep brown" => Some(Rgba8::from_hex(b"#410200")),
-        "greenish beige" => Some(Rgba8::from_hex(b"#c9d179")),
-        "manilla" => Some(Rgba8::from_hex(b"#fffa86")),
-        "off blue" => Some(Rgba8::from_hex(b"#5684ae")),
-        "battleship grey" => Some(Rgba8::from_hex(b"#6b7c85")),
-        "browny green" => Some(Rgba8::from_hex(b"#6f6c0a")),
-        "bruise" => Some(Rgba8::from_hex(b"#7e4071")),
-        "kelley green" => Some(Rgba8::from_hex(b"#009337")),
-        "sickly yellow" => Some(Rgba8::from_hex(b"#d0e429")),
-        "sunny yellow" => Some(Rgba8::from_hex(b"#fff917")),
-        "azul" => Some(Rgba8::from_hex(b"#1d5dec")),
-        "darkgreen" => Some(Rgba8::from_hex(b"#054907")),
-        "green/yellow" => Some(Rgba8::from_hex(b"#b5ce08")),
-        "lichen" => Some(Rgba8::from_hex(b"#8fb67b")),
-        "light light green" => Some(Rgba8::from_hex(b"#c8ffb0")),
-        "pale gold" => Some(Rgba8::from_hex(b"#fdde6c")),
-        "sun yellow" => Some(Rgba8::from_hex(b"#ffdf22")),
-        "tan green" => Some(Rgba8::from_hex(b"#a9be70")),
-        "burple" => Some(Rgba8::from_hex(b"#6832e3")),
-        "butterscotch" => Some(Rgba8::from_hex(b"#fdb147")),
-        "toupe" => Some(Rgba8::from_hex(b"#c7ac7d")),
-        "dark cream" => Some(Rgba8::from_hex(b"#fff39a")),
-        "indian red" => Some(Rgba8::from_hex(b"#850e04")),
-        "light lavendar" => Some(Rgba8::from_hex(b"#efc0fe")),
-        "poison green" => Some(Rgba8::from_hex(b"#40fd14")),
-        "baby puke green" => Some(Rgba8::from_hex(b"#b6c406")),
-        "bright yellow green" => Some(Rgba8::from_hex(b"#9dff00")),
-        "charcoal grey" => Some(Rgba8::from_hex(b"#3c4142")),
-        "squash" => Some(Rgba8::from_hex(b"#f2ab15")),
-        "cinnamon" => Some(Rgba8::from_hex(b"#ac4f06")),
-        "light pea green" => Some(Rgba8::from_hex(b"#c4fe82")),
-        "radioactive green" => Some(Rgba8::from_hex(b"#2cfa1f")),
-        "raw sienna" => Some(Rgba8::from_hex(b"#9a6200")),
-        "baby purple" => Some(Rgba8::from_hex(b"#ca9bf7")),
-        "cocoa" => Some(Rgba8::from_hex(b"#875f42")),
-        "light royal blue" => Some(Rgba8::from_hex(b"#3a2efe")),
-        "orangeish" => Some(Rgba8::from_hex(b"#fd8d49")),
-        "rust brown" => Some(Rgba8::from_hex(b"#8b3103")),
-        "sand brown" => Some(Rgba8::from_hex(b"#cba560")),
-        "swamp" => Some(Rgba8::from_hex(b"#698339")),
-        "tealish green" => Some(Rgba8::from_hex(b"#0cdc73")),
-        "burnt siena" => Some(Rgba8::from_hex(b"#b75203")),
-        "camo" => Some(Rgba8::from_hex(b"#7f8f4e")),
-        "dusk blue" => Some(Rgba8::from_hex(b"#26538d")),
-        "fern" => Some(Rgba8::from_hex(b"#63a950")),
-        "old rose" => Some(Rgba8::from_hex(b"#c87f89")),
-        "pale light green" => Some(Rgba8::from_hex(b"#b1fc99")),
-        "peachy pink" => Some(Rgba8::from_hex(b"#ff9a8a")),
-        "rosy pink" => Some(Rgba8::from_hex(b"#f6688e")),
-        "light bluish green" => Some(Rgba8::from_hex(b"#76fda8")),
-        "light bright green" => Some(Rgba8::from_hex(b"#53fe5c")),
-        "light neon green" => Some(Rgba8::from_hex(b"#4efd54")),
-        "light seafoam" => Some(Rgba8::from_hex(b"#a0febf")),
-        "tiffany blue" => Some(Rgba8::from_hex(b"#7bf2da")),
-        "washed out green" => Some(Rgba8::from_hex(b"#bcf5a6")),
-        "browny orange" => Some(Rgba8::from_hex(b"#ca6b02")),
-        "nice blue" => Some(Rgba8::from_hex(b"#107ab0")),
-        "sapphire" => Some(Rgba8::from_hex(b"#2138ab")),
-        "greyish teal" => Some(Rgba8::from_hex(b"#719f91")),
-        "orangey yellow" => Some(Rgba8::from_hex(b"#fdb915")),
-        "parchment" => Some(Rgba8::from_hex(b"#fefcaf")),
-        "straw" => Some(Rgba8::from_hex(b"#fcf679")),
-        "very dark brown" => Some(Rgba8::from_hex(b"#1d0200")),
-        "terracota" => Some(Rgba8::from_hex(b"#cb6843")),
-        "ugly blue" => Some(Rgba8::from_hex(b"#31668a")),
-        "clear blue" => Some(Rgba8::from_hex(b"#247afd")),
-        "creme" => Some(Rgba8::from_hex(b"#ffffb6")),
-        "foam green" => Some(Rgba8::from_hex(b"#90fda9")),
-        "grey/green" => Some(Rgba8::from_hex(b"#86a17d")),
-        "light gold" => Some(Rgba8::from_hex(b"#fddc5c")),
-        "seafoam blue" => Some(Rgba8::from_hex(b"#78d1b6")),
-        "topaz" => Some(Rgba8::from_hex(b"#13bbaf")),
-        "violet pink" => Some(Rgba8::from_hex(b"#fb5ffc")),
-        "wintergreen" => Some(Rgba8::from_hex(b"#20f986")),
-        "yellow tan" => Some(Rgba8::from_hex(b"#ffe36e")),
-        "dark fuchsia" => Some(Rgba8::from_hex(b"#9d0759")),
-        "indigo blue" => Some(Rgba8::from_hex(b"#3a18b1")),
-        "light yellowish green" => Some(Rgba8::from_hex(b"#c2ff89")),
-        "pale magenta" => Some(Rgba8::from_hex(b"#d767ad")),
-        "rich purple" => Some(Rgba8::from_hex(b"#720058")),
-        "sunflower yellow" => Some(Rgba8::from_hex(b"#ffda03")),
-        "green/blue" => Some(Rgba8::from_hex(b"#01c08d")),
-        "leather" => Some(Rgba8::from_hex(b"#ac7434")),
-        "racing green" => Some(Rgba8::from_hex(b"#014600")),
-        "vivid purple" => Some(Rgba8::from_hex(b"#9900fa")),
-        "dark royal blue" => Some(Rgba8::from_hex(b"#02066f")),
-        "hazel" => Some(Rgba8::from_hex(b"#8e7618")),
-        "muted pink" => Some(Rgba8::from_hex(b"#d1768f")),
-        "booger green" => Some(Rgba8::from_hex(b"#96b403")),
-        "canary" => Some(Rgba8::from_hex(b"#fdff63")),
-        "cool grey" => Some(Rgba8::from_hex(b"#95a3a6")),
-        "dark taupe" => Some(Rgba8::from_hex(b"#7f684e")),
-        "darkish purple" => Some(Rgba8::from_hex(b"#751973")),
-        "true green" => Some(Rgba8::from_hex(b"#089404")),
-        "coral pink" => Some(Rgba8::from_hex(b"#ff6163")),
-        "dark sage" => Some(Rgba8::from_hex(b"#598556")),
-        "dark slate blue" => Some(Rgba8::from_hex(b"#214761")),
-        "flat blue" => Some(Rgba8::from_hex(b"#3c73a8")),
-        "mushroom" => Some(Rgba8::from_hex(b"#ba9e88")),
-        "rich blue" => Some(Rgba8::from_hex(b"#021bf9")),
-        "dirty purple" => Some(Rgba8::from_hex(b"#734a65")),
-        "greenblue" => Some(Rgba8::from_hex(b"#23c48b")),
-        "icky green" => Some(Rgba8::from_hex(b"#8fae22")),
-        "light khaki" => Some(Rgba8::from_hex(b"#e6f2a2")),
-        "warm blue" => Some(Rgba8::from_hex(b"#4b57db")),
-        "dark hot pink" => Some(Rgba8::from_hex(b"#d90166")),
-        "deep sea blue" => Some(Rgba8::from_hex(b"#015482")),
-        "carmine" => Some(Rgba8::from_hex(b"#9d0216")),
-        "dark yellow green" => Some(Rgba8::from_hex(b"#728f02")),
-        "pale peach" => Some(Rgba8::from_hex(b"#ffe5ad")),
-        "plum purple" => Some(Rgba8::from_hex(b"#4e0550")),
-        "golden rod" => Some(Rgba8::from_hex(b"#f9bc08")),
-        "neon red" => Some(Rgba8::from_hex(b"#ff073a")),
-        "old pink" => Some(Rgba8::from_hex(b"#c77986")),
-        "very pale blue" => Some(Rgba8::from_hex(b"#d6fffe")),
-        "blood orange" => Some(Rgba8::from_hex(b"#fe4b03")),
-        "grapefruit" => Some(Rgba8::from_hex(b"#fd5956")),
-        "sand yellow" => Some(Rgba8::from_hex(b"#fce166")),
-        "clay brown" => Some(Rgba8::from_hex(b"#b2713d")),
-        "dark blue grey" => Some(Rgba8::from_hex(b"#1f3b4d")),
-        "flat green" => Some(Rgba8::from_hex(b"#699d4c")),
-        "light green blue" => Some(Rgba8::from_hex(b"#56fca2")),
-        "warm pink" => Some(Rgba8::from_hex(b"#fb5581")),
-        "dodger blue" => Some(Rgba8::from_hex(b"#3e82fc")),
-        "gross green" => Some(Rgba8::from_hex(b"#a0bf16")),
-        "ice" => Some(Rgba8::from_hex(b"#d6fffa")),
-        "metallic blue" => Some(Rgba8::from_hex(b"#4f738e")),
-        "pale salmon" => Some(Rgba8::from_hex(b"#ffb19a")),
-        "sap green" => Some(Rgba8::from_hex(b"#5c8b15")),
-        "algae" => Some(Rgba8::from_hex(b"#54ac68")),
-        "bluey grey" => Some(Rgba8::from_hex(b"#89a0b0")),
-        "greeny grey" => Some(Rgba8::from_hex(b"#7ea07a")),
-        "highlighter green" => Some(Rgba8::from_hex(b"#1bfc06")),
-        "light light blue" => Some(Rgba8::from_hex(b"#cafffb")),
-        "light mint" => Some(Rgba8::from_hex(b"#b6ffbb")),
-        "raw umber" => Some(Rgba8::from_hex(b"#a75e09")),
-        "vivid blue" => Some(Rgba8::from_hex(b"#152eff")),
-        "deep lavender" => Some(Rgba8::from_hex(b"#8d5eb7")),
-        "dull teal" => Some(Rgba8::from_hex(b"#5f9e8f")),
-        "light greenish blue" => Some(Rgba8::from_hex(b"#63f7b4")),
-        "mud green" => Some(Rgba8::from_hex(b"#606602")),
-        "pinky" => Some(Rgba8::from_hex(b"#fc86aa")),
-        "red wine" => Some(Rgba8::from_hex(b"#8c0034")),
-        "shit green" => Some(Rgba8::from_hex(b"#758000")),
-        "tan brown" => Some(Rgba8::from_hex(b"#ab7e4c")),
-        "darkblue" => Some(Rgba8::from_hex(b"#030764")),
-        "rosa" => Some(Rgba8::from_hex(b"#fe86a4")),
-        "lipstick" => Some(Rgba8::from_hex(b"#d5174e")),
-        "pale mauve" => Some(Rgba8::from_hex(b"#fed0fc")),
-        "claret" => Some(Rgba8::from_hex(b"#680018")),
-        "dandelion" => Some(Rgba8::from_hex(b"#fedf08")),
-        "orangered" => Some(Rgba8::from_hex(b"#fe420f")),
-        "poop green" => Some(Rgba8::from_hex(b"#6f7c00")),
-        "ruby" => Some(Rgba8::from_hex(b"#ca0147")),
-        "dark" => Some(Rgba8::from_hex(b"#1b2431")),
-        "greenish turquoise" => Some(Rgba8::from_hex(b"#00fbb0")),
-        "pastel red" => Some(Rgba8::from_hex(b"#db5856")),
-        "piss yellow" => Some(Rgba8::from_hex(b"#ddd618")),
-        "bright cyan" => Some(Rgba8::from_hex(b"#41fdfe")),
-        "dark coral" => Some(Rgba8::from_hex(b"#cf524e")),
-        "algae green" => Some(Rgba8::from_hex(b"#21c36f")),
-        "darkish red" => Some(Rgba8::from_hex(b"#a90308")),
-        "reddy brown" => Some(Rgba8::from_hex(b"#6e1005")),
-        "blush pink" => Some(Rgba8::from_hex(b"#fe828c")),
-        "camouflage green" => Some(Rgba8::from_hex(b"#4b6113")),
-        "lawn green" => Some(Rgba8::from_hex(b"#4da409")),
-        "putty" => Some(Rgba8::from_hex(b"#beae8a")),
-        "vibrant blue" => Some(Rgba8::from_hex(b"#0339f8")),
-        "dark sand" => Some(Rgba8::from_hex(b"#a88f59")),
-        "purple/blue" => Some(Rgba8::from_hex(b"#5d21d0")),
-        "saffron" => Some(Rgba8::from_hex(b"#feb209")),
-        "twilight" => Some(Rgba8::from_hex(b"#4e518b")),
-        "warm brown" => Some(Rgba8::from_hex(b"#964e02")),
-        "bluegrey" => Some(Rgba8::from_hex(b"#85a3b2")),
-        "bubble gum pink" => Some(Rgba8::from_hex(b"#ff69af")),
-        "duck egg blue" => Some(Rgba8::from_hex(b"#c3fbf4")),
-        "greenish cyan" => Some(Rgba8::from_hex(b"#2afeb7")),
-        "petrol" => Some(Rgba8::from_hex(b"#005f6a")),
-        "royal" => Some(Rgba8::from_hex(b"#0c1793")),
-        "butter" => Some(Rgba8::from_hex(b"#ffff81")),
-        "dusty orange" => Some(Rgba8::from_hex(b"#f0833a")),
-        "off yellow" => Some(Rgba8::from_hex(b"#f1f33f")),
-        "pale olive green" => Some(Rgba8::from_hex(b"#b1d27b")),
-        "orangish" => Some(Rgba8::from_hex(b"#fc824a")),
-        "leaf" => Some(Rgba8::from_hex(b"#71aa34")),
-        "light blue grey" => Some(Rgba8::from_hex(b"#b7c9e2")),
-        "dried blood" => Some(Rgba8::from_hex(b"#4b0101")),
-        "lightish purple" => Some(Rgba8::from_hex(b"#a552e6")),
-        "rusty red" => Some(Rgba8::from_hex(b"#af2f0d")),
-        "lavender blue" => Some(Rgba8::from_hex(b"#8b88f8")),
-        "light grass green" => Some(Rgba8::from_hex(b"#9af764")),
-        "light mint green" => Some(Rgba8::from_hex(b"#a6fbb2")),
-        "sunflower" => Some(Rgba8::from_hex(b"#ffc512")),
-        "velvet" => Some(Rgba8::from_hex(b"#750851")),
-        "brick orange" => Some(Rgba8::from_hex(b"#c14a09")),
-        "lightish red" => Some(Rgba8::from_hex(b"#fe2f4a")),
-        "pure blue" => Some(Rgba8::from_hex(b"#0203e2")),
-        "twilight blue" => Some(Rgba8::from_hex(b"#0a437a")),
-        "violet red" => Some(Rgba8::from_hex(b"#a50055")),
-        "yellowy brown" => Some(Rgba8::from_hex(b"#ae8b0c")),
-        "carnation" => Some(Rgba8::from_hex(b"#fd798f")),
-        "muddy yellow" => Some(Rgba8::from_hex(b"#bfac05")),
-        "dark seafoam green" => Some(Rgba8::from_hex(b"#3eaf76")),
-        "deep rose" => Some(Rgba8::from_hex(b"#c74767")),
-        "dusty red" => Some(Rgba8::from_hex(b"#b9484e")),
-        "grey/blue" => Some(Rgba8::from_hex(b"#647d8e")),
-        "lemon lime" => Some(Rgba8::from_hex(b"#bffe28")),
-        "purple/pink" => Some(Rgba8::from_hex(b"#d725de")),
-        "brown yellow" => Some(Rgba8::from_hex(b"#b29705")),
-        "purple brown" => Some(Rgba8::from_hex(b"#673a3f")),
-        "wisteria" => Some(Rgba8::from_hex(b"#a87dc2")),
-        "banana yellow" => Some(Rgba8::from_hex(b"#fafe4b")),
-        "lipstick red" => Some(Rgba8::from_hex(b"#c0022f")),
-        "water blue" => Some(Rgba8::from_hex(b"#0e87cc")),
-        "brown grey" => Some(Rgba8::from_hex(b"#8d8468")),
-        "vibrant purple" => Some(Rgba8::from_hex(b"#ad03de")),
-        "baby green" => Some(Rgba8::from_hex(b"#8cff9e")),
-        "barf green" => Some(Rgba8::from_hex(b"#94ac02")),
-        "eggshell blue" => Some(Rgba8::from_hex(b"#c4fff7")),
-        "sandy yellow" => Some(Rgba8::from_hex(b"#fdee73")),
-        "cool green" => Some(Rgba8::from_hex(b"#33b864")),
-        "pale" => Some(Rgba8::from_hex(b"#fff9d0")),
-        "blue/grey" => Some(Rgba8::from_hex(b"#758da3")),
-        "hot magenta" => Some(Rgba8::from_hex(b"#f504c9")),
-        "greyblue" => Some(Rgba8::from_hex(b"#77a1b5")),
-        "purpley" => Some(Rgba8::from_hex(b"#8756e4")),
-        "baby shit green" => Some(Rgba8::from_hex(b"#889717")),
-        "brownish pink" => Some(Rgba8::from_hex(b"#c27e79")),
-        "dark aquamarine" => Some(Rgba8::from_hex(b"#017371")),
-        "diarrhea" => Some(Rgba8::from_hex(b"#9f8303")),
-        "light mustard" => Some(Rgba8::from_hex(b"#f7d560")),
-        "pale sky blue" => Some(Rgba8::from_hex(b"#bdf6fe")),
-        "turtle green" => Some(Rgba8::from_hex(b"#75b84f")),
-        "bright olive" => Some(Rgba8::from_hex(b"#9cbb04")),
-        "dark grey blue" => Some(Rgba8::from_hex(b"#29465b")),
-        "greeny brown" => Some(Rgba8::from_hex(b"#696006")),
-        "lemon green" => Some(Rgba8::from_hex(b"#adf802")),
-        "light periwinkle" => Some(Rgba8::from_hex(b"#c1c6fc")),
-        "seaweed green" => Some(Rgba8::from_hex(b"#35ad6b")),
-        "sunshine yellow" => Some(Rgba8::from_hex(b"#fffd37")),
-        "ugly purple" => Some(Rgba8::from_hex(b"#a442a0")),
-        "medium pink" => Some(Rgba8::from_hex(b"#f36196")),
-        "puke brown" => Some(Rgba8::from_hex(b"#947706")),
-        "very light pink" => Some(Rgba8::from_hex(b"#fff4f2")),
-        "viridian" => Some(Rgba8::from_hex(b"#1e9167")),
-        "bile" => Some(Rgba8::from_hex(b"#b5c306")),
-        "faded yellow" => Some(Rgba8::from_hex(b"#feff7f")),
-        "very pale green" => Some(Rgba8::from_hex(b"#cffdbc")),
-        "vibrant green" => Some(Rgba8::from_hex(b"#0add08")),
-        "bright lime" => Some(Rgba8::from_hex(b"#87fd05")),
-        "spearmint" => Some(Rgba8::from_hex(b"#1ef876")),
-        "light aquamarine" => Some(Rgba8::from_hex(b"#7bfdc7")),
-        "light sage" => Some(Rgba8::from_hex(b"#bcecac")),
-        "yellowgreen" => Some(Rgba8::from_hex(b"#bbf90f")),
-        "baby poo" => Some(Rgba8::from_hex(b"#ab9004")),
-        "dark seafoam" => Some(Rgba8::from_hex(b"#1fb57a")),
-        "deep teal" => Some(Rgba8::from_hex(b"#00555a")),
-        "heather" => Some(Rgba8::from_hex(b"#a484ac")),
-        "rust orange" => Some(Rgba8::from_hex(b"#c45508")),
-        "dirty blue" => Some(Rgba8::from_hex(b"#3f829d")),
-        "fern green" => Some(Rgba8::from_hex(b"#548d44")),
-        "bright lilac" => Some(Rgba8::from_hex(b"#c95efb")),
-        "weird green" => Some(Rgba8::from_hex(b"#3ae57f")),
-        "peacock blue" => Some(Rgba8::from_hex(b"#016795")),
-        "avocado green" => Some(Rgba8::from_hex(b"#87a922")),
-        "faded orange" => Some(Rgba8::from_hex(b"#f0944d")),
-        "grape purple" => Some(Rgba8::from_hex(b"#5d1451")),
-        "hot green" => Some(Rgba8::from_hex(b"#25ff29")),
-        "lime yellow" => Some(Rgba8::from_hex(b"#d0fe1d")),
-        "mango" => Some(Rgba8::from_hex(b"#ffa62b")),
-        "shamrock" => Some(Rgba8::from_hex(b"#01b44c")),
-        "bubblegum" => Some(Rgba8::from_hex(b"#ff6cb5")),
-        "purplish brown" => Some(Rgba8::from_hex(b"#6b4247")),
-        "vomit yellow" => Some(Rgba8::from_hex(b"#c7c10c")),
-        "pale cyan" => Some(Rgba8::from_hex(b"#b7fffa")),
-        "key lime" => Some(Rgba8::from_hex(b"#aeff6e")),
-        "tomato red" => Some(Rgba8::from_hex(b"#ec2d01")),
-        "lightgreen" => Some(Rgba8::from_hex(b"#76ff7b")),
-        "merlot" => Some(Rgba8::from_hex(b"#730039")),
-        "night blue" => Some(Rgba8::from_hex(b"#040348")),
-        "purpleish pink" => Some(Rgba8::from_hex(b"#df4ec8")),
-        "apple" => Some(Rgba8::from_hex(b"#6ecb3c")),
-        "baby poop green" => Some(Rgba8::from_hex(b"#8f9805")),
-        "green apple" => Some(Rgba8::from_hex(b"#5edc1f")),
-        "heliotrope" => Some(Rgba8::from_hex(b"#d94ff5")),
-        "yellow/green" => Some(Rgba8::from_hex(b"#c8fd3d")),
-        "almost black" => Some(Rgba8::from_hex(b"#070d0d")),
-        "cool blue" => Some(Rgba8::from_hex(b"#4984b8")),
-        "leafy green" => Some(Rgba8::from_hex(b"#51b73b")),
-        "mustard brown" => Some(Rgba8::from_hex(b"#ac7e04")),
-        "dusk" => Some(Rgba8::from_hex(b"#4e5481")),
-        "dull brown" => Some(Rgba8::from_hex(b"#876e4b")),
-        "frog green" => Some(Rgba8::from_hex(b"#58bc08")),
-        "vivid green" => Some(Rgba8::from_hex(b"#2fef10")),
-        "bright light green" => Some(Rgba8::from_hex(b"#2dfe54")),
-        "fluro green" => Some(Rgba8::from_hex(b"#0aff02")),
-        "kiwi" => Some(Rgba8::from_hex(b"#9cef43")),
-        "seaweed" => Some(Rgba8::from_hex(b"#18d17b")),
-        "navy green" => Some(Rgba8::from_hex(b"#35530a")),
-        "ultramarine blue" => Some(Rgba8::from_hex(b"#1805db")),
-        "iris" => Some(Rgba8::from_hex(b"#6258c4")),
-        "pastel orange" => Some(Rgba8::from_hex(b"#ff964f")),
-        "yellowish orange" => Some(Rgba8::from_hex(b"#ffab0f")),
-        "perrywinkle" => Some(Rgba8::from_hex(b"#8f8ce7")),
-        "tealish" => Some(Rgba8::from_hex(b"#24bca8")),
-        "dark plum" => Some(Rgba8::from_hex(b"#3f012c")),
-        "pear" => Some(Rgba8::from_hex(b"#cbf85f")),
-        "pinkish orange" => Some(Rgba8::from_hex(b"#ff724c")),
-        "midnight purple" => Some(Rgba8::from_hex(b"#280137")),
-        "light urple" => Some(Rgba8::from_hex(b"#b36ff6")),
-        "dark mint" => Some(Rgba8::from_hex(b"#48c072")),
-        "greenish tan" => Some(Rgba8::from_hex(b"#bccb7a")),
-        "light burgundy" => Some(Rgba8::from_hex(b"#a8415b")),
-        "turquoise blue" => Some(Rgba8::from_hex(b"#06b1c4")),
-        "ugly pink" => Some(Rgba8::from_hex(b"#cd7584")),
-        "sandy" => Some(Rgba8::from_hex(b"#f1da7a")),
-        "electric pink" => Some(Rgba8::from_hex(b"#ff0490")),
-        "muted purple" => Some(Rgba8::from_hex(b"#805b87")),
-        "mid green" => Some(Rgba8::from_hex(b"#50a747")),
-        "greyish" => Some(Rgba8::from_hex(b"#a8a495")),
-        "neon yellow" => Some(Rgba8::from_hex(b"#cfff04")),
-        "banana" => Some(Rgba8::from_hex(b"#ffff7e")),
-        "carnation pink" => Some(Rgba8::from_hex(b"#ff7fa7")),
-        "tomato" => Some(Rgba8::from_hex(b"#ef4026")),
-        "sea" => Some(Rgba8::from_hex(b"#3c9992")),
-        "muddy brown" => Some(Rgba8::from_hex(b"#886806")),
-        "turquoise green" => Some(Rgba8::from_hex(b"#04f489")),
-        "buff" => Some(Rgba8::from_hex(b"#fef69e")),
-        "fawn" => Some(Rgba8::from_hex(b"#cfaf7b")),
-        "muted blue" => Some(Rgba8::from_hex(b"#3b719f")),
-        "pale rose" => Some(Rgba8::from_hex(b"#fdc1c5")),
-        "dark mint green" => Some(Rgba8::from_hex(b"#20c073")),
-        "amethyst" => Some(Rgba8::from_hex(b"#9b5fc0")),
-        "blue/green" => Some(Rgba8::from_hex(b"#0f9b8e")),
-        "chestnut" => Some(Rgba8::from_hex(b"#742802")),
-        "sick green" => Some(Rgba8::from_hex(b"#9db92c")),
-        "pea" => Some(Rgba8::from_hex(b"#a4bf20")),
-        "rusty orange" => Some(Rgba8::from_hex(b"#cd5909")),
-        "stone" => Some(Rgba8::from_hex(b"#ada587")),
-        "rose red" => Some(Rgba8::from_hex(b"#be013c")),
-        "pale aqua" => Some(Rgba8::from_hex(b"#b8ffeb")),
-        "deep orange" => Some(Rgba8::from_hex(b"#dc4d01")),
-        "earth" => Some(Rgba8::from_hex(b"#a2653e")),
-        "mossy green" => Some(Rgba8::from_hex(b"#638b27")),
-        "grassy green" => Some(Rgba8::from_hex(b"#419c03")),
-        "pale lime green" => Some(Rgba8::from_hex(b"#b1ff65")),
-        "light grey blue" => Some(Rgba8::from_hex(b"#9dbcd4")),
-        "pale grey" => Some(Rgba8::from_hex(b"#fdfdfe")),
-        "asparagus" => Some(Rgba8::from_hex(b"#77ab56")),
-        "blueberry" => Some(Rgba8::from_hex(b"#464196")),
-        "purple red" => Some(Rgba8::from_hex(b"#990147")),
-        "pale lime" => Some(Rgba8::from_hex(b"#befd73")),
-        "greenish teal" => Some(Rgba8::from_hex(b"#32bf84")),
-        "caramel" => Some(Rgba8::from_hex(b"#af6f09")),
-        "deep magenta" => Some(Rgba8::from_hex(b"#a0025c")),
-        "light peach" => Some(Rgba8::from_hex(b"#ffd8b1")),
-        "milk chocolate" => Some(Rgba8::from_hex(b"#7f4e1e")),
-        "ocher" => Some(Rgba8::from_hex(b"#bf9b0c")),
-        "off green" => Some(Rgba8::from_hex(b"#6ba353")),
-        "purply pink" => Some(Rgba8::from_hex(b"#f075e6")),
-        "lightblue" => Some(Rgba8::from_hex(b"#7bc8f6")),
-        "dusky blue" => Some(Rgba8::from_hex(b"#475f94")),
-        "golden" => Some(Rgba8::from_hex(b"#f5bf03")),
-        "light beige" => Some(Rgba8::from_hex(b"#fffeb6")),
-        "butter yellow" => Some(Rgba8::from_hex(b"#fffd74")),
-        "dusky purple" => Some(Rgba8::from_hex(b"#895b7b")),
-        "french blue" => Some(Rgba8::from_hex(b"#436bad")),
-        "ugly yellow" => Some(Rgba8::from_hex(b"#d0c101")),
-        "greeny yellow" => Some(Rgba8::from_hex(b"#c6f808")),
-        "orangish red" => Some(Rgba8::from_hex(b"#f43605")),
-        "shamrock green" => Some(Rgba8::from_hex(b"#02c14d")),
-        "orangish brown" => Some(Rgba8::from_hex(b"#b25f03")),
-        "tree green" => Some(Rgba8::from_hex(b"#2a7e19")),
-        "deep violet" => Some(Rgba8::from_hex(b"#490648")),
-        "gunmetal" => Some(Rgba8::from_hex(b"#536267")),
-        "blue/purple" => Some(Rgba8::from_hex(b"#5a06ef")),
-        "cherry" => Some(Rgba8::from_hex(b"#cf0234")),
-        "sandy brown" => Some(Rgba8::from_hex(b"#c4a661")),
-        "warm grey" => Some(Rgba8::from_hex(b"#978a84")),
-        "dark indigo" => Some(Rgba8::from_hex(b"#1f0954")),
-        "midnight" => Some(Rgba8::from_hex(b"#03012d")),
-        "bluey green" => Some(Rgba8::from_hex(b"#2bb179")),
-        "grey pink" => Some(Rgba8::from_hex(b"#c3909b")),
-        "soft purple" => Some(Rgba8::from_hex(b"#a66fb5")),
-        "blood" => Some(Rgba8::from_hex(b"#770001")),
-        "brown red" => Some(Rgba8::from_hex(b"#922b05")),
-        "medium grey" => Some(Rgba8::from_hex(b"#7d7f7c")),
-        "berry" => Some(Rgba8::from_hex(b"#990f4b")),
-        "poo" => Some(Rgba8::from_hex(b"#8f7303")),
-        "purpley pink" => Some(Rgba8::from_hex(b"#c83cb9")),
-        "light salmon" => Some(Rgba8::from_hex(b"#fea993")),
-        "snot" => Some(Rgba8::from_hex(b"#acbb0d")),
-        "easter purple" => Some(Rgba8::from_hex(b"#c071fe")),
-        "light yellow green" => Some(Rgba8::from_hex(b"#ccfd7f")),
-        "dark navy blue" => Some(Rgba8::from_hex(b"#00022e")),
-        "drab" => Some(Rgba8::from_hex(b"#828344")),
-        "light rose" => Some(Rgba8::from_hex(b"#ffc5cb")),
-        "rouge" => Some(Rgba8::from_hex(b"#ab1239")),
-        "purplish red" => Some(Rgba8::from_hex(b"#b0054b")),
-        "slime green" => Some(Rgba8::from_hex(b"#99cc04")),
-        "baby poop" => Some(Rgba8::from_hex(b"#937c00")),
-        "irish green" => Some(Rgba8::from_hex(b"#019529")),
-        "pink/purple" => Some(Rgba8::from_hex(b"#ef1de7")),
-        "dark navy" => Some(Rgba8::from_hex(b"#000435")),
-        "greeny blue" => Some(Rgba8::from_hex(b"#42b395")),
-        "light plum" => Some(Rgba8::from_hex(b"#9d5783")),
-        "pinkish grey" => Some(Rgba8::from_hex(b"#c8aca9")),
-        "dirty orange" => Some(Rgba8::from_hex(b"#c87606")),
-        "rust red" => Some(Rgba8::from_hex(b"#aa2704")),
-        "pale lilac" => Some(Rgba8::from_hex(b"#e4cbff")),
-        "orangey red" => Some(Rgba8::from_hex(b"#fa4224")),
-        "primary blue" => Some(Rgba8::from_hex(b"#0804f9")),
-        "kermit green" => Some(Rgba8::from_hex(b"#5cb200")),
-        "brownish purple" => Some(Rgba8::from_hex(b"#76424e")),
-        "murky green" => Some(Rgba8::from_hex(b"#6c7a0e")),
-        "wheat" => Some(Rgba8::from_hex(b"#fbdd7e")),
-        "very dark purple" => Some(Rgba8::from_hex(b"#2a0134")),
-        "bottle green" => Some(Rgba8::from_hex(b"#044a05")),
-        "watermelon" => Some(Rgba8::from_hex(b"#fd4659")),
-        "deep sky blue" => Some(Rgba8::from_hex(b"#0d75f8")),
-        "fire engine red" => Some(Rgba8::from_hex(b"#fe0002")),
-        "yellow ochre" => Some(Rgba8::from_hex(b"#cb9d06")),
-        "pumpkin orange" => Some(Rgba8::from_hex(b"#fb7d07")),
-        "pale olive" => Some(Rgba8::from_hex(b"#b9cc81")),
-        "light lilac" => Some(Rgba8::from_hex(b"#edc8ff")),
-        "lightish green" => Some(Rgba8::from_hex(b"#61e160")),
-        "carolina blue" => Some(Rgba8::from_hex(b"#8ab8fe")),
-        "mulberry" => Some(Rgba8::from_hex(b"#920a4e")),
-        "shocking pink" => Some(Rgba8::from_hex(b"#fe02a2")),
-        "auburn" => Some(Rgba8::from_hex(b"#9a3001")),
-        "bright lime green" => Some(Rgba8::from_hex(b"#65fe08")),
-        "celadon" => Some(Rgba8::from_hex(b"#befdb7")),
-        "pinkish brown" => Some(Rgba8::from_hex(b"#b17261")),
-        "poo brown" => Some(Rgba8::from_hex(b"#885f01")),
-        "bright sky blue" => Some(Rgba8::from_hex(b"#02ccfe")),
-        "celery" => Some(Rgba8::from_hex(b"#c1fd95")),
-        "dirt brown" => Some(Rgba8::from_hex(b"#836539")),
-        "strawberry" => Some(Rgba8::from_hex(b"#fb2943")),
-        "dark lime" => Some(Rgba8::from_hex(b"#84b701")),
-        "copper" => Some(Rgba8::from_hex(b"#b66325")),
-        "medium brown" => Some(Rgba8::from_hex(b"#7f5112")),
-        "muted green" => Some(Rgba8::from_hex(b"#5fa052")),
-        "robin's egg" => Some(Rgba8::from_hex(b"#6dedfd")),
-        "bright aqua" => Some(Rgba8::from_hex(b"#0bf9ea")),
-        "bright lavender" => Some(Rgba8::from_hex(b"#c760ff")),
-        "ivory" => Some(Rgba8::from_hex(b"#ffffcb")),
-        "very light purple" => Some(Rgba8::from_hex(b"#f6cefc")),
-        "light navy" => Some(Rgba8::from_hex(b"#155084")),
-        "pink red" => Some(Rgba8::from_hex(b"#f5054f")),
-        "olive brown" => Some(Rgba8::from_hex(b"#645403")),
-        "poop brown" => Some(Rgba8::from_hex(b"#7a5901")),
-        "mustard green" => Some(Rgba8::from_hex(b"#a8b504")),
-        "ocean green" => Some(Rgba8::from_hex(b"#3d9973")),
-        "very dark blue" => Some(Rgba8::from_hex(b"#000133")),
-        "dusty green" => Some(Rgba8::from_hex(b"#76a973")),
-        "light navy blue" => Some(Rgba8::from_hex(b"#2e5a88")),
-        "minty green" => Some(Rgba8::from_hex(b"#0bf77d")),
-        "adobe" => Some(Rgba8::from_hex(b"#bd6c48")),
-        "barney" => Some(Rgba8::from_hex(b"#ac1db8")),
-        "jade green" => Some(Rgba8::from_hex(b"#2baf6a")),
-        "bright light blue" => Some(Rgba8::from_hex(b"#26f7fd")),
-        "light lime" => Some(Rgba8::from_hex(b"#aefd6c")),
-        "dark khaki" => Some(Rgba8::from_hex(b"#9b8f55")),
-        "orange yellow" => Some(Rgba8::from_hex(b"#ffad01")),
-        "ocre" => Some(Rgba8::from_hex(b"#c69c04")),
-        "maize" => Some(Rgba8::from_hex(b"#f4d054")),
-        "faded pink" => Some(Rgba8::from_hex(b"#de9dac")),
-        "british racing green" => Some(Rgba8::from_hex(b"#05480d")),
-        "sandstone" => Some(Rgba8::from_hex(b"#c9ae74")),
-        "mud brown" => Some(Rgba8::from_hex(b"#60460f")),
-        "light sea green" => Some(Rgba8::from_hex(b"#98f6b0")),
-        "robin egg blue" => Some(Rgba8::from_hex(b"#8af1fe")),
-        "aqua marine" => Some(Rgba8::from_hex(b"#2ee8bb")),
-        "dark sea green" => Some(Rgba8::from_hex(b"#11875d")),
-        "soft pink" => Some(Rgba8::from_hex(b"#fdb0c0")),
-        "orangey brown" => Some(Rgba8::from_hex(b"#b16002")),
-        "cherry red" => Some(Rgba8::from_hex(b"#f7022a")),
-        "burnt yellow" => Some(Rgba8::from_hex(b"#d5ab09")),
-        "brownish grey" => Some(Rgba8::from_hex(b"#86775f")),
-        "camel" => Some(Rgba8::from_hex(b"#c69f59")),
-        "purplish grey" => Some(Rgba8::from_hex(b"#7a687f")),
-        "marine" => Some(Rgba8::from_hex(b"#042e60")),
-        "greyish pink" => Some(Rgba8::from_hex(b"#c88d94")),
-        "pale turquoise" => Some(Rgba8::from_hex(b"#a5fbd5")),
-        "pastel yellow" => Some(Rgba8::from_hex(b"#fffe71")),
-        "bluey purple" => Some(Rgba8::from_hex(b"#6241c7")),
-        "canary yellow" => Some(Rgba8::from_hex(b"#fffe40")),
-        "faded red" => Some(Rgba8::from_hex(b"#d3494e")),
-        "sepia" => Some(Rgba8::from_hex(b"#985e2b")),
-        "coffee" => Some(Rgba8::from_hex(b"#a6814c")),
-        "bright magenta" => Some(Rgba8::from_hex(b"#ff08e8")),
-        "mocha" => Some(Rgba8::from_hex(b"#9d7651")),
-        "ecru" => Some(Rgba8::from_hex(b"#feffca")),
-        "purpleish" => Some(Rgba8::from_hex(b"#98568d")),
-        "cranberry" => Some(Rgba8::from_hex(b"#9e003a")),
-        "darkish green" => Some(Rgba8::from_hex(b"#287c37")),
-        "brown orange" => Some(Rgba8::from_hex(b"#b96902")),
-        "dusky rose" => Some(Rgba8::from_hex(b"#ba6873")),
-        "melon" => Some(Rgba8::from_hex(b"#ff7855")),
-        "sickly green" => Some(Rgba8::from_hex(b"#94b21c")),
-        "silver" => Some(Rgba8::from_hex(b"#c5c9c7")),
-        "purply blue" => Some(Rgba8::from_hex(b"#661aee")),
-        "purpleish blue" => Some(Rgba8::from_hex(b"#6140ef")),
-        "hospital green" => Some(Rgba8::from_hex(b"#9be5aa")),
-        "shit brown" => Some(Rgba8::from_hex(b"#7b5804")),
-        "mid blue" => Some(Rgba8::from_hex(b"#276ab3")),
-        "amber" => Some(Rgba8::from_hex(b"#feb308")),
-        "easter green" => Some(Rgba8::from_hex(b"#8cfd7e")),
-        "soft blue" => Some(Rgba8::from_hex(b"#6488ea")),
-        "cerulean blue" => Some(Rgba8::from_hex(b"#056eee")),
-        "golden brown" => Some(Rgba8::from_hex(b"#b27a01")),
-        "bright turquoise" => Some(Rgba8::from_hex(b"#0ffef9")),
-        "red pink" => Some(Rgba8::from_hex(b"#fa2a55")),
-        "red purple" => Some(Rgba8::from_hex(b"#820747")),
-        "greyish brown" => Some(Rgba8::from_hex(b"#7a6a4f")),
-        "vermillion" => Some(Rgba8::from_hex(b"#f4320c")),
-        "russet" => Some(Rgba8::from_hex(b"#a13905")),
-        "steel grey" => Some(Rgba8::from_hex(b"#6f828a")),
-        "lighter purple" => Some(Rgba8::from_hex(b"#a55af4")),
-        "bright violet" => Some(Rgba8::from_hex(b"#ad0afd")),
-        "prussian blue" => Some(Rgba8::from_hex(b"#004577")),
-        "slate green" => Some(Rgba8::from_hex(b"#658d6d")),
-        "dirty pink" => Some(Rgba8::from_hex(b"#ca7b80")),
-        "dark blue green" => Some(Rgba8::from_hex(b"#005249")),
-        "pine" => Some(Rgba8::from_hex(b"#2b5d34")),
-        "yellowy green" => Some(Rgba8::from_hex(b"#bff128")),
-        "dark gold" => Some(Rgba8::from_hex(b"#b59410")),
-        "bluish" => Some(Rgba8::from_hex(b"#2976bb")),
-        "darkish blue" => Some(Rgba8::from_hex(b"#014182")),
-        "dull red" => Some(Rgba8::from_hex(b"#bb3f3f")),
-        "pinky red" => Some(Rgba8::from_hex(b"#fc2647")),
-        "bronze" => Some(Rgba8::from_hex(b"#a87900")),
-        "pale teal" => Some(Rgba8::from_hex(b"#82cbb2")),
-        "military green" => Some(Rgba8::from_hex(b"#667c3e")),
-        "barbie pink" => Some(Rgba8::from_hex(b"#fe46a5")),
-        "bubblegum pink" => Some(Rgba8::from_hex(b"#fe83cc")),
-        "pea soup green" => Some(Rgba8::from_hex(b"#94a617")),
-        "dark mustard" => Some(Rgba8::from_hex(b"#a88905")),
-        "shit" => Some(Rgba8::from_hex(b"#7f5f00")),
-        "medium purple" => Some(Rgba8::from_hex(b"#9e43a2")),
-        "very dark green" => Some(Rgba8::from_hex(b"#062e03")),
-        "dirt" => Some(Rgba8::from_hex(b"#8a6e45")),
-        "dusky pink" => Some(Rgba8::from_hex(b"#cc7a8b")),
-        "red violet" => Some(Rgba8::from_hex(b"#9e0168")),
-        "lemon yellow" => Some(Rgba8::from_hex(b"#fdff38")),
-        "pistachio" => Some(Rgba8::from_hex(b"#c0fa8b")),
-        "dull yellow" => Some(Rgba8::from_hex(b"#eedc5b")),
-        "dark lime green" => Some(Rgba8::from_hex(b"#7ebd01")),
-        "denim blue" => Some(Rgba8::from_hex(b"#3b5b92")),
-        "teal blue" => Some(Rgba8::from_hex(b"#01889f")),
-        "lightish blue" => Some(Rgba8::from_hex(b"#3d7afd")),
-        "purpley blue" => Some(Rgba8::from_hex(b"#5f34e7")),
-        "light indigo" => Some(Rgba8::from_hex(b"#6d5acf")),
-        "swamp green" => Some(Rgba8::from_hex(b"#748500")),
-        "brown green" => Some(Rgba8::from_hex(b"#706c11")),
-        "dark maroon" => Some(Rgba8::from_hex(b"#3c0008")),
-        "hot purple" => Some(Rgba8::from_hex(b"#cb00f5")),
-        "dark forest green" => Some(Rgba8::from_hex(b"#002d04")),
-        "faded blue" => Some(Rgba8::from_hex(b"#658cbb")),
-        "drab green" => Some(Rgba8::from_hex(b"#749551")),
-        "light lime green" => Some(Rgba8::from_hex(b"#b9ff66")),
-        "snot green" => Some(Rgba8::from_hex(b"#9dc100")),
-        "yellowish" => Some(Rgba8::from_hex(b"#faee66")),
-        "light blue green" => Some(Rgba8::from_hex(b"#7efbb3")),
-        "bordeaux" => Some(Rgba8::from_hex(b"#7b002c")),
-        "light mauve" => Some(Rgba8::from_hex(b"#c292a1")),
-        "ocean" => Some(Rgba8::from_hex(b"#017b92")),
-        "marigold" => Some(Rgba8::from_hex(b"#fcc006")),
-        "muddy green" => Some(Rgba8::from_hex(b"#657432")),
-        "dull orange" => Some(Rgba8::from_hex(b"#d8863b")),
-        "steel" => Some(Rgba8::from_hex(b"#738595")),
-        "electric purple" => Some(Rgba8::from_hex(b"#aa23ff")),
-        "fluorescent green" => Some(Rgba8::from_hex(b"#08ff08")),
-        "yellowish brown" => Some(Rgba8::from_hex(b"#9b7a01")),
-        "blush" => Some(Rgba8::from_hex(b"#f29e8e")),
-        "soft green" => Some(Rgba8::from_hex(b"#6fc276")),
-        "bright orange" => Some(Rgba8::from_hex(b"#ff5b00")),
-        "lemon" => Some(Rgba8::from_hex(b"#fdff52")),
-        "purple grey" => Some(Rgba8::from_hex(b"#866f85")),
-        "acid green" => Some(Rgba8::from_hex(b"#8ffe09")),
-        "pale lavender" => Some(Rgba8::from_hex(b"#eecffe")),
-        "violet blue" => Some(Rgba8::from_hex(b"#510ac9")),
-        "light forest green" => Some(Rgba8::from_hex(b"#4f9153")),
-        "burnt red" => Some(Rgba8::from_hex(b"#9f2305")),
-        "khaki green" => Some(Rgba8::from_hex(b"#728639")),
-        "cerise" => Some(Rgba8::from_hex(b"#de0c62")),
-        "faded purple" => Some(Rgba8::from_hex(b"#916e99")),
-        "apricot" => Some(Rgba8::from_hex(b"#ffb16d")),
-        "dark olive green" => Some(Rgba8::from_hex(b"#3c4d03")),
-        "grey brown" => Some(Rgba8::from_hex(b"#7f7053")),
-        "green grey" => Some(Rgba8::from_hex(b"#77926f")),
-        "true blue" => Some(Rgba8::from_hex(b"#010fcc")),
-        "pale violet" => Some(Rgba8::from_hex(b"#ceaefa")),
-        "periwinkle blue" => Some(Rgba8::from_hex(b"#8f99fb")),
-        "light sky blue" => Some(Rgba8::from_hex(b"#c6fcff")),
-        "blurple" => Some(Rgba8::from_hex(b"#5539cc")),
-        "green brown" => Some(Rgba8::from_hex(b"#544e03")),
-        "bluegreen" => Some(Rgba8::from_hex(b"#017a79")),
-        "bright teal" => Some(Rgba8::from_hex(b"#01f9c6")),
-        "brownish yellow" => Some(Rgba8::from_hex(b"#c9b003")),
-        "pea soup" => Some(Rgba8::from_hex(b"#929901")),
-        "forest" => Some(Rgba8::from_hex(b"#0b5509")),
-        "barney purple" => Some(Rgba8::from_hex(b"#a00498")),
-        "ultramarine" => Some(Rgba8::from_hex(b"#2000b1")),
-        "purplish" => Some(Rgba8::from_hex(b"#94568c")),
-        "puke yellow" => Some(Rgba8::from_hex(b"#c2be0e")),
-        "bluish grey" => Some(Rgba8::from_hex(b"#748b97")),
-        "dark periwinkle" => Some(Rgba8::from_hex(b"#665fd1")),
-        "dark lilac" => Some(Rgba8::from_hex(b"#9c6da5")),
-        "reddish" => Some(Rgba8::from_hex(b"#c44240")),
-        "light maroon" => Some(Rgba8::from_hex(b"#a24857")),
-        "dusty purple" => Some(Rgba8::from_hex(b"#825f87")),
-        "terra cotta" => Some(Rgba8::from_hex(b"#c9643b")),
-        "avocado" => Some(Rgba8::from_hex(b"#90b134")),
-        "marine blue" => Some(Rgba8::from_hex(b"#01386a")),
-        "teal green" => Some(Rgba8::from_hex(b"#25a36f")),
-        "slate grey" => Some(Rgba8::from_hex(b"#59656d")),
-        "lighter green" => Some(Rgba8::from_hex(b"#75fd63")),
-        "electric green" => Some(Rgba8::from_hex(b"#21fc0d")),
-        "dusty blue" => Some(Rgba8::from_hex(b"#5a86ad")),
-        "golden yellow" => Some(Rgba8::from_hex(b"#fec615")),
-        "bright yellow" => Some(Rgba8::from_hex(b"#fffd01")),
-        "light lavender" => Some(Rgba8::from_hex(b"#dfc5fe")),
-        "umber" => Some(Rgba8::from_hex(b"#b26400")),
-        "poop" => Some(Rgba8::from_hex(b"#7f5e00")),
-        "dark peach" => Some(Rgba8::from_hex(b"#de7e5d")),
-        "jungle green" => Some(Rgba8::from_hex(b"#048243")),
-        "eggshell" => Some(Rgba8::from_hex(b"#ffffd4")),
-        "denim" => Some(Rgba8::from_hex(b"#3b638c")),
-        "yellow brown" => Some(Rgba8::from_hex(b"#b79400")),
-        "dull purple" => Some(Rgba8::from_hex(b"#84597e")),
-        "chocolate brown" => Some(Rgba8::from_hex(b"#411900")),
-        "wine red" => Some(Rgba8::from_hex(b"#7b0323")),
-        "neon blue" => Some(Rgba8::from_hex(b"#04d9ff")),
-        "dirty green" => Some(Rgba8::from_hex(b"#667e2c")),
-        "light tan" => Some(Rgba8::from_hex(b"#fbeeac")),
-        "ice blue" => Some(Rgba8::from_hex(b"#d7fffe")),
-        "cadet blue" => Some(Rgba8::from_hex(b"#4e7496")),
-        "dark mauve" => Some(Rgba8::from_hex(b"#874c62")),
-        "very light blue" => Some(Rgba8::from_hex(b"#d5ffff")),
-        "grey purple" => Some(Rgba8::from_hex(b"#826d8c")),
-        "pastel pink" => Some(Rgba8::from_hex(b"#ffbacd")),
-        "very light green" => Some(Rgba8::from_hex(b"#d1ffbd")),
-        "dark sky blue" => Some(Rgba8::from_hex(b"#448ee4")),
-        "evergreen" => Some(Rgba8::from_hex(b"#05472a")),
-        "dull pink" => Some(Rgba8::from_hex(b"#d5869d")),
-        "aubergine" => Some(Rgba8::from_hex(b"#3d0734")),
-        "mahogany" => Some(Rgba8::from_hex(b"#4a0100")),
-        "reddish orange" => Some(Rgba8::from_hex(b"#f8481c")),
-        "deep green" => Some(Rgba8::from_hex(b"#02590f")),
-        "vomit green" => Some(Rgba8::from_hex(b"#89a203")),
-        "purple pink" => Some(Rgba8::from_hex(b"#e03fd8")),
-        "dusty pink" => Some(Rgba8::from_hex(b"#d58a94")),
-        "faded green" => Some(Rgba8::from_hex(b"#7bb274")),
-        "camo green" => Some(Rgba8::from_hex(b"#526525")),
-        "pinky purple" => Some(Rgba8::from_hex(b"#c94cbe")),
-        "pink purple" => Some(Rgba8::from_hex(b"#db4bda")),
-        "brownish red" => Some(Rgba8::from_hex(b"#9e3623")),
-        "dark rose" => Some(Rgba8::from_hex(b"#b5485d")),
-        "mud" => Some(Rgba8::from_hex(b"#735c12")),
-        "brownish" => Some(Rgba8::from_hex(b"#9c6d57")),
-        "emerald green" => Some(Rgba8::from_hex(b"#028f1e")),
-        "pale brown" => Some(Rgba8::from_hex(b"#b1916e")),
-        "dull blue" => Some(Rgba8::from_hex(b"#49759c")),
-        "burnt umber" => Some(Rgba8::from_hex(b"#a0450e")),
-        "medium green" => Some(Rgba8::from_hex(b"#39ad48")),
-        "clay" => Some(Rgba8::from_hex(b"#b66a50")),
-        "light aqua" => Some(Rgba8::from_hex(b"#8cffdb")),
-        "light olive green" => Some(Rgba8::from_hex(b"#a4be5c")),
-        "brownish orange" => Some(Rgba8::from_hex(b"#cb7723")),
-        "dark aqua" => Some(Rgba8::from_hex(b"#05696b")),
-        "purplish pink" => Some(Rgba8::from_hex(b"#ce5dae")),
-        "dark salmon" => Some(Rgba8::from_hex(b"#c85a53")),
-        "greenish grey" => Some(Rgba8::from_hex(b"#96ae8d")),
-        "jade" => Some(Rgba8::from_hex(b"#1fa774")),
-        "ugly green" => Some(Rgba8::from_hex(b"#7a9703")),
-        "dark beige" => Some(Rgba8::from_hex(b"#ac9362")),
-        "emerald" => Some(Rgba8::from_hex(b"#01a049")),
-        "pale red" => Some(Rgba8::from_hex(b"#d9544d")),
-        "light magenta" => Some(Rgba8::from_hex(b"#fa5ff7")),
-        "sky" => Some(Rgba8::from_hex(b"#82cafc")),
-        "light cyan" => Some(Rgba8::from_hex(b"#acfffc")),
-        "yellow orange" => Some(Rgba8::from_hex(b"#fcb001")),
-        "reddish purple" => Some(Rgba8::from_hex(b"#910951")),
-        "reddish pink" => Some(Rgba8::from_hex(b"#fe2c54")),
-        "orchid" => Some(Rgba8::from_hex(b"#c875c4")),
-        "dirty yellow" => Some(Rgba8::from_hex(b"#cdc50a")),
-        "orange red" => Some(Rgba8::from_hex(b"#fd411e")),
-        "deep red" => Some(Rgba8::from_hex(b"#9a0200")),
-        "orange brown" => Some(Rgba8::from_hex(b"#be6400")),
-        "cobalt blue" => Some(Rgba8::from_hex(b"#030aa7")),
-        "neon pink" => Some(Rgba8::from_hex(b"#fe019a")),
-        "rose pink" => Some(Rgba8::from_hex(b"#f7879a")),
-        "greyish purple" => Some(Rgba8::from_hex(b"#887191")),
-        "raspberry" => Some(Rgba8::from_hex(b"#b00149")),
-        "aqua green" => Some(Rgba8::from_hex(b"#12e193")),
-        "salmon pink" => Some(Rgba8::from_hex(b"#fe7b7c")),
-        "tangerine" => Some(Rgba8::from_hex(b"#ff9408")),
-        "brownish green" => Some(Rgba8::from_hex(b"#6a6e09")),
-        "red brown" => Some(Rgba8::from_hex(b"#8b2e16")),
-        "greenish brown" => Some(Rgba8::from_hex(b"#696112")),
-        "pumpkin" => Some(Rgba8::from_hex(b"#e17701")),
-        "pine green" => Some(Rgba8::from_hex(b"#0a481e")),
-        "charcoal" => Some(Rgba8::from_hex(b"#343837")),
-        "baby pink" => Some(Rgba8::from_hex(b"#ffb7ce")),
-        "cornflower" => Some(Rgba8::from_hex(b"#6a79f7")),
-        "blue violet" => Some(Rgba8::from_hex(b"#5d06e9")),
-        "chocolate" => Some(Rgba8::from_hex(b"#3d1c02")),
-        "greyish green" => Some(Rgba8::from_hex(b"#82a67d")),
-        "scarlet" => Some(Rgba8::from_hex(b"#be0119")),
-        "green yellow" => Some(Rgba8::from_hex(b"#c9ff27")),
-        "dark olive" => Some(Rgba8::from_hex(b"#373e02")),
-        "sienna" => Some(Rgba8::from_hex(b"#a9561e")),
-        "pastel purple" => Some(Rgba8::from_hex(b"#caa0ff")),
-        "terracotta" => Some(Rgba8::from_hex(b"#ca6641")),
-        "aqua blue" => Some(Rgba8::from_hex(b"#02d8e9")),
-        "sage green" => Some(Rgba8::from_hex(b"#88b378")),
-        "blood red" => Some(Rgba8::from_hex(b"#980002")),
-        "deep pink" => Some(Rgba8::from_hex(b"#cb0162")),
-        "grass" => Some(Rgba8::from_hex(b"#5cac2d")),
-        "moss" => Some(Rgba8::from_hex(b"#769958")),
-        "pastel blue" => Some(Rgba8::from_hex(b"#a2bffe")),
-        "bluish green" => Some(Rgba8::from_hex(b"#10a674")),
-        "green blue" => Some(Rgba8::from_hex(b"#06b48b")),
-        "dark tan" => Some(Rgba8::from_hex(b"#af884a")),
-        "greenish blue" => Some(Rgba8::from_hex(b"#0b8b87")),
-        "pale orange" => Some(Rgba8::from_hex(b"#ffa756")),
-        "vomit" => Some(Rgba8::from_hex(b"#a2a415")),
-        "forrest green" => Some(Rgba8::from_hex(b"#154406")),
-        "dark lavender" => Some(Rgba8::from_hex(b"#856798")),
-        "dark violet" => Some(Rgba8::from_hex(b"#34013f")),
-        "purple blue" => Some(Rgba8::from_hex(b"#632de9")),
-        "dark cyan" => Some(Rgba8::from_hex(b"#0a888a")),
-        "olive drab" => Some(Rgba8::from_hex(b"#6f7632")),
-        "pinkish" => Some(Rgba8::from_hex(b"#d46a7e")),
-        "cobalt" => Some(Rgba8::from_hex(b"#1e488f")),
-        "neon purple" => Some(Rgba8::from_hex(b"#bc13fe")),
-        "light turquoise" => Some(Rgba8::from_hex(b"#7ef4cc")),
-        "apple green" => Some(Rgba8::from_hex(b"#76cd26")),
-        "dull green" => Some(Rgba8::from_hex(b"#74a662")),
-        "wine" => Some(Rgba8::from_hex(b"#80013f")),
-        "powder blue" => Some(Rgba8::from_hex(b"#b1d1fc")),
-        "off white" => Some(Rgba8::from_hex(b"#ffffe4")),
-        "electric blue" => Some(Rgba8::from_hex(b"#0652ff")),
-        "dark turquoise" => Some(Rgba8::from_hex(b"#045c5a")),
-        "blue purple" => Some(Rgba8::from_hex(b"#5729ce")),
-        "azure" => Some(Rgba8::from_hex(b"#069af3")),
-        "bright red" => Some(Rgba8::from_hex(b"#ff000d")),
-        "pinkish red" => Some(Rgba8::from_hex(b"#f10c45")),
-        "cornflower blue" => Some(Rgba8::from_hex(b"#5170d7")),
-        "light olive" => Some(Rgba8::from_hex(b"#acbf69")),
-        "grape" => Some(Rgba8::from_hex(b"#6c3461")),
-        "greyish blue" => Some(Rgba8::from_hex(b"#5e819d")),
-        "purplish blue" => Some(Rgba8::from_hex(b"#601ef9")),
-        "yellowish green" => Some(Rgba8::from_hex(b"#b0dd16")),
-        "greenish yellow" => Some(Rgba8::from_hex(b"#cdfd02")),
-        "medium blue" => Some(Rgba8::from_hex(b"#2c6fbb")),
-        "dusty rose" => Some(Rgba8::from_hex(b"#c0737a")),
-        "light violet" => Some(Rgba8::from_hex(b"#d6b4fc")),
-        "midnight blue" => Some(Rgba8::from_hex(b"#020035")),
-        "bluish purple" => Some(Rgba8::from_hex(b"#703be7")),
-        "red orange" => Some(Rgba8::from_hex(b"#fd3c06")),
-        "dark magenta" => Some(Rgba8::from_hex(b"#960056")),
-        "greenish" => Some(Rgba8::from_hex(b"#40a368")),
-        "ocean blue" => Some(Rgba8::from_hex(b"#03719c")),
-        "coral" => Some(Rgba8::from_hex(b"#fc5a50")),
-        "cream" => Some(Rgba8::from_hex(b"#ffffc2")),
-        "reddish brown" => Some(Rgba8::from_hex(b"#7f2b0a")),
-        "burnt sienna" => Some(Rgba8::from_hex(b"#b04e0f")),
-        "brick" => Some(Rgba8::from_hex(b"#a03623")),
-        "sage" => Some(Rgba8::from_hex(b"#87ae73")),
-        "grey green" => Some(Rgba8::from_hex(b"#789b73")),
-        "white" => Some(Rgba8::from_hex(b"#ffffff")),
-        "robin's egg blue" => Some(Rgba8::from_hex(b"#98eff9")),
-        "moss green" => Some(Rgba8::from_hex(b"#658b38")),
-        "steel blue" => Some(Rgba8::from_hex(b"#5a7d9a")),
-        "eggplant" => Some(Rgba8::from_hex(b"#380835")),
-        "light yellow" => Some(Rgba8::from_hex(b"#fffe7a")),
-        "leaf green" => Some(Rgba8::from_hex(b"#5ca904")),
-        "light grey" => Some(Rgba8::from_hex(b"#d8dcd6")),
-        "puke" => Some(Rgba8::from_hex(b"#a5a502")),
-        "pinkish purple" => Some(Rgba8::from_hex(b"#d648d7")),
-        "sea blue" => Some(Rgba8::from_hex(b"#047495")),
-        "pale purple" => Some(Rgba8::from_hex(b"#b790d4")),
-        "slate blue" => Some(Rgba8::from_hex(b"#5b7c99")),
-        "blue grey" => Some(Rgba8::from_hex(b"#607c8e")),
-        "hunter green" => Some(Rgba8::from_hex(b"#0b4008")),
-        "fuchsia" => Some(Rgba8::from_hex(b"#ed0dd9")),
-        "crimson" => Some(Rgba8::from_hex(b"#8c000f")),
-        "pale yellow" => Some(Rgba8::from_hex(b"#ffff84")),
-        "ochre" => Some(Rgba8::from_hex(b"#bf9005")),
-        "mustard yellow" => Some(Rgba8::from_hex(b"#d2bd0a")),
-        "light red" => Some(Rgba8::from_hex(b"#ff474c")),
-        "cerulean" => Some(Rgba8::from_hex(b"#0485d1")),
-        "pale pink" => Some(Rgba8::from_hex(b"#ffcfdc")),
-        "deep blue" => Some(Rgba8::from_hex(b"#040273")),
-        "rust" => Some(Rgba8::from_hex(b"#a83c09")),
-        "light teal" => Some(Rgba8::from_hex(b"#90e4c1")),
-        "slate" => Some(Rgba8::from_hex(b"#516572")),
-        "goldenrod" => Some(Rgba8::from_hex(b"#fac205")),
-        "dark yellow" => Some(Rgba8::from_hex(b"#d5b60a")),
-        "dark grey" => Some(Rgba8::from_hex(b"#363737")),
-        "army green" => Some(Rgba8::from_hex(b"#4b5d16")),
-        "grey blue" => Some(Rgba8::from_hex(b"#6b8ba4")),
-        "seafoam" => Some(Rgba8::from_hex(b"#80f9ad")),
-        "puce" => Some(Rgba8::from_hex(b"#a57e52")),
-        "spring green" => Some(Rgba8::from_hex(b"#a9f971")),
-        "dark orange" => Some(Rgba8::from_hex(b"#c65102")),
-        "sand" => Some(Rgba8::from_hex(b"#e2ca76")),
-        "pastel green" => Some(Rgba8::from_hex(b"#b0ff9d")),
-        "mint" => Some(Rgba8::from_hex(b"#9ffeb0")),
-        "light orange" => Some(Rgba8::from_hex(b"#fdaa48")),
-        "bright pink" => Some(Rgba8::from_hex(b"#fe01b1")),
-        "chartreuse" => Some(Rgba8::from_hex(b"#c1f80a")),
-        "deep purple" => Some(Rgba8::from_hex(b"#36013f")),
-        "dark brown" => Some(Rgba8::from_hex(b"#341c02")),
-        "taupe" => Some(Rgba8::from_hex(b"#b9a281")),
-        "pea green" => Some(Rgba8::from_hex(b"#8eab12")),
-        "puke green" => Some(Rgba8::from_hex(b"#9aae07")),
-        "kelly green" => Some(Rgba8::from_hex(b"#02ab2e")),
-        "seafoam green" => Some(Rgba8::from_hex(b"#7af9ab")),
-        "blue green" => Some(Rgba8::from_hex(b"#137e6d")),
-        "khaki" => Some(Rgba8::from_hex(b"#aaa662")),
-        "burgundy" => Some(Rgba8::from_hex(b"#610023")),
-        "dark teal" => Some(Rgba8::from_hex(b"#014d4e")),
-        "brick red" => Some(Rgba8::from_hex(b"#8f1402")),
-        "royal purple" => Some(Rgba8::from_hex(b"#4b006e")),
-        "plum" => Some(Rgba8::from_hex(b"#580f41")),
-        "mint green" => Some(Rgba8::from_hex(b"#8fff9f")),
-        "gold" => Some(Rgba8::from_hex(b"#dbb40c")),
-        "baby blue" => Some(Rgba8::from_hex(b"#a2cffe")),
-        "yellow green" => Some(Rgba8::from_hex(b"#c0fb2d")),
-        "bright purple" => Some(Rgba8::from_hex(b"#be03fd")),
-        "dark red" => Some(Rgba8::from_hex(b"#840000")),
-        "pale blue" => Some(Rgba8::from_hex(b"#d0fefe")),
-        "grass green" => Some(Rgba8::from_hex(b"#3f9b0b")),
-        "navy" => Some(Rgba8::from_hex(b"#01153e")),
-        "aquamarine" => Some(Rgba8::from_hex(b"#04d8b2")),
-        "burnt orange" => Some(Rgba8::from_hex(b"#c04e01")),
-        "neon green" => Some(Rgba8::from_hex(b"#0cff0c")),
-        "bright blue" => Some(Rgba8::from_hex(b"#0165fc")),
-        "rose" => Some(Rgba8::from_hex(b"#cf6275")),
-        "light pink" => Some(Rgba8::from_hex(b"#ffd1df")),
-        "mustard" => Some(Rgba8::from_hex(b"#ceb301")),
-        "indigo" => Some(Rgba8::from_hex(b"#380282")),
-        "lime" => Some(Rgba8::from_hex(b"#aaff32")),
-        "sea green" => Some(Rgba8::from_hex(b"#53fca1")),
-        "periwinkle" => Some(Rgba8::from_hex(b"#8e82fe")),
-        "dark pink" => Some(Rgba8::from_hex(b"#cb416b")),
-        "olive green" => Some(Rgba8::from_hex(b"#677a04")),
-        "peach" => Some(Rgba8::from_hex(b"#ffb07c")),
-        "pale green" => Some(Rgba8::from_hex(b"#c7fdb5")),
-        "light brown" => Some(Rgba8::from_hex(b"#ad8150")),
-        "hot pink" => Some(Rgba8::from_hex(b"#ff028d")),
-        "black" => Some(Rgba8::from_hex(b"#000000")),
-        "lilac" => Some(Rgba8::from_hex(b"#cea2fd")),
-        "navy blue" => Some(Rgba8::from_hex(b"#001146")),
-        "royal blue" => Some(Rgba8::from_hex(b"#0504aa")),
-        "beige" => Some(Rgba8::from_hex(b"#e6daa6")),
-        "salmon" => Some(Rgba8::from_hex(b"#ff796c")),
-        "olive" => Some(Rgba8::from_hex(b"#6e750e")),
-        "maroon" => Some(Rgba8::from_hex(b"#650021")),
-        "bright green" => Some(Rgba8::from_hex(b"#01ff07")),
-        "dark purple" => Some(Rgba8::from_hex(b"#35063e")),
-        "mauve" => Some(Rgba8::from_hex(b"#ae7181")),
-        "forest green" => Some(Rgba8::from_hex(b"#06470c")),
-        "aqua" => Some(Rgba8::from_hex(b"#13eac9")),
-        "cyan" => Some(Rgba8::from_hex(b"#00ffff")),
-        "tan" => Some(Rgba8::from_hex(b"#d1b26f")),
-        "dark blue" => Some(Rgba8::from_hex(b"#00035b")),
-        "lavender" => Some(Rgba8::from_hex(b"#c79fef")),
-        "turquoise" => Some(Rgba8::from_hex(b"#06c2ac")),
-        "dark green" => Some(Rgba8::from_hex(b"#033500")),
-        "violet" => Some(Rgba8::from_hex(b"#9a0eea")),
-        "light purple" => Some(Rgba8::from_hex(b"#bf77f6")),
-        "lime green" => Some(Rgba8::from_hex(b"#89fe05")),
-        "grey" => Some(Rgba8::from_hex(b"#929591")),
-        "sky blue" => Some(Rgba8::from_hex(b"#75bbfd")),
-        "yellow" => Some(Rgba8::from_hex(b"#ffff14")),
-        "magenta" => Some(Rgba8::from_hex(b"#c20078")),
-        "light green" => Some(Rgba8::from_hex(b"#96f97b")),
-        "orange" => Some(Rgba8::from_hex(b"#f97306")),
-        "teal" => Some(Rgba8::from_hex(b"#029386")),
-        "light blue" => Some(Rgba8::from_hex(b"#95d0fc")),
-        "red" => Some(Rgba8::from_hex(b"#e50000")),
-        "brown" => Some(Rgba8::from_hex(b"#653700")),
-        "pink" => Some(Rgba8::from_hex(b"#ff81c0")),
-        "blue" => Some(Rgba8::from_hex(b"#0343df")),
-        "green" => Some(Rgba8::from_hex(b"#15b01a")),
-        "purple" => Some(Rgba8::from_hex(b"#7e1e9c")),
-        _ => None,
-    }
-}
+pub const COLORS: &[(&str, Rgba8)] = &[
+    ("cloudy blue", Rgba8::from_hex(b"#acc2d9")),
+    ("dark pastel green", Rgba8::from_hex(b"#56ae57")),
+    ("dust", Rgba8::from_hex(b"#b2996e")),
+    ("electric lime", Rgba8::from_hex(b"#a8ff04")),
+    ("fresh green", Rgba8::from_hex(b"#69d84f")),
+    ("light eggplant", Rgba8::from_hex(b"#894585")),
+    ("nasty green", Rgba8::from_hex(b"#70b23f")),
+    ("really light blue", Rgba8::from_hex(b"#d4ffff")),
+    ("tea", Rgba8::from_hex(b"#65ab7c")),
+    ("warm purple", Rgba8::from_hex(b"#952e8f")),
+    ("yellowish tan", Rgba8::from_hex(b"#fcfc81")),
+    ("cement", Rgba8::from_hex(b"#a5a391")),
+    ("dark grass green", Rgba8::from_hex(b"#388004")),
+    ("dusty teal", Rgba8::from_hex(b"#4c9085")),
+    ("grey teal", Rgba8::from_hex(b"#5e9b8a")),
+    ("macaroni and cheese", Rgba8::from_hex(b"#efb435")),
+    ("pinkish tan", Rgba8::from_hex(b"#d99b82")),
+    ("spruce", Rgba8::from_hex(b"#0a5f38")),
+    ("strong blue", Rgba8::from_hex(b"#0c06f7")),
+    ("toxic green", Rgba8::from_hex(b"#61de2a")),
+    ("windows blue", Rgba8::from_hex(b"#3778bf")),
+    ("blue blue", Rgba8::from_hex(b"#2242c7")),
+    ("blue with a hint of purple", Rgba8::from_hex(b"#533cc6")),
+    ("booger", Rgba8::from_hex(b"#9bb53c")),
+    ("bright sea green", Rgba8::from_hex(b"#05ffa6")),
+    ("dark green blue", Rgba8::from_hex(b"#1f6357")),
+    ("deep turquoise", Rgba8::from_hex(b"#017374")),
+    ("green teal", Rgba8::from_hex(b"#0cb577")),
+    ("strong pink", Rgba8::from_hex(b"#ff0789")),
+    ("bland", Rgba8::from_hex(b"#afa88b")),
+    ("deep aqua", Rgba8::from_hex(b"#08787f")),
+    ("lavender pink", Rgba8::from_hex(b"#dd85d7")),
+    ("light moss green", Rgba8::from_hex(b"#a6c875")),
+    ("light seafoam green", Rgba8::from_hex(b"#a7ffb5")),
+    ("olive yellow", Rgba8::from_hex(b"#c2b709")),
+    ("pig pink", Rgba8::from_hex(b"#e78ea5")),
+    ("deep lilac", Rgba8::from_hex(b"#966ebd")),
+    ("desert", Rgba8::from_hex(b"#ccad60")),
+    ("dusty lavender", Rgba8::from_hex(b"#ac86a8")),
+    ("purpley grey", Rgba8::from_hex(b"#947e94")),
+    ("purply", Rgba8::from_hex(b"#983fb2")),
+    ("candy pink", Rgba8::from_hex(b"#ff63e9")),
+    ("light pastel green", Rgba8::from_hex(b"#b2fba5")),
+    ("boring green", Rgba8::from_hex(b"#63b365")),
+    ("kiwi green", Rgba8::from_hex(b"#8ee53f")),
+    ("light grey green", Rgba8::from_hex(b"#b7e1a1")),
+    ("orange pink", Rgba8::from_hex(b"#ff6f52")),
+    ("tea green", Rgba8::from_hex(b"#bdf8a3")),
+    ("very light brown", Rgba8::from_hex(b"#d3b683")),
+    ("egg shell", Rgba8::from_hex(b"#fffcc4")),
+    ("eggplant purple", Rgba8::from_hex(b"#430541")),
+    ("powder pink", Rgba8::from_hex(b"#ffb2d0")),
+    ("reddish grey", Rgba8::from_hex(b"#997570")),
+    ("baby shit brown", Rgba8::from_hex(b"#ad900d")),
+    ("liliac", Rgba8::from_hex(b"#c48efd")),
+    ("stormy blue", Rgba8::from_hex(b"#507b9c")),
+    ("ugly brown", Rgba8::from_hex(b"#7d7103")),
+    ("custard", Rgba8::from_hex(b"#fffd78")),
+    ("darkish pink", Rgba8::from_hex(b"#da467d")),
+    ("deep brown", Rgba8::from_hex(b"#410200")),
+    ("greenish beige", Rgba8::from_hex(b"#c9d179")),
+    ("manilla", Rgba8::from_hex(b"#fffa86")),
+    ("off blue", Rgba8::from_hex(b"#5684ae")),
+    ("battleship grey", Rgba8::from_hex(b"#6b7c85")),
+    ("browny green", Rgba8::from_hex(b"#6f6c0a")),
+    ("bruise", Rgba8::from_hex(b"#7e4071")),
+    ("kelley green", Rgba8::from_hex(b"#009337")),
+    ("sickly yellow", Rgba8::from_hex(b"#d0e429")),
+    ("sunny yellow", Rgba8::from_hex(b"#fff917")),
+    ("azul", Rgba8::from_hex(b"#1d5dec")),
+    ("green/yellow", Rgba8::from_hex(b"#b5ce08")),
+    ("lichen", Rgba8::from_hex(b"#8fb67b")),
+    ("light light green", Rgba8::from_hex(b"#c8ffb0")),
+    ("pale gold", Rgba8::from_hex(b"#fdde6c")),
+    ("sun yellow", Rgba8::from_hex(b"#ffdf22")),
+    ("tan green", Rgba8::from_hex(b"#a9be70")),
+    ("burple", Rgba8::from_hex(b"#6832e3")),
+    ("butterscotch", Rgba8::from_hex(b"#fdb147")),
+    ("toupe", Rgba8::from_hex(b"#c7ac7d")),
+    ("dark cream", Rgba8::from_hex(b"#fff39a")),
+    ("indian red", Rgba8::from_hex(b"#850e04")),
+    ("light lavendar", Rgba8::from_hex(b"#efc0fe")),
+    ("poison green", Rgba8::from_hex(b"#40fd14")),
+    ("baby puke green", Rgba8::from_hex(b"#b6c406")),
+    ("bright yellow green", Rgba8::from_hex(b"#9dff00")),
+    ("charcoal grey", Rgba8::from_hex(b"#3c4142")),
+    ("squash", Rgba8::from_hex(b"#f2ab15")),
+    ("cinnamon", Rgba8::from_hex(b"#ac4f06")),
+    ("light pea green", Rgba8::from_hex(b"#c4fe82")),
+    ("radioactive green", Rgba8::from_hex(b"#2cfa1f")),
+    ("raw sienna", Rgba8::from_hex(b"#9a6200")),
+    ("baby purple", Rgba8::from_hex(b"#ca9bf7")),
+    ("cocoa", Rgba8::from_hex(b"#875f42")),
+    ("light royal blue", Rgba8::from_hex(b"#3a2efe")),
+    ("orangeish", Rgba8::from_hex(b"#fd8d49")),
+    ("rust brown", Rgba8::from_hex(b"#8b3103")),
+    ("sand brown", Rgba8::from_hex(b"#cba560")),
+    ("swamp", Rgba8::from_hex(b"#698339")),
+    ("tealish green", Rgba8::from_hex(b"#0cdc73")),
+    ("burnt siena", Rgba8::from_hex(b"#b75203")),
+    ("camo", Rgba8::from_hex(b"#7f8f4e")),
+    ("dusk blue", Rgba8::from_hex(b"#26538d")),
+    ("fern", Rgba8::from_hex(b"#63a950")),
+    ("old rose", Rgba8::from_hex(b"#c87f89")),
+    ("pale light green", Rgba8::from_hex(b"#b1fc99")),
+    ("peachy pink", Rgba8::from_hex(b"#ff9a8a")),
+    ("rosy pink", Rgba8::from_hex(b"#f6688e")),
+    ("light bluish green", Rgba8::from_hex(b"#76fda8")),
+    ("light bright green", Rgba8::from_hex(b"#53fe5c")),
+    ("light neon green", Rgba8::from_hex(b"#4efd54")),
+    ("light seafoam", Rgba8::from_hex(b"#a0febf")),
+    ("tiffany blue", Rgba8::from_hex(b"#7bf2da")),
+    ("washed out green", Rgba8::from_hex(b"#bcf5a6")),
+    ("browny orange", Rgba8::from_hex(b"#ca6b02")),
+    ("nice blue", Rgba8::from_hex(b"#107ab0")),
+    ("sapphire", Rgba8::from_hex(b"#2138ab")),
+    ("greyish teal", Rgba8::from_hex(b"#719f91")),
+    ("orangey yellow", Rgba8::from_hex(b"#fdb915")),
+    ("parchment", Rgba8::from_hex(b"#fefcaf")),
+    ("straw", Rgba8::from_hex(b"#fcf679")),
+    ("very dark brown", Rgba8::from_hex(b"#1d0200")),
+    ("terracota", Rgba8::from_hex(b"#cb6843")),
+    ("ugly blue", Rgba8::from_hex(b"#31668a")),
+    ("clear blue", Rgba8::from_hex(b"#247afd")),
+    ("creme", Rgba8::from_hex(b"#ffffb6")),
+    ("foam green", Rgba8::from_hex(b"#90fda9")),
+    ("grey/green", Rgba8::from_hex(b"#86a17d")),
+    ("light gold", Rgba8::from_hex(b"#fddc5c")),
+    ("seafoam blue", Rgba8::from_hex(b"#78d1b6")),
+    ("topaz", Rgba8::from_hex(b"#13bbaf")),
+    ("violet pink", Rgba8::from_hex(b"#fb5ffc")),
+    ("wintergreen", Rgba8::from_hex(b"#20f986")),
+    ("yellow tan", Rgba8::from_hex(b"#ffe36e")),
+    ("dark fuchsia", Rgba8::from_hex(b"#9d0759")),
+    ("indigo blue", Rgba8::from_hex(b"#3a18b1")),
+    ("light yellowish green", Rgba8::from_hex(b"#c2ff89")),
+    ("pale magenta", Rgba8::from_hex(b"#d767ad")),
+    ("rich purple", Rgba8::from_hex(b"#720058")),
+    ("sunflower yellow", Rgba8::from_hex(b"#ffda03")),
+    ("green/blue", Rgba8::from_hex(b"#01c08d")),
+    ("leather", Rgba8::from_hex(b"#ac7434")),
+    ("racing green", Rgba8::from_hex(b"#014600")),
+    ("vivid purple", Rgba8::from_hex(b"#9900fa")),
+    ("dark royal blue", Rgba8::from_hex(b"#02066f")),
+    ("hazel", Rgba8::from_hex(b"#8e7618")),
+    ("muted pink", Rgba8::from_hex(b"#d1768f")),
+    ("booger green", Rgba8::from_hex(b"#96b403")),
+    ("canary", Rgba8::from_hex(b"#fdff63")),
+    ("cool grey", Rgba8::from_hex(b"#95a3a6")),
+    ("dark taupe", Rgba8::from_hex(b"#7f684e")),
+    ("darkish purple", Rgba8::from_hex(b"#751973")),
+    ("true green", Rgba8::from_hex(b"#089404")),
+    ("coral pink", Rgba8::from_hex(b"#ff6163")),
+    ("dark sage", Rgba8::from_hex(b"#598556")),
+    ("dark slate blue", Rgba8::from_hex(b"#214761")),
+    ("flat blue", Rgba8::from_hex(b"#3c73a8")),
+    ("mushroom", Rgba8::from_hex(b"#ba9e88")),
+    ("rich blue", Rgba8::from_hex(b"#021bf9")),
+    ("dirty purple", Rgba8::from_hex(b"#734a65")),
+    ("greenblue", Rgba8::from_hex(b"#23c48b")),
+    ("icky green", Rgba8::from_hex(b"#8fae22")),
+    ("light khaki", Rgba8::from_hex(b"#e6f2a2")),
+    ("warm blue", Rgba8::from_hex(b"#4b57db")),
+    ("dark hot pink", Rgba8::from_hex(b"#d90166")),
+    ("deep sea blue", Rgba8::from_hex(b"#015482")),
+    ("carmine", Rgba8::from_hex(b"#9d0216")),
+    ("dark yellow green", Rgba8::from_hex(b"#728f02")),
+    ("pale peach", Rgba8::from_hex(b"#ffe5ad")),
+    ("plum purple", Rgba8::from_hex(b"#4e0550")),
+    ("golden rod", Rgba8::from_hex(b"#f9bc08")),
+    ("neon red", Rgba8::from_hex(b"#ff073a")),
+    ("old pink", Rgba8::from_hex(b"#c77986")),
+    ("very pale blue", Rgba8::from_hex(b"#d6fffe")),
+    ("blood orange", Rgba8::from_hex(b"#fe4b03")),
+    ("grapefruit", Rgba8::from_hex(b"#fd5956")),
+    ("sand yellow", Rgba8::from_hex(b"#fce166")),
+    ("clay brown", Rgba8::from_hex(b"#b2713d")),
+    ("dark blue grey", Rgba8::from_hex(b"#1f3b4d")),
+    ("flat green", Rgba8::from_hex(b"#699d4c")),
+    ("light green blue", Rgba8::from_hex(b"#56fca2")),
+    ("warm pink", Rgba8::from_hex(b"#fb5581")),
+    ("dodger blue", Rgba8::from_hex(b"#3e82fc")),
+    ("gross green", Rgba8::from_hex(b"#a0bf16")),
+    ("ice", Rgba8::from_hex(b"#d6fffa")),
+    ("metallic blue", Rgba8::from_hex(b"#4f738e")),
+    ("pale salmon", Rgba8::from_hex(b"#ffb19a")),
+    ("sap green", Rgba8::from_hex(b"#5c8b15")),
+    ("algae", Rgba8::from_hex(b"#54ac68")),
+    ("bluey grey", Rgba8::from_hex(b"#89a0b0")),
+    ("greeny grey", Rgba8::from_hex(b"#7ea07a")),
+    ("highlighter green", Rgba8::from_hex(b"#1bfc06")),
+    ("light light blue", Rgba8::from_hex(b"#cafffb")),
+    ("light mint", Rgba8::from_hex(b"#b6ffbb")),
+    ("raw umber", Rgba8::from_hex(b"#a75e09")),
+    ("vivid blue", Rgba8::from_hex(b"#152eff")),
+    ("deep lavender", Rgba8::from_hex(b"#8d5eb7")),
+    ("dull teal", Rgba8::from_hex(b"#5f9e8f")),
+    ("light greenish blue", Rgba8::from_hex(b"#63f7b4")),
+    ("mud green", Rgba8::from_hex(b"#606602")),
+    ("pinky", Rgba8::from_hex(b"#fc86aa")),
+    ("red wine", Rgba8::from_hex(b"#8c0034")),
+    ("shit green", Rgba8::from_hex(b"#758000")),
+    ("tan brown", Rgba8::from_hex(b"#ab7e4c")),
+    ("rosa", Rgba8::from_hex(b"#fe86a4")),
+    ("lipstick", Rgba8::from_hex(b"#d5174e")),
+    ("pale mauve", Rgba8::from_hex(b"#fed0fc")),
+    ("claret", Rgba8::from_hex(b"#680018")),
+    ("dandelion", Rgba8::from_hex(b"#fedf08")),
+    ("poop green", Rgba8::from_hex(b"#6f7c00")),
+    ("ruby", Rgba8::from_hex(b"#ca0147")),
+    ("dark", Rgba8::from_hex(b"#1b2431")),
+    ("greenish turquoise", Rgba8::from_hex(b"#00fbb0")),
+    ("pastel red", Rgba8::from_hex(b"#db5856")),
+    ("piss yellow", Rgba8::from_hex(b"#ddd618")),
+    ("bright cyan", Rgba8::from_hex(b"#41fdfe")),
+    ("dark coral", Rgba8::from_hex(b"#cf524e")),
+    ("algae green", Rgba8::from_hex(b"#21c36f")),
+    ("darkish red", Rgba8::from_hex(b"#a90308")),
+    ("reddy brown", Rgba8::from_hex(b"#6e1005")),
+    ("blush pink", Rgba8::from_hex(b"#fe828c")),
+    ("camouflage green", Rgba8::from_hex(b"#4b6113")),
+    ("lawn green", Rgba8::from_hex(b"#4da409")),
+    ("putty", Rgba8::from_hex(b"#beae8a")),
+    ("vibrant blue", Rgba8::from_hex(b"#0339f8")),
+    ("dark sand", Rgba8::from_hex(b"#a88f59")),
+    ("purple/blue", Rgba8::from_hex(b"#5d21d0")),
+    ("saffron", Rgba8::from_hex(b"#feb209")),
+    ("twilight", Rgba8::from_hex(b"#4e518b")),
+    ("warm brown", Rgba8::from_hex(b"#964e02")),
+    ("bluegrey", Rgba8::from_hex(b"#85a3b2")),
+    ("bubble gum pink", Rgba8::from_hex(b"#ff69af")),
+    ("duck egg blue", Rgba8::from_hex(b"#c3fbf4")),
+    ("greenish cyan", Rgba8::from_hex(b"#2afeb7")),
+    ("petrol", Rgba8::from_hex(b"#005f6a")),
+    ("royal", Rgba8::from_hex(b"#0c1793")),
+    ("butter", Rgba8::from_hex(b"#ffff81")),
+    ("dusty orange", Rgba8::from_hex(b"#f0833a")),
+    ("off yellow", Rgba8::from_hex(b"#f1f33f")),
+    ("pale olive green", Rgba8::from_hex(b"#b1d27b")),
+    ("orangish", Rgba8::from_hex(b"#fc824a")),
+    ("leaf", Rgba8::from_hex(b"#71aa34")),
+    ("light blue grey", Rgba8::from_hex(b"#b7c9e2")),
+    ("dried blood", Rgba8::from_hex(b"#4b0101")),
+    ("lightish purple", Rgba8::from_hex(b"#a552e6")),
+    ("rusty red", Rgba8::from_hex(b"#af2f0d")),
+    ("lavender blue", Rgba8::from_hex(b"#8b88f8")),
+    ("light grass green", Rgba8::from_hex(b"#9af764")),
+    ("light mint green", Rgba8::from_hex(b"#a6fbb2")),
+    ("sunflower", Rgba8::from_hex(b"#ffc512")),
+    ("velvet", Rgba8::from_hex(b"#750851")),
+    ("brick orange", Rgba8::from_hex(b"#c14a09")),
+    ("lightish red", Rgba8::from_hex(b"#fe2f4a")),
+    ("pure blue", Rgba8::from_hex(b"#0203e2")),
+    ("twilight blue", Rgba8::from_hex(b"#0a437a")),
+    ("violet red", Rgba8::from_hex(b"#a50055")),
+    ("yellowy brown", Rgba8::from_hex(b"#ae8b0c")),
+    ("carnation", Rgba8::from_hex(b"#fd798f")),
+    ("muddy yellow", Rgba8::from_hex(b"#bfac05")),
+    ("dark seafoam green", Rgba8::from_hex(b"#3eaf76")),
+    ("deep rose", Rgba8::from_hex(b"#c74767")),
+    ("dusty red", Rgba8::from_hex(b"#b9484e")),
+    ("grey/blue", Rgba8::from_hex(b"#647d8e")),
+    ("lemon lime", Rgba8::from_hex(b"#bffe28")),
+    ("purple/pink", Rgba8::from_hex(b"#d725de")),
+    ("brown yellow", Rgba8::from_hex(b"#b29705")),
+    ("purple brown", Rgba8::from_hex(b"#673a3f")),
+    ("wisteria", Rgba8::from_hex(b"#a87dc2")),
+    ("banana yellow", Rgba8::from_hex(b"#fafe4b")),
+    ("lipstick red", Rgba8::from_hex(b"#c0022f")),
+    ("water blue", Rgba8::from_hex(b"#0e87cc")),
+    ("brown grey", Rgba8::from_hex(b"#8d8468")),
+    ("vibrant purple", Rgba8::from_hex(b"#ad03de")),
+    ("baby green", Rgba8::from_hex(b"#8cff9e")),
+    ("barf green", Rgba8::from_hex(b"#94ac02")),
+    ("eggshell blue", Rgba8::from_hex(b"#c4fff7")),
+    ("sandy yellow", Rgba8::from_hex(b"#fdee73")),
+    ("cool green", Rgba8::from_hex(b"#33b864")),
+    ("pale", Rgba8::from_hex(b"#fff9d0")),
+    ("blue/grey", Rgba8::from_hex(b"#758da3")),
+    ("hot magenta", Rgba8::from_hex(b"#f504c9")),
+    ("greyblue", Rgba8::from_hex(b"#77a1b5")),
+    ("purpley", Rgba8::from_hex(b"#8756e4")),
+    ("baby shit green", Rgba8::from_hex(b"#889717")),
+    ("brownish pink", Rgba8::from_hex(b"#c27e79")),
+    ("dark aquamarine", Rgba8::from_hex(b"#017371")),
+    ("diarrhea", Rgba8::from_hex(b"#9f8303")),
+    ("light mustard", Rgba8::from_hex(b"#f7d560")),
+    ("pale sky blue", Rgba8::from_hex(b"#bdf6fe")),
+    ("turtle green", Rgba8::from_hex(b"#75b84f")),
+    ("bright olive", Rgba8::from_hex(b"#9cbb04")),
+    ("dark grey blue", Rgba8::from_hex(b"#29465b")),
+    ("greeny brown", Rgba8::from_hex(b"#696006")),
+    ("lemon green", Rgba8::from_hex(b"#adf802")),
+    ("light periwinkle", Rgba8::from_hex(b"#c1c6fc")),
+    ("seaweed green", Rgba8::from_hex(b"#35ad6b")),
+    ("sunshine yellow", Rgba8::from_hex(b"#fffd37")),
+    ("ugly purple", Rgba8::from_hex(b"#a442a0")),
+    ("medium pink", Rgba8::from_hex(b"#f36196")),
+    ("puke brown", Rgba8::from_hex(b"#947706")),
+    ("very light pink", Rgba8::from_hex(b"#fff4f2")),
+    ("viridian", Rgba8::from_hex(b"#1e9167")),
+    ("bile", Rgba8::from_hex(b"#b5c306")),
+    ("faded yellow", Rgba8::from_hex(b"#feff7f")),
+    ("very pale green", Rgba8::from_hex(b"#cffdbc")),
+    ("vibrant green", Rgba8::from_hex(b"#0add08")),
+    ("bright lime", Rgba8::from_hex(b"#87fd05")),
+    ("spearmint", Rgba8::from_hex(b"#1ef876")),
+    ("light aquamarine", Rgba8::from_hex(b"#7bfdc7")),
+    ("light sage", Rgba8::from_hex(b"#bcecac")),
+    ("baby poo", Rgba8::from_hex(b"#ab9004")),
+    ("dark seafoam", Rgba8::from_hex(b"#1fb57a")),
+    ("deep teal", Rgba8::from_hex(b"#00555a")),
+    ("heather", Rgba8::from_hex(b"#a484ac")),
+    ("rust orange", Rgba8::from_hex(b"#c45508")),
+    ("dirty blue", Rgba8::from_hex(b"#3f829d")),
+    ("fern green", Rgba8::from_hex(b"#548d44")),
+    ("bright lilac", Rgba8::from_hex(b"#c95efb")),
+    ("weird green", Rgba8::from_hex(b"#3ae57f")),
+    ("peacock blue", Rgba8::from_hex(b"#016795")),
+    ("avocado green", Rgba8::from_hex(b"#87a922")),
+    ("faded orange", Rgba8::from_hex(b"#f0944d")),
+    ("grape purple", Rgba8::from_hex(b"#5d1451")),
+    ("hot green", Rgba8::from_hex(b"#25ff29")),
+    ("lime yellow", Rgba8::from_hex(b"#d0fe1d")),
+    ("mango", Rgba8::from_hex(b"#ffa62b")),
+    ("shamrock", Rgba8::from_hex(b"#01b44c")),
+    ("bubblegum", Rgba8::from_hex(b"#ff6cb5")),
+    ("purplish brown", Rgba8::from_hex(b"#6b4247")),
+    ("vomit yellow", Rgba8::from_hex(b"#c7c10c")),
+    ("pale cyan", Rgba8::from_hex(b"#b7fffa")),
+    ("key lime", Rgba8::from_hex(b"#aeff6e")),
+    ("tomato red", Rgba8::from_hex(b"#ec2d01")),
+    ("merlot", Rgba8::from_hex(b"#730039")),
+    ("night blue", Rgba8::from_hex(b"#040348")),
+    ("purpleish pink", Rgba8::from_hex(b"#df4ec8")),
+    ("apple", Rgba8::from_hex(b"#6ecb3c")),
+    ("baby poop green", Rgba8::from_hex(b"#8f9805")),
+    ("green apple", Rgba8::from_hex(b"#5edc1f")),
+    ("heliotrope", Rgba8::from_hex(b"#d94ff5")),
+    ("yellow/green", Rgba8::from_hex(b"#c8fd3d")),
+    ("almost black", Rgba8::from_hex(b"#070d0d")),
+    ("cool blue", Rgba8::from_hex(b"#4984b8")),
+    ("leafy green", Rgba8::from_hex(b"#51b73b")),
+    ("mustard brown", Rgba8::from_hex(b"#ac7e04")),
+    ("dusk", Rgba8::from_hex(b"#4e5481")),
+    ("dull brown", Rgba8::from_hex(b"#876e4b")),
+    ("frog green", Rgba8::from_hex(b"#58bc08")),
+    ("vivid green", Rgba8::from_hex(b"#2fef10")),
+    ("bright light green", Rgba8::from_hex(b"#2dfe54")),
+    ("fluro green", Rgba8::from_hex(b"#0aff02")),
+    ("kiwi", Rgba8::from_hex(b"#9cef43")),
+    ("seaweed", Rgba8::from_hex(b"#18d17b")),
+    ("navy green", Rgba8::from_hex(b"#35530a")),
+    ("ultramarine blue", Rgba8::from_hex(b"#1805db")),
+    ("iris", Rgba8::from_hex(b"#6258c4")),
+    ("pastel orange", Rgba8::from_hex(b"#ff964f")),
+    ("yellowish orange", Rgba8::from_hex(b"#ffab0f")),
+    ("perrywinkle", Rgba8::from_hex(b"#8f8ce7")),
+    ("tealish", Rgba8::from_hex(b"#24bca8")),
+    ("dark plum", Rgba8::from_hex(b"#3f012c")),
+    ("pear", Rgba8::from_hex(b"#cbf85f")),
+    ("pinkish orange", Rgba8::from_hex(b"#ff724c")),
+    ("midnight purple", Rgba8::from_hex(b"#280137")),
+    ("light urple", Rgba8::from_hex(b"#b36ff6")),
+    ("dark mint", Rgba8::from_hex(b"#48c072")),
+    ("greenish tan", Rgba8::from_hex(b"#bccb7a")),
+    ("light burgundy", Rgba8::from_hex(b"#a8415b")),
+    ("turquoise blue", Rgba8::from_hex(b"#06b1c4")),
+    ("ugly pink", Rgba8::from_hex(b"#cd7584")),
+    ("sandy", Rgba8::from_hex(b"#f1da7a")),
+    ("electric pink", Rgba8::from_hex(b"#ff0490")),
+    ("muted purple", Rgba8::from_hex(b"#805b87")),
+    ("mid green", Rgba8::from_hex(b"#50a747")),
+    ("greyish", Rgba8::from_hex(b"#a8a495")),
+    ("neon yellow", Rgba8::from_hex(b"#cfff04")),
+    ("banana", Rgba8::from_hex(b"#ffff7e")),
+    ("carnation pink", Rgba8::from_hex(b"#ff7fa7")),
+    ("sea", Rgba8::from_hex(b"#3c9992")),
+    ("muddy brown", Rgba8::from_hex(b"#886806")),
+    ("turquoise green", Rgba8::from_hex(b"#04f489")),
+    ("buff", Rgba8::from_hex(b"#fef69e")),
+    ("fawn", Rgba8::from_hex(b"#cfaf7b")),
+    ("muted blue", Rgba8::from_hex(b"#3b719f")),
+    ("pale rose", Rgba8::from_hex(b"#fdc1c5")),
+    ("dark mint green", Rgba8::from_hex(b"#20c073")),
+    ("amethyst", Rgba8::from_hex(b"#9b5fc0")),
+    ("blue/green", Rgba8::from_hex(b"#0f9b8e")),
+    ("chestnut", Rgba8::from_hex(b"#742802")),
+    ("sick green", Rgba8::from_hex(b"#9db92c")),
+    ("pea", Rgba8::from_hex(b"#a4bf20")),
+    ("rusty orange", Rgba8::from_hex(b"#cd5909")),
+    ("stone", Rgba8::from_hex(b"#ada587")),
+    ("rose red", Rgba8::from_hex(b"#be013c")),
+    ("pale aqua", Rgba8::from_hex(b"#b8ffeb")),
+    ("deep orange", Rgba8::from_hex(b"#dc4d01")),
+    ("earth", Rgba8::from_hex(b"#a2653e")),
+    ("mossy green", Rgba8::from_hex(b"#638b27")),
+    ("grassy green", Rgba8::from_hex(b"#419c03")),
+    ("pale lime green", Rgba8::from_hex(b"#b1ff65")),
+    ("light grey blue", Rgba8::from_hex(b"#9dbcd4")),
+    ("pale grey", Rgba8::from_hex(b"#fdfdfe")),
+    ("asparagus", Rgba8::from_hex(b"#77ab56")),
+    ("blueberry", Rgba8::from_hex(b"#464196")),
+    ("purple red", Rgba8::from_hex(b"#990147")),
+    ("pale lime", Rgba8::from_hex(b"#befd73")),
+    ("greenish teal", Rgba8::from_hex(b"#32bf84")),
+    ("caramel", Rgba8::from_hex(b"#af6f09")),
+    ("deep magenta", Rgba8::from_hex(b"#a0025c")),
+    ("light peach", Rgba8::from_hex(b"#ffd8b1")),
+    ("milk chocolate", Rgba8::from_hex(b"#7f4e1e")),
+    ("ocher", Rgba8::from_hex(b"#bf9b0c")),
+    ("off green", Rgba8::from_hex(b"#6ba353")),
+    ("purply pink", Rgba8::from_hex(b"#f075e6")),
+    ("dusky blue", Rgba8::from_hex(b"#475f94")),
+    ("golden", Rgba8::from_hex(b"#f5bf03")),
+    ("light beige", Rgba8::from_hex(b"#fffeb6")),
+    ("butter yellow", Rgba8::from_hex(b"#fffd74")),
+    ("dusky purple", Rgba8::from_hex(b"#895b7b")),
+    ("french blue", Rgba8::from_hex(b"#436bad")),
+    ("ugly yellow", Rgba8::from_hex(b"#d0c101")),
+    ("greeny yellow", Rgba8::from_hex(b"#c6f808")),
+    ("orangish red", Rgba8::from_hex(b"#f43605")),
+    ("shamrock green", Rgba8::from_hex(b"#02c14d")),
+    ("orangish brown", Rgba8::from_hex(b"#b25f03")),
+    ("tree green", Rgba8::from_hex(b"#2a7e19")),
+    ("deep violet", Rgba8::from_hex(b"#490648")),
+    ("gunmetal", Rgba8::from_hex(b"#536267")),
+    ("blue/purple", Rgba8::from_hex(b"#5a06ef")),
+    ("cherry", Rgba8::from_hex(b"#cf0234")),
+    ("sandy brown", Rgba8::from_hex(b"#c4a661")),
+    ("warm grey", Rgba8::from_hex(b"#978a84")),
+    ("dark indigo", Rgba8::from_hex(b"#1f0954")),
+    ("midnight", Rgba8::from_hex(b"#03012d")),
+    ("bluey green", Rgba8::from_hex(b"#2bb179")),
+    ("grey pink", Rgba8::from_hex(b"#c3909b")),
+    ("soft purple", Rgba8::from_hex(b"#a66fb5")),
+    ("blood", Rgba8::from_hex(b"#770001")),
+    ("brown red", Rgba8::from_hex(b"#922b05")),
+    ("medium grey", Rgba8::from_hex(b"#7d7f7c")),
+    ("berry", Rgba8::from_hex(b"#990f4b")),
+    ("poo", Rgba8::from_hex(b"#8f7303")),
+    ("purpley pink", Rgba8::from_hex(b"#c83cb9")),
+    ("light salmon", Rgba8::from_hex(b"#fea993")),
+    ("snot", Rgba8::from_hex(b"#acbb0d")),
+    ("easter purple", Rgba8::from_hex(b"#c071fe")),
+    ("light yellow green", Rgba8::from_hex(b"#ccfd7f")),
+    ("dark navy blue", Rgba8::from_hex(b"#00022e")),
+    ("drab", Rgba8::from_hex(b"#828344")),
+    ("light rose", Rgba8::from_hex(b"#ffc5cb")),
+    ("rouge", Rgba8::from_hex(b"#ab1239")),
+    ("purplish red", Rgba8::from_hex(b"#b0054b")),
+    ("slime green", Rgba8::from_hex(b"#99cc04")),
+    ("baby poop", Rgba8::from_hex(b"#937c00")),
+    ("irish green", Rgba8::from_hex(b"#019529")),
+    ("pink/purple", Rgba8::from_hex(b"#ef1de7")),
+    ("dark navy", Rgba8::from_hex(b"#000435")),
+    ("greeny blue", Rgba8::from_hex(b"#42b395")),
+    ("light plum", Rgba8::from_hex(b"#9d5783")),
+    ("pinkish grey", Rgba8::from_hex(b"#c8aca9")),
+    ("dirty orange", Rgba8::from_hex(b"#c87606")),
+    ("rust red", Rgba8::from_hex(b"#aa2704")),
+    ("pale lilac", Rgba8::from_hex(b"#e4cbff")),
+    ("orangey red", Rgba8::from_hex(b"#fa4224")),
+    ("primary blue", Rgba8::from_hex(b"#0804f9")),
+    ("kermit green", Rgba8::from_hex(b"#5cb200")),
+    ("brownish purple", Rgba8::from_hex(b"#76424e")),
+    ("murky green", Rgba8::from_hex(b"#6c7a0e")),
+    ("very dark purple", Rgba8::from_hex(b"#2a0134")),
+    ("bottle green", Rgba8::from_hex(b"#044a05")),
+    ("watermelon", Rgba8::from_hex(b"#fd4659")),
+    ("deep sky blue", Rgba8::from_hex(b"#0d75f8")),
+    ("fire engine red", Rgba8::from_hex(b"#fe0002")),
+    ("yellow ochre", Rgba8::from_hex(b"#cb9d06")),
+    ("pumpkin orange", Rgba8::from_hex(b"#fb7d07")),
+    ("pale olive", Rgba8::from_hex(b"#b9cc81")),
+    ("light lilac", Rgba8::from_hex(b"#edc8ff")),
+    ("lightish green", Rgba8::from_hex(b"#61e160")),
+    ("carolina blue", Rgba8::from_hex(b"#8ab8fe")),
+    ("mulberry", Rgba8::from_hex(b"#920a4e")),
+    ("shocking pink", Rgba8::from_hex(b"#fe02a2")),
+    ("auburn", Rgba8::from_hex(b"#9a3001")),
+    ("bright lime green", Rgba8::from_hex(b"#65fe08")),
+    ("celadon", Rgba8::from_hex(b"#befdb7")),
+    ("pinkish brown", Rgba8::from_hex(b"#b17261")),
+    ("poo brown", Rgba8::from_hex(b"#885f01")),
+    ("bright sky blue", Rgba8::from_hex(b"#02ccfe")),
+    ("celery", Rgba8::from_hex(b"#c1fd95")),
+    ("dirt brown", Rgba8::from_hex(b"#836539")),
+    ("strawberry", Rgba8::from_hex(b"#fb2943")),
+    ("dark lime", Rgba8::from_hex(b"#84b701")),
+    ("copper", Rgba8::from_hex(b"#b66325")),
+    ("medium brown", Rgba8::from_hex(b"#7f5112")),
+    ("muted green", Rgba8::from_hex(b"#5fa052")),
+    ("robin's egg", Rgba8::from_hex(b"#6dedfd")),
+    ("bright aqua", Rgba8::from_hex(b"#0bf9ea")),
+    ("bright lavender", Rgba8::from_hex(b"#c760ff")),
+    ("very light purple", Rgba8::from_hex(b"#f6cefc")),
+    ("light navy", Rgba8::from_hex(b"#155084")),
+    ("pink red", Rgba8::from_hex(b"#f5054f")),
+    ("olive brown", Rgba8::from_hex(b"#645403")),
+    ("poop brown", Rgba8::from_hex(b"#7a5901")),
+    ("mustard green", Rgba8::from_hex(b"#a8b504")),
+    ("ocean green", Rgba8::from_hex(b"#3d9973")),
+    ("very dark blue", Rgba8::from_hex(b"#000133")),
+    ("dusty green", Rgba8::from_hex(b"#76a973")),
+    ("light navy blue", Rgba8::from_hex(b"#2e5a88")),
+    ("minty green", Rgba8::from_hex(b"#0bf77d")),
+    ("adobe", Rgba8::from_hex(b"#bd6c48")),
+    ("barney", Rgba8::from_hex(b"#ac1db8")),
+    ("jade green", Rgba8::from_hex(b"#2baf6a")),
+    ("bright light blue", Rgba8::from_hex(b"#26f7fd")),
+    ("light lime", Rgba8::from_hex(b"#aefd6c")),
+    ("dark khaki", Rgba8::from_hex(b"#9b8f55")),
+    ("orange yellow", Rgba8::from_hex(b"#ffad01")),
+    ("ocre", Rgba8::from_hex(b"#c69c04")),
+    ("maize", Rgba8::from_hex(b"#f4d054")),
+    ("faded pink", Rgba8::from_hex(b"#de9dac")),
+    ("british racing green", Rgba8::from_hex(b"#05480d")),
+    ("sandstone", Rgba8::from_hex(b"#c9ae74")),
+    ("mud brown", Rgba8::from_hex(b"#60460f")),
+    ("light sea green", Rgba8::from_hex(b"#98f6b0")),
+    ("robin egg blue", Rgba8::from_hex(b"#8af1fe")),
+    ("aqua marine", Rgba8::from_hex(b"#2ee8bb")),
+    ("dark sea green", Rgba8::from_hex(b"#11875d")),
+    ("soft pink", Rgba8::from_hex(b"#fdb0c0")),
+    ("orangey brown", Rgba8::from_hex(b"#b16002")),
+    ("cherry red", Rgba8::from_hex(b"#f7022a")),
+    ("burnt yellow", Rgba8::from_hex(b"#d5ab09")),
+    ("brownish grey", Rgba8::from_hex(b"#86775f")),
+    ("camel", Rgba8::from_hex(b"#c69f59")),
+    ("purplish grey", Rgba8::from_hex(b"#7a687f")),
+    ("marine", Rgba8::from_hex(b"#042e60")),
+    ("greyish pink", Rgba8::from_hex(b"#c88d94")),
+    ("pale turquoise", Rgba8::from_hex(b"#a5fbd5")),
+    ("pastel yellow", Rgba8::from_hex(b"#fffe71")),
+    ("bluey purple", Rgba8::from_hex(b"#6241c7")),
+    ("canary yellow", Rgba8::from_hex(b"#fffe40")),
+    ("faded red", Rgba8::from_hex(b"#d3494e")),
+    ("sepia", Rgba8::from_hex(b"#985e2b")),
+    ("coffee", Rgba8::from_hex(b"#a6814c")),
+    ("bright magenta", Rgba8::from_hex(b"#ff08e8")),
+    ("mocha", Rgba8::from_hex(b"#9d7651")),
+    ("ecru", Rgba8::from_hex(b"#feffca")),
+    ("purpleish", Rgba8::from_hex(b"#98568d")),
+    ("cranberry", Rgba8::from_hex(b"#9e003a")),
+    ("darkish green", Rgba8::from_hex(b"#287c37")),
+    ("brown orange", Rgba8::from_hex(b"#b96902")),
+    ("dusky rose", Rgba8::from_hex(b"#ba6873")),
+    ("melon", Rgba8::from_hex(b"#ff7855")),
+    ("sickly green", Rgba8::from_hex(b"#94b21c")),
+    ("purply blue", Rgba8::from_hex(b"#661aee")),
+    ("purpleish blue", Rgba8::from_hex(b"#6140ef")),
+    ("hospital green", Rgba8::from_hex(b"#9be5aa")),
+    ("shit brown", Rgba8::from_hex(b"#7b5804")),
+    ("mid blue", Rgba8::from_hex(b"#276ab3")),
+    ("amber", Rgba8::from_hex(b"#feb308")),
+    ("easter green", Rgba8::from_hex(b"#8cfd7e")),
+    ("soft blue", Rgba8::from_hex(b"#6488ea")),
+    ("cerulean blue", Rgba8::from_hex(b"#056eee")),
+    ("golden brown", Rgba8::from_hex(b"#b27a01")),
+    ("bright turquoise", Rgba8::from_hex(b"#0ffef9")),
+    ("red pink", Rgba8::from_hex(b"#fa2a55")),
+    ("red purple", Rgba8::from_hex(b"#820747")),
+    ("greyish brown", Rgba8::from_hex(b"#7a6a4f")),
+    ("vermillion", Rgba8::from_hex(b"#f4320c")),
+    ("russet", Rgba8::from_hex(b"#a13905")),
+    ("steel grey", Rgba8::from_hex(b"#6f828a")),
+    ("lighter purple", Rgba8::from_hex(b"#a55af4")),
+    ("bright violet", Rgba8::from_hex(b"#ad0afd")),
+    ("prussian blue", Rgba8::from_hex(b"#004577")),
+    ("slate green", Rgba8::from_hex(b"#658d6d")),
+    ("dirty pink", Rgba8::from_hex(b"#ca7b80")),
+    ("dark blue green", Rgba8::from_hex(b"#005249")),
+    ("pine", Rgba8::from_hex(b"#2b5d34")),
+    ("yellowy green", Rgba8::from_hex(b"#bff128")),
+    ("dark gold", Rgba8::from_hex(b"#b59410")),
+    ("bluish", Rgba8::from_hex(b"#2976bb")),
+    ("darkish blue", Rgba8::from_hex(b"#014182")),
+    ("dull red", Rgba8::from_hex(b"#bb3f3f")),
+    ("pinky red", Rgba8::from_hex(b"#fc2647")),
+    ("bronze", Rgba8::from_hex(b"#a87900")),
+    ("pale teal", Rgba8::from_hex(b"#82cbb2")),
+    ("military green", Rgba8::from_hex(b"#667c3e")),
+    ("barbie pink", Rgba8::from_hex(b"#fe46a5")),
+    ("bubblegum pink", Rgba8::from_hex(b"#fe83cc")),
+    ("pea soup green", Rgba8::from_hex(b"#94a617")),
+    ("dark mustard", Rgba8::from_hex(b"#a88905")),
+    ("shit", Rgba8::from_hex(b"#7f5f00")),
+    ("medium purple", Rgba8::from_hex(b"#9e43a2")),
+    ("very dark green", Rgba8::from_hex(b"#062e03")),
+    ("dirt", Rgba8::from_hex(b"#8a6e45")),
+    ("dusky pink", Rgba8::from_hex(b"#cc7a8b")),
+    ("red violet", Rgba8::from_hex(b"#9e0168")),
+    ("lemon yellow", Rgba8::from_hex(b"#fdff38")),
+    ("pistachio", Rgba8::from_hex(b"#c0fa8b")),
+    ("dull yellow", Rgba8::from_hex(b"#eedc5b")),
+    ("dark lime green", Rgba8::from_hex(b"#7ebd01")),
+    ("denim blue", Rgba8::from_hex(b"#3b5b92")),
+    ("teal blue", Rgba8::from_hex(b"#01889f")),
+    ("lightish blue", Rgba8::from_hex(b"#3d7afd")),
+    ("purpley blue", Rgba8::from_hex(b"#5f34e7")),
+    ("light indigo", Rgba8::from_hex(b"#6d5acf")),
+    ("swamp green", Rgba8::from_hex(b"#748500")),
+    ("brown green", Rgba8::from_hex(b"#706c11")),
+    ("dark maroon", Rgba8::from_hex(b"#3c0008")),
+    ("hot purple", Rgba8::from_hex(b"#cb00f5")),
+    ("dark forest green", Rgba8::from_hex(b"#002d04")),
+    ("faded blue", Rgba8::from_hex(b"#658cbb")),
+    ("drab green", Rgba8::from_hex(b"#749551")),
+    ("light lime green", Rgba8::from_hex(b"#b9ff66")),
+    ("snot green", Rgba8::from_hex(b"#9dc100")),
+    ("yellowish", Rgba8::from_hex(b"#faee66")),
+    ("light blue green", Rgba8::from_hex(b"#7efbb3")),
+    ("bordeaux", Rgba8::from_hex(b"#7b002c")),
+    ("light mauve", Rgba8::from_hex(b"#c292a1")),
+    ("ocean", Rgba8::from_hex(b"#017b92")),
+    ("marigold", Rgba8::from_hex(b"#fcc006")),
+    ("muddy green", Rgba8::from_hex(b"#657432")),
+    ("dull orange", Rgba8::from_hex(b"#d8863b")),
+    ("steel", Rgba8::from_hex(b"#738595")),
+    ("electric purple", Rgba8::from_hex(b"#aa23ff")),
+    ("fluorescent green", Rgba8::from_hex(b"#08ff08")),
+    ("yellowish brown", Rgba8::from_hex(b"#9b7a01")),
+    ("blush", Rgba8::from_hex(b"#f29e8e")),
+    ("soft green", Rgba8::from_hex(b"#6fc276")),
+    ("bright orange", Rgba8::from_hex(b"#ff5b00")),
+    ("lemon", Rgba8::from_hex(b"#fdff52")),
+    ("purple grey", Rgba8::from_hex(b"#866f85")),
+    ("acid green", Rgba8::from_hex(b"#8ffe09")),
+    ("pale lavender", Rgba8::from_hex(b"#eecffe")),
+    ("violet blue", Rgba8::from_hex(b"#510ac9")),
+    ("light forest green", Rgba8::from_hex(b"#4f9153")),
+    ("burnt red", Rgba8::from_hex(b"#9f2305")),
+    ("khaki green", Rgba8::from_hex(b"#728639")),
+    ("cerise", Rgba8::from_hex(b"#de0c62")),
+    ("faded purple", Rgba8::from_hex(b"#916e99")),
+    ("apricot", Rgba8::from_hex(b"#ffb16d")),
+    ("dark olive green", Rgba8::from_hex(b"#3c4d03")),
+    ("grey brown", Rgba8::from_hex(b"#7f7053")),
+    ("green grey", Rgba8::from_hex(b"#77926f")),
+    ("true blue", Rgba8::from_hex(b"#010fcc")),
+    ("pale violet", Rgba8::from_hex(b"#ceaefa")),
+    ("periwinkle blue", Rgba8::from_hex(b"#8f99fb")),
+    ("light sky blue", Rgba8::from_hex(b"#c6fcff")),
+    ("blurple", Rgba8::from_hex(b"#5539cc")),
+    ("green brown", Rgba8::from_hex(b"#544e03")),
+    ("bluegreen", Rgba8::from_hex(b"#017a79")),
+    ("bright teal", Rgba8::from_hex(b"#01f9c6")),
+    ("brownish yellow", Rgba8::from_hex(b"#c9b003")),
+    ("pea soup", Rgba8::from_hex(b"#929901")),
+    ("forest", Rgba8::from_hex(b"#0b5509")),
+    ("barney purple", Rgba8::from_hex(b"#a00498")),
+    ("ultramarine", Rgba8::from_hex(b"#2000b1")),
+    ("purplish", Rgba8::from_hex(b"#94568c")),
+    ("puke yellow", Rgba8::from_hex(b"#c2be0e")),
+    ("bluish grey", Rgba8::from_hex(b"#748b97")),
+    ("dark periwinkle", Rgba8::from_hex(b"#665fd1")),
+    ("dark lilac", Rgba8::from_hex(b"#9c6da5")),
+    ("reddish", Rgba8::from_hex(b"#c44240")),
+    ("light maroon", Rgba8::from_hex(b"#a24857")),
+    ("dusty purple", Rgba8::from_hex(b"#825f87")),
+    ("terra cotta", Rgba8::from_hex(b"#c9643b")),
+    ("avocado", Rgba8::from_hex(b"#90b134")),
+    ("marine blue", Rgba8::from_hex(b"#01386a")),
+    ("teal green", Rgba8::from_hex(b"#25a36f")),
+    ("slate grey", Rgba8::from_hex(b"#59656d")),
+    ("lighter green", Rgba8::from_hex(b"#75fd63")),
+    ("electric green", Rgba8::from_hex(b"#21fc0d")),
+    ("dusty blue", Rgba8::from_hex(b"#5a86ad")),
+    ("golden yellow", Rgba8::from_hex(b"#fec615")),
+    ("bright yellow", Rgba8::from_hex(b"#fffd01")),
+    ("light lavender", Rgba8::from_hex(b"#dfc5fe")),
+    ("umber", Rgba8::from_hex(b"#b26400")),
+    ("poop", Rgba8::from_hex(b"#7f5e00")),
+    ("dark peach", Rgba8::from_hex(b"#de7e5d")),
+    ("jungle green", Rgba8::from_hex(b"#048243")),
+    ("eggshell", Rgba8::from_hex(b"#ffffd4")),
+    ("denim", Rgba8::from_hex(b"#3b638c")),
+    ("yellow brown", Rgba8::from_hex(b"#b79400")),
+    ("dull purple", Rgba8::from_hex(b"#84597e")),
+    ("chocolate brown", Rgba8::from_hex(b"#411900")),
+    ("wine red", Rgba8::from_hex(b"#7b0323")),
+    ("neon blue", Rgba8::from_hex(b"#04d9ff")),
+    ("dirty green", Rgba8::from_hex(b"#667e2c")),
+    ("light tan", Rgba8::from_hex(b"#fbeeac")),
+    ("ice blue", Rgba8::from_hex(b"#d7fffe")),
+    ("cadet blue", Rgba8::from_hex(b"#4e7496")),
+    ("dark mauve", Rgba8::from_hex(b"#874c62")),
+    ("very light blue", Rgba8::from_hex(b"#d5ffff")),
+    ("grey purple", Rgba8::from_hex(b"#826d8c")),
+    ("pastel pink", Rgba8::from_hex(b"#ffbacd")),
+    ("very light green", Rgba8::from_hex(b"#d1ffbd")),
+    ("dark sky blue", Rgba8::from_hex(b"#448ee4")),
+    ("evergreen", Rgba8::from_hex(b"#05472a")),
+    ("dull pink", Rgba8::from_hex(b"#d5869d")),
+    ("aubergine", Rgba8::from_hex(b"#3d0734")),
+    ("mahogany", Rgba8::from_hex(b"#4a0100")),
+    ("reddish orange", Rgba8::from_hex(b"#f8481c")),
+    ("deep green", Rgba8::from_hex(b"#02590f")),
+    ("vomit green", Rgba8::from_hex(b"#89a203")),
+    ("purple pink", Rgba8::from_hex(b"#e03fd8")),
+    ("dusty pink", Rgba8::from_hex(b"#d58a94")),
+    ("faded green", Rgba8::from_hex(b"#7bb274")),
+    ("camo green", Rgba8::from_hex(b"#526525")),
+    ("pinky purple", Rgba8::from_hex(b"#c94cbe")),
+    ("pink purple", Rgba8::from_hex(b"#db4bda")),
+    ("brownish red", Rgba8::from_hex(b"#9e3623")),
+    ("dark rose", Rgba8::from_hex(b"#b5485d")),
+    ("mud", Rgba8::from_hex(b"#735c12")),
+    ("brownish", Rgba8::from_hex(b"#9c6d57")),
+    ("emerald green", Rgba8::from_hex(b"#028f1e")),
+    ("pale brown", Rgba8::from_hex(b"#b1916e")),
+    ("dull blue", Rgba8::from_hex(b"#49759c")),
+    ("burnt umber", Rgba8::from_hex(b"#a0450e")),
+    ("medium green", Rgba8::from_hex(b"#39ad48")),
+    ("clay", Rgba8::from_hex(b"#b66a50")),
+    ("light aqua", Rgba8::from_hex(b"#8cffdb")),
+    ("light olive green", Rgba8::from_hex(b"#a4be5c")),
+    ("brownish orange", Rgba8::from_hex(b"#cb7723")),
+    ("dark aqua", Rgba8::from_hex(b"#05696b")),
+    ("purplish pink", Rgba8::from_hex(b"#ce5dae")),
+    ("dark salmon", Rgba8::from_hex(b"#c85a53")),
+    ("greenish grey", Rgba8::from_hex(b"#96ae8d")),
+    ("jade", Rgba8::from_hex(b"#1fa774")),
+    ("ugly green", Rgba8::from_hex(b"#7a9703")),
+    ("dark beige", Rgba8::from_hex(b"#ac9362")),
+    ("emerald", Rgba8::from_hex(b"#01a049")),
+    ("pale red", Rgba8::from_hex(b"#d9544d")),
+    ("light magenta", Rgba8::from_hex(b"#fa5ff7")),
+    ("sky", Rgba8::from_hex(b"#82cafc")),
+    ("light cyan", Rgba8::from_hex(b"#acfffc")),
+    ("yellow orange", Rgba8::from_hex(b"#fcb001")),
+    ("reddish purple", Rgba8::from_hex(b"#910951")),
+    ("reddish pink", Rgba8::from_hex(b"#fe2c54")),
+    ("dirty yellow", Rgba8::from_hex(b"#cdc50a")),
+    ("orange red", Rgba8::from_hex(b"#fd411e")),
+    ("deep red", Rgba8::from_hex(b"#9a0200")),
+    ("orange brown", Rgba8::from_hex(b"#be6400")),
+    ("cobalt blue", Rgba8::from_hex(b"#030aa7")),
+    ("neon pink", Rgba8::from_hex(b"#fe019a")),
+    ("rose pink", Rgba8::from_hex(b"#f7879a")),
+    ("greyish purple", Rgba8::from_hex(b"#887191")),
+    ("raspberry", Rgba8::from_hex(b"#b00149")),
+    ("aqua green", Rgba8::from_hex(b"#12e193")),
+    ("salmon pink", Rgba8::from_hex(b"#fe7b7c")),
+    ("tangerine", Rgba8::from_hex(b"#ff9408")),
+    ("brownish green", Rgba8::from_hex(b"#6a6e09")),
+    ("red brown", Rgba8::from_hex(b"#8b2e16")),
+    ("greenish brown", Rgba8::from_hex(b"#696112")),
+    ("pumpkin", Rgba8::from_hex(b"#e17701")),
+    ("pine green", Rgba8::from_hex(b"#0a481e")),
+    ("charcoal", Rgba8::from_hex(b"#343837")),
+    ("baby pink", Rgba8::from_hex(b"#ffb7ce")),
+    ("cornflower", Rgba8::from_hex(b"#6a79f7")),
+    ("blue violet", Rgba8::from_hex(b"#5d06e9")),
+    ("greyish green", Rgba8::from_hex(b"#82a67d")),
+    ("scarlet", Rgba8::from_hex(b"#be0119")),
+    ("green yellow", Rgba8::from_hex(b"#c9ff27")),
+    ("dark olive", Rgba8::from_hex(b"#373e02")),
+    ("pastel purple", Rgba8::from_hex(b"#caa0ff")),
+    ("terracotta", Rgba8::from_hex(b"#ca6641")),
+    ("aqua blue", Rgba8::from_hex(b"#02d8e9")),
+    ("sage green", Rgba8::from_hex(b"#88b378")),
+    ("blood red", Rgba8::from_hex(b"#980002")),
+    ("deep pink", Rgba8::from_hex(b"#cb0162")),
+    ("grass", Rgba8::from_hex(b"#5cac2d")),
+    ("moss", Rgba8::from_hex(b"#769958")),
+    ("pastel blue", Rgba8::from_hex(b"#a2bffe")),
+    ("bluish green", Rgba8::from_hex(b"#10a674")),
+    ("green blue", Rgba8::from_hex(b"#06b48b")),
+    ("dark tan", Rgba8::from_hex(b"#af884a")),
+    ("greenish blue", Rgba8::from_hex(b"#0b8b87")),
+    ("pale orange", Rgba8::from_hex(b"#ffa756")),
+    ("vomit", Rgba8::from_hex(b"#a2a415")),
+    ("forrest green", Rgba8::from_hex(b"#154406")),
+    ("dark lavender", Rgba8::from_hex(b"#856798")),
+    ("dark violet", Rgba8::from_hex(b"#34013f")),
+    ("purple blue", Rgba8::from_hex(b"#632de9")),
+    ("dark cyan", Rgba8::from_hex(b"#0a888a")),
+    ("olive drab", Rgba8::from_hex(b"#6f7632")),
+    ("pinkish", Rgba8::from_hex(b"#d46a7e")),
+    ("cobalt", Rgba8::from_hex(b"#1e488f")),
+    ("neon purple", Rgba8::from_hex(b"#bc13fe")),
+    ("light turquoise", Rgba8::from_hex(b"#7ef4cc")),
+    ("apple green", Rgba8::from_hex(b"#76cd26")),
+    ("dull green", Rgba8::from_hex(b"#74a662")),
+    ("wine", Rgba8::from_hex(b"#80013f")),
+    ("powder blue", Rgba8::from_hex(b"#b1d1fc")),
+    ("off white", Rgba8::from_hex(b"#ffffe4")),
+    ("electric blue", Rgba8::from_hex(b"#0652ff")),
+    ("dark turquoise", Rgba8::from_hex(b"#045c5a")),
+    ("blue purple", Rgba8::from_hex(b"#5729ce")),
+    ("bright red", Rgba8::from_hex(b"#ff000d")),
+    ("pinkish red", Rgba8::from_hex(b"#f10c45")),
+    ("cornflower blue", Rgba8::from_hex(b"#5170d7")),
+    ("light olive", Rgba8::from_hex(b"#acbf69")),
+    ("grape", Rgba8::from_hex(b"#6c3461")),
+    ("greyish blue", Rgba8::from_hex(b"#5e819d")),
+    ("purplish blue", Rgba8::from_hex(b"#601ef9")),
+    ("yellowish green", Rgba8::from_hex(b"#b0dd16")),
+    ("greenish yellow", Rgba8::from_hex(b"#cdfd02")),
+    ("medium blue", Rgba8::from_hex(b"#2c6fbb")),
+    ("dusty rose", Rgba8::from_hex(b"#c0737a")),
+    ("light violet", Rgba8::from_hex(b"#d6b4fc")),
+    ("midnight blue", Rgba8::from_hex(b"#020035")),
+    ("bluish purple", Rgba8::from_hex(b"#703be7")),
+    ("red orange", Rgba8::from_hex(b"#fd3c06")),
+    ("dark magenta", Rgba8::from_hex(b"#960056")),
+    ("greenish", Rgba8::from_hex(b"#40a368")),
+    ("ocean blue", Rgba8::from_hex(b"#03719c")),
+    ("cream", Rgba8::from_hex(b"#ffffc2")),
+    ("reddish brown", Rgba8::from_hex(b"#7f2b0a")),
+    ("burnt sienna", Rgba8::from_hex(b"#b04e0f")),
+    ("brick", Rgba8::from_hex(b"#a03623")),
+    ("sage", Rgba8::from_hex(b"#87ae73")),
+    ("grey green", Rgba8::from_hex(b"#789b73")),
+    ("robin's egg blue", Rgba8::from_hex(b"#98eff9")),
+    ("moss green", Rgba8::from_hex(b"#658b38")),
+    ("steel blue", Rgba8::from_hex(b"#5a7d9a")),
+    ("eggplant", Rgba8::from_hex(b"#380835")),
+    ("light yellow", Rgba8::from_hex(b"#fffe7a")),
+    ("leaf green", Rgba8::from_hex(b"#5ca904")),
+    ("light grey", Rgba8::from_hex(b"#d8dcd6")),
+    ("puke", Rgba8::from_hex(b"#a5a502")),
+    ("pinkish purple", Rgba8::from_hex(b"#d648d7")),
+    ("sea blue", Rgba8::from_hex(b"#047495")),
+    ("pale purple", Rgba8::from_hex(b"#b790d4")),
+    ("slate blue", Rgba8::from_hex(b"#5b7c99")),
+    ("blue grey", Rgba8::from_hex(b"#607c8e")),
+    ("hunter green", Rgba8::from_hex(b"#0b4008")),
+    ("pale yellow", Rgba8::from_hex(b"#ffff84")),
+    ("ochre", Rgba8::from_hex(b"#bf9005")),
+    ("mustard yellow", Rgba8::from_hex(b"#d2bd0a")),
+    ("light red", Rgba8::from_hex(b"#ff474c")),
+    ("cerulean", Rgba8::from_hex(b"#0485d1")),
+    ("pale pink", Rgba8::from_hex(b"#ffcfdc")),
+    ("deep blue", Rgba8::from_hex(b"#040273")),
+    ("rust", Rgba8::from_hex(b"#a83c09")),
+    ("light teal", Rgba8::from_hex(b"#90e4c1")),
+    ("slate", Rgba8::from_hex(b"#516572")),
+    ("dark yellow", Rgba8::from_hex(b"#d5b60a")),
+    ("dark grey", Rgba8::from_hex(b"#363737")),
+    ("army green", Rgba8::from_hex(b"#4b5d16")),
+    ("grey blue", Rgba8::from_hex(b"#6b8ba4")),
+    ("seafoam", Rgba8::from_hex(b"#80f9ad")),
+    ("puce", Rgba8::from_hex(b"#a57e52")),
+    ("spring green", Rgba8::from_hex(b"#a9f971")),
+    ("dark orange", Rgba8::from_hex(b"#c65102")),
+    ("sand", Rgba8::from_hex(b"#e2ca76")),
+    ("pastel green", Rgba8::from_hex(b"#b0ff9d")),
+    ("mint", Rgba8::from_hex(b"#9ffeb0")),
+    ("light orange", Rgba8::from_hex(b"#fdaa48")),
+    ("bright pink", Rgba8::from_hex(b"#fe01b1")),
+    ("deep purple", Rgba8::from_hex(b"#36013f")),
+    ("dark brown", Rgba8::from_hex(b"#341c02")),
+    ("taupe", Rgba8::from_hex(b"#b9a281")),
+    ("pea green", Rgba8::from_hex(b"#8eab12")),
+    ("puke green", Rgba8::from_hex(b"#9aae07")),
+    ("kelly green", Rgba8::from_hex(b"#02ab2e")),
+    ("seafoam green", Rgba8::from_hex(b"#7af9ab")),
+    ("blue green", Rgba8::from_hex(b"#137e6d")),
+    ("burgundy", Rgba8::from_hex(b"#610023")),
+    ("dark teal", Rgba8::from_hex(b"#014d4e")),
+    ("brick red", Rgba8::from_hex(b"#8f1402")),
+    ("royal purple", Rgba8::from_hex(b"#4b006e")),
+    ("mint green", Rgba8::from_hex(b"#8fff9f")),
+    ("baby blue", Rgba8::from_hex(b"#a2cffe")),
+    ("yellow green", Rgba8::from_hex(b"#c0fb2d")),
+    ("bright purple", Rgba8::from_hex(b"#be03fd")),
+    ("dark red", Rgba8::from_hex(b"#840000")),
+    ("pale blue", Rgba8::from_hex(b"#d0fefe")),
+    ("grass green", Rgba8::from_hex(b"#3f9b0b")),
+    ("burnt orange", Rgba8::from_hex(b"#c04e01")),
+    ("neon green", Rgba8::from_hex(b"#0cff0c")),
+    ("bright blue", Rgba8::from_hex(b"#0165fc")),
+    ("rose", Rgba8::from_hex(b"#cf6275")),
+    ("light pink", Rgba8::from_hex(b"#ffd1df")),
+    ("mustard", Rgba8::from_hex(b"#ceb301")),
+    ("sea green", Rgba8::from_hex(b"#53fca1")),
+    ("periwinkle", Rgba8::from_hex(b"#8e82fe")),
+    ("dark pink", Rgba8::from_hex(b"#cb416b")),
+    ("olive green", Rgba8::from_hex(b"#677a04")),
+    ("peach", Rgba8::from_hex(b"#ffb07c")),
+    ("pale green", Rgba8::from_hex(b"#c7fdb5")),
+    ("light brown", Rgba8::from_hex(b"#ad8150")),
+    ("hot pink", Rgba8::from_hex(b"#ff028d")),
+    ("lilac", Rgba8::from_hex(b"#cea2fd")),
+    ("navy blue", Rgba8::from_hex(b"#001146")),
+    ("royal blue", Rgba8::from_hex(b"#0504aa")),
+    ("bright green", Rgba8::from_hex(b"#01ff07")),
+    ("dark purple", Rgba8::from_hex(b"#35063e")),
+    ("mauve", Rgba8::from_hex(b"#ae7181")),
+    ("forest green", Rgba8::from_hex(b"#06470c")),
+    ("dark blue", Rgba8::from_hex(b"#00035b")),
+    ("dark green", Rgba8::from_hex(b"#033500")),
+    ("light purple", Rgba8::from_hex(b"#bf77f6")),
+    ("lime green", Rgba8::from_hex(b"#89fe05")),
+    ("sky blue", Rgba8::from_hex(b"#75bbfd")),
+    ("light green", Rgba8::from_hex(b"#96f97b")),
+    ("light blue", Rgba8::from_hex(b"#95d0fc")),
+];
diff --git a/base/src/geom.rs b/base/src/geom.rs
index f322d0d4..fcbff2a1 100644
--- a/base/src/geom.rs
+++ b/base/src/geom.rs
@@ -410,27 +410,27 @@ impl Rect {
 }
 
 /// Padding within a graphical element
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy, PartialEq)]
 pub enum Padding {
     /// Uniform padding in all directions
     Even(f32),
     /// Vertical and horizontal padding
     Center {
         /// Vertical padding
-        v: f32,
+        ver: f32,
         /// Horizontal padding
-        h: f32,
+        hor: f32,
     },
     /// Top, right, bottom and left padding
     Custom {
         /// Top padding
-        t: f32,
+        top: f32,
         /// Right padding
-        r: f32,
+        right: f32,
         /// Bottom padding
-        b: f32,
+        bottom: f32,
         /// Left padding
-        l: f32,
+        left: f32,
     },
 }
 
@@ -439,8 +439,8 @@ impl Padding {
     pub const fn top(&self) -> f32 {
         match self {
             Padding::Even(p) => *p,
-            Padding::Center { v, .. } => *v,
-            Padding::Custom { t, .. } => *t,
+            Padding::Center { ver: v, .. } => *v,
+            Padding::Custom { top: t, .. } => *t,
         }
     }
 
@@ -448,8 +448,8 @@ impl Padding {
     pub const fn right(&self) -> f32 {
         match self {
             Padding::Even(p) => *p,
-            Padding::Center { h, .. } => *h,
-            Padding::Custom { r, .. } => *r,
+            Padding::Center { hor: h, .. } => *h,
+            Padding::Custom { right: r, .. } => *r,
         }
     }
 
@@ -457,8 +457,8 @@ impl Padding {
     pub const fn bottom(&self) -> f32 {
         match self {
             Padding::Even(p) => *p,
-            Padding::Center { v, .. } => *v,
-            Padding::Custom { b, .. } => *b,
+            Padding::Center { ver: v, .. } => *v,
+            Padding::Custom { bottom: b, .. } => *b,
         }
     }
 
@@ -466,8 +466,8 @@ impl Padding {
     pub const fn left(&self) -> f32 {
         match self {
             Padding::Even(p) => *p,
-            Padding::Center { h, .. } => *h,
-            Padding::Custom { l, .. } => *l,
+            Padding::Center { hor: h, .. } => *h,
+            Padding::Custom { left: l, .. } => *l,
         }
     }
 
@@ -475,8 +475,10 @@ impl Padding {
     pub const fn sum_ver(&self) -> f32 {
         match self {
             Padding::Even(p) => *p * 2.0,
-            Padding::Center { v, .. } => *v * 2.0,
-            Padding::Custom { t, b, .. } => *t + *b,
+            Padding::Center { ver: v, .. } => *v * 2.0,
+            Padding::Custom {
+                top: t, bottom: b, ..
+            } => *t + *b,
         }
     }
 
@@ -484,8 +486,10 @@ impl Padding {
     pub const fn sum_hor(&self) -> f32 {
         match self {
             Padding::Even(p) => *p * 2.0,
-            Padding::Center { h, .. } => *h * 2.0,
-            Padding::Custom { l, r, .. } => *l + *r,
+            Padding::Center { hor: h, .. } => *h * 2.0,
+            Padding::Custom {
+                left: l, right: r, ..
+            } => *l + *r,
         }
     }
 }
@@ -498,13 +502,18 @@ impl From<f32> for Padding {
 
 impl From<(f32, f32)> for Padding {
     fn from((v, h): (f32, f32)) -> Self {
-        Padding::Center { v, h }
+        Padding::Center { ver: v, hor: h }
     }
 }
 
 impl From<(f32, f32, f32, f32)> for Padding {
     fn from((t, r, b, l): (f32, f32, f32, f32)) -> Self {
-        Padding::Custom { t, r, b, l }
+        Padding::Custom {
+            top: t,
+            right: r,
+            bottom: b,
+            left: l,
+        }
     }
 }
 
diff --git a/base/src/lib.rs b/base/src/lib.rs
index cafcec17..4dbda7d5 100644
--- a/base/src/lib.rs
+++ b/base/src/lib.rs
@@ -2,3 +2,6 @@ pub mod color;
 pub use color::{Color, ResolveColor, Rgb8, Rgba8};
 
 pub mod geom;
+
+#[cfg(feature = "serde")]
+mod sd;
diff --git a/base/src/sd.rs b/base/src/sd.rs
new file mode 100644
index 00000000..775ce00d
--- /dev/null
+++ b/base/src/sd.rs
@@ -0,0 +1,455 @@
+use std::borrow::Cow;
+use std::collections::HashMap;
+use std::fmt;
+use std::sync::LazyLock;
+
+use crate::color::{css4, xkcd};
+use crate::geom::{Padding, Size};
+use crate::{Rgb8, Rgba8, geom};
+
+static INVERSE_COLOR_MAP: LazyLock<HashMap<Rgba8, &'static str>> = LazyLock::new(|| {
+    let mut map = HashMap::with_capacity(xkcd::COLORS.len() + css4::COLORS.len());
+    map.extend(xkcd::COLORS.iter().map(|(name, rgba)| (*rgba, *name)));
+    map.extend(css4::COLORS.iter().map(|(name, rgba)| (*rgba, *name)));
+    map
+});
+
+impl serde::Serialize for Rgb8 {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        if let Some(name) = INVERSE_COLOR_MAP.get(&self.opaque()) {
+            name.serialize(serializer)
+        } else {
+            self.html().serialize(serializer)
+        }
+    }
+}
+
+impl serde::Serialize for Rgba8 {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        if let Some(name) = INVERSE_COLOR_MAP.get(self) {
+            name.serialize(serializer)
+        } else {
+            self.html().serialize(serializer)
+        }
+    }
+}
+struct ColorSeqVisitor;
+
+impl<'de> serde::de::Visitor<'de> for ColorSeqVisitor {
+    type Value = Vec<u8>;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        formatter.write_str("a color string or an RGB/RGBA tuple")
+    }
+
+    fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
+    where
+        E: serde::de::Error,
+    {
+        let rgba = value.parse::<Rgba8>().map_err(E::custom)?;
+        Ok(vec![rgba.r(), rgba.g(), rgba.b(), rgba.a()])
+    }
+
+    fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
+    where
+        A: serde::de::SeqAccess<'de>,
+    {
+        let mut values = Vec::with_capacity(seq.size_hint().unwrap_or(4));
+        while let Some(v) = seq.next_element::<u8>()? {
+            values.push(v);
+        }
+        match values.len() {
+            3 | 4 => Ok(values),
+            len => Err(serde::de::Error::invalid_length(len, &self)),
+        }
+    }
+}
+
+impl<'de> serde::Deserialize<'de> for Rgb8 {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let values = deserializer.deserialize_any(ColorSeqVisitor)?;
+        match values.as_slice() {
+            [r, g, b] => Ok(Rgb8::new(*r, *g, *b)),
+            [r, g, b, a] if *a == 255 => Ok(Rgb8::new(*r, *g, *b)),
+            [..] => Err(serde::de::Error::custom(
+                "RGB colors cannot include a non-opaque alpha component",
+            )),
+        }
+    }
+}
+
+impl<'de> serde::Deserialize<'de> for Rgba8 {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let values = deserializer.deserialize_any(ColorSeqVisitor)?;
+        match values.as_slice() {
+            [r, g, b] => Ok(Rgba8::new(*r, *g, *b, 255)),
+            [r, g, b, a] => Ok(Rgba8::new(*r, *g, *b, *a)),
+            _ => unreachable!(),
+        }
+    }
+}
+
+impl serde::Serialize for geom::Size {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        (self.width(), self.height()).serialize(serializer)
+    }
+}
+
+impl<'de> serde::Deserialize<'de> for geom::Size {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        struct SizeVisitor;
+
+        impl<'de> serde::de::Visitor<'de> for SizeVisitor {
+            type Value = Size;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+                formatter.write_str("a [width, height] tuple or an object { width, height }")
+            }
+
+            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
+            where
+                A: serde::de::SeqAccess<'de>,
+            {
+                let width = seq
+                    .next_element::<f32>()?
+                    .ok_or_else(|| serde::de::Error::invalid_length(0, &self))?;
+                let height = seq
+                    .next_element::<f32>()?
+                    .ok_or_else(|| serde::de::Error::invalid_length(1, &self))?;
+                Ok(Size::new(width, height))
+            }
+
+            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
+            where
+                A: serde::de::MapAccess<'de>,
+            {
+                let mut width = None::<f32>;
+                let mut height = None::<f32>;
+
+                while let Some(key) = map.next_key::<std::borrow::Cow<'de, str>>()? {
+                    match key.as_ref() {
+                        "width" => {
+                            if width.is_some() {
+                                let _: f32 = map.next_value()?;
+                                return Err(serde::de::Error::duplicate_field("width"));
+                            }
+                            width = Some(map.next_value()?);
+                        }
+                        "height" => {
+                            if height.is_some() {
+                                let _: f32 = map.next_value()?;
+                                return Err(serde::de::Error::duplicate_field("height"));
+                            }
+                            height = Some(map.next_value()?);
+                        }
+                        _ => {
+                            return Err(serde::de::Error::unknown_field(
+                                key.as_ref(),
+                                &["width", "height"],
+                            ));
+                        }
+                    }
+                }
+
+                Ok(Size::new(
+                    width.ok_or_else(|| serde::de::Error::missing_field("width"))?,
+                    height.ok_or_else(|| serde::de::Error::missing_field("height"))?,
+                ))
+            }
+        }
+
+        deserializer.deserialize_any(SizeVisitor)
+    }
+}
+
+impl serde::Serialize for geom::Padding {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        match self {
+            geom::Padding::Even(p) => p.serialize(serializer),
+            geom::Padding::Center { ver, hor } => (ver, hor).serialize(serializer),
+            geom::Padding::Custom {
+                top,
+                right,
+                bottom,
+                left,
+            } => (top, right, bottom, left).serialize(serializer),
+        }
+    }
+}
+
+impl<'de> serde::Deserialize<'de> for Padding {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        struct PaddingVisitor;
+
+        impl<'de> serde::de::Visitor<'de> for PaddingVisitor {
+            type Value = Padding;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+                formatter.write_str("a single float for even padding, a tuple of two floats for center padding, or a tuple of four floats for custom padding")
+            }
+
+            fn visit_i64<E>(self, value: i64) -> Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                Ok(Padding::Even(value as f32))
+            }
+
+            fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                Ok(Padding::Even(value as f32))
+            }
+
+            fn visit_f32<E>(self, value: f32) -> Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                Ok(Padding::Even(value))
+            }
+
+            fn visit_f64<E>(self, value: f64) -> Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                Ok(Padding::Even(value as f32))
+            }
+
+            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
+            where
+                A: serde::de::SeqAccess<'de>,
+            {
+                let first = seq
+                    .next_element::<f32>()?
+                    .ok_or_else(|| serde::de::Error::invalid_length(0, &self))?;
+                let second = seq
+                    .next_element::<f32>()?
+                    .ok_or_else(|| serde::de::Error::invalid_length(1, &self))?;
+
+                if let Some(third) = seq.next_element::<f32>()? {
+                    let fourth = seq
+                        .next_element::<f32>()?
+                        .ok_or_else(|| serde::de::Error::invalid_length(3, &self))?;
+                    Ok(Padding::Custom {
+                        top: first,
+                        right: second,
+                        bottom: third,
+                        left: fourth,
+                    })
+                } else {
+                    Ok(Padding::Center {
+                        ver: first,
+                        hor: second,
+                    })
+                }
+            }
+
+            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
+            where
+                A: serde::de::MapAccess<'de>,
+            {
+                let mut ver = None::<f32>;
+                let mut hor = None::<f32>;
+                let mut top = None::<f32>;
+                let mut right = None::<f32>;
+                let mut bottom = None::<f32>;
+                let mut left = None::<f32>;
+
+                while let Some(field) = map.next_key::<Cow<'de, str>>()? {
+                    match &*field {
+                        "ver" => {
+                            ver = Some(map.next_value()?);
+                        }
+                        "hor" => {
+                            hor = Some(map.next_value()?);
+                        }
+                        "top" => top = Some(map.next_value()?),
+                        "right" => right = Some(map.next_value()?),
+                        "bottom" => bottom = Some(map.next_value()?),
+                        "left" => left = Some(map.next_value()?),
+                        _ => {
+                            return Err(serde::de::Error::unknown_field(
+                                &field,
+                                &["ver", "hor", "top", "right", "bottom", "left"],
+                            ));
+                        }
+                    }
+                }
+
+                match (ver, hor, top, right, bottom, left) {
+                    (Some(ver), Some(hor), None, None, None, None) => {
+                        Ok(geom::Padding::Center { ver, hor })
+                    }
+                    (None, None, Some(top), Some(right), Some(bottom), Some(left)) => {
+                        Ok(geom::Padding::Custom {
+                            top,
+                            right,
+                            bottom,
+                            left,
+                        })
+                    }
+                    _ => Err(serde::de::Error::custom(
+                        "Expected either a tuple of two floats for center padding or a tuple of four floats for custom padding",
+                    )),
+                }
+            }
+        }
+
+        deserializer.deserialize_any(PaddingVisitor)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_color_ser() {
+        let color = Rgba8::new(255, 0, 0, 255);
+        let serialized = serde_json::to_string(&color).unwrap();
+        assert_eq!(serialized, "\"red\"");
+
+        let color = "antiquewhite".parse::<Rgba8>().unwrap();
+        let serialized = serde_json::to_string(&color).unwrap();
+        assert_eq!(serialized, "\"antiquewhite\"");
+
+        let color = Rgba8::new(0x12, 0x34, 0x56, 0xff);
+        let serialized = serde_json::to_string(&color).unwrap();
+        assert_eq!(serialized, "\"#123456\"");
+
+        let color = Rgba8::new(0x12, 0x34, 0x56, 0);
+        let serialized = serde_json::to_string(&color).unwrap();
+        assert_eq!(serialized, "\"rgba(18, 52, 86, 0)\"");
+    }
+
+    #[test]
+    fn test_color_deser() {
+        let json = "\"red\"";
+        let deserialized: Rgba8 = serde_json::from_str(json).unwrap();
+        assert_eq!(deserialized, Rgba8::new(255, 0, 0, 255));
+
+        let json = "\"#123456\"";
+        let deserialized: Rgba8 = serde_json::from_str(json).unwrap();
+        assert_eq!(deserialized, Rgba8::new(0x12, 0x34, 0x56, 255));
+
+        let json = "\"rgba(18, 52, 86, 0)\"";
+        let deserialized: Rgba8 = serde_json::from_str(json).unwrap();
+        assert_eq!(deserialized, Rgba8::new(0x12, 0x34, 0x56, 0));
+
+        let json = "[18, 52, 86]";
+        let deserialized: Rgba8 = serde_json::from_str(json).unwrap();
+        assert_eq!(deserialized, Rgba8::new(0x12, 0x34, 0x56, 255));
+    }
+
+    #[test]
+    fn test_size_ser() {
+        let size = Size::new(100.0, 200.0);
+        let serialized = serde_json::to_string(&size).unwrap();
+        assert_eq!(serialized, "[100.0,200.0]");
+    }
+
+    #[test]
+    fn test_size_deser() {
+        let json = "[100.0, 200.0]";
+        let deserialized: Size = serde_json::from_str(json).unwrap();
+        assert_eq!(deserialized, Size::new(100.0, 200.0));
+        let json = r#"{"width": 100.0, "height": 200.0}"#;
+        let deserialized: Size = serde_json::from_str(json).unwrap();
+        assert_eq!(deserialized, Size::new(100.0, 200.0));
+    }
+
+    #[test]
+    fn test_padding_ser() {
+        let tests = vec![
+            (Padding::Even(10.0), "10.0"),
+            (
+                Padding::Center {
+                    ver: 5.0,
+                    hor: 15.0,
+                },
+                "[5.0,15.0]",
+            ),
+            (
+                Padding::Custom {
+                    top: 1.0,
+                    right: 2.0,
+                    bottom: 3.0,
+                    left: 4.0,
+                },
+                "[1.0,2.0,3.0,4.0]",
+            ),
+        ];
+        for (padding, expected) in tests {
+            let serialized = serde_json::to_string(&padding).unwrap();
+            assert_eq!(serialized, expected);
+        }
+    }
+
+    #[test]
+    fn test_padding_deser() {
+        let tests = vec![
+            ("10.0", Padding::Even(10.0)),
+            (
+                "[5.0, 15.0]",
+                Padding::Center {
+                    ver: 5.0,
+                    hor: 15.0,
+                },
+            ),
+            (
+                "[1.0, 2.0, 3.0, 4.0]",
+                Padding::Custom {
+                    top: 1.0,
+                    right: 2.0,
+                    bottom: 3.0,
+                    left: 4.0,
+                },
+            ),
+            (
+                r#"{"ver": 5.0, "hor": 15.0}"#,
+                Padding::Center {
+                    ver: 5.0,
+                    hor: 15.0,
+                },
+            ),
+            (
+                r#"{"top": 1.0, "right": 2.0, "bottom": 3.0, "left": 4.0}"#,
+                Padding::Custom {
+                    top: 1.0,
+                    right: 2.0,
+                    bottom: 3.0,
+                    left: 4.0,
+                },
+            ),
+        ];
+        for (json, expected) in tests {
+            let deserialized: Padding = serde_json::from_str(json).unwrap();
+            assert_eq!(deserialized, expected);
+        }
+    }
+}
diff --git a/examples/common/mod.rs b/examples/common/mod.rs
index 7ff8e206..a263feee 100644
--- a/examples/common/mod.rs
+++ b/examples/common/mod.rs
@@ -36,10 +36,30 @@ enum Svg {
     Yes(Option<PathBuf>),
 }
 
+#[cfg(feature = "serde")]
+#[derive(Debug, Clone, Default)]
+enum Json {
+    #[default]
+    No,
+    Yes(Option<PathBuf>),
+}
+
+#[cfg(feature = "serde")]
+#[derive(Debug, Clone, Default)]
+enum Yml {
+    #[default]
+    No,
+    Yes(Option<PathBuf>),
+}
+
 #[derive(Debug, Clone, Default)]
 struct Args {
     png: Png,
     svg: Svg,
+    #[cfg(feature = "serde")]
+    json: Json,
+    #[cfg(feature = "serde")]
+    yml: Yml,
     show: bool,
     style: Option<Style>,
 }
@@ -51,6 +71,10 @@ fn parse_args() -> Args {
         match arg.as_str() {
             "png" => args.png = Png::Yes(None),
             "svg" => args.svg = Svg::Yes(None),
+            #[cfg(feature = "serde")]
+            "json" => args.json = Json::Yes(None),
+            #[cfg(feature = "serde")]
+            "yml" => args.yml = Yml::Yes(None),
             "show" => args.show = true,
             "light" => args.style = Some(Style::light()),
             "tol-bright" => args.style = Some(Style::tol_bright()),
@@ -80,12 +104,20 @@ fn parse_args() -> Args {
         }
     }
 
+    #[cfg(not(feature = "serde"))]
     if matches!(
         (&args.png, &args.svg, &args.show),
         (Png::No, Svg::No, false)
     ) {
         args.show = true;
     }
+    #[cfg(feature = "serde")]
+    if matches!(
+        (&args.png, &args.svg, &args.show, &args.json, &args.yml),
+        (Png::No, Svg::No, false, Json::No, Yml::No)
+    ) {
+        args.show = true;
+    }
 
     args
 }
@@ -116,7 +148,7 @@ fn save_fig<D>(
 ) where
     D: data::Source + ?Sized,
 {
-    let fig = fig.prepare(data_source, Some(fontdb)).unwrap();
+    let prepared_fig = fig.prepare(data_source, Some(fontdb)).unwrap();
 
     match &args.png {
         Png::No => (),
@@ -125,16 +157,17 @@ fn save_fig<D>(
                 Some(path) => path.to_string_lossy().to_string(),
                 None => format!("{}.png", default_name),
             };
-            fig.save_png(
-                &file_name,
-                data_source,
-                plotive_pxl::Params {
-                    style: args.style.as_ref().cloned().unwrap_or_default(),
-                    scale: 2.0,
-                    fontdb: Some(fontdb),
-                },
-            )
-            .unwrap();
+            prepared_fig
+                .save_png(
+                    &file_name,
+                    data_source,
+                    plotive_pxl::Params {
+                        style: args.style.as_ref().cloned().unwrap_or_default(),
+                        scale: 2.0,
+                        fontdb: Some(fontdb),
+                    },
+                )
+                .unwrap();
         }
     }
 
@@ -145,17 +178,44 @@ fn save_fig<D>(
                 Some(path) => path.to_string_lossy().to_string(),
                 None => format!("{}.svg", default_name),
             };
-            fig.save_svg(
-                &file_name,
-                data_source,
-                plotive_svg::Params {
-                    style: args.style.as_ref().cloned().unwrap_or_default(),
-                    scale: 1.0,
-                    fontdb: Some(fontdb),
-                    id_prefix: Some(format!("{}", default_name)),
-                },
-            )
-            .unwrap();
+            prepared_fig
+                .save_svg(
+                    &file_name,
+                    data_source,
+                    plotive_svg::Params {
+                        style: args.style.as_ref().cloned().unwrap_or_default(),
+                        scale: 1.0,
+                        fontdb: Some(fontdb),
+                        id_prefix: Some(format!("{}", default_name)),
+                    },
+                )
+                .unwrap();
+        }
+    }
+
+    #[cfg(feature = "serde")]
+    match &args.json {
+        Json::No => (),
+        Json::Yes(filename) => {
+            let file_name = match filename {
+                Some(path) => path.to_string_lossy().to_string(),
+                None => format!("{}.json", default_name),
+            };
+
+            serde_json::to_writer_pretty(std::fs::File::create(&file_name).unwrap(), &fig).unwrap();
+        }
+    }
+
+    #[cfg(feature = "serde")]
+    match &args.yml {
+        Yml::No => (),
+        Yml::Yes(filename) => {
+            let file_name = match filename {
+                Some(path) => path.to_string_lossy().to_string(),
+                None => format!("{}.yml", default_name),
+            };
+
+            noyalib::to_writer(std::fs::File::create(&file_name).unwrap(), &fig).unwrap();
         }
     }
 
@@ -163,14 +223,15 @@ fn save_fig<D>(
         let data_source = data_source.copy();
         let fontdb = Arc::new(fontdb.clone());
 
-        fig.show(
-            data_source,
-            plotive_iced::show::Params {
-                style: args.style.clone(),
-                fontdb: Some(fontdb),
-                ..Default::default()
-            },
-        )
-        .unwrap();
+        prepared_fig
+            .show(
+                data_source,
+                plotive_iced::show::Params {
+                    style: args.style.clone(),
+                    fontdb: Some(fontdb),
+                    ..Default::default()
+                },
+            )
+            .unwrap();
     }
 }
diff --git a/examples/minimal.rs b/examples/minimal.rs
new file mode 100644
index 00000000..ff8f6e75
--- /dev/null
+++ b/examples/minimal.rs
@@ -0,0 +1,19 @@
+mod common;
+
+use plotive::{data, des};
+
+fn main() {
+    let fig = des::series::Line::new(des::data_src_ref("x"), des::data_src_ref("y"))
+        .into_plot()
+        .into_figure()
+        .with_title("Minimal Figure".into());
+
+    let x = vec![1.0, 2.0, 3.0];
+    let y = vec![3.0, 1.0, 2.0];
+
+    let data_source = data::TableSource::new()
+        .with_f64_column("x".into(), x)
+        .with_f64_column("y".into(), y);
+
+    common::save_figure(&fig, &data_source, None, "minimal");
+}
diff --git a/examples/multiple_axes.rs b/examples/multiple_axes.rs
index 01ea4606..26a06839 100644
--- a/examples/multiple_axes.rs
+++ b/examples/multiple_axes.rs
@@ -34,7 +34,7 @@ fn main() {
         .into();
 
     let plot = des::Plot::new(vec![series1, series2])
-        .with_border(des::plot::AxisArrow::default().into())
+        .with_border(des::plot::AxisArrowBorder::default().into())
         .with_x_axis(x_axis)
         .with_y_axis(y1_axis)
         .with_y_axis(y2_axis);
diff --git a/examples/sine.rs b/examples/sine.rs
index e3fefa75..ab7122e2 100644
--- a/examples/sine.rs
+++ b/examples/sine.rs
@@ -26,7 +26,7 @@ fn main() {
                 .with_minor_ticks(Default::default())
                 .with_minor_grid(Default::default()),
         )
-        .with_border(des::plot::AxisArrow::default().into())
+        .with_border(des::plot::AxisArrowBorder::default().into())
         .with_legend(des::plot::LegendPos::InTopRight.into())
         .into_figure()
         .with_title("Sine wave".into());
diff --git a/run_all_examples.sh b/run_all_examples.sh
index b9eff2b2..e04e6a42 100755
--- a/run_all_examples.sh
+++ b/run_all_examples.sh
@@ -1,28 +1,29 @@
 #! /bin/bash
 
+if [ $# -eq 0 ]; then
+    echo "No output format specified, defaulting to png"
+    set -- png
+fi
 
 cargo run --example text_line --package plotive-text --features noto-sans
 cargo run --example text_rich --package plotive-text --features noto-sans,noto-serif
 
-cargo run --example area -- $@
-cargo run --example bars -- $@
-cargo run --example gauss -- $@
-cargo run --example sine -- $@
-
-cargo run --example bouncing_ball --features time -- $@
-
-cargo run --example bode_rlc --features noto-serif-italic,utils -- $@
-
-cargo run --example multiple_axes --features utils -- $@
-cargo run --example subplots --features utils -- $@
-
-cargo run --example bitcoin --features data-csv,time -- $@
-cargo run --example iris --features data-csv -- $@
-cargo run --example stars --features data-csv -- $@
-
-cargo run --example bode_rlc_dsl --features dsl,noto-serif-italic,utils -- $@
-
-cargo run --example iris_dsl --features data-csv,dsl -- $@
-
-cargo run --example multiple_axes_dsl --features dsl,utils -- $@
-cargo run --example subplots_dsl --features dsl,utils -- $@
+# passing all needed feature to each example to avoid unnecessary recompilation
+features="data-csv,dsl,noto-sans,noto-serif-italic,serde,time,utils"
+
+cargo run --example area --features $features -- $@
+cargo run --example bars --features $features -- $@
+cargo run --example bitcoin --features $features -- $@
+cargo run --example bode_rlc --features $features -- $@
+cargo run --example bode_rlc_dsl --features $features -- $@
+cargo run --example bouncing_ball --features $features -- $@
+cargo run --example gauss --features $features -- $@
+cargo run --example iris --features $features -- $@
+cargo run --example iris_dsl --features $features -- $@
+cargo run --example minimal --features $features -- $@
+cargo run --example multiple_axes --features $features -- $@
+cargo run --example multiple_axes_dsl --features $features -- $@
+cargo run --example sine --features $features -- $@
+cargo run --example stars --features $features -- $@
+cargo run --example subplots --features $features -- $@
+cargo run --example subplots_dsl --features $features -- $@
diff --git a/src/data.rs b/src/data.rs
index b8d1a184..cd63d572 100644
--- a/src/data.rs
+++ b/src/data.rs
@@ -1445,7 +1445,7 @@ impl<'a> Source for NamedColumns<'a> {
 }
 
 /// Column implementation backed by vectors, type known at runtime
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq)]
 pub enum VecColumn {
     /// f64 column
     F64(Vec<f64>),
diff --git a/src/des.rs b/src/des.rs
index 27814d16..0458e386 100644
--- a/src/des.rs
+++ b/src/des.rs
@@ -12,6 +12,9 @@ pub mod legend;
 pub mod plot;
 pub mod series;
 
+#[cfg(feature = "serde")]
+mod sd;
+
 pub use annot::Annotation;
 pub use axis::Axis;
 pub use colorbar::ColorBar;
@@ -112,7 +115,7 @@ macro_rules! define_rich_text_structs {
         pub type $opt_props_struct = $crate::text::rich::TextOptProps<$crate::style::theme::Color>;
 
         /// Rich text base properties with plotive theme colors
-        #[derive(Debug, Clone)]
+        #[derive(Debug, Clone, PartialEq)]
         pub struct $props_struct($crate::text::rich::TextProps<$crate::style::theme::Color>);
 
         impl $props_struct {
@@ -175,7 +178,7 @@ macro_rules! define_rich_text_structs {
         }
 
         /// Rich text structure with plotive theme colors
-        #[derive(Debug, Clone)]
+        #[derive(Debug, Clone, PartialEq)]
         pub struct $text_struct {
             text: String,
             props: $props_struct,
diff --git a/src/des/annot.rs b/src/des/annot.rs
index 0b97f4e0..58b3d446 100644
--- a/src/des/annot.rs
+++ b/src/des/annot.rs
@@ -7,7 +7,7 @@ use crate::text::Font;
 /// The placement is made according to the data coordinates.
 /// By default, lines are plotted under the series, and other annotations are plotted above the series.
 /// This can be changed using [`with_zpos()`](Annotation::with_zpos).
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq)]
 pub enum Annotation {
     /// A line plotted on the plot area.
     Line(Line),
@@ -124,7 +124,7 @@ pub enum ZPos {
 }
 
 /// A line plotted on the plot area.
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct Line {
     direction: LineDir,
     stroke: theme::Stroke,
@@ -136,7 +136,7 @@ pub struct Line {
 
 /// The definition of the direction of a line plotted on the plot area.
 /// This type defines the position and orientation of the line in data coordinates.
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy, PartialEq)]
 pub enum LineDir {
     /// A horizontal line passing by the given y value in data coordinates
     Horizontal(f64),
@@ -279,7 +279,7 @@ impl Line {
 }
 
 /// An arrow plotted on the plot area
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct Arrow {
     x: f64,
     y: f64,
@@ -386,7 +386,7 @@ impl Arrow {
 }
 
 /// An arbitrary marker to place on the plot area
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct Marker {
     x: f64,
     y: f64,
@@ -493,7 +493,7 @@ pub enum Anchor {
 }
 
 /// An arbitrary label to place on the plot area
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct Label {
     x: f64,
     y: f64,
diff --git a/src/des/axis.rs b/src/des/axis.rs
index 0745592f..7fb82bdc 100644
--- a/src/des/axis.rs
+++ b/src/des/axis.rs
@@ -35,7 +35,7 @@ pub enum Side {
 /// Axes references can be used in two contexts:
 ///     - sharing axes across different subplots of a figure
 ///     - attach series to a specific axis in the case of multiple X or Y axes
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub enum Ref {
     /// Reference by index in the order declared in the plot,
     /// for the given orientation (X or Y), and starting at 0.
@@ -43,15 +43,6 @@ pub enum Ref {
     /// To refer to indices in a different plot (for subplot shared axes),
     /// you may use [Ref::Id]
     Idx(usize),
-    /// Reference by index in the order declared in the figure,
-    /// for the given orientation (X or Y), and starting at 0.
-    /// As an example, if a figure has 2 plots, each with a single X axis and two Y axes,
-    /// Ref::FigIdx(1) will refer to the X axis of the second plot in X context,
-    /// and to the second Y axis of the first plot in Y context.
-    ///
-    /// FigIdx can only be used in the context of shared axes across subplots (see [`Scale::Shared`]).
-    /// An error is raised if it is assigned to a series or annotation.
-    FigIdx(usize),
     /// Reference by id (see [Axis::id]) or by title (see [Axis::title]).
     /// If two axes have the same id or title, the first one found will be used.
     Id(String),
@@ -79,7 +70,7 @@ pub fn ref_id(id: impl Into<String>) -> Ref {
 }
 
 /// Axis definition
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct Axis {
     id: Option<String>,
     title: Option<Title>,
@@ -240,7 +231,7 @@ impl Axis {
 
 /// Describe the bounds of an axis in data space
 /// None means automatic bounds depending on the data
-#[derive(Debug, Clone, Copy, Default)]
+#[derive(Debug, Clone, Copy, Default, PartialEq)]
 pub struct Range(pub Option<f64>, pub Option<f64>);
 
 impl From<(Option<f64>, Option<f64>)> for Range {
@@ -290,7 +281,7 @@ impl Range {
 }
 
 /// Describe a logarithmic scale options
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy, PartialEq)]
 pub struct LogScale {
     /// Logarithm base (typically 10.0)
     pub base: f64,
@@ -322,7 +313,7 @@ impl Default for LogScale {
 }
 
 /// Describes the type of an axis scale
-#[derive(Debug, Clone, Default)]
+#[derive(Debug, Clone, Default, PartialEq)]
 pub enum Scale {
     /// Full auto scale, depending on the data and type of plot.
     /// Will typically translate to auto linear axis for numerical data
@@ -403,7 +394,7 @@ pub mod ticks {
     use crate::text::Font;
 
     /// Describes how to locate the ticks of an axis
-    #[derive(Debug, Default, Clone)]
+    #[derive(Debug, Default, Clone, PartialEq)]
     pub enum Locator {
         /// Automatic tick placement, that depends on the type of axis (linear, logarithmic, categories),
         /// on the axis data range (bounds) and whether the ticks are major or minor
@@ -430,7 +421,7 @@ pub mod ticks {
     }
 
     /// A locator that places ticks at the specified locations in data space
-    #[derive(Debug, Clone)]
+    #[derive(Debug, Clone, PartialEq)]
     pub struct ListLocator(pub Vec<f64>);
 
     impl From<Vec<f64>> for Locator {
@@ -452,7 +443,7 @@ pub mod ticks {
     }
 
     /// A locator that places ticks automatically, using the specified number of bins and steps
-    #[derive(Debug, Clone)]
+    #[derive(Debug, Clone, PartialEq)]
     pub struct MaxNLocator {
         /// Number of bins (that is number of ticks - 1)
         pub bins: u32,
@@ -478,7 +469,7 @@ pub mod ticks {
 
     /// A locator that places ticks at multiples of π
     /// The axis will be annotated with `× π`
-    #[derive(Debug, Clone, Copy)]
+    #[derive(Debug, Clone, Copy, PartialEq)]
     pub struct PiMultipleLocator {
         /// Number of bins (that is number of ticks - 1)
         pub bins: u32,
@@ -497,7 +488,7 @@ pub mod ticks {
     }
 
     /// A locator that places ticks on a logarithmic scale
-    #[derive(Debug, Clone, Copy)]
+    #[derive(Debug, Clone, Copy, PartialEq)]
     pub struct LogLocator {
         /// Logarithm base
         pub base: f64,
@@ -517,7 +508,7 @@ pub mod ticks {
 
     #[cfg(feature = "time")]
     /// Describes how to locate the ticks of a DateTime axis
-    #[derive(Debug, Default, Clone, Copy)]
+    #[derive(Debug, Default, Clone, Copy, PartialEq)]
     pub enum DateTimeLocator {
         /// Automatic tick placement for DateTime axis using
         /// the axis bounds and heuristics to have a reasonable number of ticks
@@ -550,7 +541,7 @@ pub mod ticks {
 
     #[cfg(feature = "time")]
     /// Describes how to locate the ticks of a TimeDelta axis
-    #[derive(Debug, Default, Clone, Copy)]
+    #[derive(Debug, Default, Clone, Copy, PartialEq)]
     pub enum TimeDeltaLocator {
         /// Automatic tick placement for TimeDelta axis using
         /// the axis bounds and heuristics to have a reasonable number of ticks
@@ -577,7 +568,7 @@ pub mod ticks {
 
     #[allow(missing_copy_implementations)]
     /// Describes how to format the ticks labels
-    #[derive(Debug, Default, Clone)]
+    #[derive(Debug, Default, Clone, PartialEq)]
     pub enum Formatter {
         /// Automatic tick formatting.
         /// Depending on the scale and locator, the formatter will pick a suitable format.
@@ -604,7 +595,7 @@ pub mod ticks {
     }
 
     /// A label formatter for DateTime ticks
-    #[derive(Debug, Clone, Copy, Default)]
+    #[derive(Debug, Clone, Copy, Default, PartialEq)]
     pub struct PercentFormatter {
         /// Number of decimal places
         /// None means automatic
@@ -619,7 +610,7 @@ pub mod ticks {
 
     #[cfg(feature = "time")]
     /// A label formatter for DateTime ticks
-    #[derive(Debug, Clone, Default)]
+    #[derive(Debug, Clone, Default, PartialEq)]
     pub enum DateTimeFormatter {
         /// Choose the format automatically according to time bounds
         #[default]
@@ -634,6 +625,21 @@ pub mod ticks {
         Custom(String),
     }
 
+    #[cfg(feature = "time")]
+    impl DateTimeFormatter {
+        /// Returns the format string for this formatter, if any
+        /// None means automatic formatting
+        pub fn fmt_str(&self) -> Option<String> {
+            match self {
+                DateTimeFormatter::Auto => None,
+                DateTimeFormatter::DateTime => Some("%Y-%m-%d %H:%M:%S".to_string()),
+                DateTimeFormatter::Date => Some("%Y-%m-%d".to_string()),
+                DateTimeFormatter::Time => Some("%H:%M:%S".to_string()),
+                DateTimeFormatter::Custom(fmt) => Some(fmt.clone()),
+            }
+        }
+    }
+
     #[cfg(feature = "time")]
     impl From<DateTimeFormatter> for Formatter {
         fn from(fmt: DateTimeFormatter) -> Self {
@@ -643,7 +649,7 @@ pub mod ticks {
 
     #[cfg(feature = "time")]
     /// A label formatter for TimeDelta ticks
-    #[derive(Debug, Clone, Default)]
+    #[derive(Debug, Clone, Default, PartialEq)]
     pub enum TimeDeltaFormatter {
         /// Choose the format automatically based on data bounds
         #[default]
@@ -652,6 +658,18 @@ pub mod ticks {
         Custom(String),
     }
 
+    #[cfg(feature = "time")]
+    impl TimeDeltaFormatter {
+        /// Returns the format string for this formatter, if any
+        /// None means automatic formatting
+        pub fn fmt_str(&self) -> Option<String> {
+            match self {
+                TimeDeltaFormatter::Auto => None,
+                TimeDeltaFormatter::Custom(fmt) => Some(fmt.clone()),
+            }
+        }
+    }
+
     #[cfg(feature = "time")]
     impl From<TimeDeltaFormatter> for Formatter {
         fn from(fmt: TimeDeltaFormatter) -> Self {
@@ -660,7 +678,7 @@ pub mod ticks {
     }
 
     /// Describes the font of the ticks labels
-    #[derive(Debug, Clone)]
+    #[derive(Debug, Clone, PartialEq)]
     pub struct TicksFont {
         /// The font of the ticks labels
         pub font: Font,
@@ -678,7 +696,7 @@ pub mod ticks {
     }
 
     /// Describes the style of the major grid lines
-    #[derive(Debug, Clone)]
+    #[derive(Debug, Clone, PartialEq)]
     pub struct Grid(pub theme::Stroke);
 
     impl Default for Grid {
@@ -698,8 +716,20 @@ pub mod ticks {
         }
     }
 
+    impl From<Grid> for theme::Stroke {
+        fn from(grid: Grid) -> Self {
+            grid.0
+        }
+    }
+
+    impl AsRef<theme::Stroke> for Grid {
+        fn as_ref(&self) -> &theme::Stroke {
+            &self.0
+        }
+    }
+
     /// Describes the major ticks of an axis
-    #[derive(Debug, Clone)]
+    #[derive(Debug, Clone, PartialEq)]
     pub struct Ticks {
         locator: Locator,
         formatter: Option<Formatter>,
@@ -775,7 +805,7 @@ pub mod ticks {
     }
 
     /// Describes the style of the minor grid lines
-    #[derive(Debug, Clone)]
+    #[derive(Debug, Clone, PartialEq)]
     pub struct MinorGrid(pub theme::Stroke);
 
     impl Default for MinorGrid {
@@ -795,8 +825,20 @@ pub mod ticks {
         }
     }
 
+    impl From<MinorGrid> for theme::Stroke {
+        fn from(grid: MinorGrid) -> Self {
+            grid.0
+        }
+    }
+
+    impl AsRef<theme::Stroke> for MinorGrid {
+        fn as_ref(&self) -> &theme::Stroke {
+            &self.0
+        }
+    }
+
     /// Describes the minor ticks of an axis
-    #[derive(Debug, Clone)]
+    #[derive(Debug, Clone, PartialEq)]
     pub struct MinorTicks {
         /// Minor ticks locator
         locator: Locator,
diff --git a/src/des/cmap.rs b/src/des/cmap.rs
index 5a858dc3..4cc0e130 100644
--- a/src/des/cmap.rs
+++ b/src/des/cmap.rs
@@ -4,7 +4,7 @@ use crate::color::Rgb8;
 use crate::des::axis;
 
 /// Describes how to interpolate between colors in a color map, either in linear RGB or perceptual color space.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
 pub enum LerpMethod {
     /// Do not interpolate colors, only pick the nearest one
     Nearest,
@@ -13,6 +13,7 @@ pub enum LerpMethod {
     /// and can result in less visually appealing color maps.
     /// Use this if you have significant amount of stops in the colormap gradient or significant performance constraints.
     SRgb,
+    #[default]
     /// Interpolate colors in the linear RGB color space.
     LinearRgb,
     /// Interpolate colors in a perceptual color space (OkLab).
@@ -22,13 +23,15 @@ pub enum LerpMethod {
 }
 
 /// A color map that can be converted to a `MapColor` implementation at draw time.
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct LerpColorMap {
     method: LerpMethod,
     start: Rgb8,
     end: Rgb8,
     stops: Vec<(f32, Rgb8)>,
     scale: axis::Scale,
+    #[cfg(feature = "serde")]
+    name: Option<&'static str>,
 }
 
 impl LerpColorMap {
@@ -40,24 +43,54 @@ impl LerpColorMap {
             end,
             scale: Default::default(),
             stops: Vec::new(),
+            #[cfg(feature = "serde")]
+            name: None,
         }
     }
+
     /// Adds a color stop at the specified position (between 0.0 and 1.0) with the given color.
     pub fn with_stop(mut self, (position, color): (f32, Rgb8)) -> Self {
         assert!(
             position > 0.0 && position < 1.0,
             "Color stop position must be in range"
         );
+        #[cfg(feature = "serde")]
+        {
+            self.name = None;
+        }
         self.stops.push((position, color));
         self.stops.sort_by(|a, b| a.0.partial_cmp(&b.0).unwrap());
         self
     }
 
+    /// Set all the stops at once.
+    /// Previously set stops are erased
+    pub fn with_stops(mut self, stops: Vec<(f32, Rgb8)>) -> Self {
+        assert!(
+            stops
+                .iter()
+                .all(|(position, _)| position > &0.0 && position < &1.0),
+            "Color stop position must be in range"
+        );
+        #[cfg(feature = "serde")]
+        {
+            self.name = None;
+        }
+        let mut stops = stops;
+        stops.sort_by(|a, b| a.0.partial_cmp(&b.0).unwrap());
+        self.stops = stops;
+        self
+    }
+
     /// Assign a scale to this colormap.
     ///
     /// By default, the colormap will map linearly the full range of data values in the plot, but this can be overridden with this method.
     pub fn with_scale(mut self, scale: axis::Scale) -> Self {
         assert!(!scale.is_shared(), "Color map scale cannot be shared");
+        #[cfg(feature = "serde")]
+        {
+            self.name = None;
+        }
         self.scale = scale;
         self
     }
@@ -89,6 +122,40 @@ impl LerpColorMap {
     pub fn scale(&self) -> &axis::Scale {
         &self.scale
     }
+
+    #[cfg(feature = "serde")]
+    pub(crate) fn name(&self) -> Option<&'static str> {
+        self.name
+    }
+
+    #[allow(unused)]
+    fn with_name(mut self, name: &'static str) -> Self {
+        #[cfg(feature = "serde")]
+        {
+            self.name = Some(name);
+        }
+        self
+    }
+
+    #[cfg(feature = "serde")]
+    pub(crate) fn is_monotonic(&self) -> bool {
+        let div = 1.0 / (self.stops.len() as f32 + 1.0);
+        let mut cur = div;
+        for (pos, _) in self.stops.iter() {
+            if (cur - pos).abs() < 0.00001 {
+                cur += div;
+            } else {
+                return false;
+            }
+        }
+        true
+    }
+}
+
+impl Default for LerpColorMap {
+    fn default() -> Self {
+        viridis()
+    }
 }
 
 impl From<(LerpMethod, &[Rgb8])> for LerpColorMap {
@@ -174,6 +241,7 @@ pub fn stellar() -> LerpColorMap {
     .with_stop(stop_for_temp(10000.0))
     .with_stop(stop_for_temp(12500.0))
     .with_scale((MIN_TEMP, MAX_TEMP).into())
+    .with_name("stellar")
 }
 
 /// The famous "viridis" color map from matplotlib
@@ -185,5 +253,6 @@ pub fn viridis() -> LerpColorMap {
         Rgb8::from_hex(b"#5bc862"),
         Rgb8::from_hex(b"#fde724"),
     ];
-    (LerpMethod::Perceptual, STOPS).into()
+    let cmap: LerpColorMap = (LerpMethod::Perceptual, STOPS).into();
+    cmap.with_name("viridis")
 }
diff --git a/src/des/colorbar.rs b/src/des/colorbar.rs
index 0277be22..12ac64dc 100644
--- a/src/des/colorbar.rs
+++ b/src/des/colorbar.rs
@@ -12,7 +12,7 @@ impl Default for TitleProps {
 }
 
 /// Position of a color bar relatively to the plot
-#[derive(Debug, Default, Clone, Copy)]
+#[derive(Debug, Default, Clone, Copy, PartialEq)]
 pub enum Pos {
     /// Position the color bar above the plot area
     Top,
@@ -26,7 +26,7 @@ pub enum Pos {
 }
 
 /// Font configuration for color bar ticks
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct TicksFont {
     /// The font size in figure units
     pub size: f32,
@@ -47,9 +47,10 @@ impl Default for TicksFont {
 }
 
 /// ColorBar configuration for a plot
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct ColorBar {
-    pos: Pos,
+    // pub(crate) for serde implementation
+    pub(crate) pos: Pos,
     width: f32,
     title: Option<Title>,
     ticks_font: TicksFont,
diff --git a/src/des/figure.rs b/src/des/figure.rs
index d9e9f95b..2ac8f96d 100644
--- a/src/des/figure.rs
+++ b/src/des/figure.rs
@@ -14,7 +14,7 @@ impl Default for TitleProps {
 }
 
 /// Position of the legend relatively to the figure
-#[derive(Debug, Clone, Copy, Default)]
+#[derive(Debug, Clone, Copy, Default, PartialEq)]
 pub enum LegendPos {
     /// Position the legend at the top of the figure
     Top,
@@ -44,7 +44,7 @@ impl From<LegendPos> for FigLegend {
 }
 
 /// Figure structure. This is the top-level structure representing a figure to be drawn.
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct Figure {
     plots: Plots,
 
@@ -138,7 +138,7 @@ impl Figure {
 }
 
 /// Collection of plots for a figure
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq)]
 pub enum Plots {
     /// Unique plot on the figure
     Plot(Plot),
diff --git a/src/des/legend.rs b/src/des/legend.rs
index 5cf9f519..965278f9 100644
--- a/src/des/legend.rs
+++ b/src/des/legend.rs
@@ -8,7 +8,7 @@ use crate::style::{defaults, theme};
 use crate::text;
 
 /// The font configuration for legend entries
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct EntryFont {
     /// The font size in figure units
     pub size: f32,
@@ -29,7 +29,7 @@ impl Default for EntryFont {
 }
 
 /// Legend configuration for a plot
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct Legend<Pos> {
     pos: Pos,
     font: EntryFont,
@@ -49,11 +49,10 @@ impl<Pos: Default> Default for Legend<Pos> {
     /// - Default column layout (depdend on the position and number and width of entries)
     /// - Default padding and spacing
     fn default() -> Self {
-        let fill: theme::Fill = theme::Col::LegendFill.into();
         Self {
             pos: Pos::default(),
             font: EntryFont::default(),
-            fill: Some(fill.with_opacity(0.5)),
+            fill: defaults::legend_fill(),
             border: Some(theme::Col::LegendBorder.into()),
             columns: None,
             padding: defaults::LEGEND_PADDING.into(),
diff --git a/src/des/plot.rs b/src/des/plot.rs
index 077dde3b..62f0863a 100644
--- a/src/des/plot.rs
+++ b/src/des/plot.rs
@@ -3,9 +3,29 @@
 use crate::des::{Annotation, Axis, ColorBar, Legend, PlotIdx, Series};
 use crate::style::{defaults, theme};
 
+/// Border style for the plot area that draws a box all around the plot area
+#[derive(Debug, Clone, PartialEq)]
+pub struct BoxBorder(pub theme::Stroke);
+
+impl Default for BoxBorder {
+    fn default() -> Self {
+        BoxBorder(theme::Col::Foreground.into())
+    }
+}
+
+/// Border style for the plot area that draws lines where there are axes
+#[derive(Debug, Clone, PartialEq)]
+pub struct AxisBorder(pub theme::Stroke);
+
+impl Default for AxisBorder {
+    fn default() -> Self {
+        AxisBorder(theme::Col::Foreground.into())
+    }
+}
+
 /// Arrow border style for the plot area
-#[derive(Debug, Clone)]
-pub struct AxisArrow {
+#[derive(Debug, Clone, PartialEq)]
+pub struct AxisArrowBorder {
     /// Line style for the border and arrow
     pub stroke: theme::Stroke,
     /// Size of the arrow head
@@ -18,9 +38,9 @@ pub struct AxisArrow {
     pub overflow: f32,
 }
 
-impl Default for AxisArrow {
+impl Default for AxisArrowBorder {
     fn default() -> Self {
-        AxisArrow {
+        AxisArrowBorder {
             stroke: theme::Col::Foreground.into(),
             size: defaults::PLOT_AXIS_ARROW_SIZE,
             overflow: defaults::PLOT_AXIS_ARROW_OVERFLOW,
@@ -29,48 +49,72 @@ impl Default for AxisArrow {
 }
 
 /// Border style for the plot area
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq)]
 pub enum Border {
     /// A box border around the plot area
-    Box(theme::Stroke),
+    Box(BoxBorder),
     /// Border only on the axes sides
-    Axis(theme::Stroke),
+    Axis(AxisBorder),
     /// Arrow border on the axes sides
-    AxisArrow(AxisArrow),
+    AxisArrow(AxisArrowBorder),
 }
 
 impl Border {
     /// Get the line style for the border if applicable
-    pub fn line(&self) -> &theme::Stroke {
+    pub fn stroke(&self) -> &theme::Stroke {
         match self {
-            Border::Box(line) => line,
-            Border::Axis(line) => line,
-            Border::AxisArrow(arrow) => &arrow.stroke,
+            Border::Box(border) => &border.0,
+            Border::Axis(border) => &border.0,
+            Border::AxisArrow(border) => &border.stroke,
         }
     }
 }
 
 impl Default for Border {
     fn default() -> Self {
-        Border::Box(theme::Col::Foreground.into())
+        Border::Box(BoxBorder::default())
+    }
+}
+
+impl From<BoxBorder> for Border {
+    fn from(bb: BoxBorder) -> Self {
+        Border::Box(bb)
+    }
+}
+
+impl From<BoxBorder> for Option<Border> {
+    fn from(bb: BoxBorder) -> Self {
+        Some(Border::Box(bb))
+    }
+}
+
+impl From<AxisBorder> for Border {
+    fn from(ab: AxisBorder) -> Self {
+        Border::Axis(ab)
+    }
+}
+
+impl From<AxisBorder> for Option<Border> {
+    fn from(ab: AxisBorder) -> Self {
+        Some(Border::Axis(ab))
     }
 }
 
-impl From<AxisArrow> for Border {
-    fn from(aa: AxisArrow) -> Self {
+impl From<AxisArrowBorder> for Border {
+    fn from(aa: AxisArrowBorder) -> Self {
         Border::AxisArrow(aa)
     }
 }
 
-impl From<AxisArrow> for Option<Border> {
-    fn from(aa: AxisArrow) -> Self {
+impl From<AxisArrowBorder> for Option<Border> {
+    fn from(aa: AxisArrowBorder) -> Self {
         Some(Border::AxisArrow(aa))
     }
 }
 
-/// Insets inside the plot area
-/// around the data.
-#[derive(Debug, Default, Clone, Copy)]
+/// Insets inside the plot area, leaving blank space
+/// between the data series and the plot border
+#[derive(Debug, Default, Clone, Copy, PartialEq)]
 pub enum Insets {
     /// The insets depends on the style of series
     #[default]
@@ -80,7 +124,7 @@ pub enum Insets {
 }
 
 /// Position of the legend relatively to the plot
-#[derive(Debug, Default, Clone, Copy)]
+#[derive(Debug, Default, Clone, Copy, PartialEq)]
 pub enum LegendPos {
     /// Position the legend outside the plot area at the top
     OutTop,
@@ -141,7 +185,7 @@ impl From<LegendPos> for PlotLegend {
 }
 
 /// A plot, containing series, axes, title, legend, and styles
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct Plot {
     series: Vec<Series>,
 
@@ -332,7 +376,7 @@ impl Plot {
 }
 
 /// A collection of plots, arranged in a grid
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct Subplots {
     rows: u32,
     cols: u32,
diff --git a/src/des/sd.rs b/src/des/sd.rs
new file mode 100644
index 00000000..83664487
--- /dev/null
+++ b/src/des/sd.rs
@@ -0,0 +1,378 @@
+//! Serialization and deserialization of figures
+
+use serde::ser::SerializeStruct;
+
+use super::Figure;
+use crate::des::{FigLegend, Plot, Subplots, figure};
+use crate::geom;
+use crate::style::{defaults, theme};
+
+mod annot;
+mod axis;
+mod cmap;
+mod colorbar;
+mod legend;
+mod plot;
+mod series;
+mod style;
+#[cfg(feature = "time")]
+mod time;
+// MARK: figure::Title
+
+impl serde::Serialize for figure::Title {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        if self.spans().is_empty() && self.props() == &figure::TitleProps::default() {
+            self.text().serialize(serializer)
+        } else {
+            let mut state = serializer.serialize_struct("Title", 2)?;
+            state.serialize_field("text", self.text())?;
+            todo!("Serialize rich props and spans")
+            //state.end()
+        }
+    }
+}
+
+impl<'de> serde::Deserialize<'de> for figure::Title {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        struct TitleVisitor;
+
+        impl<'de> serde::de::Visitor<'de> for TitleVisitor {
+            type Value = figure::Title;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+                formatter.write_str("a figure title string or rich text")
+            }
+
+            fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                Ok(figure::Title::from(value.to_string()))
+            }
+
+            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
+            where
+                A: serde::de::MapAccess<'de>,
+            {
+                deserialize_map_fields!('de, map,
+                    "text" => text: Option<String>,
+                );
+                Ok(figure::Title::from(
+                    text.ok_or_else(|| serde::de::Error::missing_field("text"))?,
+                ))
+            }
+        }
+        deserializer.deserialize_any(TitleVisitor)
+    }
+}
+
+// MARK: Figure
+
+impl serde::Serialize for Figure {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let mut state = serializer.serialize_struct("Figure", 5)?;
+        if self.size() != defaults::FIG_SIZE {
+            state.serialize_field("size", &self.size())?;
+        }
+        if let Some(title) = self.title() {
+            state.serialize_field("title", title)?;
+        }
+        if self.fill() != Some(theme::Col::Background.into()) {
+            state.serialize_field("fill", &self.fill())?;
+        }
+        if let Some(legend) = self.legend() {
+            state.serialize_field("legend", legend)?;
+        }
+        if self.padding() != &defaults::FIG_PADDING {
+            state.serialize_field("padding", &self.padding())?;
+        }
+
+        match self.plots() {
+            figure::Plots::Plot(plot) => {
+                state.serialize_field("plot", plot)?;
+            }
+            figure::Plots::Subplots(subplots) => {
+                if subplots.space() != 0.0 {
+                    state.serialize_field("space", &subplots.space())?;
+                }
+
+                state.serialize_field("plots", subplots)?;
+            }
+        }
+
+        state.end()
+    }
+}
+
+impl<'de> serde::Deserialize<'de> for Figure {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        deserializer.deserialize_map(FigureVisitor)
+    }
+}
+
+struct FigureVisitor;
+
+impl<'de> serde::de::Visitor<'de> for FigureVisitor {
+    type Value = Figure;
+
+    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+        formatter.write_str("a figure object")
+    }
+
+    fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
+    where
+        A: serde::de::MapAccess<'de>,
+    {
+        deserialize_map_fields!('de, map,
+            "plot" => plot: Option<Plot>,
+            "plots" => plots: Option<Subplots>,
+            "space" => space: Option<f32>,
+            "size" => size: Option<geom::Size>,
+            "title" => title: Option<figure::Title>,
+            "fill" => fill: Option<Option<theme::Fill>>,
+            "legend" => legend: Option<FigLegend>,
+            "padding" => padding: Option<geom::Padding>,
+        );
+
+        let plots = match (plot, plots) {
+            (Some(plot), None) => {
+                if space.is_some() {
+                    return Err(serde::de::Error::custom(
+                        "The 'space' field can only be specified when using 'plots' field, not 'plot'",
+                    ));
+                }
+                figure::Plots::Plot(plot)
+            }
+            (None, Some(mut plots)) => {
+                if let Some(space) = space {
+                    plots = plots.with_space(space);
+                }
+                figure::Plots::Subplots(plots)
+            }
+            (Some(_), Some(_)) => {
+                return Err(serde::de::Error::custom(
+                    "Both 'plot' and 'plots' fields cannot be specified at the same time",
+                ));
+            }
+            (None, None) => {
+                return Err(serde::de::Error::custom(
+                    "Either 'plot' or 'plots' field must be specified",
+                ));
+            }
+        };
+
+        let mut figure = Figure::new(plots);
+
+        if let Some(size) = size {
+            figure = figure.with_size(size);
+        }
+
+        if let Some(title) = title {
+            figure = figure.with_title(title);
+        }
+
+        if let Some(fill) = fill {
+            figure = figure.with_fill(fill);
+        }
+
+        if let Some(legend) = legend {
+            figure = figure.with_legend(legend);
+        }
+
+        if let Some(padding) = padding {
+            figure = figure.with_padding(padding);
+        }
+
+        Ok(figure)
+    }
+}
+
+// MARK: map macros
+
+macro_rules! serialize_tagged_map_variant {
+    ($serializer:expr, $tag:expr, ($obj:ident, $typ:ty), $($key:expr => $field:ident,)+) => {
+        {
+            let typ_name = std::stringify!($typ);
+            let default = <$typ>::default();
+            if $obj == &default {
+                $tag.serialize($serializer)
+            } else {
+                let mut len = 1; // for the tag
+                $(
+                    if $obj.$field != default.$field {
+                        len += 1;
+                    }
+                )+
+                let mut map = $serializer.serialize_struct(typ_name, len)?;
+                map.serialize_field("type", $tag)?;
+                $(
+                    if $obj.$field != default.$field {
+                        map.serialize_field($key, &$obj.$field)?;
+                    }
+                )+
+                map.end()
+            }
+        }
+    };
+}
+
+pub(crate) use serialize_tagged_map_variant;
+
+macro_rules! deserialize_map_fields {
+    ($de:lifetime, $map:expr, $($key:expr => $name:ident: Option<$ty:ty>,)+) => {
+        $(
+            let mut $name = None::<$ty>;
+        )+
+
+        while let Some(key) = $map.next_key::<std::borrow::Cow<$de, str>>()? {
+            match key.as_ref() {
+                $($key => {
+                    if $name.is_some() {
+                        let _: $ty = $map.next_value()?;
+                        return Err(serde::de::Error::duplicate_field($key));
+                    }
+                    $name = Some($map.next_value::<$ty>()?);
+                })+
+                _ => {
+                    return Err(serde::de::Error::unknown_field(key.as_ref(), &[$($key),+]));
+                }
+            }
+        }
+    }
+}
+
+pub(crate) use deserialize_map_fields;
+
+macro_rules! deserialize_tagged_map_fields {
+    ($de:lifetime, $map:expr, $buffered:expr, $($key:expr => $name:ident: Option<$ty:ty>,)+) => {
+        $(
+            let mut $name = None::<$ty>;
+        )+
+        for (key, value) in $buffered {
+            match key.as_str() {
+                "type" => {
+                    return Err(serde::de::Error::duplicate_field("type"));
+                }
+                $($key => {
+                    if $name.is_some() {
+                        return Err(serde::de::Error::duplicate_field($key));
+                    }
+                    $name = Some(
+                        value
+                            .deserialize_into::<$ty>()
+                            .map_err(serde::de::Error::custom)?,
+                    );
+
+                })+
+                _ => {}
+            }
+        }
+
+        while let Some(key) = $map.next_key::<std::borrow::Cow<$de, str>>()? {
+            match key.as_ref() {
+                "type" => {
+                    let _: String = $map.next_value()?;
+                    return Err(serde::de::Error::duplicate_field("type"));
+                }
+                $($key => {
+                    if $name.is_some() {
+                        let _: $ty = $map.next_value()?;
+                        return Err(serde::de::Error::duplicate_field($key));
+                    }
+                    $name = Some($map.next_value::<$ty>()?);
+                })+
+                _ => {
+                    return Err(serde::de::Error::unknown_field(key.as_ref(), &[$($key),+]));
+                }
+            }
+        }
+    }
+}
+
+pub(crate) use deserialize_tagged_map_fields;
+
+#[allow(unused)]
+macro_rules! deserialize_tagged_enum {
+    ($de:lifetime, $map:expr, $buffered:expr, $enum_ty:ty,  $($key:expr => $variant:ident,)+) => {{
+        let mut enum_val = std::option::Option::None::<$enum_ty>;
+        for (key, value) in $buffered {
+            match key.as_str() {
+                "type" => {
+                    return Err(serde::de::Error::duplicate_field("type"));
+                }
+                $($key => {
+                    if enum_val.is_some() {
+                        return Err(serde::de::Error::duplicate_field($key));
+                    }
+                    let value = value
+                        .deserialize_into()
+                        .map_err(serde::de::Error::custom)?;
+                    enum_val = Some(<$enum_ty>::$variant(value));
+                })+
+                _ => {}
+            }
+        }
+
+        while let Some(key) = $map.next_key::<std::borrow::Cow<$de, str>>()? {
+            match key.as_ref() {
+                "type" => {
+                    let _: String = $map.next_value()?;
+                    return Err(serde::de::Error::duplicate_field("type"));
+                }
+                $($key => {
+                    if enum_val.is_some() {
+                        return Err(serde::de::Error::duplicate_field($key));
+                    }
+                    let value = $map.next_value()?;
+                    enum_val = Some(<$enum_ty>::$variant(value));
+                })+
+                _ => {
+                    return Err(serde::de::Error::unknown_field(key.as_ref(), &[$($key),+]));
+                }
+            }
+        }
+        enum_val.ok_or(serde::de::Error::missing_field("type"))
+    }}
+}
+
+#[allow(unused)]
+pub(crate) use deserialize_tagged_enum;
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::des::{Plot, series};
+
+    #[test]
+    fn test_figure_ser() {
+        let figure =
+            Plot::new(vec![series::Line::new("x".into(), "y".into()).into()]).into_figure();
+
+        let serialized = serde_json::to_string(&figure).unwrap();
+        let expected = r#"{"plot":{"series":{"type":"line","x":"x","y":"y"}}}"#;
+        assert_eq!(serialized, expected);
+    }
+
+    #[test]
+    fn test_figure_de() {
+        let json = r#"{"title":"Title","plot":{"series":{"type":"line","x":"x","y":"y"}}}"#;
+        let figure: Figure = serde_json::from_str(json).unwrap();
+
+        let expected = Plot::new(vec![series::Line::new("x".into(), "y".into()).into()])
+            .into_figure()
+            .with_title("Title".into());
+        assert_eq!(figure, expected);
+    }
+}
diff --git a/src/des/sd/annot.rs b/src/des/sd/annot.rs
new file mode 100644
index 00000000..21b728cd
--- /dev/null
+++ b/src/des/sd/annot.rs
@@ -0,0 +1,472 @@
+use serde::de::{Error, MapAccess};
+use serde::ser::SerializeStruct;
+use serde_value::Value;
+
+use crate::des::{Annotation, annot, axis};
+use crate::style::{self, theme};
+
+impl serde::Serialize for annot::ZPos {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        match self {
+            annot::ZPos::BelowSeries => "below-series",
+            annot::ZPos::AboveSeries => "above-series",
+        }
+        .serialize(serializer)
+    }
+}
+
+impl<'de> serde::Deserialize<'de> for annot::ZPos {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let value = String::deserialize(deserializer)?;
+        match value.as_str() {
+            "below-series" => Ok(annot::ZPos::BelowSeries),
+            "above-series" => Ok(annot::ZPos::AboveSeries),
+            _ => Err(serde::de::Error::unknown_variant(
+                &value,
+                &["below-series", "above-series"],
+            )),
+        }
+    }
+}
+
+impl serde::Serialize for annot::Anchor {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let value = match self {
+            annot::Anchor::TopLeft => "top-left",
+            annot::Anchor::TopCenter => "top-center",
+            annot::Anchor::TopRight => "top-right",
+            annot::Anchor::CenterLeft => "center-left",
+            annot::Anchor::Center => "center",
+            annot::Anchor::CenterRight => "center-right",
+            annot::Anchor::BottomLeft => "bottom-left",
+            annot::Anchor::BottomCenter => "bottom-center",
+            annot::Anchor::BottomRight => "bottom-right",
+        };
+        value.serialize(serializer)
+    }
+}
+
+impl<'de> serde::Deserialize<'de> for annot::Anchor {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let value = String::deserialize(deserializer)?;
+        match value.as_str() {
+            "top-left" => Ok(annot::Anchor::TopLeft),
+            "top-center" => Ok(annot::Anchor::TopCenter),
+            "top-right" => Ok(annot::Anchor::TopRight),
+            "center-left" => Ok(annot::Anchor::CenterLeft),
+            "center" => Ok(annot::Anchor::Center),
+            "center-right" => Ok(annot::Anchor::CenterRight),
+            "bottom-left" => Ok(annot::Anchor::BottomLeft),
+            "bottom-center" => Ok(annot::Anchor::BottomCenter),
+            "bottom-right" => Ok(annot::Anchor::BottomRight),
+            _ => Err(serde::de::Error::unknown_variant(
+                &value,
+                &[
+                    "top-left",
+                    "top-center",
+                    "top-right",
+                    "center-left",
+                    "center",
+                    "center-right",
+                    "bottom-left",
+                    "bottom-center",
+                    "bottom-right",
+                ],
+            )),
+        }
+    }
+}
+
+impl serde::Serialize for Annotation {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        match self {
+            Annotation::Line(line) => serialize_line(line, serializer),
+            Annotation::Arrow(arrow) => serialize_arrow(arrow, serializer),
+            Annotation::Marker(marker) => serialize_marker(marker, serializer),
+            Annotation::Label(label) => serialize_label(label, serializer),
+        }
+    }
+}
+
+fn serialize_base_fields<S>(
+    state: &mut S,
+    x_axis: &axis::Ref,
+    y_axis: &axis::Ref,
+    zpos: annot::ZPos,
+    default_zpos: annot::ZPos,
+) -> Result<(), S::Error>
+where
+    S: serde::ser::SerializeStruct,
+{
+    if x_axis != &axis::Ref::default() {
+        state.serialize_field("xAxis", x_axis)?;
+    }
+    if y_axis != &axis::Ref::default() {
+        state.serialize_field("yAxis", y_axis)?;
+    }
+    if zpos != default_zpos {
+        state.serialize_field("zpos", &zpos)?;
+    }
+    Ok(())
+}
+
+fn serialize_line<S>(line: &annot::Line, serializer: S) -> Result<S::Ok, S::Error>
+where
+    S: serde::Serializer,
+{
+    let mut state = serializer.serialize_struct("LineAnnotation", 8)?;
+    state.serialize_field("type", "line")?;
+    match line.direction() {
+        annot::LineDir::Horizontal(y) => state.serialize_field("horizontal", &y)?,
+        annot::LineDir::Vertical(x) => state.serialize_field("vertical", &x)?,
+        annot::LineDir::Slope { x, y, slope } => {
+            state.serialize_field("slope", &((x, y), slope))?
+        }
+        annot::LineDir::TwoPoints { x1, y1, x2, y2 } => {
+            state.serialize_field("twoPoints", &((x1, y1), (x2, y2)))?
+        }
+    }
+    if line.stroke() != &theme::Stroke::from(theme::Col::Foreground) {
+        state.serialize_field("stroke", line.stroke())?;
+    }
+    serialize_base_fields(
+        &mut state,
+        line.x_axis(),
+        line.y_axis(),
+        line.zpos(),
+        annot::ZPos::BelowSeries,
+    )?;
+    state.end()
+}
+
+fn serialize_arrow<S>(arrow: &annot::Arrow, serializer: S) -> Result<S::Ok, S::Error>
+where
+    S: serde::Serializer,
+{
+    let mut state = serializer.serialize_struct("ArrowAnnotation", 8)?;
+    state.serialize_field("type", "arrow")?;
+    state.serialize_field("xy", &arrow.target())?;
+    state.serialize_field("dxy", &arrow.delta())?;
+    if arrow.stroke() != &theme::Stroke::from(theme::Col::Foreground) {
+        state.serialize_field("stroke", arrow.stroke())?;
+    }
+    if (arrow.head_size() - 10.0).abs() > f32::EPSILON {
+        state.serialize_field("headSize", &arrow.head_size())?;
+    }
+    serialize_base_fields(
+        &mut state,
+        arrow.x_axis(),
+        arrow.y_axis(),
+        arrow.zpos(),
+        annot::ZPos::AboveSeries,
+    )?;
+    state.end()
+}
+
+fn serialize_marker<S>(marker: &annot::Marker, serializer: S) -> Result<S::Ok, S::Error>
+where
+    S: serde::Serializer,
+{
+    let mut state = serializer.serialize_struct("MarkerAnnotation", 6)?;
+    state.serialize_field("xy", &marker.position())?;
+    if marker.marker() != &theme::Marker::default() {
+        state.serialize_field("marker", marker.marker())?;
+    }
+    serialize_base_fields(
+        &mut state,
+        marker.x_axis(),
+        marker.y_axis(),
+        marker.zpos(),
+        annot::ZPos::AboveSeries,
+    )?;
+    state.end()
+}
+
+fn serialize_label<S>(label: &annot::Label, serializer: S) -> Result<S::Ok, S::Error>
+where
+    S: serde::Serializer,
+{
+    let mut state = serializer.serialize_struct("LabelAnnotation", 10)?;
+    state.serialize_field("type", "label")?;
+    state.serialize_field("xy", &label.position())?;
+    state.serialize_field("text", label.text())?;
+    if label.anchor() != annot::Anchor::default() {
+        state.serialize_field("anchor", &label.anchor())?;
+    }
+    let (fill, stroke) = label.frame();
+    if let (Some(fill), Some(stroke)) = (fill, stroke) {
+        state.serialize_field("frame", &(fill, stroke))?;
+    }
+    if label.color() != &theme::Color::from(theme::Col::Foreground) {
+        state.serialize_field("color", label.color())?;
+    }
+    if label.angle() != 0.0 {
+        state.serialize_field("angle", &label.angle())?;
+    }
+    serialize_base_fields(
+        &mut state,
+        label.x_axis(),
+        label.y_axis(),
+        label.zpos(),
+        annot::ZPos::AboveSeries,
+    )?;
+    state.end()
+}
+
+impl<'de> serde::Deserialize<'de> for Annotation {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        deserializer.deserialize_map(AnnotVisitor)
+    }
+}
+
+struct AnnotVisitor;
+
+impl<'de> serde::de::Visitor<'de> for AnnotVisitor {
+    type Value = Annotation;
+
+    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+        formatter.write_str("a tagged series map")
+    }
+
+    fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
+    where
+        A: serde::de::MapAccess<'de>,
+    {
+        let mut buffered = Vec::<(String, Value)>::new();
+
+        while let Some(key) = map.next_key::<String>()? {
+            if key == "type" {
+                let tag = map.next_value::<String>()?;
+                return match tag.as_str() {
+                    // If type is first, `buffered` is empty and we deserialize directly from map.
+                    // If not, only the fields before `type` are buffered.
+                    "line" => deserialize_line_annotation(&mut map, buffered).map(Annotation::Line),
+                    "arrow" => {
+                        deserialize_arrow_annotation(&mut map, buffered).map(Annotation::Arrow)
+                    }
+                    "marker" => {
+                        deserialize_marker_annotation(&mut map, buffered).map(Annotation::Marker)
+                    }
+                    "label" => {
+                        deserialize_label_annotation(&mut map, buffered).map(Annotation::Label)
+                    }
+                    _ => Err(serde::de::Error::unknown_variant(
+                        &tag,
+                        &["line", "arrow", "marker", "label"],
+                    )),
+                };
+            }
+
+            let value = map.next_value::<Value>()?;
+            buffered.push((key, value));
+        }
+
+        Err(serde::de::Error::missing_field("type"))
+    }
+}
+
+fn deserialize_line_annotation<'de, A>(
+    map: &mut A,
+    buffered: Vec<(String, Value)>,
+) -> Result<annot::Line, A::Error>
+where
+    A: MapAccess<'de>,
+    A::Error: serde::de::Error,
+{
+    super::deserialize_tagged_map_fields! {
+        'de, map, buffered,
+        "horizontal" => horizontal: Option<f64>,
+        "vertical" => vertical: Option<f64>,
+        "slope" => slope: Option<((f64, f64), f32)>,
+        "twoPoints" => two_points: Option<((f64, f64), (f64, f64))>,
+        "stroke" => stroke: Option<theme::Stroke>,
+        "pattern" => pattern: Option<style::LinePattern>,
+        "xAxis" => x_axis: Option<axis::Ref>,
+        "yAxis" => y_axis: Option<axis::Ref>,
+        "zPos" => z_pos: Option<annot::ZPos>,
+    }
+
+    let mut count = 0;
+    count += horizontal.is_some() as usize;
+    count += vertical.is_some() as usize;
+    count += slope.is_some() as usize;
+    count += two_points.is_some() as usize;
+    if count != 1 {
+        return Err(A::Error::custom(
+            "line annotations require exactly one of horizontal, vertical, slope, or twoPoints",
+        ));
+    }
+
+    let mut annot = if let Some(y) = horizontal {
+        annot::Line::horizontal(y)
+    } else if let Some(x) = vertical {
+        annot::Line::vertical(x)
+    } else if let Some(((x, y), slope)) = slope {
+        annot::Line::slope(x, y, slope)
+    } else {
+        let ((x1, y1), (x2, y2)) = two_points.expect("validated above");
+        annot::Line::two_points(x1, y1, x2, y2)
+    };
+
+    if let Some(pattern) = pattern {
+        let current = stroke.unwrap_or_else(|| theme::Stroke::from(theme::Col::Foreground));
+        stroke = Some(current.with_pattern(pattern));
+    }
+    if let Some(stroke) = stroke {
+        annot = annot.with_stroke(stroke);
+    }
+    if let Some(x_axis) = x_axis {
+        annot = annot.with_x_axis(x_axis);
+    }
+    if let Some(y_axis) = y_axis {
+        annot = annot.with_y_axis(y_axis);
+    }
+    if let Some(z_pos) = z_pos {
+        annot = annot.with_zpos(z_pos);
+    }
+    Ok(annot)
+}
+
+fn deserialize_arrow_annotation<'de, A>(
+    map: &mut A,
+    buffered: Vec<(String, Value)>,
+) -> Result<annot::Arrow, A::Error>
+where
+    A: MapAccess<'de>,
+    A::Error: serde::de::Error,
+{
+    super::deserialize_tagged_map_fields! {
+        'de, map, buffered,
+        "xy" => xy: Option<(f64, f64)>,
+        "dxy" => dxy: Option<(f32, f32)>,
+        "headSize" => head_size: Option<f32>,
+        "stroke" => stroke: Option<theme::Stroke>,
+        "xAxis" => x_axis: Option<axis::Ref>,
+        "yAxis" => y_axis: Option<axis::Ref>,
+        "zPos" => z_pos: Option<annot::ZPos>,
+    }
+
+    let xy = xy.ok_or_else(|| A::Error::missing_field("xy"))?;
+    let dxy = dxy.ok_or_else(|| A::Error::missing_field("dxy"))?;
+
+    let mut annot = annot::Arrow::new(xy.0, xy.1, dxy.0, dxy.1);
+    if let Some(head_size) = head_size {
+        annot = annot.with_head_size(head_size);
+    }
+    if let Some(stroke) = stroke {
+        annot = annot.with_stroke(stroke);
+    }
+    if let Some(x_axis) = x_axis {
+        annot = annot.with_x_axis(x_axis);
+    }
+    if let Some(y_axis) = y_axis {
+        annot = annot.with_y_axis(y_axis);
+    }
+    if let Some(z_pos) = z_pos {
+        annot = annot.with_zpos(z_pos);
+    }
+    Ok(annot)
+}
+
+fn deserialize_marker_annotation<'de, A>(
+    map: &mut A,
+    buffered: Vec<(String, Value)>,
+) -> Result<annot::Marker, A::Error>
+where
+    A: MapAccess<'de>,
+    A::Error: serde::de::Error,
+{
+    super::deserialize_tagged_map_fields! {
+        'de, map, buffered,
+        "xy" => xy: Option<(f64, f64)>,
+        "marker" => marker: Option<theme::Marker>,
+        "xAxis" => x_axis: Option<axis::Ref>,
+        "yAxis" => y_axis: Option<axis::Ref>,
+        "zPos" => z_pos: Option<annot::ZPos>,
+    }
+
+    let xy = xy.ok_or_else(|| A::Error::missing_field("xy"))?;
+
+    let mut annot = annot::Marker::new(xy.0, xy.1);
+    if let Some(marker) = marker {
+        annot = annot.with_marker(marker)
+    }
+    if let Some(x_axis) = x_axis {
+        annot = annot.with_x_axis(x_axis);
+    }
+    if let Some(y_axis) = y_axis {
+        annot = annot.with_y_axis(y_axis);
+    }
+    if let Some(z_pos) = z_pos {
+        annot = annot.with_zpos(z_pos);
+    }
+    Ok(annot)
+}
+
+fn deserialize_label_annotation<'de, A>(
+    map: &mut A,
+    buffered: Vec<(String, Value)>,
+) -> Result<annot::Label, A::Error>
+where
+    A: MapAccess<'de>,
+    A::Error: serde::de::Error,
+{
+    super::deserialize_tagged_map_fields! {
+        'de, map, buffered,
+        "xy" => xy: Option<(f64, f64)>,
+        "text" => text: Option<String>,
+        "anchor" => anchor: Option<annot::Anchor>,
+        "frame" => frame: Option<(Option<theme::Fill>, Option<theme::Stroke>)>,
+        "color" => color: Option<theme::Color>,
+        "angle" => angle: Option<f32>,
+        "xAxis" => x_axis: Option<axis::Ref>,
+        "yAxis" => y_axis: Option<axis::Ref>,
+        "zPos" => z_pos: Option<annot::ZPos>,
+    }
+
+    let xy = xy.ok_or_else(|| A::Error::missing_field("xy"))?;
+    let text = text.ok_or_else(|| A::Error::missing_field("text"))?;
+
+    let mut annot = annot::Label::new(text, xy.0, xy.1);
+    if let Some(anchor) = anchor {
+        annot = annot.with_anchor(anchor);
+    }
+    if let Some((fill, stroke)) = frame {
+        annot = annot.with_frame(fill, stroke);
+    }
+    if let Some(color) = color {
+        annot = annot.with_color(color);
+    }
+    if let Some(angle) = angle {
+        annot = annot.with_angle(angle);
+    }
+    if let Some(x_axis) = x_axis {
+        annot = annot.with_x_axis(x_axis);
+    }
+    if let Some(y_axis) = y_axis {
+        annot = annot.with_y_axis(y_axis);
+    }
+    if let Some(z_pos) = z_pos {
+        annot = annot.with_zpos(z_pos);
+    }
+
+    Ok(annot)
+}
diff --git a/src/des/sd/axis.rs b/src/des/sd/axis.rs
new file mode 100644
index 00000000..49a66a69
--- /dev/null
+++ b/src/des/sd/axis.rs
@@ -0,0 +1,1523 @@
+use std::borrow::Cow;
+use std::marker::PhantomData;
+
+use serde::de::{Error, SeqAccess};
+use serde::ser::{SerializeSeq, SerializeStruct};
+use serde::{Deserializer, Serializer};
+use serde_value::Value;
+
+use crate::des::sd::{deserialize_map_fields, deserialize_tagged_map_fields};
+use crate::des::{axis, sd};
+use crate::style::theme;
+
+// MARK: axis::Title
+
+impl serde::Serialize for axis::Title {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        if self.spans().is_empty() && self.props() == &axis::TitleProps::default() {
+            self.text().serialize(serializer)
+        } else {
+            let mut state = serializer.serialize_struct("Title", 2)?;
+            state.serialize_field("text", self.text())?;
+            todo!("Serialize rich props and spans")
+            //state.end()
+        }
+    }
+}
+
+impl<'de> serde::Deserialize<'de> for axis::Title {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        struct TitleVisitor;
+
+        impl<'de> serde::de::Visitor<'de> for TitleVisitor {
+            type Value = axis::Title;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+                formatter.write_str("an axis title string or rich text")
+            }
+
+            fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                Ok(axis::Title::from(value.to_string()))
+            }
+
+            fn visit_map<A>(self, _map: A) -> Result<Self::Value, A::Error>
+            where
+                A: serde::de::MapAccess<'de>,
+            {
+                todo!("Deserialize rich title with props and spans")
+            }
+        }
+        deserializer.deserialize_any(TitleVisitor)
+    }
+}
+
+// MARK: axis::Ref
+
+impl serde::Serialize for axis::Ref {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        match self {
+            axis::Ref::Id(id) => serializer.serialize_str(id),
+            axis::Ref::Idx(idx) => serializer.serialize_u32(*idx as _),
+        }
+    }
+}
+
+impl<'de> serde::Deserialize<'de> for axis::Ref {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        deserializer.deserialize_any(AxisRefVisitor)
+    }
+}
+
+struct AxisRefVisitor;
+
+impl<'de> serde::de::Visitor<'de> for AxisRefVisitor {
+    type Value = axis::Ref;
+
+    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+        formatter.write_str("an axis id string or a non-negative axis index")
+    }
+
+    fn visit_i64<E>(self, value: i64) -> Result<Self::Value, E>
+    where
+        E: serde::de::Error,
+    {
+        if value < 0 {
+            Err(E::custom("axis index cannot be negative"))
+        } else {
+            Ok(axis::Ref::Idx(value as usize))
+        }
+    }
+
+    fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E>
+    where
+        E: serde::de::Error,
+    {
+        Ok(axis::Ref::Idx(value as usize))
+    }
+
+    fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
+    where
+        E: serde::de::Error,
+    {
+        Ok(axis::Ref::Id(value.to_string()))
+    }
+}
+
+// MARK: axis::Range
+
+impl serde::Serialize for axis::Range {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        (self.0, self.1).serialize(serializer)
+    }
+}
+
+struct BoundDeser(f64);
+
+impl<'de> serde::de::Deserialize<'de> for BoundDeser {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        struct Visitor;
+
+        impl<'de> serde::de::Visitor<'de> for Visitor {
+            type Value = BoundDeser;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+                formatter.write_str("a number or null")
+            }
+
+            fn visit_f64<E>(self, value: f64) -> Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                Ok(BoundDeser(value))
+            }
+
+            fn visit_i64<E>(self, value: i64) -> Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                Ok(BoundDeser(value as f64))
+            }
+
+            fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                Ok(BoundDeser(value as f64))
+            }
+
+            #[cfg(feature = "time")]
+            fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                const FMT: &str = "%Y-%m-%d %H:%M:%S%.f";
+                let datetime= crate::time::DateTime::fmt_parse(value, FMT)
+                    .map_err(|err| E::custom(format!(
+                        "Bound string only allowed for DateTime, got '{}' which can't be parsed as such: {}",
+                        value, err
+                    )))?;
+                Ok(BoundDeser(datetime.timestamp()))
+            }
+
+            fn visit_none<E>(self) -> Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                Err(E::custom("null is not allowed for this bound"))
+            }
+        }
+        deserializer.deserialize_any(Visitor)
+    }
+}
+
+impl<'de> serde::Deserialize<'de> for axis::Range {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        // deserialize range from [min, max] seq
+        // both min and max can be null to indicate automatic bounds
+
+        deserializer.deserialize_seq(RangeVisitor)
+    }
+}
+
+struct RangeVisitor;
+
+impl<'de> serde::de::Visitor<'de> for RangeVisitor {
+    type Value = axis::Range;
+
+    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+        formatter.write_str("a range as a [min, max] sequence")
+    }
+
+    fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
+    where
+        A: serde::de::SeqAccess<'de>,
+    {
+        let min: Option<Option<BoundDeser>> = seq.next_element()?;
+        let max: Option<Option<BoundDeser>> = seq.next_element()?;
+
+        if min.is_none() || max.is_none() {
+            return Err(serde::de::Error::invalid_length(
+                seq.size_hint().unwrap_or(0),
+                &self,
+            ));
+        }
+        let min = min.unwrap().map(|b| b.0);
+        let max = max.unwrap().map(|b| b.0);
+
+        Ok(axis::Range(min, max))
+    }
+}
+
+// MARK: axis::Scale
+
+impl serde::Serialize for axis::Scale {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        match self {
+            axis::Scale::Auto => "auto".serialize(serializer),
+            axis::Scale::Linear(range) => {
+                if range == &axis::Range::default() {
+                    "lin".serialize(serializer)
+                } else {
+                    range.serialize(serializer)
+                }
+            }
+            axis::Scale::Log(log_scale) => {
+                sd::serialize_tagged_map_variant!(
+                    serializer, "log",
+                    (log_scale, axis::LogScale),
+                    "base" => base,
+                    "range" => range,
+                )
+            }
+            axis::Scale::Shared(id) => {
+                let mut map = serializer.serialize_struct("SharedScale", 1)?;
+                map.serialize_field("type", "shared")?;
+                map.serialize_field("ref", id)?;
+                map.end()
+            }
+        }
+    }
+}
+
+impl<'de> serde::Deserialize<'de> for axis::Scale {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        deserializer.deserialize_any(ScaleVisitor)
+    }
+}
+
+struct ScaleVisitor;
+
+impl<'de> serde::de::Visitor<'de> for ScaleVisitor {
+    type Value = axis::Scale;
+
+    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+        formatter.write_str("a scale type string, a shared scale id string, or a scale object")
+    }
+
+    fn visit_i64<E>(self, value: i64) -> Result<Self::Value, E>
+    where
+        E: serde::de::Error,
+    {
+        if value < 0 {
+            Err(E::custom("axis index cannot be negative"))
+        } else {
+            Ok(axis::Scale::Shared(axis::Ref::Idx(value as usize)))
+        }
+    }
+
+    fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E>
+    where
+        E: serde::de::Error,
+    {
+        Ok(axis::Scale::Shared(axis::Ref::Idx(value as usize)))
+    }
+
+    fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
+    where
+        E: serde::de::Error,
+    {
+        match value {
+            "auto" => Ok(axis::Scale::Auto),
+            "lin" => Ok(axis::Scale::Linear(axis::Range::default())),
+            "log" => Ok(axis::Scale::Log(axis::LogScale::default())),
+            other => Ok(axis::Scale::Shared(other.to_string().into())),
+        }
+    }
+
+    fn visit_seq<A>(self, seq: A) -> Result<Self::Value, A::Error>
+    where
+        A: serde::de::SeqAccess<'de>,
+    {
+        let visitor = RangeVisitor;
+        visitor.visit_seq(seq).map(axis::Scale::Linear)
+    }
+
+    fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
+    where
+        A: serde::de::MapAccess<'de>,
+    {
+        let mut buffered = Vec::<(String, Value)>::new();
+
+        while let Some(key) = map.next_key::<String>()? {
+            if key == "type" {
+                let tag = map.next_value::<String>()?;
+                return match tag.as_str() {
+                    // If type is first, `buffered` is empty and we deserialize directly from map.
+                    // If not, only the fields before `type` are buffered.
+                    "lin" => deserialize_lin_scale(&mut map, buffered).map(axis::Scale::Linear),
+                    "log" => deserialize_log_scale(&mut map, buffered).map(axis::Scale::Log),
+                    "shared" => {
+                        deserialize_shared_scale(&mut map, buffered).map(axis::Scale::Shared)
+                    }
+                    _ => Err(serde::de::Error::unknown_variant(
+                        &tag,
+                        &["lin", "log", "shared"],
+                    )),
+                };
+            }
+
+            let value = map.next_value::<Value>()?;
+            buffered.push((key, value));
+        }
+
+        Err(serde::de::Error::missing_field("type"))
+    }
+}
+
+fn deserialize_lin_scale<'de, A>(
+    map: &mut A,
+    buffered: Vec<(String, Value)>,
+) -> Result<axis::Range, A::Error>
+where
+    A: serde::de::MapAccess<'de>,
+{
+    deserialize_tagged_map_fields!(
+        'de, map, buffered,
+        "range" => range: Option<axis::Range>,
+    );
+    if let Some(range) = range {
+        Ok(range)
+    } else {
+        Ok(axis::Range::default())
+    }
+}
+
+fn deserialize_log_scale<'de, A>(
+    map: &mut A,
+    buffered: Vec<(String, Value)>,
+) -> Result<axis::LogScale, A::Error>
+where
+    A: serde::de::MapAccess<'de>,
+{
+    deserialize_tagged_map_fields!(
+        'de, map, buffered,
+        "base" => base: Option<f64>,
+        "range" => range: Option<axis::Range>,
+    );
+    let mut log_scale = axis::LogScale::default();
+    if let Some(base) = base {
+        log_scale.base = base;
+    }
+    if let Some(range) = range {
+        log_scale.range = range;
+    }
+    Ok(log_scale)
+}
+
+fn deserialize_shared_scale<'de, A>(
+    map: &mut A,
+    buffered: Vec<(String, Value)>,
+) -> Result<axis::Ref, A::Error>
+where
+    A: serde::de::MapAccess<'de>,
+{
+    deserialize_tagged_map_fields!(
+        'de, map, buffered,
+        "ref" => id: Option<axis::Ref>,
+    );
+    let Some(id) = id else {
+        return Err(serde::de::Error::missing_field("ref"));
+    };
+    Ok(id)
+}
+
+// MARK: ticks::Locator
+
+impl serde::Serialize for axis::ticks::Locator {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        match self {
+            axis::ticks::Locator::Auto => "auto".serialize(serializer),
+            axis::ticks::Locator::List(locator) => locator.0.serialize(serializer),
+            axis::ticks::Locator::MaxN(locator) => {
+                sd::serialize_tagged_map_variant!(
+                    serializer, "maxn",
+                    (locator, axis::ticks::MaxNLocator),
+                    "bins" => bins,
+                    "steps" => steps,
+                )
+            }
+            axis::ticks::Locator::PiMultiple(locator) => {
+                sd::serialize_tagged_map_variant!(
+                    serializer, "pimultiple",
+                    (locator, axis::ticks::PiMultipleLocator),
+                    "bins" => bins,
+                )
+            }
+            axis::ticks::Locator::Log(locator) => {
+                sd::serialize_tagged_map_variant!(
+                    serializer, "log",
+                    (locator, axis::ticks::LogLocator),
+                    "base" => base,
+                )
+            }
+            #[cfg(feature = "time")]
+            axis::ticks::Locator::DateTime(locator) => {
+                let mut map = serializer.serialize_struct("DateTimeLocator", 2)?;
+                map.serialize_field("type", "datetime")?;
+                match locator {
+                    axis::ticks::DateTimeLocator::Auto => {}
+                    axis::ticks::DateTimeLocator::Years(years) => {
+                        map.serialize_field("years", years)?;
+                    }
+                    axis::ticks::DateTimeLocator::Months(months) => {
+                        map.serialize_field("months", months)?;
+                    }
+                    axis::ticks::DateTimeLocator::Weeks(weeks) => {
+                        map.serialize_field("weeks", weeks)?;
+                    }
+                    axis::ticks::DateTimeLocator::Days(days) => {
+                        map.serialize_field("days", days)?;
+                    }
+                    axis::ticks::DateTimeLocator::Hours(hours) => {
+                        map.serialize_field("hours", hours)?;
+                    }
+                    axis::ticks::DateTimeLocator::Minutes(minutes) => {
+                        map.serialize_field("minutes", minutes)?;
+                    }
+                    axis::ticks::DateTimeLocator::Seconds(seconds) => {
+                        map.serialize_field("seconds", seconds)?;
+                    }
+                    axis::ticks::DateTimeLocator::Micros(micros) => {
+                        map.serialize_field("micros", micros)?;
+                    }
+                }
+                map.end()
+            }
+            #[cfg(feature = "time")]
+            axis::ticks::Locator::TimeDelta(locator) => {
+                let mut map = serializer.serialize_struct("TimeDeltaLocator", 2)?;
+                map.serialize_field("type", "timedelta")?;
+                match locator {
+                    axis::ticks::TimeDeltaLocator::Auto => {}
+                    axis::ticks::TimeDeltaLocator::Days(days) => {
+                        map.serialize_field("days", days)?;
+                    }
+                    axis::ticks::TimeDeltaLocator::Hours(hours) => {
+                        map.serialize_field("hours", hours)?;
+                    }
+                    axis::ticks::TimeDeltaLocator::Minutes(minutes) => {
+                        map.serialize_field("minutes", minutes)?;
+                    }
+                    axis::ticks::TimeDeltaLocator::Seconds(seconds) => {
+                        map.serialize_field("seconds", seconds)?;
+                    }
+                    axis::ticks::TimeDeltaLocator::Micros(micros) => {
+                        map.serialize_field("micros", micros)?;
+                    }
+                }
+                map.end()
+            }
+        }
+    }
+}
+
+impl<'de> serde::Deserialize<'de> for axis::ticks::Locator {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        deserializer.deserialize_any(LocatorVisitor)
+    }
+}
+
+struct LocatorVisitor;
+
+impl<'de> serde::de::Visitor<'de> for LocatorVisitor {
+    type Value = axis::ticks::Locator;
+
+    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+        formatter.write_str("a ticks locator type string or a locator object")
+    }
+
+    fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
+    where
+        E: serde::de::Error,
+    {
+        match value {
+            "auto" => Ok(axis::ticks::Locator::Auto),
+            "maxn" => Ok(axis::ticks::Locator::MaxN(Default::default())),
+            "pimultiple" => Ok(axis::ticks::Locator::PiMultiple(Default::default())),
+            "log" => Ok(axis::ticks::Locator::Log(Default::default())),
+            other => Err(E::unknown_variant(
+                other,
+                &["auto", "maxn", "pimultiple", "log"],
+            )),
+        }
+    }
+
+    fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
+    where
+        A: SeqAccess<'de>,
+    {
+        let mut ticks: Vec<f64> = Vec::with_capacity(seq.size_hint().unwrap_or(0));
+        while let Some(tick) = seq.next_element()? {
+            ticks.push(tick);
+        }
+        Ok(axis::ticks::Locator::List(ticks.into()))
+    }
+
+    fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
+    where
+        A: serde::de::MapAccess<'de>,
+    {
+        let mut buffered = Vec::<(String, Value)>::new();
+
+        while let Some(key) = map.next_key::<String>()? {
+            if key == "type" {
+                let tag = map.next_value::<String>()?;
+                return match tag.as_str() {
+                    "maxn" => {
+                        deserialize_maxn_locator(&mut map, buffered).map(axis::ticks::Locator::MaxN)
+                    }
+                    "pimultiple" => deserialize_pimultiple_locator(&mut map, buffered)
+                        .map(axis::ticks::Locator::PiMultiple),
+                    "log" => {
+                        deserialize_log_locator(&mut map, buffered).map(axis::ticks::Locator::Log)
+                    }
+                    #[cfg(feature = "time")]
+                    "datetime" => deserialize_datetime_locator(&mut map, buffered)
+                        .map(axis::ticks::Locator::DateTime),
+                    #[cfg(feature = "time")]
+                    "timedelta" => deserialize_timedelta_locator(&mut map, buffered)
+                        .map(axis::ticks::Locator::TimeDelta),
+                    _ => Err(serde::de::Error::unknown_variant(
+                        &tag,
+                        &["maxn", "pimultiple", "log"],
+                    )),
+                };
+            }
+
+            let value = map.next_value::<Value>()?;
+            buffered.push((key, value));
+        }
+
+        Err(serde::de::Error::missing_field("type"))
+    }
+}
+
+fn deserialize_maxn_locator<'de, A>(
+    map: &mut A,
+    buffered: Vec<(String, Value)>,
+) -> Result<axis::ticks::MaxNLocator, A::Error>
+where
+    A: serde::de::MapAccess<'de>,
+{
+    deserialize_tagged_map_fields!(
+        'de, map, buffered,
+        "bins" => bins: Option<u32>,
+        "steps" => steps: Option<Vec<f64>>,
+    );
+    let mut locator = axis::ticks::MaxNLocator::default();
+    if let Some(bins) = bins {
+        locator.bins = bins;
+    }
+    if let Some(steps) = steps {
+        locator.steps = steps;
+    }
+    Ok(locator)
+}
+
+fn deserialize_pimultiple_locator<'de, A>(
+    map: &mut A,
+    buffered: Vec<(String, Value)>,
+) -> Result<axis::ticks::PiMultipleLocator, A::Error>
+where
+    A: serde::de::MapAccess<'de>,
+{
+    deserialize_tagged_map_fields!(
+        'de, map, buffered,
+        "bins" => bins: Option<u32>,
+    );
+    let mut locator = axis::ticks::PiMultipleLocator::default();
+    if let Some(bins) = bins {
+        locator.bins = bins;
+    }
+    Ok(locator)
+}
+
+fn deserialize_log_locator<'de, A>(
+    map: &mut A,
+    buffered: Vec<(String, Value)>,
+) -> Result<axis::ticks::LogLocator, A::Error>
+where
+    A: serde::de::MapAccess<'de>,
+{
+    deserialize_tagged_map_fields!(
+        'de, map, buffered,
+        "base" => base: Option<f64>,
+    );
+    let mut locator = axis::ticks::LogLocator::default();
+    if let Some(base) = base {
+        locator.base = base;
+    }
+    Ok(locator)
+}
+
+#[cfg(feature = "time")]
+fn deserialize_datetime_locator<'de, A>(
+    map: &mut A,
+    buffered: Vec<(String, Value)>,
+) -> Result<axis::ticks::DateTimeLocator, A::Error>
+where
+    A: serde::de::MapAccess<'de>,
+{
+    super::deserialize_tagged_enum!(
+        'de, map, buffered, axis::ticks::DateTimeLocator,
+        "years" => Years,
+        "months" => Months,
+        "weeks" => Weeks,
+        "days" => Days,
+        "hours" => Hours,
+        "minutes" => Minutes,
+        "seconds" => Seconds,
+        "micros" => Micros,
+    )
+}
+
+#[cfg(feature = "time")]
+fn deserialize_timedelta_locator<'de, A>(
+    map: &mut A,
+    buffered: Vec<(String, Value)>,
+) -> Result<axis::ticks::TimeDeltaLocator, A::Error>
+where
+    A: serde::de::MapAccess<'de>,
+{
+    super::deserialize_tagged_enum!(
+        'de, map, buffered, axis::ticks::TimeDeltaLocator,
+        "days" => Days,
+        "hours" => Hours,
+        "minutes" => Minutes,
+        "seconds" => Seconds,
+        "micros" => Micros,
+    )
+}
+
+fn deserialize_locator<'de, A>(type_: &str, mut map: A) -> Result<axis::ticks::Locator, A::Error>
+where
+    A: serde::de::MapAccess<'de>,
+{
+    match type_ {
+        "maxn" => Ok(deserialize_maxn_locator(&mut map, Vec::new())?.into()),
+        "pimultiple" => Ok(deserialize_pimultiple_locator(&mut map, Vec::new())?.into()),
+        "log" => Ok(deserialize_log_locator(&mut map, Vec::new())?.into()),
+        #[cfg(feature = "time")]
+        "datetime" => Ok(deserialize_datetime_locator(&mut map, Vec::new())?.into()),
+        #[cfg(feature = "time")]
+        "timedelta" => Ok(deserialize_timedelta_locator(&mut map, Vec::new())?.into()),
+        _ => Err(A::Error::unknown_variant(
+            type_,
+            &["maxn", "pimultiple", "log"],
+        )),
+    }
+}
+
+// MARK: ticks::Formatter
+
+impl serde::Serialize for axis::ticks::Formatter {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        match self {
+            axis::ticks::Formatter::Auto => "auto".serialize(serializer),
+            axis::ticks::Formatter::SharedAuto => "shared-auto".serialize(serializer),
+            axis::ticks::Formatter::Prec(prec) => {
+                let mut map = serializer.serialize_struct("PrecFormatter", 2)?;
+                map.serialize_field("type", "prec")?;
+                map.serialize_field("digits", prec)?;
+                map.end()
+            }
+            axis::ticks::Formatter::Percent(formatter) => {
+                if let Some(decimals) = formatter.decimal_places {
+                    let mut map = serializer.serialize_struct("PercentFormatter", 2)?;
+                    map.serialize_field("type", "percent")?;
+                    map.serialize_field("decimals", &decimals)?;
+                    map.end()
+                } else {
+                    "percent".serialize(serializer)
+                }
+            }
+            #[cfg(feature = "time")]
+            axis::ticks::Formatter::DateTime(formatter) => {
+                let mut map = serializer.serialize_struct("DateTimeFormatter", 2)?;
+                map.serialize_field("type", "datetime")?;
+                let fmt_str = formatter.fmt_str();
+                if let Some(fmt_str) = fmt_str {
+                    map.serialize_field("format", &fmt_str)?;
+                }
+                map.end()
+            }
+            #[cfg(feature = "time")]
+            axis::ticks::Formatter::TimeDelta(formatter) => {
+                let mut map = serializer.serialize_struct("TimeDeltaFormatter", 2)?;
+                map.serialize_field("type", "timedelta")?;
+                if let Some(fmt_str) = formatter.fmt_str() {
+                    map.serialize_field("format", &fmt_str)?;
+                }
+                map.end()
+            }
+            #[allow(unreachable_patterns)]
+            _ => todo!("Serialize other formatter types: {:?}", self),
+        }
+    }
+}
+
+impl<'de> serde::Deserialize<'de> for axis::ticks::Formatter {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        deserializer.deserialize_any(FormatterVisitor)
+    }
+}
+
+struct FormatterVisitor;
+
+impl<'de> serde::de::Visitor<'de> for FormatterVisitor {
+    type Value = axis::ticks::Formatter;
+
+    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+        formatter.write_str("a ticks formatter type string or a formatter object")
+    }
+
+    fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
+    where
+        E: serde::de::Error,
+    {
+        match value {
+            "auto" => Ok(axis::ticks::Formatter::Auto),
+            "shared-auto" => Ok(axis::ticks::Formatter::SharedAuto),
+            other => Err(E::unknown_variant(other, &["auto", "shared-auto"])),
+        }
+    }
+
+    fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
+    where
+        A: serde::de::MapAccess<'de>,
+    {
+        let mut buffered = Vec::<(String, Value)>::new();
+
+        while let Some(key) = map.next_key::<String>()? {
+            if key == "type" {
+                let tag = map.next_value::<String>()?;
+                return match tag.as_str() {
+                    "prec" => deserialize_prec_formatter(&mut map, buffered)
+                        .map(axis::ticks::Formatter::Prec),
+                    "percent" => deserialize_percent_formatter(&mut map, buffered)
+                        .map(axis::ticks::Formatter::Percent),
+                    #[cfg(feature = "time")]
+                    "datetime" => deserialize_datetime_formatter(&mut map, buffered)
+                        .map(axis::ticks::Formatter::DateTime),
+                    #[cfg(feature = "time")]
+                    "timedelta" => deserialize_timedelta_formatter(&mut map, buffered)
+                        .map(axis::ticks::Formatter::TimeDelta),
+                    _ => Err(serde::de::Error::unknown_variant(
+                        &tag,
+                        &["prec", "percent", "datetime", "timedelta"],
+                    )),
+                };
+            }
+
+            let value = map.next_value::<Value>()?;
+            buffered.push((key, value));
+        }
+
+        Err(serde::de::Error::missing_field("type"))
+    }
+}
+
+fn deserialize_prec_formatter<'de, A>(
+    map: &mut A,
+    buffered: Vec<(String, Value)>,
+) -> Result<usize, A::Error>
+where
+    A: serde::de::MapAccess<'de>,
+{
+    deserialize_tagged_map_fields!(
+        'de, map, buffered,
+        "digits" => digits: Option<usize>,
+    );
+    let Some(prec) = digits else {
+        return Err(serde::de::Error::missing_field("digits"));
+    };
+    Ok(prec)
+}
+
+fn deserialize_percent_formatter<'de, A>(
+    map: &mut A,
+    buffered: Vec<(String, Value)>,
+) -> Result<axis::ticks::PercentFormatter, A::Error>
+where
+    A: serde::de::MapAccess<'de>,
+{
+    deserialize_tagged_map_fields!(
+        'de, map, buffered,
+        "decimals" => decimals: Option<usize>,
+    );
+    Ok(axis::ticks::PercentFormatter {
+        decimal_places: decimals,
+    })
+}
+
+#[cfg(feature = "time")]
+fn deserialize_datetime_formatter<'de, A>(
+    map: &mut A,
+    buffered: Vec<(String, Value)>,
+) -> Result<axis::ticks::DateTimeFormatter, A::Error>
+where
+    A: serde::de::MapAccess<'de>,
+{
+    deserialize_tagged_map_fields!(
+        'de, map, buffered,
+        "format" => format: Option<String>,
+    );
+    match format {
+        Some(fmt_str) => {
+            if &fmt_str == "%Y-%m-%d %H:%M:%S" {
+                return Ok(axis::ticks::DateTimeFormatter::DateTime);
+            }
+            if &fmt_str == "%Y-%m-%d" {
+                return Ok(axis::ticks::DateTimeFormatter::Date);
+            }
+            if &fmt_str == "%H:%M:%S" {
+                return Ok(axis::ticks::DateTimeFormatter::Time);
+            }
+            if &fmt_str == "auto" {
+                return Ok(axis::ticks::DateTimeFormatter::Auto);
+            }
+            Ok(axis::ticks::DateTimeFormatter::Custom(fmt_str))
+        }
+        None => Ok(axis::ticks::DateTimeFormatter::Auto),
+    }
+}
+
+#[cfg(feature = "time")]
+fn deserialize_timedelta_formatter<'de, A>(
+    map: &mut A,
+    buffered: Vec<(String, Value)>,
+) -> Result<axis::ticks::TimeDeltaFormatter, A::Error>
+where
+    A: serde::de::MapAccess<'de>,
+{
+    deserialize_tagged_map_fields!(
+        'de, map, buffered,
+        "format" => format: Option<String>,
+    );
+    match format {
+        Some(fmt_str) => {
+            if &fmt_str == "auto" {
+                return Ok(axis::ticks::TimeDeltaFormatter::Auto);
+            }
+            Ok(axis::ticks::TimeDeltaFormatter::Custom(fmt_str))
+        }
+        None => Ok(axis::ticks::TimeDeltaFormatter::Auto),
+    }
+}
+
+// MARK: axis::Ticks
+
+impl serde::Serialize for axis::Ticks {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let default = axis::Ticks::default();
+        if self == &default {
+            return "auto".serialize(serializer);
+        }
+
+        let has_default_locator = self.locator() == default.locator();
+        let has_default_formatter = self.formatter() == default.formatter();
+        let has_default_color = self.color() == default.color();
+
+        match (
+            has_default_locator,
+            has_default_formatter,
+            has_default_color,
+        ) {
+            (true, true, true) => "auto".serialize(serializer),
+            (false, true, true) => self.locator().serialize(serializer),
+            (true, false, true) => self.formatter().serialize(serializer),
+            (true, true, false) => self.color().serialize(serializer),
+            _ => {
+                let len = 3
+                    - has_default_locator as usize
+                    - has_default_formatter as usize
+                    - has_default_color as usize;
+                let mut state = serializer.serialize_struct("Ticks", len)?;
+                if !has_default_locator {
+                    state.serialize_field("locator", self.locator())?;
+                }
+                if !has_default_formatter {
+                    state.serialize_field("formatter", &self.formatter())?;
+                }
+                if !has_default_color {
+                    state.serialize_field("color", &self.color())?;
+                }
+                state.end()
+            }
+        }
+    }
+}
+
+impl<'de> serde::Deserialize<'de> for axis::Ticks {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        deserializer.deserialize_any(TicksVisitor)
+    }
+}
+
+struct TicksVisitor;
+
+impl<'de> serde::de::Visitor<'de> for TicksVisitor {
+    type Value = axis::Ticks;
+
+    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+        formatter.write_str("a ticks object or a ticks locator/formatter/color")
+    }
+
+    fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
+    where
+        E: serde::de::Error,
+    {
+        match value {
+            "auto" => Ok(axis::Ticks::default()),
+            "maxn" => {
+                Ok(axis::Ticks::default().with_locator(axis::ticks::MaxNLocator::default().into()))
+            }
+            "pimultiple" => Ok(axis::Ticks::default()
+                .with_locator(axis::ticks::PiMultipleLocator::default().into())),
+            "log" => {
+                Ok(axis::Ticks::default().with_locator(axis::ticks::LogLocator::default().into()))
+            }
+            "percent" => Ok(axis::Ticks::default()
+                .with_formatter(Some(axis::ticks::PercentFormatter::default().into()))),
+            _ => {
+                let color = value.parse::<theme::Color>().map_err(|_| {
+                    E::unknown_variant(
+                        value,
+                        &[
+                            "auto",
+                            "maxn",
+                            "pimultiple",
+                            "log",
+                            "percent",
+                            "[color string]",
+                        ],
+                    )
+                })?;
+                Ok(axis::Ticks::default().with_color(color))
+            }
+        }
+    }
+
+    fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
+    where
+        A: serde::de::SeqAccess<'de>,
+    {
+        let mut locs = Vec::<f64>::with_capacity(seq.size_hint().unwrap_or(0));
+        while let Some(loc) = seq.next_element()? {
+            locs.push(loc);
+        }
+        Ok(axis::Ticks::default().with_locator(locs.into()))
+    }
+
+    fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
+    where
+        A: serde::de::MapAccess<'de>,
+    {
+        let mut ticks = axis::Ticks::default();
+
+        while let Some(key) = map.next_key::<Cow<'de, str>>()? {
+            match &*key {
+                "locator" => {
+                    let locator = map.next_value()?;
+                    ticks = ticks.with_locator(locator);
+                }
+                "formatter" => {
+                    let formatter = map.next_value()?;
+                    ticks = ticks.with_formatter(formatter);
+                }
+                "color" => {
+                    let color = map.next_value()?;
+                    ticks = ticks.with_color(color);
+                }
+                // serialized directly as a locator or formatter
+                "type" => {
+                    let type_: &str = map.next_value()?;
+                    match type_ {
+                        "maxn" | "pimultiple" | "log" => {
+                            ticks =
+                                ticks.with_locator(deserialize_locator(type_, &mut map)?.into());
+                        }
+                        #[cfg(feature = "time")]
+                        "datetime" | "timedelta" => {
+                            ticks =
+                                ticks.with_locator(deserialize_locator(type_, &mut map)?.into());
+                        }
+                        "percent" => {
+                            ticks = ticks.with_formatter(Some(
+                                deserialize_percent_formatter(&mut map, Vec::new())?.into(),
+                            ));
+                        }
+                        _ => {
+                            return Err(A::Error::unknown_variant(
+                                type_,
+                                &[
+                                    "maxn",
+                                    "pimultiple",
+                                    "log",
+                                    "timedelta",
+                                    "datetime",
+                                    "percent",
+                                ],
+                            ));
+                        }
+                    }
+                }
+                _ => {
+                    return Err(serde::de::Error::unknown_field(
+                        &key,
+                        &["locator", "formatter", "color", "type"],
+                    ));
+                }
+            }
+        }
+
+        Ok(ticks)
+    }
+}
+
+// MARK: MinorTicks
+
+impl serde::Serialize for axis::MinorTicks {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let default = axis::MinorTicks::default();
+        let has_default_locator = self.locator() == default.locator();
+        let has_default_color = self.color() == default.color();
+
+        match (has_default_locator, has_default_color) {
+            (true, true) => "auto".serialize(serializer),
+            (false, true) => self.locator().serialize(serializer),
+            (true, false) => self.color().serialize(serializer),
+            _ => {
+                let len = 2 - has_default_locator as usize - has_default_color as usize;
+                let mut state = serializer.serialize_struct("MinorTicks", len)?;
+                if !has_default_locator {
+                    state.serialize_field("locator", self.locator())?;
+                }
+                if !has_default_color {
+                    state.serialize_field("color", &self.color())?;
+                }
+                state.end()
+            }
+        }
+    }
+}
+
+impl<'de> serde::Deserialize<'de> for axis::MinorTicks {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let visitor = MinorTicksVisitor;
+        deserializer.deserialize_any(visitor)
+    }
+}
+
+struct MinorTicksVisitor;
+
+impl<'de> serde::de::Visitor<'de> for MinorTicksVisitor {
+    type Value = axis::MinorTicks;
+
+    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+        formatter.write_str("a minor ticks object or string")
+    }
+
+    fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
+    where
+        E: serde::de::Error,
+    {
+        if value == "auto" {
+            return Ok(axis::MinorTicks::default());
+        }
+        let color: Result<theme::Color, _> = value.parse();
+        if let Ok(color) = color {
+            Ok(axis::MinorTicks::default().with_color(color))
+        } else {
+            let locator = LocatorVisitor
+                .visit_str::<serde::de::value::Error>(value)
+                .map_err(|_| {
+                    serde::de::Error::custom("expecting a color or locator string for Minor axis")
+                })?;
+            Ok(axis::MinorTicks::default().with_locator(locator))
+        }
+    }
+
+    fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
+    where
+        A: serde::de::MapAccess<'de>,
+    {
+        let mut minor_ticks = axis::MinorTicks::default();
+
+        while let Some(key) = map.next_key::<Cow<'de, str>>()? {
+            match &*key {
+                "locator" => {
+                    let locator = map.next_value()?;
+                    minor_ticks = minor_ticks.with_locator(locator);
+                }
+                "color" => {
+                    let color = map.next_value()?;
+                    minor_ticks = minor_ticks.with_color(color);
+                }
+                "type" => {
+                    // directly a locator
+                    let type_: &str = map.next_value()?;
+                    let locator = deserialize_locator(type_, &mut map)?;
+                    minor_ticks = minor_ticks.with_locator(locator);
+                }
+                _ => {
+                    return Err(serde::de::Error::unknown_field(&key, &["locator", "color"]));
+                }
+            }
+        }
+
+        Ok(minor_ticks)
+    }
+}
+
+// MARK: Grids
+
+impl serde::Serialize for axis::Grid {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let default_stroke = Some(axis::Grid::default().0);
+        sd::style::serialize_stroke(&self.0, default_stroke, "Grid", serializer)
+    }
+}
+
+impl<'de> serde::Deserialize<'de> for axis::Grid {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let default_stroke = Some(axis::Grid::default().0);
+        let visitor = sd::style::StrokeVisitor::new("Grid", default_stroke);
+        let stroke = deserializer.deserialize_any(visitor)?;
+        Ok(axis::Grid(stroke))
+    }
+}
+
+impl serde::Serialize for axis::MinorGrid {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let default_stroke = Some(axis::MinorGrid::default().0);
+        sd::style::serialize_stroke(&self.0, default_stroke, "MinorGrid", serializer)
+    }
+}
+
+impl<'de> serde::Deserialize<'de> for axis::MinorGrid {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let default_stroke = Some(axis::MinorGrid::default().0);
+        let visitor = sd::style::StrokeVisitor::new("MinorGrid", default_stroke);
+        let stroke = deserializer.deserialize_any(visitor)?;
+        Ok(axis::MinorGrid(stroke))
+    }
+}
+
+// MARK: Axis
+
+#[derive(Debug, Clone, Copy)]
+pub enum Dir {
+    X,
+    Y,
+    Unknown,
+}
+
+pub struct SerAxis<'a> {
+    pub axis: &'a axis::Axis,
+    pub dir: Dir,
+}
+
+impl SerAxis<'_> {
+    fn side_str(&self) -> &'static str {
+        use axis::Side;
+        match (self.axis.side(), &self.dir) {
+            (Side::Main, Dir::Y) => "left",
+            (Side::Main, Dir::X) => "bottom",
+            (Side::Main, Dir::Unknown) => "main",
+            (Side::Opposite, Dir::Y) => "right",
+            (Side::Opposite, Dir::X) => "top",
+            (Side::Opposite, Dir::Unknown) => "opposite",
+        }
+    }
+}
+
+pub struct SerAxes<'a> {
+    pub axes: &'a [axis::Axis],
+    pub dir: Dir,
+}
+
+impl<'a> serde::Serialize for SerAxes<'a> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let mut state = serializer.serialize_seq(Some(self.axes.len()))?;
+
+        for axis in self.axes {
+            let axis = SerAxis {
+                axis,
+                dir: self.dir,
+            };
+            state.serialize_element(&axis)?;
+        }
+
+        state.end()
+    }
+}
+
+impl<'a> serde::Serialize for SerAxis<'a> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let mut state = serializer.serialize_struct("Axis", 3)?;
+
+        if let Some(id) = self.axis.id() {
+            state.serialize_field("id", id)?;
+        }
+
+        if let Some(title) = self.axis.title() {
+            state.serialize_field("title", title)?;
+        }
+
+        if self.axis.side() != axis::Side::default() {
+            let side_str = self.side_str();
+            state.serialize_field("side", side_str)?;
+        }
+
+        if self.axis.scale() != &axis::Scale::default() {
+            state.serialize_field("scale", self.axis.scale())?;
+        }
+
+        if let Some(ticks) = self.axis.ticks() {
+            state.serialize_field("ticks", ticks)?;
+        }
+
+        if let Some(minor_ticks) = self.axis.minor_ticks() {
+            state.serialize_field("minorTicks", minor_ticks)?;
+        }
+
+        if let Some(grid) = self.axis.grid() {
+            state.serialize_field("grid", grid)?;
+        }
+
+        if let Some(minor_grid) = self.axis.minor_grid() {
+            state.serialize_field("minorGrid", minor_grid)?;
+        }
+
+        state.end()
+    }
+}
+
+impl serde::Serialize for axis::Axis {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let axis = SerAxis {
+            axis: self,
+            dir: Dir::Unknown,
+        };
+        axis.serialize(serializer)
+    }
+}
+
+trait DeDir {
+    fn dir() -> Dir;
+}
+
+pub struct DeX;
+pub struct DeY;
+struct DeUnknown;
+
+impl DeDir for DeX {
+    fn dir() -> Dir {
+        Dir::X
+    }
+}
+
+impl DeDir for DeY {
+    fn dir() -> Dir {
+        Dir::Y
+    }
+}
+
+impl DeDir for DeUnknown {
+    fn dir() -> Dir {
+        Dir::Unknown
+    }
+}
+
+pub type DeXAxis = DeAxis<DeX>;
+pub type DeYAxis = DeAxis<DeY>;
+
+pub struct DeAxis<Dr> {
+    pub axis: axis::Axis,
+    phantom: PhantomData<Dr>,
+}
+
+impl<'de, Dr> serde::Deserialize<'de> for DeAxis<Dr>
+where
+    Dr: DeDir,
+{
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        deserializer.deserialize_any(AxisVisitor {
+            phantom: PhantomData,
+        })
+    }
+}
+
+impl<'de> serde::Deserialize<'de> for axis::Axis {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let axis = deserializer.deserialize_map(AxisVisitor {
+            phantom: PhantomData::<DeUnknown>,
+        })?;
+        Ok(axis.axis)
+    }
+}
+
+struct AxisVisitor<Dr> {
+    phantom: PhantomData<Dr>,
+}
+
+impl<'de, Dr> serde::de::Visitor<'de> for AxisVisitor<Dr>
+where
+    Dr: DeDir,
+{
+    type Value = DeAxis<Dr>;
+
+    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+        formatter.write_str("an axis object")
+    }
+
+    fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
+    where
+        A: serde::de::MapAccess<'de>,
+    {
+        deserialize_map_fields!(
+            'de, map,
+            "id" => id: Option<String>,
+            "title" => title: Option<axis::Title>,
+            "side" => side: Option<String>,
+            "scale" => scale: Option<axis::Scale>,
+            "ticks" => ticks: Option<axis::Ticks>,
+            "minorTicks" => minor_ticks: Option<axis::MinorTicks>,
+            "grid" => grid: Option<axis::Grid>,
+            "minorGrid" => minor_grid: Option<axis::MinorGrid>,
+        );
+
+        let side = match (side.as_deref(), Dr::dir()) {
+            (Some("main"), _) => axis::Side::Main,
+            (Some("opposite"), _) => axis::Side::Opposite,
+            (Some("bottom"), Dir::X) => axis::Side::Main,
+            (Some("top"), Dir::X) => axis::Side::Opposite,
+            (Some("left"), Dir::Y) => axis::Side::Main,
+            (Some("right"), Dir::Y) => axis::Side::Opposite,
+            (Some("bottom") | Some("top"), Dir::Y) => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid side '{}' for y-axis",
+                    side.unwrap()
+                )));
+            }
+            (Some("left") | Some("right"), Dir::X) => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid side '{}' for x-axis",
+                    side.unwrap()
+                )));
+            }
+            (Some(other), _) => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid side '{}'",
+                    other
+                )));
+            }
+            (None, _) => axis::Side::default(),
+        };
+
+        let mut axis = axis::Axis::new();
+        if let Some(id) = id {
+            axis = axis.with_id(id);
+        }
+        if let Some(title) = title {
+            axis = axis.with_title(title);
+        }
+        if side == axis::Side::Opposite {
+            axis = axis.with_opposite_side();
+        }
+        if let Some(scale) = scale {
+            axis = axis.with_scale(scale);
+        }
+        if let Some(ticks) = ticks {
+            axis = axis.with_ticks(ticks);
+        }
+        if let Some(minor_ticks) = minor_ticks {
+            axis = axis.with_minor_ticks(minor_ticks);
+        }
+        if let Some(grid) = grid {
+            axis = axis.with_grid(grid);
+        }
+        if let Some(minor_grid) = minor_grid {
+            axis = axis.with_minor_grid(minor_grid);
+        }
+
+        Ok(DeAxis {
+            axis,
+            phantom: PhantomData,
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const SHARED_SCALE_JSON: &str = r#"
+{
+  "scale": {
+    "type": "shared",
+    "ref": "x2"
+  }
+}
+"#;
+
+    #[test]
+    fn test_shared_scale_ser() {
+        let input =
+            axis::Axis::new().with_scale(axis::Scale::Shared(axis::Ref::Id("x2".to_string())));
+        let result = serde_json::to_string_pretty(&input).unwrap();
+        let expected = SHARED_SCALE_JSON.trim();
+        assert_eq!(result, expected);
+    }
+
+    #[test]
+    fn test_shared_scale_deser() {
+        let input = SHARED_SCALE_JSON;
+        let result: axis::Axis = serde_json::from_str(input).unwrap();
+        let expected =
+            axis::Axis::new().with_scale(axis::Scale::Shared(axis::Ref::Id("x2".to_string())));
+        assert_eq!(result, expected);
+    }
+}
diff --git a/src/des/sd/cmap.rs b/src/des/sd/cmap.rs
new file mode 100644
index 00000000..cf1a779d
--- /dev/null
+++ b/src/des/sd/cmap.rs
@@ -0,0 +1,288 @@
+use plotive_base::Rgb8;
+use serde::Deserializer;
+use serde::de::{Error, SeqAccess};
+use serde::ser::{SerializeSeq, SerializeStruct};
+
+use crate::des;
+use crate::des::cmap;
+use crate::des::cmap::{LerpColorMap, LerpMethod};
+
+impl serde::Serialize for LerpMethod {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let name = match self {
+            LerpMethod::Nearest => "nearest",
+            LerpMethod::SRgb => "srgb",
+            LerpMethod::LinearRgb => "linear-rgb",
+            LerpMethod::Perceptual => "perceptual",
+            LerpMethod::Xyz => "xyz",
+        };
+        serializer.serialize_str(name)
+    }
+}
+
+impl<'de> serde::Deserialize<'de> for LerpMethod {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        struct LerpMethodVisitor;
+
+        impl<'de> serde::de::Visitor<'de> for LerpMethodVisitor {
+            type Value = LerpMethod;
+            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+                formatter.write_str("one of [nearest, srgb, linear-rgb, perceptual, xyz]")
+            }
+            fn visit_str<E>(self, value: &str) -> Result<LerpMethod, E>
+            where
+                E: serde::de::Error,
+            {
+                match value {
+                    "nearest" => Ok(LerpMethod::Nearest),
+                    "srgb" => Ok(LerpMethod::SRgb),
+                    "linear-rgb" => Ok(LerpMethod::LinearRgb),
+                    "perceptual" => Ok(LerpMethod::Perceptual),
+                    "xyz" => Ok(LerpMethod::Xyz),
+                    _ => Err(E::custom(format!("unknown lerp method: {}", value))),
+                }
+            }
+        }
+
+        deserializer.deserialize_str(LerpMethodVisitor)
+    }
+}
+
+struct SerStops<'a> {
+    monotonic: bool,
+    start: Rgb8,
+    end: Rgb8,
+    stops: &'a [(f32, Rgb8)],
+}
+
+impl<'a> serde::Serialize for SerStops<'a> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let mut seq = serializer.serialize_seq(Some(self.stops.len() + 2))?;
+        if self.monotonic {
+            seq.serialize_element(&self.start)?;
+            for stop in self.stops {
+                seq.serialize_element(&stop.1)?;
+            }
+            seq.serialize_element(&self.end)?;
+        } else {
+            seq.serialize_element(&(0.0, self.start))?;
+            for stop in self.stops {
+                seq.serialize_element(stop)?;
+            }
+            seq.serialize_element(&(1.0, self.end))?;
+        }
+        seq.end()
+    }
+}
+
+#[derive(Debug)]
+struct DeStops {
+    start: Rgb8,
+    end: Rgb8,
+    stops: Vec<(f32, Rgb8)>,
+}
+
+impl<'de> serde::Deserialize<'de> for DeStops {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        struct StopsVisitor;
+
+        impl<'de> serde::de::Visitor<'de> for StopsVisitor {
+            type Value = DeStops;
+            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+                formatter.write_str("a sequence of stops")
+            }
+
+            fn visit_seq<A>(self, seq: A) -> Result<Self::Value, A::Error>
+            where
+                A: SeqAccess<'de>,
+            {
+                let mut seq = seq;
+                let mut de_stops = Vec::with_capacity(seq.size_hint().unwrap_or(0));
+                while let Some(de_stop) = seq.next_element::<DeStop>()? {
+                    de_stops.push(de_stop);
+                }
+                if de_stops.len() < 2 {
+                    return Err(A::Error::invalid_length(de_stops.len(), &"stops"));
+                }
+                let monotonic = de_stops[0].pos.is_none();
+                if monotonic {
+                    if !de_stops.iter().skip(1).all(|stop| stop.pos.is_none()) {
+                        return Err(A::Error::custom(
+                            "Can't mix stops with and without position",
+                        ));
+                    }
+                    let start = de_stops[0].color;
+                    let end = de_stops.pop().unwrap().color;
+                    let monotonic_div = 1.0 / (de_stops.len() as f32);
+                    let stops = de_stops
+                        .iter()
+                        .skip(1)
+                        .enumerate()
+                        .map(|(i, stop)| (monotonic_div * (i as f32 + 1.0), stop.color))
+                        .collect();
+                    Ok(DeStops { start, end, stops })
+                } else {
+                    if !de_stops.iter().skip(1).all(|stop| stop.pos.is_some()) {
+                        return Err(A::Error::custom(
+                            "Can't mix stops with and without position",
+                        ));
+                    }
+                    const EPS: f32 = 0.001;
+                    fn near(value: f32, target: f32) -> bool {
+                        target - EPS < value && value < target + EPS
+                    }
+                    if !near(*de_stops[0].pos.as_ref().unwrap(), 0.0) {
+                        return Err(A::Error::custom("First stop must have position 0.0"));
+                    }
+                    if !near(*de_stops.last().unwrap().pos.as_ref().unwrap(), 1.0) {
+                        return Err(A::Error::custom("Last stop must have position 1.0"));
+                    }
+                    let start = de_stops[0].color;
+                    let end = de_stops.pop().unwrap().color;
+                    let stops = de_stops
+                        .into_iter()
+                        .skip(1)
+                        .map(|stop| (stop.pos.unwrap(), stop.color))
+                        .collect();
+                    Ok(DeStops { start, end, stops })
+                }
+            }
+        }
+
+        deserializer.deserialize_seq(StopsVisitor)
+    }
+}
+
+#[derive(Debug)]
+struct DeStop {
+    pos: Option<f32>,
+    color: Rgb8,
+}
+
+impl<'de> serde::Deserialize<'de> for DeStop {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        struct StopVisitor;
+        impl<'de> serde::de::Visitor<'de> for StopVisitor {
+            type Value = DeStop;
+            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+                formatter.write_str("a color stop")
+            }
+            fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                let color = value.parse::<Rgb8>().map_err(E::custom)?;
+                Ok(DeStop { pos: None, color })
+            }
+            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
+            where
+                A: SeqAccess<'de>,
+            {
+                let pos = seq
+                    .next_element::<f32>()?
+                    .ok_or_else(|| serde::de::Error::custom("expected position"))?;
+                let color = seq
+                    .next_element::<Rgb8>()?
+                    .ok_or_else(|| serde::de::Error::custom("expected color"))?;
+                Ok(DeStop {
+                    pos: Some(pos),
+                    color,
+                })
+            }
+        }
+        deserializer.deserialize_any(StopVisitor)
+    }
+}
+
+impl serde::Serialize for LerpColorMap {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        if let Some(name) = self.name() {
+            name.serialize(serializer)
+        } else {
+            let mut state = serializer.serialize_struct("LerpColorMap", 1)?;
+            if self.method() != LerpMethod::default() {
+                state.serialize_field("method", &self.method())?;
+            }
+            let stops = SerStops {
+                monotonic: self.is_monotonic(),
+                start: self.start(),
+                end: self.end(),
+                stops: self.stops(),
+            };
+            state.serialize_field("stops", &stops)?;
+            state.serialize_field("scale", self.scale())?;
+            state.end()
+        }
+    }
+}
+
+impl<'de> serde::Deserialize<'de> for LerpColorMap {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        struct LerpColorMapVisitor;
+
+        impl<'de> serde::de::Visitor<'de> for LerpColorMapVisitor {
+            type Value = LerpColorMap;
+            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+                formatter.write_str("a LerpColorMap")
+            }
+
+            fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                if let Some(cmap) = cmap::from_name(value) {
+                    Ok(cmap)
+                } else {
+                    Err(E::custom(format!("Unknown ColorMap name: {}", value)))
+                }
+            }
+
+            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
+            where
+                A: serde::de::MapAccess<'de>,
+            {
+                super::deserialize_map_fields!(
+                    'de, map,
+                    "method" => method: Option<LerpMethod>,
+                    "stops" => stops: Option<DeStops>,
+                    "scale" => scale: Option<des::axis::Scale>,
+                );
+
+                let Some(stops) = stops else {
+                    return Err(A::Error::missing_field("stops"));
+                };
+                let method = method.unwrap_or(LerpMethod::default());
+                let mut cmap = LerpColorMap::new(method, stops.start, stops.end);
+                if !stops.stops.is_empty() {
+                    cmap = cmap.with_stops(stops.stops);
+                }
+                if let Some(scale) = scale {
+                    cmap = cmap.with_scale(scale);
+                }
+                Ok(cmap)
+            }
+        }
+        deserializer.deserialize_any(LerpColorMapVisitor)
+    }
+}
diff --git a/src/des/sd/colorbar.rs b/src/des/sd/colorbar.rs
new file mode 100644
index 00000000..01c66f54
--- /dev/null
+++ b/src/des/sd/colorbar.rs
@@ -0,0 +1,202 @@
+use serde::de::MapAccess;
+use serde::ser::SerializeStruct;
+use serde::{Deserializer, Serializer};
+
+use crate::des::axis::ticks;
+use crate::des::colorbar;
+use crate::style::theme;
+
+impl serde::Serialize for colorbar::Title {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        if self.spans().is_empty() && self.props() == &colorbar::TitleProps::default() {
+            self.text().serialize(serializer)
+        } else {
+            let mut state = serializer.serialize_struct("Title", 2)?;
+            state.serialize_field("text", self.text())?;
+            todo!("Serialize rich props and spans")
+            //state.end()
+        }
+    }
+}
+
+impl<'de> serde::Deserialize<'de> for colorbar::Title {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        struct TitleVisitor;
+
+        impl<'de> serde::de::Visitor<'de> for TitleVisitor {
+            type Value = colorbar::Title;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+                formatter.write_str("an axis title string or rich text")
+            }
+
+            fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                Ok(colorbar::Title::from(value.to_string()))
+            }
+
+            fn visit_map<A>(self, _map: A) -> Result<Self::Value, A::Error>
+            where
+                A: serde::de::MapAccess<'de>,
+            {
+                todo!("Deserialize rich title with props and spans")
+            }
+        }
+        deserializer.deserialize_any(TitleVisitor)
+    }
+}
+
+impl serde::Serialize for colorbar::Pos {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            colorbar::Pos::Left => serializer.serialize_str("left"),
+            colorbar::Pos::Right => serializer.serialize_str("right"),
+            colorbar::Pos::Top => serializer.serialize_str("top"),
+            colorbar::Pos::Bottom => serializer.serialize_str("bottom"),
+        }
+    }
+}
+
+impl<'de> serde::Deserialize<'de> for colorbar::Pos {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        struct Visitor;
+        impl<'de> serde::de::Visitor<'de> for Visitor {
+            type Value = colorbar::Pos;
+            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+                formatter.write_str("a string")
+            }
+            fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                match v {
+                    "auto" => Ok(colorbar::Pos::default()),
+                    "left" => Ok(colorbar::Pos::Left),
+                    "right" => Ok(colorbar::Pos::Right),
+                    "top" => Ok(colorbar::Pos::Top),
+                    "bottom" => Ok(colorbar::Pos::Bottom),
+                    _ => Err(E::invalid_value(serde::de::Unexpected::Str(v), &self)),
+                }
+            }
+        }
+        deserializer.deserialize_str(Visitor)
+    }
+}
+
+impl serde::Serialize for colorbar::ColorBar {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let default = colorbar::ColorBar::default();
+        if self == &default {
+            return "auto".serialize(serializer);
+        }
+
+        // check if only the pos has changed
+        let mut self_default_pos = self.clone();
+        self_default_pos.pos = Default::default();
+        if self_default_pos == default {
+            return self.pos().serialize(serializer);
+        }
+
+        let mut map = serializer.serialize_struct("ColorBar", 6)?;
+        if self.pos() != default.pos() {
+            map.serialize_field("pos", &self.pos())?;
+        }
+        if self.width() != default.width() {
+            map.serialize_field("width", &self.width())?;
+        }
+        if self.title() != default.title() {
+            map.serialize_field("title", &self.title())?;
+        }
+        if self.border() != default.border() {
+            map.serialize_field("border", &self.border())?;
+        }
+        if self.ticks_locator() != default.ticks_locator() {
+            map.serialize_field("ticks", &self.ticks_locator())?;
+        }
+        if self.margin() != default.margin() {
+            map.serialize_field("margin", &self.margin())?;
+        }
+        map.end()
+    }
+}
+
+impl<'de> serde::Deserialize<'de> for colorbar::ColorBar {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        struct Visitor;
+        impl<'de> serde::de::Visitor<'de> for Visitor {
+            type Value = colorbar::ColorBar;
+            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+                formatter.write_str("a string or a map")
+            }
+            fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                match v {
+                    "auto" => Ok(colorbar::ColorBar::default()),
+                    "left" => Ok(colorbar::ColorBar::new(colorbar::Pos::Left)),
+                    "right" => Ok(colorbar::ColorBar::new(colorbar::Pos::Right)),
+                    "top" => Ok(colorbar::ColorBar::new(colorbar::Pos::Top)),
+                    "bottom" => Ok(colorbar::ColorBar::new(colorbar::Pos::Bottom)),
+                    _ => Err(E::invalid_value(serde::de::Unexpected::Str(v), &self)),
+                }
+            }
+            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
+            where
+                A: MapAccess<'de>,
+            {
+                super::deserialize_map_fields!(
+                    'de, map,
+                    "pos" => pos: Option<colorbar::Pos>,
+                    "width" => width: Option<f32>,
+                    "title" => title: Option<colorbar::Title>,
+                    "border" => border: Option<Option<theme::Stroke>>,
+                    "ticks" => ticks: Option<ticks::Locator>,
+                    "margin" => margin: Option<f32>,
+                );
+                let mut colorbar = if let Some(pos) = pos {
+                    colorbar::ColorBar::new(pos)
+                } else {
+                    colorbar::ColorBar::default()
+                };
+                if let Some(width) = width {
+                    colorbar = colorbar.with_width(width);
+                }
+                if let Some(title) = title {
+                    colorbar = colorbar.with_title(title);
+                }
+                if let Some(border) = border {
+                    colorbar = colorbar.with_border(border)
+                }
+                if let Some(ticks) = ticks {
+                    colorbar = colorbar.with_ticks_locator(ticks)
+                }
+                if let Some(margin) = margin {
+                    colorbar = colorbar.with_margin(margin)
+                }
+                Ok(colorbar)
+            }
+        }
+        deserializer.deserialize_any(Visitor)
+    }
+}
diff --git a/src/des/sd/legend.rs b/src/des/sd/legend.rs
new file mode 100644
index 00000000..1df0dbb7
--- /dev/null
+++ b/src/des/sd/legend.rs
@@ -0,0 +1,237 @@
+use std::borrow::Cow;
+
+use serde::ser::SerializeStruct;
+
+use crate::des::{Legend, figure, legend, plot};
+use crate::geom;
+use crate::style::{defaults, theme};
+
+// MARK: figure::LegendPos
+
+impl serde::Serialize for figure::LegendPos {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        match self {
+            figure::LegendPos::Top => "top",
+            figure::LegendPos::Right => "right",
+            figure::LegendPos::Bottom => "bottom",
+            figure::LegendPos::Left => "left",
+        }
+        .serialize(serializer)
+    }
+}
+
+impl<'de> serde::de::Deserialize<'de> for figure::LegendPos {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::de::Deserializer<'de>,
+    {
+        let s: Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
+        match &*s {
+            "top" => Ok(figure::LegendPos::Top),
+            "right" => Ok(figure::LegendPos::Right),
+            "bottom" => Ok(figure::LegendPos::Bottom),
+            "left" => Ok(figure::LegendPos::Left),
+            _ => Err(serde::de::Error::unknown_variant(
+                &s,
+                &["top", "right", "bottom", "left"],
+            )),
+        }
+    }
+}
+
+// MARK: plot::LegendPos
+
+impl serde::Serialize for plot::LegendPos {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        match self {
+            plot::LegendPos::OutTop => "out-top",
+            plot::LegendPos::OutRight => "out-right",
+            plot::LegendPos::OutBottom => "out-bottom",
+            plot::LegendPos::OutLeft => "out-left",
+            plot::LegendPos::InTopLeft => "in-top-left",
+            plot::LegendPos::InTop => "in-top",
+            plot::LegendPos::InTopRight => "in-top-right",
+            plot::LegendPos::InRight => "in-right",
+            plot::LegendPos::InBottomRight => "in-bottom-right",
+            plot::LegendPos::InBottom => "in-bottom",
+            plot::LegendPos::InBottomLeft => "in-bottom-left",
+            plot::LegendPos::InLeft => "in-left",
+        }
+        .serialize(serializer)
+    }
+}
+
+impl<'de> serde::de::Deserialize<'de> for plot::LegendPos {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::de::Deserializer<'de>,
+    {
+        let s: Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
+        match &*s {
+            "out-top" => Ok(plot::LegendPos::OutTop),
+            "out-right" => Ok(plot::LegendPos::OutRight),
+            "out-bottom" => Ok(plot::LegendPos::OutBottom),
+            "out-left" => Ok(plot::LegendPos::OutLeft),
+            "in-top-left" => Ok(plot::LegendPos::InTopLeft),
+            "in-top" => Ok(plot::LegendPos::InTop),
+            "in-top-right" => Ok(plot::LegendPos::InTopRight),
+            "in-right" => Ok(plot::LegendPos::InRight),
+            "in-bottom-right" => Ok(plot::LegendPos::InBottomRight),
+            "in-bottom" => Ok(plot::LegendPos::InBottom),
+            "in-bottom-left" => Ok(plot::LegendPos::InBottomLeft),
+            "in-left" => Ok(plot::LegendPos::InLeft),
+            _ => Err(serde::de::Error::unknown_variant(
+                s.as_ref(),
+                &[
+                    "out-top",
+                    "out-right",
+                    "out-bottom",
+                    "out-left",
+                    "in-top-left",
+                    "in-top",
+                    "in-top-right",
+                    "in-right",
+                    "in-bottom-right",
+                    "in-bottom",
+                    "in-bottom-left",
+                    "in-left",
+                ],
+            )),
+        }
+    }
+}
+
+// MARK: Legend
+
+impl<P> serde::Serialize for Legend<P>
+where
+    P: serde::Serialize + Copy,
+{
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let font_default = self.font() == &legend::EntryFont::default();
+        let fill_default = self.fill() == defaults::legend_fill().as_ref();
+        let border_default = self.border() == Some(&theme::Col::LegendBorder.into());
+        let columns_default = self.columns().is_none();
+        let padding_default = self.padding() == defaults::LEGEND_PADDING.into();
+        let margin_default = self.margin() == defaults::LEGEND_MARGIN;
+        let spacing_default = self.spacing()
+            == geom::Size::new(defaults::LEGEND_H_SPACING, defaults::LEGEND_V_SPACING);
+
+        if font_default
+            && fill_default
+            && border_default
+            && columns_default
+            && padding_default
+            && margin_default
+            && spacing_default
+        {
+            self.pos().serialize(serializer)
+        } else {
+            let mut state = serializer.serialize_struct("Legend", 2)?;
+            state.serialize_field("pos", &self.pos())?;
+            if !font_default {
+                todo!("Serialize legend::EntryFont")
+            }
+            if !fill_default {
+                state.serialize_field("fill", &self.fill())?;
+            }
+            if !border_default {
+                state.serialize_field("border", &self.border())?;
+            }
+            if !columns_default {
+                state.serialize_field("columns", &self.columns())?;
+            }
+            if !padding_default {
+                todo!("Serialize geom::Padding")
+            }
+            if !margin_default {
+                state.serialize_field("margin", &self.margin())?;
+            }
+            if !spacing_default {
+                state.serialize_field("spacing", &self.spacing())?;
+            }
+            state.end()
+        }
+    }
+}
+
+impl<'de, P> serde::de::Deserialize<'de> for Legend<P>
+where
+    P: serde::de::Deserialize<'de> + Default,
+{
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::de::Deserializer<'de>,
+    {
+        deserializer.deserialize_any(LegendVisitor {
+            marker: std::marker::PhantomData,
+        })
+    }
+}
+
+struct LegendVisitor<P> {
+    marker: std::marker::PhantomData<P>,
+}
+
+impl<'de, P> serde::de::Visitor<'de> for LegendVisitor<P>
+where
+    P: serde::de::Deserialize<'de> + Default,
+{
+    type Value = Legend<P>;
+
+    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+        formatter.write_str("a legend position or a legend object")
+    }
+
+    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+    where
+        E: serde::de::Error,
+    {
+        let deserializer = serde::de::value::StrDeserializer::<E>::new(v);
+        if let Ok(pos) = P::deserialize(deserializer) {
+            return Ok(Legend::<P>::new(pos));
+        }
+        Err(serde::de::Error::custom(format!(
+            "invalid legend position: {}",
+            v
+        )))
+    }
+
+    fn visit_map<M>(self, mut map: M) -> Result<Self::Value, M::Error>
+    where
+        M: serde::de::MapAccess<'de>,
+    {
+        let mut legend = Legend::<P>::default();
+        while let Some(key) = map.next_key::<Cow<'de, str>>()? {
+            match &*key {
+                "pos" => legend = legend.with_pos(map.next_value()?),
+                "font" => todo!("Deserialize legend::EntryFont"),
+                "fill" => legend = legend.with_fill(map.next_value()?),
+                "border" => legend = legend.with_border(map.next_value()?),
+                "columns" => legend = legend.with_columns(map.next_value()?),
+                "padding" => todo!("Deserialize geom::Padding"),
+                "margin" => legend = legend.with_margin(map.next_value()?),
+                "spacing" => legend = legend.with_spacing(map.next_value()?),
+                _ => {
+                    return Err(serde::de::Error::unknown_field(
+                        &key,
+                        &[
+                            "pos", "font", "fill", "border", "columns", "padding", "margin",
+                            "spacing",
+                        ],
+                    ));
+                }
+            }
+        }
+        Ok(legend)
+    }
+}
diff --git a/src/des/sd/plot.rs b/src/des/sd/plot.rs
new file mode 100644
index 00000000..f44c8c61
--- /dev/null
+++ b/src/des/sd/plot.rs
@@ -0,0 +1,656 @@
+use serde::Deserialize;
+use serde::ser::{SerializeSeq, SerializeStruct, SerializeTuple};
+use serde_value::Value;
+
+use crate::des::sd::axis::{DeXAxis, DeYAxis};
+use crate::des::sd::{self, deserialize_map_fields, deserialize_tagged_map_fields};
+use crate::des::{Annotation, Plot, PlotLegend, Subplots, axis, colorbar, plot, series};
+use crate::style::theme;
+
+// MARK: Plot
+
+struct SerPlot<'a> {
+    plot: &'a Plot,
+    subplot: Option<(u32, u32)>,
+}
+
+struct DePlot {
+    plot: Plot,
+    subplot: Option<(u32, u32)>,
+}
+
+impl serde::Serialize for Plot {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let plot = SerPlot {
+            plot: self,
+            subplot: None,
+        };
+        plot.serialize(serializer)
+    }
+}
+
+impl serde::Serialize for SerPlot<'_> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let mut state = serializer.serialize_struct("Plot", 2)?;
+        if let Some(subplot) = self.subplot {
+            state.serialize_field("subplot", &subplot)?;
+        }
+
+        if let Some(title) = self.plot.title() {
+            state.serialize_field("title", &title)?;
+        }
+
+        if self.plot.series().len() == 1 {
+            state.serialize_field("series", &self.plot.series()[0])?;
+        } else {
+            state.serialize_field("series", &self.plot.series())?;
+        }
+
+        serialize_axes(&mut state, self.plot.x_axes(), sd::axis::Dir::X)?;
+        serialize_axes(&mut state, self.plot.y_axes(), sd::axis::Dir::Y)?;
+
+        if let Some(fill) = self.plot.fill() {
+            state.serialize_field("fill", &fill)?;
+        }
+
+        if self.plot.border() != Some(&plot::Border::default()) {
+            state.serialize_field("border", &self.plot.border())?;
+        }
+
+        if self.plot.insets() != Some(&plot::Insets::default()) {
+            state.serialize_field("insets", &self.plot.insets())?;
+        }
+
+        if let Some(legend) = self.plot.legend() {
+            state.serialize_field("legend", &legend)?;
+        }
+
+        if let Some(colorbar) = self.plot.colorbar() {
+            state.serialize_field("colorbar", &colorbar)?;
+        }
+
+        if !self.plot.annotations().is_empty() {
+            state.serialize_field("annotations", self.plot.annotations())?;
+        }
+
+        state.end()
+    }
+}
+
+fn serialize_axes<S>(state: &mut S, axes: &[axis::Axis], dir: sd::axis::Dir) -> Result<(), S::Error>
+where
+    S: serde::ser::SerializeStruct,
+{
+    if axes.len() == 1 {
+        let axis = super::axis::SerAxis {
+            axis: &axes[0],
+            dir,
+        };
+        let field_name = match dir {
+            sd::axis::Dir::X => "xAxis",
+            sd::axis::Dir::Y => "yAxis",
+            sd::axis::Dir::Unknown => unreachable!(),
+        };
+        if axis.axis != &axis::Axis::default() {
+            state.serialize_field(field_name, &axis)?;
+        }
+    } else if !axes.is_empty() {
+        // TODO: avoid the vec allocation
+        let oriented_axes = super::axis::SerAxes { axes, dir };
+        let field_name = match dir {
+            sd::axis::Dir::X => "xAxes",
+            sd::axis::Dir::Y => "yAxes",
+            sd::axis::Dir::Unknown => unreachable!(),
+        };
+        state.serialize_field(field_name, &oriented_axes)?;
+    }
+    Ok(())
+}
+
+struct DeSeries(Vec<series::Series>);
+
+impl<'de> serde::Deserialize<'de> for DeSeries {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        struct SeriesVisitor;
+
+        impl<'de> serde::de::Visitor<'de> for SeriesVisitor {
+            type Value = DeSeries;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+                formatter.write_str("a series object or an array of series objects")
+            }
+
+            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
+            where
+                A: serde::de::SeqAccess<'de>,
+            {
+                let mut series = Vec::<series::Series>::with_capacity(1);
+                while let Some(s) = seq.next_element()? {
+                    series.push(s);
+                }
+                Ok(DeSeries(series))
+            }
+
+            fn visit_map<A>(self, map: A) -> Result<Self::Value, A::Error>
+            where
+                A: serde::de::MapAccess<'de>,
+            {
+                let s =
+                    series::Series::deserialize(serde::de::value::MapAccessDeserializer::new(map))?;
+                Ok(DeSeries(vec![s]))
+            }
+        }
+
+        deserializer.deserialize_any(SeriesVisitor)
+    }
+}
+
+impl<'de> serde::Deserialize<'de> for Plot {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let de_plot = DePlot::deserialize(deserializer)?;
+        if de_plot.subplot.is_some() {
+            return Err(serde::de::Error::custom(
+                "The 'subplot' field is not allowed when deserializing a Plot directly. It is only used when deserializing a Figure with multiple plots.",
+            ));
+        }
+        Ok(de_plot.plot)
+    }
+}
+
+impl<'de> serde::Deserialize<'de> for DePlot {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        deserializer.deserialize_map(PlotVisitor)
+    }
+}
+
+struct PlotVisitor;
+
+impl<'de> serde::de::Visitor<'de> for PlotVisitor {
+    type Value = DePlot;
+
+    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+        formatter.write_str("a plot object")
+    }
+
+    fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
+    where
+        A: serde::de::MapAccess<'de>,
+    {
+        deserialize_map_fields!(
+            'de, map,
+            "subplot" => subplot: Option<(u32, u32)>,
+            "series" => series: Option<DeSeries>,
+            "title" => title: Option<String>,
+            "xAxis" => x_axis: Option<DeXAxis>,
+            "yAxis" => y_axis: Option<DeYAxis>,
+            "xAxes" => x_axes: Option<Vec<DeXAxis>>,
+            "yAxes" => y_axes: Option<Vec<DeYAxis>>,
+            "fill" => fill: Option<theme::Fill>,
+            "border" => border: Option<Option<plot::Border>>,
+            "insets" => insets: Option<Option<plot::Insets>>,
+            "legend" => legend: Option<PlotLegend>,
+            "colorbar" => colorbar: Option<colorbar::ColorBar>,
+            "annotations" => annotations: Option<Vec<Annotation>>,
+        );
+
+        let Some(series) = series.map(|s| s.0) else {
+            return Err(serde::de::Error::missing_field("series"));
+        };
+
+        let mut plot = Plot::new(series);
+        if let Some(title) = title {
+            plot = plot.with_title(title);
+        }
+        match (x_axis, x_axes) {
+            (Some(x_axis), None) => plot = plot.with_x_axis(x_axis.axis),
+            (None, Some(x_axes)) => {
+                for x_axis in x_axes {
+                    plot = plot.with_x_axis(x_axis.axis);
+                }
+            }
+            (Some(_), Some(_)) => {
+                return Err(serde::de::Error::custom(
+                    "Both 'x_axis' and 'x_axes' fields cannot be specified at the same time",
+                ));
+            }
+            (None, None) => {}
+        }
+        match (y_axis, y_axes) {
+            (Some(y_axis), None) => plot = plot.with_y_axis(y_axis.axis),
+            (None, Some(y_axes)) => {
+                for y_axis in y_axes {
+                    plot = plot.with_y_axis(y_axis.axis);
+                }
+            }
+            (Some(_), Some(_)) => {
+                return Err(serde::de::Error::custom(
+                    "Both 'y_axis' and 'y_axes' fields cannot be specified at the same time",
+                ));
+            }
+            (None, None) => {}
+        }
+        if let Some(fill) = fill {
+            plot = plot.with_fill(fill);
+        }
+        if let Some(border) = border {
+            plot = plot.with_border(border);
+        }
+        if let Some(insets) = insets {
+            plot = plot.with_insets(insets);
+        }
+        if let Some(legend) = legend {
+            plot = plot.with_legend(legend);
+        }
+        if let Some(colorbar) = colorbar {
+            plot = plot.with_colorbar(colorbar);
+        }
+        if let Some(annotations) = annotations {
+            for annotation in annotations {
+                plot = plot.with_annotation(annotation);
+            }
+        }
+        Ok(DePlot { plot, subplot })
+    }
+}
+
+// MARK: Subplots
+
+struct DePlots(Vec<DePlot>);
+
+impl serde::Serialize for Subplots {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let mut state = serializer.serialize_seq(Some(self.len()))?;
+
+        // Serialize the subplot property only if we are not in the default case of all plots contiguous in the same column.
+        let single_column = self.cols() == 1 && self.rows() == self.len() as u32;
+
+        for row in 0..self.rows() {
+            for col in 0..self.cols() {
+                if let Some(plot) = self.plot((row, col)) {
+                    let plot = SerPlot {
+                        plot,
+                        subplot: if single_column {
+                            None
+                        } else {
+                            Some((row, col))
+                        },
+                    };
+                    state.serialize_element(&plot)?;
+                }
+            }
+        }
+        state.end()
+    }
+}
+
+impl<'de> serde::Deserialize<'de> for DePlots {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        struct PlotsVisitor;
+
+        impl<'de> serde::de::Visitor<'de> for PlotsVisitor {
+            type Value = DePlots;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+                formatter.write_str("an array of plot objects")
+            }
+
+            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
+            where
+                A: serde::de::SeqAccess<'de>,
+            {
+                let capacity = seq.size_hint().unwrap_or(0);
+                let mut plots = Vec::<DePlot>::with_capacity(capacity);
+                while let Some(plot) = seq.next_element()? {
+                    plots.push(plot);
+                }
+                Ok(DePlots(plots))
+            }
+        }
+
+        deserializer.deserialize_seq(PlotsVisitor)
+    }
+}
+
+impl<'de> serde::Deserialize<'de> for Subplots {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let DePlots(de_plots) = DePlots::deserialize(deserializer)?;
+        let mut max_row = None::<u32>;
+        let mut max_col = None::<u32>;
+        for DePlot { subplot, .. } in &de_plots {
+            if let Some((row, col)) = subplot {
+                match max_row.as_mut() {
+                    Some(r) => {
+                        *r = (*r).max(*row);
+                    }
+                    None => max_row = Some(*row),
+                }
+                match max_col.as_mut() {
+                    Some(c) => {
+                        *c = (*c).max(*col);
+                    }
+                    None => max_col = Some(*col),
+                }
+            }
+        }
+        let rows = max_row.map(|r| r + 1).unwrap_or(de_plots.len() as u32);
+        let cols = max_col.map(|c| c + 1).unwrap_or(1);
+
+        let mut subplots = Subplots::new(rows, cols);
+
+        for (i, DePlot { plot, subplot }) in de_plots.iter().enumerate() {
+            let row = subplot.map(|(r, _)| r).unwrap_or(i as u32);
+            let col = subplot.map(|(_, c)| c).unwrap_or(0);
+            subplots = subplots.with_plot((row, col), plot.clone());
+        }
+        Ok(subplots)
+    }
+}
+
+// MARK: plot::Border
+
+impl serde::Serialize for plot::Border {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        match self {
+            plot::Border::Box(border) => {
+                if border == &plot::BoxBorder::default() {
+                    "box".serialize(serializer)
+                } else {
+                    let mut state = serializer.serialize_struct("Border", 2)?;
+                    state.serialize_field("type", "box")?;
+                    state.serialize_field("stroke", &border.0)?;
+                    state.end()
+                }
+            }
+            plot::Border::Axis(border) => {
+                if border == &plot::AxisBorder::default() {
+                    "axis".serialize(serializer)
+                } else {
+                    let mut state = serializer.serialize_struct("Border", 2)?;
+                    state.serialize_field("type", "axis")?;
+                    state.serialize_field("stroke", &border.0)?;
+                    state.end()
+                }
+            }
+            plot::Border::AxisArrow(border) => {
+                let default = plot::AxisArrowBorder::default();
+                if border == &default {
+                    "arrow".serialize(serializer)
+                } else {
+                    let mut state = serializer.serialize_struct("Border", 2)?;
+                    state.serialize_field("type", "arrow")?;
+                    if border.stroke != default.stroke {
+                        state.serialize_field("stroke", &border.stroke)?;
+                    }
+                    if border.size != default.size {
+                        state.serialize_field("size", &border.size)?;
+                    }
+                    if border.overflow != default.overflow {
+                        state.serialize_field("overflow", &border.overflow)?;
+                    }
+                    state.end()
+                }
+            }
+        }
+    }
+}
+
+impl<'de> serde::Deserialize<'de> for plot::Border {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        deserializer.deserialize_any(BorderVisitor)
+    }
+}
+
+struct BorderVisitor;
+
+impl<'de> serde::de::Visitor<'de> for BorderVisitor {
+    type Value = plot::Border;
+
+    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+        formatter
+            .write_str("a border type string, a theme color/stroke, or a map with a 'type' field")
+    }
+
+    fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
+    where
+        E: serde::de::Error,
+    {
+        match value {
+            "box" => Ok(plot::Border::Box(Default::default())),
+            "axis" => Ok(plot::Border::Axis(Default::default())),
+            "arrow" => Ok(plot::Border::AxisArrow(Default::default())),
+            _ => {
+                let stroke =
+                    theme::Stroke::deserialize(serde::de::value::StrDeserializer::<E>::new(value))?;
+                Ok(plot::Border::Box(plot::BoxBorder(stroke)))
+            }
+        }
+    }
+
+    fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
+    where
+        A: serde::de::MapAccess<'de>,
+    {
+        let mut buffered = Vec::<(String, Value)>::new();
+
+        while let Some(key) = map.next_key::<String>()? {
+            if key == "type" {
+                let tag = map.next_value::<String>()?;
+                return match tag.as_str() {
+                    // If type is first, `buffered` is empty and we deserialize directly from map.
+                    // If not, only the fields before `type` are buffered.
+                    "box" => deserialize_box_border(&mut map, buffered).map(plot::Border::Box),
+                    "axis" => deserialize_axis_border(&mut map, buffered).map(plot::Border::Axis),
+                    "arrow" => deserialize_axis_arrow_border(&mut map, buffered)
+                        .map(plot::Border::AxisArrow),
+                    _ => Err(serde::de::Error::unknown_variant(
+                        &tag,
+                        &["box", "axis", "arrow"],
+                    )),
+                };
+            }
+
+            let value = map.next_value::<Value>()?;
+            buffered.push((key, value));
+        }
+
+        let value = Value::Map(
+            buffered
+                .into_iter()
+                .map(|(key, value)| (Value::String(key), value))
+                .collect(),
+        );
+        let stroke = value
+            .deserialize_into::<theme::Stroke>()
+            .map_err(serde::de::Error::custom)?;
+        Ok(plot::Border::Box(plot::BoxBorder(stroke)))
+    }
+}
+
+fn deserialize_box_border<'de, A>(
+    map: &mut A,
+    buffered: Vec<(String, Value)>,
+) -> Result<plot::BoxBorder, A::Error>
+where
+    A: serde::de::MapAccess<'de>,
+{
+    deserialize_tagged_map_fields! {
+        'de, map, buffered,
+        "stroke" => stroke: Option<theme::Stroke>,
+    }
+
+    let border = stroke.map(plot::BoxBorder).unwrap_or_default();
+    Ok(border)
+}
+
+fn deserialize_axis_border<'de, A>(
+    map: &mut A,
+    buffered: Vec<(String, Value)>,
+) -> Result<plot::AxisBorder, A::Error>
+where
+    A: serde::de::MapAccess<'de>,
+{
+    deserialize_tagged_map_fields! {
+        'de, map, buffered,
+        "stroke" => stroke: Option<theme::Stroke>,
+    }
+
+    let border = stroke.map(plot::AxisBorder).unwrap_or_default();
+    Ok(border)
+}
+
+fn deserialize_axis_arrow_border<'de, A>(
+    map: &mut A,
+    buffered: Vec<(String, Value)>,
+) -> Result<plot::AxisArrowBorder, A::Error>
+where
+    A: serde::de::MapAccess<'de>,
+{
+    deserialize_tagged_map_fields! {
+        'de, map, buffered,
+        "stroke" => stroke: Option<theme::Stroke>,
+        "size" => size: Option<f32>,
+        "overflow" => overflow: Option<f32>,
+    }
+
+    let mut border = plot::AxisArrowBorder::default();
+    if let Some(stroke) = stroke {
+        border.stroke = stroke;
+    }
+    if let Some(size) = size {
+        border.size = size;
+    }
+    if let Some(overflow) = overflow {
+        border.overflow = overflow;
+    }
+    Ok(border)
+}
+
+// MARK: Insets
+
+impl serde::Serialize for plot::Insets {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        match self {
+            plot::Insets::Auto => "auto".serialize(serializer),
+            plot::Insets::Fixed(x, y) => {
+                if x == y {
+                    x.serialize(serializer)
+                } else {
+                    let mut state = serializer.serialize_tuple(2)?;
+                    state.serialize_element(x)?;
+                    state.serialize_element(y)?;
+                    state.end()
+                }
+            }
+        }
+    }
+}
+
+impl<'de> serde::Deserialize<'de> for plot::Insets {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        struct InsetsVisitor;
+
+        impl<'de> serde::de::Visitor<'de> for InsetsVisitor {
+            type Value = plot::Insets;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+                formatter.write_str("a number, a tuple of two numbers, or the string 'auto'")
+            }
+
+            fn visit_f64<E>(self, value: f64) -> Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                let value = value as f32;
+                Ok(plot::Insets::Fixed(value, value))
+            }
+
+            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
+            where
+                A: serde::de::SeqAccess<'de>,
+            {
+                let x = seq
+                    .next_element()?
+                    .ok_or_else(|| serde::de::Error::invalid_length(0, &self))?;
+                let y = seq
+                    .next_element()?
+                    .ok_or_else(|| serde::de::Error::invalid_length(1, &self))?;
+                Ok(plot::Insets::Fixed(x, y))
+            }
+
+            fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                if value == "auto" {
+                    Ok(plot::Insets::Auto)
+                } else {
+                    Err(serde::de::Error::invalid_value(
+                        serde::de::Unexpected::Str(value),
+                        &self,
+                    ))
+                }
+            }
+        }
+
+        deserializer.deserialize_any(InsetsVisitor)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_plot_ser() {
+        let plot = Plot::new(vec![series::Line::new("x".into(), "y".into()).into()]);
+
+        let serialized = serde_json::to_string(&plot).unwrap();
+        let expected = r#"{"series":{"type":"line","x":"x","y":"y"}}"#;
+        assert_eq!(serialized, expected);
+    }
+
+    #[test]
+    fn test_plot_de() {
+        let json = r#"{"series":{"type":"line","x":"x","y":"y"}}"#;
+        let plot: Plot = serde_json::from_str(json).unwrap();
+
+        let expected = Plot::new(vec![series::Line::new("x".into(), "y".into()).into()]);
+        assert_eq!(plot, expected);
+    }
+}
diff --git a/src/des/sd/series.rs b/src/des/sd/series.rs
new file mode 100644
index 00000000..956b96ac
--- /dev/null
+++ b/src/des/sd/series.rs
@@ -0,0 +1,1227 @@
+use std::borrow::Cow;
+
+use serde::Serializer;
+use serde::de::MapAccess;
+use serde::ser::SerializeStruct;
+use serde_value::Value;
+
+use crate::des::sd::deserialize_tagged_map_fields;
+use crate::des::{Series, axis, series};
+use crate::{data, des, style};
+
+// MARK: series::DataCol
+
+impl serde::Serialize for series::DataCol {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        match self {
+            series::DataCol::SrcRef(src_ref) => src_ref.serialize(serializer),
+            series::DataCol::Inline(data::VecColumn::F64(vec)) => vec.serialize(serializer),
+            series::DataCol::Inline(data::VecColumn::I64(vec)) => vec.serialize(serializer),
+            series::DataCol::Inline(data::VecColumn::Str(vec)) => vec.serialize(serializer),
+            #[cfg(feature = "time")]
+            series::DataCol::Inline(data::VecColumn::Time(vec)) => vec.serialize(serializer),
+            #[cfg(feature = "time")]
+            series::DataCol::Inline(data::VecColumn::TimeDelta(vec)) => vec.serialize(serializer),
+        }
+    }
+}
+
+impl<'de> serde::Deserialize<'de> for series::DataCol {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        deserializer.deserialize_any(DataColVisitor)
+    }
+}
+
+struct DataColVisitor;
+
+impl<'de> serde::de::Visitor<'de> for DataColVisitor {
+    type Value = series::DataCol;
+
+    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+        formatter.write_str("a data source reference string or an inline data sequence")
+    }
+
+    fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
+    where
+        E: serde::de::Error,
+    {
+        Ok(series::DataCol::SrcRef(value.to_string()))
+    }
+
+    fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
+    where
+        A: serde::de::SeqAccess<'de>,
+    {
+        // Collect all elements as Value to avoid consuming elements during type detection
+        let mut values: Vec<Value> = Vec::new();
+        while let Some(value) = seq.next_element::<Value>()? {
+            values.push(value);
+        }
+
+        // If empty sequence, assume empty f64 column
+        if values.is_empty() {
+            return Ok(series::DataCol::Inline(data::VecColumn::F64(Vec::new())));
+        }
+
+        // Count leading nulls and find first non-null element to determine type
+        let mut first_non_null_idx = None;
+        for (idx, val) in values.iter().enumerate() {
+            if !matches!(val, Value::Unit) {
+                first_non_null_idx = Some(idx);
+                break;
+            }
+        }
+
+        // All nulls: assume f64 column
+        if first_non_null_idx.is_none() {
+            let vec = vec![f64::NAN; values.len()];
+            return Ok(series::DataCol::Inline(data::VecColumn::F64(vec)));
+        }
+
+        // Try to determine type from first non-null element and deserialize all values
+        // Try f64 first
+        if let Ok(f64_vec) = deserialize_f64_vec(&values) {
+            return Ok(series::DataCol::Inline(data::VecColumn::F64(f64_vec)));
+        }
+
+        #[cfg(feature = "time")]
+        {
+            // Try DateTime
+            if let Ok(time_vec) = deserialize_datetime_vec(&values) {
+                return Ok(series::DataCol::Inline(data::VecColumn::Time(time_vec)));
+            }
+
+            // Try TimeDelta
+            if let Ok(td_vec) = deserialize_timedelta_vec(&values) {
+                return Ok(series::DataCol::Inline(data::VecColumn::TimeDelta(td_vec)));
+            }
+        }
+
+        // Try i64
+        if let Ok(i64_vec) = deserialize_i64_vec(&values) {
+            return Ok(series::DataCol::Inline(data::VecColumn::I64(i64_vec)));
+        }
+
+        // Try String
+        if let Ok(str_vec) = deserialize_string_vec(&values) {
+            return Ok(series::DataCol::Inline(data::VecColumn::Str(str_vec)));
+        }
+
+        Err(serde::de::Error::custom("unsupported data column type"))
+    }
+}
+
+// Helper functions for type-specific deserialization
+fn deserialize_f64_vec(values: &[Value]) -> Result<Vec<f64>, Box<dyn std::error::Error>> {
+    values
+        .iter()
+        .map(|v| match v {
+            Value::Unit => Ok(f64::NAN),
+            Value::F64(f) => Ok(*f),
+            Value::I64(i) => Ok(*i as f64),
+            Value::U64(u) => Ok(*u as f64),
+            Value::I32(i) => Ok(*i as f64),
+            Value::U32(u) => Ok(*u as f64),
+            Value::I16(i) => Ok(*i as f64),
+            Value::U16(u) => Ok(*u as f64),
+            Value::I8(i) => Ok(*i as f64),
+            Value::U8(u) => Ok(*u as f64),
+            _ => Err("Cannot convert value to f64".into()),
+        })
+        .collect()
+}
+
+fn deserialize_i64_vec(values: &[Value]) -> Result<Vec<Option<i64>>, Box<dyn std::error::Error>> {
+    values
+        .iter()
+        .map(|v| match v {
+            Value::Unit => Ok(None),
+            Value::I64(i) => Ok(Some(*i)),
+            Value::U64(u) => Ok(Some(*u as i64)),
+            Value::I32(i) => Ok(Some(*i as i64)),
+            Value::U32(u) => Ok(Some(*u as i64)),
+            Value::I16(i) => Ok(Some(*i as i64)),
+            Value::U16(u) => Ok(Some(*u as i64)),
+            Value::I8(i) => Ok(Some(*i as i64)),
+            Value::U8(u) => Ok(Some(*u as i64)),
+            Value::F64(f) => Ok(Some(*f as i64)),
+            _ => Err("Cannot convert value to i64".into()),
+        })
+        .collect()
+}
+
+fn deserialize_string_vec(
+    values: &[Value],
+) -> Result<Vec<Option<String>>, Box<dyn std::error::Error>> {
+    values
+        .iter()
+        .map(|v| match v {
+            Value::Unit => Ok(None),
+            Value::String(s) => Ok(Some(s.clone())),
+            _ => Err("Cannot convert value to String".into()),
+        })
+        .collect()
+}
+
+#[cfg(feature = "time")]
+fn deserialize_datetime_vec(
+    values: &[Value],
+) -> Result<Vec<Option<crate::time::DateTime>>, Box<dyn std::error::Error>> {
+    const FMT: &str = "%Y-%m-%d %H:%M:%S%.f";
+    values
+        .iter()
+        .map(|v| match v {
+            Value::Unit => Ok(None),
+            Value::String(s) => {
+                // Try to parse the string as a DateTime
+                crate::time::DateTime::fmt_parse(s, FMT)
+                    .map(Some)
+                    .map_err(|e| Box::new(e) as Box<dyn std::error::Error>)
+            }
+            Value::F64(f) => crate::time::DateTime::from_timestamp(*f)
+                .map(Some)
+                .ok_or_else(|| "invalid time".into()),
+            Value::I64(i) => crate::time::DateTime::from_timestamp(*i as f64)
+                .map(Some)
+                .ok_or_else(|| "invalid time".into()),
+            _ => Err("Cannot convert value to DateTime".into()),
+        })
+        .collect()
+}
+
+#[cfg(feature = "time")]
+fn deserialize_timedelta_vec(
+    values: &[Value],
+) -> Result<Vec<Option<crate::time::TimeDelta>>, Box<dyn std::error::Error>> {
+    values
+        .iter()
+        .map(|_v| {
+            // TimeDelta deserialization is not yet implemented
+            Err("TimeDelta deserialization is not implemented".into())
+        })
+        .collect()
+}
+
+// MARK: series::Interpolation
+
+impl serde::Serialize for series::Interpolation {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let s = match self {
+            series::Interpolation::Linear => "linear",
+            series::Interpolation::StepEarly => "step-early",
+            series::Interpolation::StepMiddle => "step-middle",
+            series::Interpolation::StepLate => "step-late",
+            series::Interpolation::Spline => "spline",
+        };
+        serializer.serialize_str(s)
+    }
+}
+
+impl<'de> serde::Deserialize<'de> for series::Interpolation {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let s: Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
+        match &*s {
+            "default" | "linear" => Ok(series::Interpolation::Linear),
+            "step-early" => Ok(series::Interpolation::StepEarly),
+            "step-middle" => Ok(series::Interpolation::StepMiddle),
+            "step-late" => Ok(series::Interpolation::StepLate),
+            "spline" => Ok(series::Interpolation::Spline),
+            _ => Err(serde::de::Error::unknown_variant(
+                &s,
+                &[
+                    "default",
+                    "linear",
+                    "step-early",
+                    "step-middle",
+                    "step-late",
+                    "spline",
+                ],
+            )),
+        }
+    }
+}
+
+// MARK: Series
+
+impl serde::Serialize for Series {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        match self {
+            Series::Line(line) => line.serialize(serializer),
+            Series::Scatter(scatter) => scatter.serialize(serializer),
+            Series::Area(area) => area.serialize(serializer),
+            Series::Histogram(hist) => hist.serialize(serializer),
+            Series::Bars(bars) => bars.serialize(serializer),
+            Series::BarsGroup(bars_group) => bars_group.serialize(serializer),
+        }
+    }
+}
+
+impl<'de> serde::Deserialize<'de> for Series {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        deserializer.deserialize_map(SeriesVisitor)
+    }
+}
+
+struct SeriesVisitor;
+
+impl<'de> serde::de::Visitor<'de> for SeriesVisitor {
+    type Value = Series;
+
+    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+        formatter.write_str("a tagged series map")
+    }
+
+    fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
+    where
+        A: serde::de::MapAccess<'de>,
+    {
+        let mut buffered = Vec::<(String, Value)>::new();
+
+        while let Some(key) = map.next_key::<String>()? {
+            if key == "type" {
+                let tag = map.next_value::<String>()?;
+                return match tag.as_str() {
+                    // If type is first, `buffered` is empty and we deserialize directly from map.
+                    // If not, only the fields before `type` are buffered.
+                    "line" => deserialize_line_series(&mut map, buffered).map(Series::Line),
+                    "scatter" => {
+                        deserialize_scatter_series(&mut map, buffered).map(Series::Scatter)
+                    }
+                    "area" => deserialize_area_series(&mut map, buffered).map(Series::Area),
+                    "hist" => {
+                        deserialize_histogram_series(&mut map, buffered).map(Series::Histogram)
+                    }
+                    "bars" => deserialize_bars_series(&mut map, buffered).map(Series::Bars),
+                    "bars-group" => {
+                        deserialize_bars_group_series(&mut map, buffered).map(Series::BarsGroup)
+                    }
+                    _ => Err(serde::de::Error::unknown_variant(
+                        &tag,
+                        &["line", "scatter", "area", "hist", "bars", "bars-group"],
+                    )),
+                };
+            }
+
+            let value = map.next_value::<Value>()?;
+            buffered.push((key, value));
+        }
+
+        Err(serde::de::Error::missing_field("type"))
+    }
+}
+
+// MARK: series::Line
+
+impl serde::Serialize for series::Line {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let mut state = serializer.serialize_struct("LineSeries", 6)?;
+        state.serialize_field("type", "line")?;
+        state.serialize_field("x", self.x_data())?;
+        state.serialize_field("y", self.y_data())?;
+
+        if let Some(name) = self.name() {
+            state.serialize_field("name", name)?;
+        }
+
+        if self.x_axis() != &axis::Ref::default() {
+            state.serialize_field("xAxis", self.x_axis())?;
+        }
+
+        if self.y_axis() != &axis::Ref::default() {
+            state.serialize_field("yAxis", self.y_axis())?;
+        }
+
+        if self.stroke() != &style::series::Stroke::default() {
+            state.serialize_field("stroke", self.stroke())?;
+        }
+
+        if let Some(marker) = self.marker() {
+            state.serialize_field("marker", marker)?;
+        }
+
+        if self.interpolation() != series::Interpolation::default() {
+            state.serialize_field("interpolation", &self.interpolation())?;
+        }
+
+        state.end()
+    }
+}
+
+fn deserialize_line_series<'de, A>(
+    map: &mut A,
+    buffered: Vec<(String, Value)>,
+) -> Result<series::Line, A::Error>
+where
+    A: MapAccess<'de>,
+{
+    deserialize_tagged_map_fields! {
+        'de, map, buffered,
+        "x" => x_data: Option<series::DataCol>,
+        "y" => y_data: Option<series::DataCol>,
+        "name" => name: Option<String>,
+        "xAxis" => x_axis: Option<axis::Ref>,
+        "yAxis" => y_axis: Option<axis::Ref>,
+        "stroke" => stroke: Option<style::series::Stroke>,
+        "marker" => marker: Option<style::series::Marker>,
+        "interpolation" => interpolation: Option<series::Interpolation> ,
+    }
+
+    let x_data = x_data.ok_or_else(|| serde::de::Error::missing_field("x"))?;
+    let y_data = y_data.ok_or_else(|| serde::de::Error::missing_field("y"))?;
+
+    let mut line = series::Line::new(x_data, y_data);
+    if let Some(name) = name {
+        line = line.with_name(name);
+    }
+    if let Some(x_axis) = x_axis {
+        line = line.with_x_axis(x_axis);
+    }
+    if let Some(y_axis) = y_axis {
+        line = line.with_y_axis(y_axis);
+    }
+    if let Some(marker) = marker {
+        line = line.with_marker(marker);
+    }
+    if let Some(stroke) = stroke {
+        line = line.with_stroke(stroke);
+    }
+    if let Some(interpolation) = interpolation {
+        line = line.with_interpolation(interpolation);
+    }
+
+    Ok(line)
+}
+
+// MARK: series::Scatter
+
+impl serde::Serialize for series::Scatter {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let mut state = serializer.serialize_struct("ScatterSeries", 6)?;
+        state.serialize_field("type", "scatter")?;
+        state.serialize_field("x", self.x_data())?;
+        state.serialize_field("y", self.y_data())?;
+
+        if let Some(name) = self.name() {
+            state.serialize_field("name", name)?;
+        }
+
+        if self.x_axis() != &axis::Ref::default() {
+            state.serialize_field("xAxis", self.x_axis())?;
+        }
+
+        if self.y_axis() != &axis::Ref::default() {
+            state.serialize_field("yAxis", self.y_axis())?;
+        }
+
+        if self.marker() != &style::series::Marker::default() {
+            state.serialize_field("marker", self.marker())?;
+        }
+
+        if let Some(sizes) = self.size_data() {
+            state.serialize_field("sizes", sizes)?;
+        }
+
+        if let Some((colors, cmap)) = self.color_data() {
+            state.serialize_field("colors", colors)?;
+            if cmap.name() != Some("viridis") {
+                state.serialize_field("cmap", cmap)?;
+            }
+        }
+
+        state.end()
+    }
+}
+
+fn deserialize_scatter_series<'de, A>(
+    map: &mut A,
+    buffered: Vec<(String, Value)>,
+) -> Result<series::Scatter, A::Error>
+where
+    A: MapAccess<'de>,
+{
+    deserialize_tagged_map_fields! {
+        'de, map, buffered,
+        "x" => x_data: Option<series::DataCol>,
+        "y" => y_data: Option<series::DataCol>,
+        "name" => name: Option<String>,
+        "xAxis" => x_axis: Option<axis::Ref>,
+        "yAxis" => y_axis: Option<axis::Ref>,
+        "stroke" => stroke: Option<style::series::Stroke>,
+        "marker" => marker: Option<style::series::Marker>,
+        "sizes" => sizes: Option<series::DataCol>,
+        "colors" => colors: Option<series::DataCol>,
+        "cmap" => cmap: Option<des::cmap::LerpColorMap>,
+    }
+
+    let x_data = x_data.ok_or_else(|| serde::de::Error::missing_field("x"))?;
+    let y_data = y_data.ok_or_else(|| serde::de::Error::missing_field("y"))?;
+
+    let mut scatter = series::Scatter::new(x_data, y_data);
+    if let Some(name) = name {
+        scatter = scatter.with_name(name);
+    }
+    if let Some(x_axis) = x_axis {
+        scatter = scatter.with_x_axis(x_axis);
+    }
+    if let Some(y_axis) = y_axis {
+        scatter = scatter.with_y_axis(y_axis);
+    }
+    if let Some(marker) = marker {
+        scatter = scatter.with_marker(marker);
+    }
+    if let Some(sizes) = sizes {
+        scatter = scatter.with_size_data(sizes);
+    }
+    match (colors, cmap) {
+        (Some(colors), cmap) => {
+            let cmap = cmap.unwrap_or_default();
+            scatter = scatter.with_color_data(colors, cmap);
+        }
+        (None, Some(_)) => {
+            return Err(serde::de::Error::custom(
+                "Can't provide cmap without colors",
+            ));
+        }
+        _ => {}
+    }
+
+    Ok(scatter)
+}
+
+// MARK: AreaY2Raw (internal helper for deserializing y2)
+
+/// Internal type for deserializing the y2 field which can be either a baseline number or a DataCol.
+enum AreaY2Raw {
+    Baseline(f64),
+    Col(series::DataCol),
+}
+
+impl<'de> serde::Deserialize<'de> for AreaY2Raw {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        deserializer.deserialize_any(AreaY2RawVisitor)
+    }
+}
+
+struct AreaY2RawVisitor;
+
+impl<'de> serde::de::Visitor<'de> for AreaY2RawVisitor {
+    type Value = AreaY2Raw;
+
+    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+        formatter.write_str("a baseline number or a data column (string or array)")
+    }
+
+    fn visit_f64<E: serde::de::Error>(self, v: f64) -> Result<Self::Value, E> {
+        Ok(AreaY2Raw::Baseline(v))
+    }
+
+    fn visit_i64<E: serde::de::Error>(self, v: i64) -> Result<Self::Value, E> {
+        Ok(AreaY2Raw::Baseline(v as f64))
+    }
+
+    fn visit_u64<E: serde::de::Error>(self, v: u64) -> Result<Self::Value, E> {
+        Ok(AreaY2Raw::Baseline(v as f64))
+    }
+
+    fn visit_str<E: serde::de::Error>(self, v: &str) -> Result<Self::Value, E> {
+        Ok(AreaY2Raw::Col(series::DataCol::SrcRef(v.to_string())))
+    }
+
+    fn visit_seq<A>(self, seq: A) -> Result<Self::Value, A::Error>
+    where
+        A: serde::de::SeqAccess<'de>,
+    {
+        DataColVisitor.visit_seq(seq).map(AreaY2Raw::Col)
+    }
+}
+
+// MARK: series::Area
+
+impl serde::Serialize for series::Area {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let mut state = serializer.serialize_struct("AreaSeries", 8)?;
+        state.serialize_field("type", "area")?;
+        state.serialize_field("x", self.x_data())?;
+        state.serialize_field("y1", self.y1_data())?;
+
+        match self.y2_data() {
+            series::AreaY2::Baseline(v) if *v != 0.0 => {
+                state.serialize_field("y2", v)?;
+            }
+            series::AreaY2::DataCol(col, interp) => {
+                state.serialize_field("y2", col)?;
+                if *interp != series::Interpolation::default() {
+                    state.serialize_field("y2Interp", interp)?;
+                }
+            }
+            _ => {} // default Baseline(0.0) — skip
+        }
+
+        if let Some(name) = self.name() {
+            state.serialize_field("name", name)?;
+        }
+
+        if self.x_axis() != &axis::Ref::default() {
+            state.serialize_field("xAxis", self.x_axis())?;
+        }
+
+        if self.y_axis() != &axis::Ref::default() {
+            state.serialize_field("yAxis", self.y_axis())?;
+        }
+
+        if self.fill() != &style::series::Fill::default() {
+            state.serialize_field("fill", self.fill())?;
+        }
+
+        if let Some(stroke) = self.y1_stroke() {
+            state.serialize_field("y1Stroke", stroke)?;
+        }
+
+        if let Some(stroke) = self.y2_stroke() {
+            state.serialize_field("y2Stroke", stroke)?;
+        }
+
+        if self.interpolation() != series::Interpolation::default() {
+            state.serialize_field("y1Interp", &self.interpolation())?;
+        }
+
+        state.end()
+    }
+}
+
+fn deserialize_area_series<'de, A>(
+    map: &mut A,
+    buffered: Vec<(String, Value)>,
+) -> Result<series::Area, A::Error>
+where
+    A: MapAccess<'de>,
+{
+    deserialize_tagged_map_fields! {
+        'de, map, buffered,
+        "x" => x_data: Option<series::DataCol>,
+        "y1" => y1_data: Option<series::DataCol>,
+        "y2" => y2_raw: Option<AreaY2Raw>,
+        "fill" => fill: Option<style::series::Fill>,
+        "y1Stroke" => y1_stroke: Option<style::series::Stroke>,
+        "y2Stroke" => y2_stroke: Option<style::series::Stroke>,
+        "y1Interp" => y1_interp: Option<series::Interpolation>,
+        "y2Interp" => y2_interp: Option<series::Interpolation>,
+        "name" => name: Option<String>,
+        "xAxis" => x_axis: Option<axis::Ref>,
+        "yAxis" => y_axis: Option<axis::Ref>,
+    }
+
+    let x_data = x_data.ok_or_else(|| serde::de::Error::missing_field("x"))?;
+    let y1_data = y1_data.ok_or_else(|| serde::de::Error::missing_field("y1"))?;
+
+    let y2_data = match (y2_raw, y2_interp) {
+        (None, _) => series::AreaY2::default(),
+        (Some(AreaY2Raw::Baseline(v)), _) => series::AreaY2::Baseline(v),
+        (Some(AreaY2Raw::Col(col)), interp) => {
+            series::AreaY2::DataCol(col, interp.unwrap_or_default())
+        }
+    };
+
+    let mut area = series::Area::new(x_data, y1_data, y2_data);
+    if let Some(name) = name {
+        area = area.with_name(name);
+    }
+    if let Some(x_axis) = x_axis {
+        area = area.with_x_axis(x_axis);
+    }
+    if let Some(y_axis) = y_axis {
+        area = area.with_y_axis(y_axis);
+    }
+    if let Some(fill) = fill {
+        area = area.with_fill(fill);
+    }
+    if let Some(stroke) = y1_stroke {
+        area = area.with_y1_stroke(stroke);
+    }
+    if let Some(stroke) = y2_stroke {
+        area = area.with_y2_stroke(stroke);
+    }
+    if let Some(interp) = y1_interp {
+        area = area.with_interpolation(interp);
+    }
+
+    Ok(area)
+}
+
+// MARK: series::Histogram
+
+impl serde::Serialize for series::Histogram {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let mut state = serializer.serialize_struct("HistogramSeries", 6)?;
+        state.serialize_field("type", "hist")?;
+        state.serialize_field("x", self.x_data())?;
+
+        if let Some(name) = self.name() {
+            state.serialize_field("name", name)?;
+        }
+
+        if self.x_axis() != &axis::Ref::default() {
+            state.serialize_field("xAxis", self.x_axis())?;
+        }
+
+        if self.y_axis() != &axis::Ref::default() {
+            state.serialize_field("yAxis", self.y_axis())?;
+        }
+
+        if self.fill() != &style::series::Fill::default() {
+            state.serialize_field("fill", self.fill())?;
+        }
+
+        if let Some(stroke) = self.stroke() {
+            state.serialize_field("stroke", stroke)?;
+        }
+
+        if self.bins() != 10 {
+            state.serialize_field("bins", &self.bins())?;
+        }
+
+        if self.density() {
+            state.serialize_field("density", &true)?;
+        }
+
+        state.end()
+    }
+}
+
+fn deserialize_histogram_series<'de, A>(
+    map: &mut A,
+    buffered: Vec<(String, Value)>,
+) -> Result<series::Histogram, A::Error>
+where
+    A: MapAccess<'de>,
+{
+    deserialize_tagged_map_fields! {
+        'de, map, buffered,
+        "x" => x_data: Option<series::DataCol>,
+        "fill" => fill: Option<style::series::Fill>,
+        "stroke" => stroke: Option<style::series::Stroke>,
+        "bins" => bins: Option<u32>,
+        "density" => density: Option<bool>,
+        "name" => name: Option<String>,
+        "xAxis" => x_axis: Option<axis::Ref>,
+        "yAxis" => y_axis: Option<axis::Ref>,
+    }
+
+    let x_data = x_data.ok_or_else(|| serde::de::Error::missing_field("x"))?;
+
+    let mut hist = series::Histogram::new(x_data);
+    if let Some(name) = name {
+        hist = hist.with_name(name);
+    }
+    if let Some(x_axis) = x_axis {
+        hist = hist.with_x_axis(x_axis);
+    }
+    if let Some(y_axis) = y_axis {
+        hist = hist.with_y_axis(y_axis);
+    }
+    if let Some(fill) = fill {
+        hist = hist.with_fill(fill);
+    }
+    if let Some(stroke) = stroke {
+        hist = hist.with_stroke(stroke);
+    }
+    if let Some(bins) = bins {
+        hist = hist.with_bins(bins);
+    }
+    if density.unwrap_or(false) {
+        hist = hist.with_density();
+    }
+
+    Ok(hist)
+}
+
+// MARK: series::BarsPosition
+
+impl serde::Serialize for series::BarsPosition {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let default = series::BarsPosition::default();
+        let mut state = serializer.serialize_struct("BarsPosition", 2)?;
+        if self.offset != default.offset {
+            state.serialize_field("offset", &self.offset)?;
+        }
+        if self.width != default.width {
+            state.serialize_field("width", &self.width)?;
+        }
+        state.end()
+    }
+}
+
+impl<'de> serde::Deserialize<'de> for series::BarsPosition {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        deserializer.deserialize_any(BarsPositionVisitor)
+    }
+}
+
+struct BarsPositionVisitor;
+
+impl<'de> serde::de::Visitor<'de> for BarsPositionVisitor {
+    type Value = series::BarsPosition;
+
+    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+        formatter.write_str("a BarsPosition object {offset?, width?} or a [offset, width] tuple")
+    }
+
+    fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
+    where
+        A: serde::de::SeqAccess<'de>,
+    {
+        let offset: f32 = seq
+            .next_element()?
+            .ok_or_else(|| serde::de::Error::invalid_length(0, &"2 elements"))?;
+        let width: f32 = seq
+            .next_element()?
+            .ok_or_else(|| serde::de::Error::invalid_length(1, &"2 elements"))?;
+        Ok(series::BarsPosition { offset, width })
+    }
+
+    fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
+    where
+        A: serde::de::MapAccess<'de>,
+    {
+        let default = series::BarsPosition::default();
+        super::deserialize_map_fields!(
+            'de, map,
+            "offset" => offset: Option<f32>,
+            "width" => width: Option<f32>,
+        );
+        Ok(series::BarsPosition {
+            offset: offset.unwrap_or(default.offset),
+            width: width.unwrap_or(default.width),
+        })
+    }
+}
+
+// MARK: series::Bars
+
+impl serde::Serialize for series::Bars {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let mut state = serializer.serialize_struct("BarsSeries", 6)?;
+        state.serialize_field("type", "bars")?;
+        state.serialize_field("x", self.x_data())?;
+        state.serialize_field("y", self.y_data())?;
+
+        if let Some(name) = self.name() {
+            state.serialize_field("name", name)?;
+        }
+
+        if self.x_axis() != &axis::Ref::default() {
+            state.serialize_field("xAxis", self.x_axis())?;
+        }
+
+        if self.y_axis() != &axis::Ref::default() {
+            state.serialize_field("yAxis", self.y_axis())?;
+        }
+
+        if self.fill() != &style::series::Fill::default() {
+            state.serialize_field("fill", self.fill())?;
+        }
+
+        if let Some(stroke) = self.stroke() {
+            state.serialize_field("stroke", stroke)?;
+        }
+
+        let default_pos = series::BarsPosition::default();
+        if self.position().offset != default_pos.offset
+            || self.position().width != default_pos.width
+        {
+            state.serialize_field("position", self.position())?;
+        }
+
+        state.end()
+    }
+}
+
+fn deserialize_bars_series<'de, A>(
+    map: &mut A,
+    buffered: Vec<(String, Value)>,
+) -> Result<series::Bars, A::Error>
+where
+    A: MapAccess<'de>,
+{
+    deserialize_tagged_map_fields! {
+        'de, map, buffered,
+        "x" => x_data: Option<series::DataCol>,
+        "y" => y_data: Option<series::DataCol>,
+        "fill" => fill: Option<style::series::Fill>,
+        "stroke" => stroke: Option<style::series::Stroke>,
+        "position" => position: Option<series::BarsPosition>,
+        "name" => name: Option<String>,
+        "xAxis" => x_axis: Option<axis::Ref>,
+        "yAxis" => y_axis: Option<axis::Ref>,
+    }
+
+    let x_data = x_data.ok_or_else(|| serde::de::Error::missing_field("x"))?;
+    let y_data = y_data.ok_or_else(|| serde::de::Error::missing_field("y"))?;
+
+    let mut bars = series::Bars::new(x_data, y_data);
+    if let Some(name) = name {
+        bars = bars.with_name(name);
+    }
+    if let Some(x_axis) = x_axis {
+        bars = bars.with_x_axis(x_axis);
+    }
+    if let Some(y_axis) = y_axis {
+        bars = bars.with_y_axis(y_axis);
+    }
+    if let Some(fill) = fill {
+        bars = bars.with_fill(fill);
+    }
+    if let Some(stroke) = stroke {
+        bars = bars.with_stroke(stroke);
+    }
+    if let Some(position) = position {
+        bars = bars.with_position(position);
+    }
+
+    Ok(bars)
+}
+
+// MARK: series::BarsOrientation
+
+impl serde::Serialize for series::BarsOrientation {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        match self {
+            series::BarsOrientation::Vertical => "vertical".serialize(serializer),
+            series::BarsOrientation::Horizontal => "horizontal".serialize(serializer),
+        }
+    }
+}
+
+impl<'de> serde::Deserialize<'de> for series::BarsOrientation {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
+        match s.as_ref() {
+            "vertical" => Ok(series::BarsOrientation::Vertical),
+            "horizontal" => Ok(series::BarsOrientation::Horizontal),
+            _ => Err(serde::de::Error::unknown_variant(
+                &s,
+                &["vertical", "horizontal"],
+            )),
+        }
+    }
+}
+
+// MARK: series::BarsArrangement
+
+impl serde::Serialize for series::BarsArrangement {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        match self {
+            series::BarsArrangement::Aside(arr) => {
+                let default = series::BarsAsideArrangement::default();
+                if arr.offset == default.offset
+                    && arr.width == default.width
+                    && arr.gap == default.gap
+                {
+                    "aside".serialize(serializer)
+                } else {
+                    let mut state = serializer.serialize_struct("BarsAsideArrangement", 4)?;
+                    state.serialize_field("type", "aside")?;
+                    if arr.offset != default.offset {
+                        state.serialize_field("offset", &arr.offset)?;
+                    }
+                    if arr.width != default.width {
+                        state.serialize_field("width", &arr.width)?;
+                    }
+                    if arr.gap != default.gap {
+                        state.serialize_field("gap", &arr.gap)?;
+                    }
+                    state.end()
+                }
+            }
+            series::BarsArrangement::Stack(arr) => {
+                let default = series::BarsStackArrangement::default();
+                if arr.offset == default.offset && arr.width == default.width {
+                    "stack".serialize(serializer)
+                } else {
+                    let mut state = serializer.serialize_struct("BarsStackArrangement", 3)?;
+                    state.serialize_field("type", "stack")?;
+                    if arr.offset != default.offset {
+                        state.serialize_field("offset", &arr.offset)?;
+                    }
+                    if arr.width != default.width {
+                        state.serialize_field("width", &arr.width)?;
+                    }
+                    state.end()
+                }
+            }
+        }
+    }
+}
+
+impl<'de> serde::Deserialize<'de> for series::BarsArrangement {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        deserializer.deserialize_any(BarsArrangementVisitor)
+    }
+}
+
+struct BarsArrangementVisitor;
+
+impl<'de> serde::de::Visitor<'de> for BarsArrangementVisitor {
+    type Value = series::BarsArrangement;
+
+    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+        formatter.write_str(
+            "'aside' | 'stack' | {type: 'aside', offset?, width?, gap?} | {type: 'stack', offset?, width?}",
+        )
+    }
+
+    fn visit_str<E: serde::de::Error>(self, v: &str) -> Result<Self::Value, E> {
+        match v {
+            "aside" => Ok(series::BarsArrangement::Aside(Default::default())),
+            "stack" => Ok(series::BarsArrangement::Stack(Default::default())),
+            _ => Err(serde::de::Error::unknown_variant(v, &["aside", "stack"])),
+        }
+    }
+
+    fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
+    where
+        A: serde::de::MapAccess<'de>,
+    {
+        let mut typ: Option<String> = None;
+        let mut offset: Option<f32> = None;
+        let mut width: Option<f32> = None;
+        let mut gap: Option<f32> = None;
+
+        while let Some(key) = map.next_key::<std::borrow::Cow<'de, str>>()? {
+            match key.as_ref() {
+                "type" => typ = Some(map.next_value()?),
+                "offset" => offset = Some(map.next_value()?),
+                "width" => width = Some(map.next_value()?),
+                "gap" => gap = Some(map.next_value()?),
+                _ => {
+                    return Err(serde::de::Error::unknown_field(
+                        key.as_ref(),
+                        &["type", "offset", "width", "gap"],
+                    ));
+                }
+            }
+        }
+
+        match typ.as_deref() {
+            Some("aside") | None => {
+                let default = series::BarsAsideArrangement::default();
+                Ok(series::BarsArrangement::Aside(
+                    series::BarsAsideArrangement {
+                        offset: offset.unwrap_or(default.offset),
+                        width: width.unwrap_or(default.width),
+                        gap: gap.unwrap_or(default.gap),
+                    },
+                ))
+            }
+            Some("stack") => {
+                let default = series::BarsStackArrangement::default();
+                Ok(series::BarsArrangement::Stack(
+                    series::BarsStackArrangement {
+                        offset: offset.unwrap_or(default.offset),
+                        width: width.unwrap_or(default.width),
+                    },
+                ))
+            }
+            Some(other) => Err(serde::de::Error::unknown_variant(
+                other,
+                &["aside", "stack"],
+            )),
+        }
+    }
+}
+
+// MARK: series::BarSeries
+
+impl serde::Serialize for series::BarSeries {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let mut state = serializer.serialize_struct("BarSeries", 4)?;
+        state.serialize_field("data", self.data())?;
+        if let Some(name) = self.name() {
+            state.serialize_field("name", name)?;
+        }
+        if self.fill() != &style::series::Fill::default() {
+            state.serialize_field("fill", self.fill())?;
+        }
+        if let Some(stroke) = self.outline() {
+            state.serialize_field("stroke", stroke)?;
+        }
+        state.end()
+    }
+}
+
+impl<'de> serde::Deserialize<'de> for series::BarSeries {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        deserializer.deserialize_map(BarSeriesVisitor)
+    }
+}
+
+struct BarSeriesVisitor;
+
+impl<'de> serde::de::Visitor<'de> for BarSeriesVisitor {
+    type Value = series::BarSeries;
+
+    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+        formatter.write_str("a BarSeries object with a 'data' field")
+    }
+
+    fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
+    where
+        A: serde::de::MapAccess<'de>,
+    {
+        super::deserialize_map_fields!(
+            'de, map,
+            "data" => data: Option<series::DataCol>,
+            "name" => name: Option<String>,
+            "fill" => fill: Option<style::series::Fill>,
+            "stroke" => stroke: Option<style::series::Stroke>,
+        );
+
+        let data = data.ok_or_else(|| serde::de::Error::missing_field("data"))?;
+        let mut bar_series = series::BarSeries::new(data);
+        if let Some(name) = name {
+            bar_series = bar_series.with_name(name);
+        }
+        if let Some(fill) = fill {
+            bar_series = bar_series.with_fill(fill);
+        }
+        if let Some(stroke) = stroke {
+            bar_series = bar_series.with_outline(stroke);
+        }
+        Ok(bar_series)
+    }
+}
+
+// MARK: series::BarsGroup
+
+impl serde::Serialize for series::BarsGroup {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let mut state = serializer.serialize_struct("BarsGroup", 6)?;
+        state.serialize_field("type", "bars-group")?;
+        state.serialize_field("categories", self.categories())?;
+        state.serialize_field("series", self.series())?;
+
+        if self.x_axis() != &axis::Ref::default() {
+            state.serialize_field("xAxis", self.x_axis())?;
+        }
+
+        if self.y_axis() != &axis::Ref::default() {
+            state.serialize_field("yAxis", self.y_axis())?;
+        }
+
+        if !matches!(self.orientation(), series::BarsOrientation::Vertical) {
+            state.serialize_field("orientation", self.orientation())?;
+        }
+
+        if !matches!(
+            self.arrangement(),
+            series::BarsArrangement::Aside(arr) if {
+                let d = series::BarsAsideArrangement::default();
+                arr.offset == d.offset && arr.width == d.width && arr.gap == d.gap
+            }
+        ) {
+            state.serialize_field("arrangement", self.arrangement())?;
+        }
+
+        state.end()
+    }
+}
+
+fn deserialize_bars_group_series<'de, A>(
+    map: &mut A,
+    buffered: Vec<(String, Value)>,
+) -> Result<series::BarsGroup, A::Error>
+where
+    A: MapAccess<'de>,
+{
+    deserialize_tagged_map_fields! {
+        'de, map, buffered,
+        "categories" => categories: Option<series::DataCol>,
+        "series" => bar_series: Option<Vec<series::BarSeries>>,
+        "orientation" => orientation: Option<series::BarsOrientation>,
+        "arrangement" => arrangement: Option<series::BarsArrangement>,
+        "xAxis" => x_axis: Option<axis::Ref>,
+        "yAxis" => y_axis: Option<axis::Ref>,
+    }
+
+    let categories = categories.ok_or_else(|| serde::de::Error::missing_field("categories"))?;
+    let bar_series = bar_series.ok_or_else(|| serde::de::Error::missing_field("series"))?;
+
+    let mut group = series::BarsGroup::new(categories, bar_series);
+    if let Some(orientation) = orientation {
+        group = group.with_orientation(orientation);
+    }
+    if let Some(arrangement) = arrangement {
+        group = group.with_arrangement(arrangement);
+    }
+    if let Some(x_axis) = x_axis {
+        group = group.with_x_axis(x_axis);
+    }
+    if let Some(y_axis) = y_axis {
+        group = group.with_y_axis(y_axis);
+    }
+
+    Ok(group)
+}
diff --git a/src/des/sd/style.rs b/src/des/sd/style.rs
new file mode 100644
index 00000000..aaceb1b3
--- /dev/null
+++ b/src/des/sd/style.rs
@@ -0,0 +1,1014 @@
+use std::borrow::Cow;
+use std::marker::PhantomData;
+use std::str::FromStr;
+
+use serde::ser::SerializeStruct;
+use serde::{Deserialize, Serialize};
+
+use crate::Color;
+use crate::style::{self, series, theme};
+
+trait DefaultColor: Color {
+    fn default_color() -> Option<Self>;
+}
+
+trait DefaultStroke: Color {
+    fn default_stroke() -> Option<style::Stroke<Self>>;
+}
+
+impl DefaultColor for theme::Color {
+    fn default_color() -> Option<Self> {
+        None
+    }
+}
+
+impl DefaultStroke for theme::Color {
+    fn default_stroke() -> Option<style::Stroke<Self>> {
+        None
+    }
+}
+
+impl DefaultColor for series::Color {
+    fn default_color() -> Option<Self> {
+        Some(series::Color::Auto)
+    }
+}
+
+impl DefaultStroke for series::Color {
+    fn default_stroke() -> Option<style::Stroke<Self>> {
+        Some(style::Stroke::default())
+    }
+}
+
+// MARK: style::theme::Color
+
+impl Serialize for style::theme::Color {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use style::theme;
+        match self {
+            theme::Color::Theme(theme::Col::Background) => "background".serialize(serializer),
+            theme::Color::Theme(theme::Col::Foreground) => "foreground".serialize(serializer),
+            theme::Color::Theme(theme::Col::LegendFill) => "legend-fill".serialize(serializer),
+            theme::Color::Theme(theme::Col::LegendBorder) => "legend-border".serialize(serializer),
+            theme::Color::Theme(theme::Col::Grid) => "grid".serialize(serializer),
+            theme::Color::Fixed(rgba) => rgba.serialize(serializer),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for style::theme::Color {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let s: Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
+
+        match s.as_ref() {
+            "background" => Ok(style::theme::Color::Theme(theme::Col::Background)),
+            "foreground" => Ok(style::theme::Color::Theme(theme::Col::Foreground)),
+            "legend-fill" => Ok(style::theme::Color::Theme(theme::Col::LegendFill)),
+            "legend-border" => Ok(style::theme::Color::Theme(theme::Col::LegendBorder)),
+            "grid" => Ok(style::theme::Color::Theme(theme::Col::Grid)),
+            _ => s
+                .parse()
+                .map(style::theme::Color::Fixed)
+                .map_err(serde::de::Error::custom),
+        }
+    }
+}
+
+// MARK: style::series::Color
+
+impl Serialize for style::series::Color {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use style::series;
+        match self {
+            series::Color::Auto => "auto".serialize(serializer),
+            series::Color::Index(idx) => idx.0.serialize(serializer),
+            series::Color::Fixed(rgba) => rgba.serialize(serializer),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for style::series::Color {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        deserializer.deserialize_any(SeriesColorVisitor)
+    }
+}
+struct SeriesColorVisitor;
+
+impl<'de> serde::de::Visitor<'de> for SeriesColorVisitor {
+    type Value = style::series::Color;
+
+    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+        formatter.write_str("a series color string or an index or a color")
+    }
+
+    fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
+    where
+        E: serde::de::Error,
+    {
+        if v < 0 {
+            return Err(E::custom("expected a non-negative integer"));
+        }
+        self.visit_u64(v as u64)
+    }
+
+    fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E>
+    where
+        E: serde::de::Error,
+    {
+        Ok(style::series::Color::Index(style::series::IndexColor(
+            value as usize,
+        )))
+    }
+
+    fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
+    where
+        E: serde::de::Error,
+    {
+        match value {
+            "auto" => Ok(style::series::Color::Auto),
+            value => {
+                let rgba = value.parse().map_err(|_| {
+                    E::custom(
+                        "invalid series color string: expected 'auto', an index, or a color string",
+                    )
+                })?;
+                Ok(style::series::Color::Fixed(rgba))
+            }
+        }
+    }
+}
+
+/////////////////////////
+// MARK: style::Fill
+/////////////////////////
+
+impl<C> Serialize for style::Fill<C>
+where
+    C: Serialize + Color,
+{
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let style::Fill::Solid { color, opacity } = self;
+
+        if let Some(opacity) = opacity {
+            if *opacity == 1.0 {
+                color.serialize(serializer)
+            } else {
+                let mut state = serializer.serialize_struct("Fill", 2)?;
+                state.serialize_field("color", color)?;
+                state.serialize_field("opacity", opacity)?;
+                state.end()
+            }
+        } else {
+            color.serialize(serializer)
+        }
+    }
+}
+
+impl<'de, C> Deserialize<'de> for style::Fill<C>
+where
+    C: Deserialize<'de> + Color + FromStr + DefaultColor,
+    <C as FromStr>::Err: std::fmt::Display,
+{
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        deserializer.deserialize_any(FillVisitor {
+            _phantom: PhantomData,
+        })
+    }
+}
+
+struct FillVisitor<C> {
+    _phantom: PhantomData<C>,
+}
+
+impl<'de, C> serde::de::Visitor<'de> for FillVisitor<C>
+where
+    C: Deserialize<'de> + Color + FromStr + DefaultColor,
+    <C as FromStr>::Err: std::fmt::Display,
+{
+    type Value = style::Fill<C>;
+
+    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+        formatter.write_str("a fill color or a map with color and opacity")
+    }
+
+    fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
+    where
+        E: serde::de::Error,
+    {
+        let color = value.parse::<C>().map_err(E::custom)?;
+        Ok(style::Fill::Solid {
+            color,
+            opacity: None,
+        })
+    }
+
+    fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
+    where
+        A: serde::de::MapAccess<'de>,
+    {
+        super::deserialize_map_fields!(
+            'de, map,
+            "color" => color: Option<C>,
+            "opacity" => opacity: Option<f32>,
+        );
+
+        let color = match (color, C::default_color()) {
+            (Some(color), _) => color,
+            (None, Some(color)) => color,
+            (None, None) => return Err(serde::de::Error::missing_field("color")),
+        };
+
+        Ok(style::Fill::Solid { color, opacity })
+    }
+}
+
+////////////////////////////////
+// MARK: style::LinePattern
+////////////////////////////////
+
+impl Serialize for style::LinePattern {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use style::LinePattern;
+        match self {
+            LinePattern::Solid => "solid".serialize(serializer),
+            LinePattern::Dashed => "dashed".serialize(serializer),
+            LinePattern::Dot => "dotted".serialize(serializer),
+            LinePattern::DashDot => "dash-dot".serialize(serializer),
+            LinePattern::Dash(dash) => dash.0.serialize(serializer),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for style::LinePattern {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        deserializer.deserialize_any(LinePatternVisitor)
+    }
+}
+
+struct LinePatternVisitor;
+
+fn str_to_line_pattern(value: &str) -> Option<style::LinePattern> {
+    match value {
+        "solid" => Some(style::LinePattern::Solid),
+        "dashed" => Some(style::LinePattern::Dashed),
+        "dotted" => Some(style::LinePattern::Dot),
+        "dash-dot" => Some(style::LinePattern::DashDot),
+        _ => None,
+    }
+}
+
+impl<'de> serde::de::Visitor<'de> for LinePatternVisitor {
+    type Value = style::LinePattern;
+
+    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+        formatter.write_str("a line pattern string or a dash array")
+    }
+
+    fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
+    where
+        E: serde::de::Error,
+    {
+        str_to_line_pattern(value)
+            .ok_or_else(|| E::unknown_variant(value, &["solid", "dashed", "dotted", "dash-dot"]))
+    }
+
+    fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
+    where
+        A: serde::de::SeqAccess<'de>,
+    {
+        let mut dash: Vec<f32> = if let Some(sz) = seq.size_hint() {
+            Vec::with_capacity(sz)
+        } else {
+            Vec::new()
+        };
+
+        while let Some(value) = seq.next_element()? {
+            dash.push(value);
+        }
+        Ok(style::LinePattern::Dash(style::Dash(dash)))
+    }
+}
+
+///////////////////////////
+// MARK: style::Stroke
+///////////////////////////
+
+impl<C> Serialize for style::Stroke<C>
+where
+    C: Serialize + Color + DefaultStroke + style::DefaultStrokeWidth + PartialEq,
+{
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        serialize_stroke(self, C::default_stroke(), "Stroke", serializer)
+    }
+}
+
+impl<'de, C> Deserialize<'de> for style::Stroke<C>
+where
+    C: Deserialize<'de> + Color + DefaultStroke + style::DefaultStrokeWidth + FromStr,
+    <C as FromStr>::Err: std::fmt::Display,
+{
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        deserializer.deserialize_any(StrokeVisitor::new("Stroke", C::default_stroke()))
+    }
+}
+
+pub fn serialize_stroke<C, S>(
+    stroke: &style::Stroke<C>,
+    default_stroke: Option<style::Stroke<C>>,
+    name: &'static str,
+    serializer: S,
+) -> Result<S::Ok, S::Error>
+where
+    C: Serialize + Color + style::DefaultStrokeWidth + PartialEq,
+    S: serde::Serializer,
+{
+    let default_width = C::default_stroke_width();
+
+    let (has_default_color, has_default_width, has_default_pattern, has_default_opacity) =
+        if let Some(default) = default_stroke {
+            (
+                default.color == stroke.color,
+                default.width == stroke.width,
+                default.pattern == stroke.pattern,
+                default.opacity == stroke.opacity,
+            )
+        } else {
+            (
+                false,
+                stroke.width == default_width,
+                stroke.pattern == Default::default(),
+                stroke.opacity.unwrap_or(1.0) == 1.0,
+            )
+        };
+
+    match (
+        has_default_color,
+        has_default_width,
+        has_default_pattern,
+        has_default_opacity,
+    ) {
+        (true, true, true, true) => "auto".serialize(serializer),
+        (false, true, true, true) => stroke.color.serialize(serializer),
+        (true, false, true, true) => stroke.width.serialize(serializer),
+        (true, true, false, true) => stroke.pattern.serialize(serializer),
+        _ => {
+            let fields = (!has_default_color as usize)
+                + (!has_default_width as usize)
+                + (!has_default_pattern as usize)
+                + (!has_default_opacity as usize);
+            let mut state = serializer.serialize_struct(name, fields)?;
+            if !has_default_color {
+                state.serialize_field("color", &stroke.color)?;
+            }
+            if !has_default_width {
+                state.serialize_field("width", &stroke.width)?;
+            }
+            if !has_default_pattern {
+                state.serialize_field("pattern", &stroke.pattern)?;
+            }
+            if !has_default_opacity {
+                state.serialize_field("opacity", &stroke.opacity.unwrap_or(1.0))?;
+            }
+            state.end()
+        }
+    }
+}
+
+pub struct StrokeVisitor<C>
+where
+    C: Color,
+{
+    name: &'static str,
+    default_stroke: Option<style::Stroke<C>>,
+}
+
+impl<C> StrokeVisitor<C>
+where
+    C: Color,
+{
+    pub fn new(name: &'static str, default_stroke: Option<style::Stroke<C>>) -> Self {
+        Self {
+            name,
+            default_stroke,
+        }
+    }
+
+    fn accepts_compact_pattern(&self) -> bool {
+        self.default_stroke.is_some()
+    }
+
+    fn accepted_string_forms(&self) -> &'static str {
+        if self.accepts_compact_pattern() {
+            "'auto', a line pattern, or a color string"
+        } else {
+            "a color string"
+        }
+    }
+
+    fn expecting_description(&self) -> &'static str {
+        if self.accepts_compact_pattern() {
+            "a stroke object, 'auto', a stroke width, a line pattern, a dash array, or a color string"
+        } else {
+            "a stroke object or a color string"
+        }
+    }
+
+    fn invalid_string_message(&self) -> String {
+        format!(
+            "Invalid string value for {}: expected {}",
+            self.name,
+            self.accepted_string_forms()
+        )
+    }
+
+    fn no_default_numeric_message(&self) -> String {
+        format!(
+            "Numeric value is not valid for {} because there is no default stroke defined",
+            self.name
+        )
+    }
+
+    fn no_default_dash_array_message(&self) -> String {
+        format!(
+            "Dash array is not valid for {} because there is no default stroke defined",
+            self.name
+        )
+    }
+}
+
+impl<'de, C> serde::de::Visitor<'de> for StrokeVisitor<C>
+where
+    C: Deserialize<'de> + Color + DefaultStroke + style::DefaultStrokeWidth + FromStr,
+    <C as FromStr>::Err: std::fmt::Display,
+{
+    type Value = style::Stroke<C>;
+
+    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+        formatter.write_str(self.expecting_description())
+    }
+
+    fn visit_i64<E>(self, value: i64) -> Result<Self::Value, E>
+    where
+        E: serde::de::Error,
+    {
+        self.visit_f64(value as f64)
+    }
+
+    fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E>
+    where
+        E: serde::de::Error,
+    {
+        self.visit_f64(value as f64)
+    }
+
+    fn visit_f64<E>(self, value: f64) -> Result<Self::Value, E>
+    where
+        E: serde::de::Error,
+    {
+        let Some(default) = self.default_stroke else {
+            return Err(serde::de::Error::custom(self.no_default_numeric_message()));
+        };
+
+        if value <= 0.0 {
+            return Err(serde::de::Error::custom(format!(
+                "Invalid stroke width for {}: width cannot be null or negative",
+                self.name
+            )));
+        }
+
+        let width = value as f32;
+        Ok(style::Stroke {
+            color: default.color,
+            width,
+            pattern: default.pattern,
+            opacity: default.opacity,
+        })
+    }
+
+    fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
+    where
+        E: serde::de::Error,
+    {
+        let invalid_string_message = self.invalid_string_message();
+
+        if value == "auto" {
+            if let Some(default) = self.default_stroke {
+                Ok(default)
+            } else {
+                Err(serde::de::Error::custom(format!(
+                    "'auto' is not a valid value for {} because there is no default stroke defined",
+                    self.name
+                )))
+            }
+        } else if let Some(default) = self.default_stroke {
+            if let Some(pattern) = str_to_line_pattern(value) {
+                return Ok(Self::Value::from(style::Stroke {
+                    color: default.color,
+                    width: default.width,
+                    pattern,
+                    opacity: default.opacity,
+                }));
+            }
+
+            let color = value
+                .parse()
+                .map_err(|_| serde::de::Error::custom(invalid_string_message))?;
+
+            Ok(Self::Value::from(style::Stroke {
+                color,
+                width: default.width,
+                pattern: default.pattern,
+                opacity: default.opacity,
+            }))
+        } else {
+            let color = value
+                .parse()
+                .map_err(|_| serde::de::Error::custom(invalid_string_message))?;
+
+            Ok(Self::Value::from(style::Stroke {
+                color,
+                width: C::default_stroke_width(),
+                pattern: Default::default(),
+                opacity: None,
+            }))
+        }
+    }
+
+    fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
+    where
+        A: serde::de::SeqAccess<'de>,
+    {
+        let no_default_dash_array_message = self.no_default_dash_array_message();
+
+        let Some(default) = self.default_stroke else {
+            return Err(serde::de::Error::custom(no_default_dash_array_message));
+        };
+
+        let mut dash: Vec<f32> = if let Some(sz) = seq.size_hint() {
+            Vec::with_capacity(sz)
+        } else {
+            Vec::new()
+        };
+
+        while let Some(value) = seq.next_element()? {
+            dash.push(value);
+        }
+
+        Ok(Self::Value::from(style::Stroke {
+            color: default.color,
+            width: default.width,
+            pattern: style::LinePattern::Dash(style::Dash(dash)),
+            opacity: default.opacity,
+        }))
+    }
+
+    fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
+    where
+        A: serde::de::MapAccess<'de>,
+    {
+        super::deserialize_map_fields!(
+            'de, map,
+            "color" => color: Option<C>,
+            "width" => width: Option<f32>,
+            "pattern" => pattern: Option<style::LinePattern>,
+            "opacity" => opacity: Option<f32>,
+        );
+        if let Some(default) = self.default_stroke {
+            Ok(style::Stroke {
+                color: color.unwrap_or(default.color),
+                width: width.unwrap_or(default.width),
+                pattern: pattern.unwrap_or(default.pattern),
+                opacity: opacity.or(default.opacity),
+            })
+        } else {
+            Ok(style::Stroke {
+                color: color.ok_or_else(|| serde::de::Error::missing_field("color"))?,
+                width: width.unwrap_or_else(|| C::default_stroke_width()),
+                pattern: pattern.unwrap_or_default(),
+                opacity,
+            })
+        }
+    }
+}
+
+///////////////////////////
+// MARK: style::Marker
+///////////////////////////
+
+impl<C> Serialize for style::Marker<C>
+where
+    C: Serialize + Color + DefaultColor + DefaultStroke + style::DefaultStrokeWidth + PartialEq,
+{
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let style::Marker {
+            size,
+            shape,
+            fill,
+            stroke,
+        } = self;
+
+        let default_color = C::default_color();
+        let default_stroke = default_color.as_ref().map(|color| style::Stroke {
+            color: color.clone(),
+            width: C::default_stroke_width(),
+            pattern: style::LinePattern::default(),
+            opacity: None,
+        });
+
+        let has_default_size = size == &style::MarkerSize::default();
+        let has_default_shape = shape == &style::MarkerShape::default();
+        let default_fill = default_color.as_ref().map(|color| style::Fill::Solid {
+            color: color.clone(),
+            opacity: None,
+        });
+        let has_default_stroke =
+            default_stroke.is_some() && stroke.as_ref() == default_stroke.as_ref();
+        let has_default_fill = default_fill.is_some() && fill.as_ref() == default_fill.as_ref();
+
+        // if all defaults, serialize as the shape only
+        // if default shape and non-default color, serialize as the color only
+        // otherwise, serialize as a struct with all non-default fields
+        if has_default_size && has_default_fill && has_default_stroke {
+            shape.serialize(serializer)
+        } else if has_default_shape && has_default_fill && has_default_stroke {
+            size.serialize(serializer)
+        } else {
+            let mut state = serializer.serialize_struct("Marker", 3)?;
+            if !has_default_shape {
+                state.serialize_field("shape", shape)?;
+            }
+            if !has_default_size {
+                state.serialize_field("size", size)?;
+            }
+            if !has_default_fill {
+                state.serialize_field("fill", fill)?;
+            }
+            if !has_default_stroke {
+                state.serialize_field("stroke", stroke)?;
+            }
+            state.end()
+        }
+    }
+}
+
+impl<'de, C> Deserialize<'de> for style::Marker<C>
+where
+    C: Deserialize<'de>
+        + Color
+        + DefaultColor
+        + DefaultStroke
+        + style::DefaultStrokeWidth
+        + FromStr,
+    <C as FromStr>::Err: std::fmt::Display,
+{
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        deserializer.deserialize_any(MarkerVisitor {
+            _phantom: PhantomData,
+        })
+    }
+}
+
+struct MarkerVisitor<C> {
+    _phantom: PhantomData<C>,
+}
+
+impl<'de, C> serde::de::Visitor<'de> for MarkerVisitor<C>
+where
+    C: Deserialize<'de>
+        + Color
+        + DefaultColor
+        + DefaultStroke
+        + style::DefaultStrokeWidth
+        + FromStr,
+    <C as FromStr>::Err: std::fmt::Display,
+{
+    type Value = style::Marker<C>;
+
+    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+        formatter.write_str("a marker shape or a marker object")
+    }
+
+    fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
+    where
+        E: serde::de::Error,
+    {
+        if let Some(shape) = str_to_shape(value) {
+            let default_color = C::default_color().ok_or_else(|| {
+                E::custom(format!(
+                    "cannot use shape-only marker without a default color: {}",
+                    value
+                ))
+            })?;
+            let mut marker = style::Marker::new_with_color(default_color);
+            marker.shape = shape;
+            Ok(marker)
+        } else if let Ok(color) = value.parse::<C>() {
+            Ok(style::Marker::new_with_color(color))
+        } else {
+            return Err(E::custom(format!("invalid marker value: {}", value)));
+        }
+    }
+
+    fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
+    where
+        A: serde::de::MapAccess<'de>,
+    {
+        let mut shape: Option<style::MarkerShape> = None;
+        let mut size: Option<style::MarkerSize> = None;
+        let mut fill: Option<style::Fill<C>> = None;
+        let mut stroke: Option<style::Stroke<C>> = None;
+        let mut color: Option<C> = None;
+        let mut fill_opacity: Option<f32> = None;
+
+        while let Some(key) = map.next_key::<Cow<'de, str>>()? {
+            match key.as_ref() {
+                "shape" => shape = Some(map.next_value()?),
+                "size" => size = Some(map.next_value()?),
+                "fill" => fill = Some(map.next_value()?),
+                "stroke" => stroke = Some(map.next_value()?),
+                "color" => color = Some(map.next_value()?),
+                "fill-opacity" => fill_opacity = Some(map.next_value()?),
+                _ => {
+                    return Err(serde::de::Error::unknown_field(
+                        key.as_ref(),
+                        &["shape", "size", "fill", "stroke", "color", "fill-opacity"],
+                    ));
+                }
+            }
+        }
+
+        let mut marker = style::Marker {
+            shape: shape.unwrap_or_default(),
+            size: size.unwrap_or_default(),
+            fill,
+            stroke,
+        };
+        if let Some(color) = color {
+            marker = marker.with_color(color);
+        }
+        if let Some(opacity) = fill_opacity {
+            marker = marker.with_fill_opacity(opacity);
+        }
+        Ok(marker)
+    }
+}
+
+///////////////////////////
+// MARK: style::MarkerShape
+///////////////////////////
+
+const SHAPE_STRS: &[&str] = &[
+    "circle",
+    "square",
+    "diamond",
+    "cross",
+    "plus",
+    "triangle-up",
+    "triangle-down",
+    "triangle-left",
+    "triangle-right",
+];
+
+fn shape_to_str(shape: &style::MarkerShape) -> &'static str {
+    match shape {
+        style::MarkerShape::Circle => "circle",
+        style::MarkerShape::Square => "square",
+        style::MarkerShape::Diamond => "diamond",
+        style::MarkerShape::Cross => "cross",
+        style::MarkerShape::Plus => "plus",
+        style::MarkerShape::TriangleUp => "triangle-up",
+        style::MarkerShape::TriangleDown => "triangle-down",
+        style::MarkerShape::TriangleLeft => "triangle-left",
+        style::MarkerShape::TriangleRight => "triangle-right",
+    }
+}
+
+fn str_to_shape(s: &str) -> Option<style::MarkerShape> {
+    match s {
+        "circle" => Some(style::MarkerShape::Circle),
+        "square" => Some(style::MarkerShape::Square),
+        "diamond" => Some(style::MarkerShape::Diamond),
+        "cross" => Some(style::MarkerShape::Cross),
+        "plus" => Some(style::MarkerShape::Plus),
+        "triangle-up" => Some(style::MarkerShape::TriangleUp),
+        "triangle-down" => Some(style::MarkerShape::TriangleDown),
+        "triangle-left" => Some(style::MarkerShape::TriangleLeft),
+        "triangle-right" => Some(style::MarkerShape::TriangleRight),
+        _ => None,
+    }
+}
+
+impl serde::Serialize for style::MarkerShape {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        shape_to_str(self).serialize(serializer)
+    }
+}
+
+impl<'de> Deserialize<'de> for style::MarkerShape {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let s: Cow<'de, str> = Deserialize::deserialize(deserializer)?;
+
+        match str_to_shape(s.as_ref()) {
+            Some(shape) => Ok(shape),
+            None => Err(serde::de::Error::unknown_variant(s.as_ref(), SHAPE_STRS)),
+        }
+    }
+}
+
+///////////////////////////
+// MARK: style::MarkerSize
+///////////////////////////
+
+impl serde::Serialize for style::MarkerSize {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        self.0.serialize(serializer)
+    }
+}
+
+impl<'de> Deserialize<'de> for style::MarkerSize {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let size = f32::deserialize(deserializer)?;
+        Ok(style::MarkerSize(size))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn deserialize_series_stroke_auto_uses_default() {
+        let stroke: style::series::Stroke = serde_json::from_str("\"auto\"").unwrap();
+
+        assert_eq!(stroke, style::series::Stroke::default());
+    }
+
+    #[test]
+    fn deserialize_series_stroke_number_uses_default_color() {
+        let stroke: style::series::Stroke = serde_json::from_str("2.5").unwrap();
+
+        assert_eq!(stroke, style::series::Stroke::default().with_width(2.5),);
+    }
+
+    #[test]
+    fn deserialize_theme_stroke_auto_still_fails_without_default() {
+        let err = serde_json::from_str::<style::theme::Stroke>("\"auto\"").unwrap_err();
+
+        assert!(
+            err.to_string()
+                .contains("there is no default stroke defined")
+        );
+    }
+
+    #[test]
+    fn deserialize_theme_stroke_invalid_string_has_precise_message() {
+        let err = serde_json::from_str::<style::theme::Stroke>("\"dashed\"").unwrap_err();
+
+        assert_eq!(
+            err.to_string(),
+            "Invalid string value for Stroke: expected a color string at line 1 column 8",
+        );
+    }
+
+    #[test]
+    fn deserialize_series_stroke_invalid_string_has_precise_message() {
+        let err = serde_json::from_str::<style::series::Stroke>("\"nope\"").unwrap_err();
+
+        assert_eq!(
+            err.to_string(),
+            "Invalid string value for Stroke: expected 'auto', a line pattern, or a color string at line 1 column 6",
+        );
+    }
+
+    #[test]
+    fn deserialize_theme_stroke_number_without_default_has_precise_message() {
+        let err = serde_json::from_str::<style::theme::Stroke>("2.5").unwrap_err();
+
+        assert_eq!(
+            err.to_string(),
+            "Numeric value is not valid for Stroke because there is no default stroke defined at line 1 column 3",
+        );
+    }
+
+    #[test]
+    fn deserialize_theme_stroke_dash_array_without_default_has_precise_message() {
+        let err = serde_json::from_str::<style::theme::Stroke>("[2.0,3.0]").unwrap_err();
+
+        assert_eq!(
+            err.to_string(),
+            "Dash array is not valid for Stroke because there is no default stroke defined at line 1 column 1",
+        );
+    }
+
+    #[test]
+    fn serialize_series_stroke_default_uses_auto() {
+        let json = serde_json::to_string(&style::series::Stroke::default()).unwrap();
+
+        assert_eq!(json, "\"auto\"");
+    }
+
+    #[test]
+    fn serialize_series_stroke_width_only_uses_number() {
+        let json =
+            serde_json::to_string(&style::series::Stroke::default().with_width(2.5)).unwrap();
+
+        assert_eq!(json, "2.5");
+    }
+
+    #[test]
+    fn serialize_series_stroke_roundtrip_width_only() {
+        let stroke = style::series::Stroke::default().with_width(2.5);
+        let json = serde_json::to_string(&stroke).unwrap();
+        let deserialized: style::series::Stroke = serde_json::from_str(&json).unwrap();
+
+        assert_eq!(json, "2.5");
+        assert_eq!(deserialized, stroke);
+    }
+
+    #[test]
+    fn serialize_theme_stroke_without_default_stays_color_string() {
+        let stroke: style::theme::Stroke = theme::Col::Foreground.into();
+        let json = serde_json::to_string(&stroke).unwrap();
+
+        assert_eq!(json, "\"foreground\"");
+    }
+
+    #[test]
+    fn deserialize_series_stroke_named_pattern_uses_default_color() {
+        let stroke: style::series::Stroke = serde_json::from_str("\"dashed\"").unwrap();
+
+        assert_eq!(
+            stroke,
+            style::series::Stroke::default().with_pattern(style::LinePattern::Dashed),
+        );
+    }
+
+    #[test]
+    fn deserialize_series_stroke_dash_array_uses_default_color() {
+        let stroke: style::series::Stroke = serde_json::from_str("[2.0,3.0]").unwrap();
+
+        assert_eq!(
+            stroke,
+            style::series::Stroke::default()
+                .with_pattern(style::LinePattern::Dash(style::Dash(vec![2.0, 3.0]))),
+        );
+    }
+
+    #[test]
+    fn serialize_series_stroke_named_pattern_roundtrip() {
+        let stroke = style::series::Stroke::default().with_pattern(style::LinePattern::DashDot);
+        let json = serde_json::to_string(&stroke).unwrap();
+        let deserialized: style::series::Stroke = serde_json::from_str(&json).unwrap();
+
+        assert_eq!(json, "\"dash-dot\"");
+        assert_eq!(deserialized, stroke);
+    }
+}
diff --git a/src/des/sd/time.rs b/src/des/sd/time.rs
new file mode 100644
index 00000000..5da4f02a
--- /dev/null
+++ b/src/des/sd/time.rs
@@ -0,0 +1,72 @@
+use crate::time;
+
+const FMT: &str = "%Y-%m-%d %H:%M:%S%.f";
+
+impl serde::Serialize for time::DateTime {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        self.fmt_to_string(FMT).serialize(serializer)
+    }
+}
+
+impl<'de> serde::Deserialize<'de> for time::DateTime {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        struct Visitor;
+        impl<'de> serde::de::Visitor<'de> for Visitor {
+            type Value = time::DateTime;
+            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+                formatter.write_str("a string or timestamp")
+            }
+            fn visit_i64<E>(self, value: i64) -> Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                println!("parsing '{}' as time", value);
+                time::DateTime::from_timestamp(value as f64)
+                    .ok_or_else(|| serde::de::Error::custom("invalid time"))
+            }
+
+            fn visit_f64<E>(self, value: f64) -> Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                println!("parsing '{}' as time", value);
+                time::DateTime::from_timestamp(value)
+                    .ok_or_else(|| serde::de::Error::custom("invalid time"))
+            }
+
+            fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                println!("parsing '{}' as time", value);
+                time::DateTime::fmt_parse(value, FMT)
+                    .map_err(|_| serde::de::Error::custom("invalid time"))
+            }
+        }
+        deserializer.deserialize_any(Visitor)
+    }
+}
+
+impl serde::Serialize for time::TimeDelta {
+    fn serialize<S>(&self, _serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        todo!("Serialize TimeDelta")
+    }
+}
+
+impl<'de> serde::Deserialize<'de> for time::TimeDelta {
+    fn deserialize<D>(_deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        todo!("Deserialize TimeDelta")
+    }
+}
diff --git a/src/des/series.rs b/src/des/series.rs
index 900c142f..63e1da63 100644
--- a/src/des/series.rs
+++ b/src/des/series.rs
@@ -1,15 +1,14 @@
 //! Data series definitions for plots.
-use crate::data;
 use crate::des::{axis, cmap};
-use crate::style::{self, defaults};
 #[cfg(feature = "time")]
 use crate::time;
+use crate::{data, style};
 
 /// A data column, either inline or a reference to a data source.
 ///
 /// Data columns can contain either inline data (vectors of values) or references
 /// to columns in a data source. This allows for flexible data handling in series.
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq)]
 pub enum DataCol {
     /// The data is provided inline, directly in the series
     Inline(data::VecColumn),
@@ -91,7 +90,7 @@ impl From<Vec<time::TimeDelta>> for DataCol {
 ///
 /// This enum represents the different types of series that can be visualized.
 /// Each variant contains specific configuration and data for that series type.
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq)]
 pub enum Series {
     /// Plots data as a continuous line.
     Line(Line),
@@ -187,7 +186,7 @@ pub enum Interpolation {
 ///
 /// Plots data as a continuous line connecting points in order.
 /// This is one of the most common series types for visualizing trends and continuous data.
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct Line {
     x_data: DataCol,
     y_data: DataCol,
@@ -210,7 +209,7 @@ impl Line {
             name: None,
             x_axis: Default::default(),
             y_axis: Default::default(),
-            stroke: style::series::Stroke::default().with_width(defaults::SERIES_LINE_WIDTH),
+            stroke: style::series::Stroke::default(),
             marker: None,
             interpolation: Interpolation::default(),
         }
@@ -329,7 +328,7 @@ impl Line {
 /// Marker size is interpreted as an area, so the actual size of the marker will be proportional to the square root of the sizes data value
 /// (e.g. for circle marker: diameter = sqrt(marker size * size column data)).
 /// The sizes data column must have the same length as the x and y data columns.
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct Scatter {
     x_data: DataCol,
     y_data: DataCol,
@@ -440,7 +439,7 @@ impl Scatter {
 }
 
 /// Definition for the `y2_data` field of the Area plot.
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq)]
 pub enum AreaY2 {
     /// Y2 is a horizontal baseline (usually Y=0)
     Baseline(f64),
@@ -477,7 +476,7 @@ impl From<(DataCol, Interpolation)> for AreaY2 {
 ///
 /// Plots data as a filled area between Y1 and Y2 lines over the X axis.
 /// This is useful for visualizing cumulative data or kernel density estimates
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct Area {
     x_data: DataCol,
     y1_data: DataCol,
@@ -634,7 +633,7 @@ impl Area {
 ///
 /// Plots data by grouping values into bins and showing the frequency or density
 /// of values in each bin. Useful for visualizing distributions of continuous data.
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct Histogram {
     x_data: DataCol,
 
@@ -753,7 +752,7 @@ impl Histogram {
 /// (the bar starts at 30% of the bin and ends at 70% of the bin).
 ///
 /// If multiple series are plotted, this offset and width should be adjusted, otherwise the bars will overlap.
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy, PartialEq)]
 pub struct BarsPosition {
     /// Offset from the start of the category bin (0.0 to 1.0).
     pub offset: f32,
@@ -774,7 +773,7 @@ impl Default for BarsPosition {
 ///
 /// Plots data as discrete bars. One axis must contain categories, and the other must be numeric.
 /// Each category gets one bar whose height (or length for horizontal bars) represents the data value.
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct Bars {
     x_data: DataCol,
     y_data: DataCol,
@@ -886,7 +885,7 @@ impl Bars {
 ///
 /// Represents a single series of bars within a [`BarsGroup`].
 /// Each `BarSeries` contains data for one set of bars across all categories.
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct BarSeries {
     data: DataCol,
 
@@ -952,7 +951,7 @@ impl BarSeries {
 /// Orientation of bars in a bar chart.
 ///
 /// Determines whether bars extend vertically (from the x-axis) or horizontally (from the y-axis).
-#[derive(Debug, Clone, Copy, Default)]
+#[derive(Debug, Clone, Copy, Default, PartialEq)]
 pub enum BarsOrientation {
     /// Bars extend vertically from the x-axis.
     #[default]
@@ -977,7 +976,7 @@ impl BarsOrientation {
 ///
 /// Defines how multiple bar series are positioned relative to each other:
 /// either side-by-side or stacked on top of each other.
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy, PartialEq)]
 pub enum BarsArrangement {
     /// Bars are placed side-by-side within each category.
     Aside(BarsAsideArrangement),
@@ -988,7 +987,7 @@ pub enum BarsArrangement {
 /// Configuration for side-by-side bar arrangement.
 ///
 /// Specifies how bars are positioned when placed side-by-side within each category.
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy, PartialEq)]
 pub struct BarsAsideArrangement {
     /// Offset of the first bar within the bin (0.0 to 1.0).
     pub offset: f32,
@@ -1011,7 +1010,7 @@ impl Default for BarsAsideArrangement {
 /// Configuration for stacked bar arrangement.
 ///
 /// Specifies how bars are positioned when stacked on top of each other within each category.
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy, PartialEq)]
 pub struct BarsStackArrangement {
     /// Offset of the stacked bars within the bin (0.0 to 1.0).
     pub offset: f32,
@@ -1039,7 +1038,7 @@ impl Default for BarsArrangement {
 /// Represents multiple bar series that share the same categories.
 /// The bars can be arranged either side-by-side or stacked, and can be oriented
 /// vertically or horizontally.
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct BarsGroup {
     categories: DataCol,
     series: Vec<BarSeries>,
@@ -1079,6 +1078,18 @@ impl BarsGroup {
         }
     }
 
+    /// Set a reference to the x axis and return self for chaining
+    pub fn with_x_axis(mut self, axis: axis::Ref) -> Self {
+        self.x_axis = axis;
+        self
+    }
+
+    /// Set a reference to the y axis and return self for chaining
+    pub fn with_y_axis(mut self, axis: axis::Ref) -> Self {
+        self.y_axis = axis;
+        self
+    }
+
     /// Get the categories data column
     pub fn categories(&self) -> &DataCol {
         &self.categories
diff --git a/src/drawing/annot.rs b/src/drawing/annot.rs
index 3f1f78b7..4ed1b08e 100644
--- a/src/drawing/annot.rs
+++ b/src/drawing/annot.rs
@@ -78,10 +78,10 @@ where
 
         // Resolve axis reference to index, to ensure no error can happen later during drawing
         let x_axis = axes
-            .or_find_idx(Orientation::X, annot.x_axis())?
+            .orientation_find_idx(Orientation::X, annot.x_axis())?
             .ok_or_else(|| super::Error::UnknownAxisRef(annot.x_axis().clone()))?;
         let y_axis = axes
-            .or_find_idx(Orientation::Y, annot.y_axis())?
+            .orientation_find_idx(Orientation::Y, annot.y_axis())?
             .ok_or_else(|| super::Error::UnknownAxisRef(annot.y_axis().clone()))?;
         annot = annot.with_axes(des::axis::Ref::Idx(x_axis), des::axis::Ref::Idx(y_axis));
 
@@ -140,11 +140,11 @@ impl Annot {
         S: render::Surface,
     {
         let x_axis = axes
-            .or_find(Orientation::X, self.x_axis())
+            .orientation_find(Orientation::X, self.x_axis())
             .unwrap()
             .unwrap();
         let y_axis = axes
-            .or_find(Orientation::Y, self.y_axis())
+            .orientation_find(Orientation::Y, self.y_axis())
             .unwrap()
             .unwrap();
         match self {
diff --git a/src/drawing/axis.rs b/src/drawing/axis.rs
index 1d4aa37d..b2a4ce8c 100644
--- a/src/drawing/axis.rs
+++ b/src/drawing/axis.rs
@@ -907,7 +907,7 @@ impl Axis {
     ) where
         S: render::Surface,
     {
-        let stroke = spine.line().as_stroke(style);
+        let stroke = spine.stroke().as_stroke(style);
         let path = self.side.spine_path(plot_rect, spine);
         let rpath = render::Path {
             path: &path,
diff --git a/src/drawing/plot.rs b/src/drawing/plot.rs
index 0f99b4cf..18c4b902 100644
--- a/src/drawing/plot.rs
+++ b/src/drawing/plot.rs
@@ -102,7 +102,7 @@ impl Axes {
         &mut self.y
     }
 
-    pub(super) fn or_find_idx(
+    pub(super) fn orientation_find_idx(
         &self,
         or: Orientation,
         ax_ref: &des::axis::Ref,
@@ -124,13 +124,12 @@ impl Axes {
                         return Ok(Some(ax_idx));
                     }
                 }
-                ax_ref => return Err(Error::IllegalAxisRef(ax_ref.clone())),
             }
         }
         Ok(None)
     }
 
-    pub(super) fn or_find(
+    pub(super) fn orientation_find(
         &self,
         or: Orientation,
         ax_ref: &des::axis::Ref,
@@ -140,7 +139,7 @@ impl Axes {
             Orientation::Y => &self.y,
         };
 
-        let ax = self.or_find_idx(or, ax_ref)?.map(|idx| &axes[idx]);
+        let ax = self.orientation_find_idx(or, ax_ref)?.map(|idx| &axes[idx]);
         Ok(ax)
     }
 
@@ -165,7 +164,7 @@ struct PlotData {
 trait IrPlotExt {
     fn x_axes(&self) -> &[des::Axis];
     fn y_axes(&self) -> &[des::Axis];
-    fn or_axes(&self, or: Orientation) -> &[des::Axis] {
+    fn orientation_axes(&self, or: Orientation) -> &[des::Axis] {
         match or {
             Orientation::X => self.x_axes(),
             Orientation::Y => self.y_axes(),
@@ -193,14 +192,14 @@ trait IrPlotsExt {
         self.plot(idx).map(|p| (idx.index(self.cols()) as usize, p))
     }
 
-    fn or_axes_len(&self, or: Orientation) -> usize {
+    fn orientation_axes_len(&self, or: Orientation) -> usize {
         self.plots()
             .filter_map(|p| p)
-            .map(|p| p.or_axes(or).len())
+            .map(|p| p.orientation_axes(or).len())
             .sum()
     }
 
-    fn or_find_axis(
+    fn orientation_find_axis(
         &self,
         or: Orientation,
         ax_ref: &des::axis::Ref,
@@ -210,18 +209,13 @@ trait IrPlotsExt {
         for (pi, plot) in self.plots().enumerate() {
             let Some(plot) = plot else { continue };
 
-            for (ai, axis) in plot.or_axes(or).iter().enumerate() {
+            for (ai, axis) in plot.orientation_axes(or).iter().enumerate() {
                 match ax_ref {
                     des::axis::Ref::Idx(idx) => {
                         if *idx == ai && plt_idx == pi {
                             return Some((fig_ax_idx, axis));
                         }
                     }
-                    des::axis::Ref::FigIdx(idx) => {
-                        if *idx == fig_ax_idx {
-                            return Some((fig_ax_idx, axis));
-                        }
-                    }
                     des::axis::Ref::Id(id) => {
                         if axis.id() == Some(id) || axis.title().map(|t| t.text()) == Some(id) {
                             return Some((fig_ax_idx, axis));
@@ -680,7 +674,7 @@ where
 
         // ax_infos is Some only for the axis owning their scale
         let mut ax_infos: Vec<Option<(Bounds, Rc<RefCell<AxisScale>>)>> =
-            vec![None; des_plots.or_axes_len(or)];
+            vec![None; des_plots.orientation_axes_len(or)];
 
         // index of the first axis of a plot, at figure level
         let mut fig_ax_idx0 = 0;
@@ -688,7 +682,7 @@ where
         for (plt_idx, des_plot) in des_plots.iter().enumerate() {
             let Some(des_plot) = des_plot else { continue };
 
-            let des_axes = des_plot.or_axes(or);
+            let des_axes = des_plot.orientation_axes(or);
             let mut axes = vec![None; des_axes.len()];
 
             // track whether the main and opposite axes are directly attached to the plot area
@@ -722,7 +716,7 @@ where
                     let series = &data.series;
                     bounds = Series::unite_bounds(or, series, bounds, &matcher, plt_idx2)?;
 
-                    for (ax_idx2, des_ax2) in des_plot2.or_axes(or).iter().enumerate() {
+                    for (ax_idx2, des_ax2) in des_plot2.orientation_axes(or).iter().enumerate() {
                         if let des::axis::Scale::Shared(ax_ref2) = des_ax2.scale() {
                             if matcher.matches_ref(ax_ref2, plt_idx2)? {
                                 let matcher = series::AxisMatcher {
@@ -781,7 +775,7 @@ where
                 continue;
             };
 
-            let des_axes = des_plot.or_axes(or);
+            let des_axes = des_plot.orientation_axes(or);
             let axes = plot_axes[plt_idx].as_mut().unwrap();
 
             // track whether the main and opposite axes are directly attached to the plot area
@@ -793,7 +787,7 @@ where
                     continue;
                 };
                 let (fig_ax_idx, _) = des_plots
-                    .or_find_axis(or, ax_ref, plt_idx)
+                    .orientation_find_axis(or, ax_ref, plt_idx)
                     .ok_or_else(|| Error::UnknownAxisRef(ax_ref.clone()))?;
 
                 let info = ax_infos[fig_ax_idx]
@@ -856,7 +850,7 @@ where
 
 fn plot_insets(plot: &des::Plot) -> geom::Padding {
     match plot.insets() {
-        Some(&des::plot::Insets::Fixed(x, y)) => geom::Padding::Center { v: y, h: x },
+        Some(&des::plot::Insets::Fixed(x, y)) => geom::Padding::Center { ver: y, hor: x },
         Some(des::plot::Insets::Auto) => auto_insets(plot),
         None => geom::Padding::Even(0.0),
     }
@@ -960,8 +954,8 @@ impl Plot {
 
         for series in self.series.iter_mut() {
             let (x_ax_ref, y_ax_ref) = series.axes();
-            let x = axes.or_find(Orientation::X, x_ax_ref)?;
-            let y = axes.or_find(Orientation::Y, y_ax_ref)?;
+            let x = axes.orientation_find(Orientation::X, x_ax_ref)?;
+            let y = axes.orientation_find(Orientation::Y, y_ax_ref)?;
             let (Some(x), Some(y)) = (x, y) else {
                 unreachable!("Series without axis");
             };
@@ -1036,11 +1030,11 @@ impl Plot {
         // otherwise, axes draw the border as spines
         let rect = self.rect;
         match self.border.as_ref() {
-            Some(des::plot::Border::Box(stroke)) => {
+            Some(des::plot::Border::Box(border)) => {
                 surface.draw_rect(&render::Rect {
                     rect,
                     fill: None,
-                    stroke: Some(stroke.as_stroke(style)),
+                    stroke: Some(border.0.as_stroke(style)),
                     transform: None,
                 });
             }
diff --git a/src/drawing/series.rs b/src/drawing/series.rs
index 19c61b7b..398c1f60 100644
--- a/src/drawing/series.rs
+++ b/src/drawing/series.rs
@@ -135,7 +135,6 @@ impl<'a> AxisMatcher<'a> {
         match ax_ref {
             des::axis::Ref::Idx(ax_idx) => Ok(self.ax_idx == *ax_idx && self.plt_idx == plt_idx),
             des::axis::Ref::Id(id) => Ok(self.id == Some(id) || self.title == Some(id)),
-            ax_ref => Err(Error::IllegalAxisRef(ax_ref.clone())),
         }
     }
 }
diff --git a/src/style.rs b/src/style.rs
index 407ff678..1f8ca328 100644
--- a/src/style.rs
+++ b/src/style.rs
@@ -228,6 +228,14 @@ const DASHED_DASH: &[f32] = &[5.0, 5.0];
 const DOT_DASH: &[f32] = &[1.0, 1.0];
 const DASH_DOT_DASH: &[f32] = &[5.0, 5.0, 1.0, 5.0];
 
+/// Trait for types that have a default stroke width for serialization purposes
+/// The trait is implemented for color types, so that the default stroke width
+/// can be associated with the color type used in the stroke.
+pub trait DefaultStrokeWidth {
+    /// Return the default stroke width for this color type.
+    fn default_stroke_width() -> f32;
+}
+
 impl<C: Color> Stroke<C> {
     /// Set the line width in figure units, returning self for chaining
     pub fn with_width(self, width: f32) -> Self {
@@ -270,6 +278,20 @@ impl<C: Color> Stroke<C> {
     }
 }
 
+impl<C> Default for Stroke<C>
+where
+    C: Color + Default + DefaultStrokeWidth,
+{
+    fn default() -> Self {
+        Stroke {
+            color: C::default(),
+            width: C::default_stroke_width(),
+            pattern: LinePattern::default(),
+            opacity: None,
+        }
+    }
+}
+
 impl<C: Color> From<C> for Stroke<C> {
     fn from(color: C) -> Self {
         Stroke {
@@ -342,7 +364,7 @@ where
 
 impl<C: Color> Fill<C> {
     /// Set the fill opacity (0.0 to 1.0), returning self for chaining
-    pub fn with_opacity(self, opacity: f32) -> Self {
+    pub const fn with_opacity(self, opacity: f32) -> Self {
         match self {
             Fill::Solid { color, .. } => Fill::Solid {
                 color,
@@ -374,7 +396,7 @@ impl<C: Color> From<C> for Fill<C> {
 }
 
 /// Shape of a marker, used in scatter plots
-#[derive(Debug, Clone, Copy, Default)]
+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
 pub enum MarkerShape {
     /// Circle marker (the default)
     #[default]
@@ -399,7 +421,7 @@ pub enum MarkerShape {
 
 /// Size of a marker, used in scatter plots
 /// The size is interpreted as an area, so it scales quadratically with the visual size of the marker.
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy, PartialEq)]
 pub struct MarkerSize(pub f32);
 
 impl MarkerSize {
@@ -427,7 +449,7 @@ impl From<f32> for MarkerSize {
 }
 
 /// Marker style definition, used in scatter plots
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct Marker<C: Color> {
     /// Marker size
     pub size: MarkerSize,
@@ -439,7 +461,10 @@ pub struct Marker<C: Color> {
     pub stroke: Option<Stroke<C>>,
 }
 
-impl<C: Color> Marker<C> {
+impl<C> Marker<C>
+where
+    C: Color + DefaultStrokeWidth,
+{
     /// Create a new marker with both fill and stroke set to the same color
     pub fn new_with_color(color: C) -> Self {
         Marker {
@@ -451,7 +476,7 @@ impl<C: Color> Marker<C> {
             }),
             stroke: Some(Stroke {
                 color,
-                width: defaults::SERIES_LINE_WIDTH,
+                width: C::default_stroke_width(),
                 pattern: LinePattern::default(),
                 opacity: None,
             }),
@@ -499,7 +524,7 @@ impl<C: Color> Marker<C> {
 
         let mut stroke = self.stroke.unwrap_or_else(|| Stroke {
             color,
-            width: defaults::SERIES_LINE_WIDTH,
+            width: C::default_stroke_width(),
             opacity: None,
             pattern: LinePattern::default(),
         });
@@ -545,7 +570,7 @@ impl<C: Color> Marker<C> {
 
 impl<C> Default for Marker<C>
 where
-    C: Color + Default,
+    C: Color + Default + DefaultStrokeWidth,
 {
     fn default() -> Self {
         Marker::new_with_color(C::default())
diff --git a/src/style/defaults.rs b/src/style/defaults.rs
index dbd03c6c..7951a468 100644
--- a/src/style/defaults.rs
+++ b/src/style/defaults.rs
@@ -1,4 +1,4 @@
-use crate::geom;
+use crate::{geom, style};
 
 pub const FONT_FAMILY: &str = "sans-serif";
 
@@ -9,7 +9,7 @@ pub const TITLE_FONT_SIZE: f32 = 20.0;
 pub const AXIS_LABEL_FONT_SIZE: f32 = 16.0;
 pub const TICKS_LABEL_FONT_SIZE: f32 = 12.0;
 
-pub const SERIES_LINE_WIDTH: f32 = 1.5;
+pub const SERIES_STROKE_WIDTH: f32 = 1.5;
 pub const MARKER_SIZE: f32 = 8.5 * 8.5;
 
 pub const LEGEND_LABEL_FONT_SIZE: f32 = 13.0;
@@ -19,6 +19,12 @@ pub const LEGEND_PADDING: f32 = 8.0;
 pub const LEGEND_H_SPACING: f32 = 16.0;
 pub const LEGEND_V_SPACING: f32 = 10.0;
 pub const LEGEND_MARGIN: f32 = 12.0;
+pub const fn legend_fill() -> Option<style::theme::Fill> {
+    Some(style::theme::Fill::Solid {
+        color: style::theme::Color::Theme(style::theme::Col::LegendFill),
+        opacity: Some(0.5),
+    })
+}
 
 pub const COLORBAR_WIDTH: f32 = 20.0;
 pub const COLORBAR_TITLE_FONT_SIZE: f32 = 16.0;
@@ -27,16 +33,16 @@ pub const COLORBAR_MARGIN: f32 = LEGEND_MARGIN;
 
 pub const PLOT_XY_AUTO_INSETS: geom::Padding = geom::Padding::Even(20.0);
 pub const PLOT_VER_BARS_AUTO_INSETS: geom::Padding = geom::Padding::Custom {
-    t: 20.0,
-    r: 20.0,
-    b: 0.0,
-    l: 20.0,
+    top: 20.0,
+    right: 20.0,
+    bottom: 0.0,
+    left: 20.0,
 };
 pub const PLOT_HOR_BARS_AUTO_INSETS: geom::Padding = geom::Padding::Custom {
-    t: 20.0,
-    r: 20.0,
-    b: 20.0,
-    l: 0.0,
+    top: 20.0,
+    right: 20.0,
+    bottom: 20.0,
+    left: 0.0,
 };
 pub const PLOT_AXIS_ARROW_SIZE: f32 = 10.0;
 pub const PLOT_AXIS_ARROW_OVERFLOW: f32 = 10.0;
diff --git a/src/style/series.rs b/src/style/series.rs
index 2772a15a..4cf0603a 100644
--- a/src/style/series.rs
+++ b/src/style/series.rs
@@ -1,6 +1,8 @@
 /*!
  * This module deals with colors and style of data series.
  */
+use plotive_base::color;
+
 use crate::style::{self, catppuccin, defaults, dracula};
 use crate::{ResolveColor, Rgba8};
 
@@ -68,19 +70,63 @@ impl Palette {
 }
 
 /// A series color identified by its index in a palette
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub struct IndexColor(pub usize);
 
 impl style::Color for IndexColor {}
 
-/// A series color that is automatically chosen from a palette based on the series index
+/// An error type for parsing an IndexColor from a string
 #[derive(Debug, Clone, Copy)]
+pub enum IndexColorParseError {
+    /// Failed to parse an series index color (e.g. "L1", "L2", etc.)
+    InvalidFormat,
+    /// Series color index must start at one (e.g. "L1" is valid, but "L0" is not)
+    InvalidIndex,
+}
+
+impl std::fmt::Display for IndexColorParseError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            IndexColorParseError::InvalidFormat => write!(f, "Invalid series color format"),
+            IndexColorParseError::InvalidIndex => write!(f, "Series color index must start at one"),
+        }
+    }
+}
+
+impl std::error::Error for IndexColorParseError {}
+
+impl std::str::FromStr for IndexColor {
+    type Err = IndexColorParseError;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        if s.starts_with("L") {
+            let index = s[1..]
+                .parse::<usize>()
+                .map_err(|_| IndexColorParseError::InvalidIndex)?;
+            if index == 0 {
+                Err(IndexColorParseError::InvalidIndex)
+            } else {
+                Ok(IndexColor(index - 1))
+            }
+        } else {
+            Err(IndexColorParseError::InvalidFormat)
+        }
+    }
+}
+
+impl std::fmt::Display for IndexColor {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "L{}", self.0 + 1)
+    }
+}
+
+/// A series color that is automatically chosen from a palette based on the series index
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub struct AutoColor;
 
 impl style::Color for AutoColor {}
 
 /// A flexible color for data series
-#[derive(Debug, Clone, Copy, Default)]
+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
 pub enum Color {
     /// Automatic color from the palette
     #[default]
@@ -111,6 +157,55 @@ impl From<Rgba8> for Color {
 
 impl style::Color for Color {}
 
+/// an error type for parsing a Color from a string
+#[derive(Debug)]
+
+pub enum ColorParseError {
+    /// Failed to parse an series index color (e.g. "L1", "L2", etc.)
+    Index(IndexColorParseError),
+    /// Failed to parse a fixed RGB color (e.g. "#RRGGBB", "antiquewhite", "rgb(...)", etc.)
+    Fixed(color::ParseError),
+}
+
+impl From<IndexColorParseError> for ColorParseError {
+    fn from(e: IndexColorParseError) -> Self {
+        ColorParseError::Index(e)
+    }
+}
+
+impl From<color::ParseError> for ColorParseError {
+    fn from(e: color::ParseError) -> Self {
+        ColorParseError::Fixed(e)
+    }
+}
+
+impl std::fmt::Display for ColorParseError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            ColorParseError::Index(e) => write!(f, "{}", e),
+            ColorParseError::Fixed(e) => write!(f, "{}", e),
+        }
+    }
+}
+
+impl std::error::Error for ColorParseError {}
+
+impl std::str::FromStr for Color {
+    type Err = ColorParseError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        if s == "auto" {
+            Ok(Color::Auto)
+        } else if s.starts_with("L") {
+            let index = s.parse::<IndexColor>()?;
+            Ok(Color::Index(index))
+        } else {
+            let c = s.parse::<Rgba8>()?;
+            Ok(Color::Fixed(c))
+        }
+    }
+}
+
 impl ResolveColor<IndexColor> for Palette {
     fn resolve_color(&self, col: &IndexColor) -> Rgba8 {
         self.get(*col)
@@ -133,25 +228,21 @@ impl ResolveColor<Color> for (&Palette, usize) {
     }
 }
 
-/// Stroke style for theme elements
-pub type Stroke = style::Stroke<Color>;
-
-impl Default for Stroke {
-    fn default() -> Self {
-        Stroke {
-            color: Color::default(),
-            width: defaults::SERIES_LINE_WIDTH,
-            pattern: style::LinePattern::default(),
-            opacity: None,
-        }
+impl super::DefaultStrokeWidth for Color {
+    fn default_stroke_width() -> f32 {
+        defaults::SERIES_STROKE_WIDTH
     }
 }
+/// Stroke style for theme elements
+pub type Stroke = style::Stroke<Color>;
 
 impl From<Rgba8> for Stroke {
     fn from(color: Rgba8) -> Self {
+        use super::DefaultStrokeWidth;
+
         Stroke {
             color: color.into(),
-            width: defaults::SERIES_LINE_WIDTH,
+            width: Color::default_stroke_width(),
             pattern: style::LinePattern::default(),
             opacity: None,
         }
diff --git a/src/style/theme.rs b/src/style/theme.rs
index b72a4ed4..4828c65d 100644
--- a/src/style/theme.rs
+++ b/src/style/theme.rs
@@ -1,7 +1,7 @@
 //! Theme definitions and implementations
 
 use crate::color::{self, Rgb8, Rgba8};
-use crate::style::{catppuccin, dracula};
+use crate::style::{DefaultStrokeWidth, catppuccin, dracula};
 use crate::{style, text};
 
 /// A theme, for styling figures
@@ -183,6 +183,19 @@ impl std::str::FromStr for Col {
     }
 }
 
+impl std::fmt::Display for Col {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let s = match self {
+            Col::Background => "background",
+            Col::Foreground => "foreground",
+            Col::Grid => "grid",
+            Col::LegendFill => "legend_fill",
+            Col::LegendBorder => "legend_border",
+        };
+        write!(f, "{}", s)
+    }
+}
+
 impl color::ResolveColor<Col> for Theme {
     fn resolve_color(&self, col: &Col) -> Rgba8 {
         match col {
@@ -231,6 +244,15 @@ impl std::str::FromStr for Color {
     }
 }
 
+impl std::fmt::Display for Color {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Color::Theme(col) => write!(f, "{}", col),
+            Color::Fixed(c) => write!(f, "{}", c.html()),
+        }
+    }
+}
+
 impl text::rich::Foreground for Color {
     fn foreground() -> Self {
         Color::Theme(Col::Foreground)
@@ -246,6 +268,12 @@ impl color::ResolveColor<Color> for Theme {
     }
 }
 
+impl super::DefaultStrokeWidth for Color {
+    fn default_stroke_width() -> f32 {
+        1.0
+    }
+}
+
 /// Stroke style for theme elements
 pub type Stroke = style::Stroke<Color>;
 
@@ -255,7 +283,7 @@ impl From<Col> for Stroke {
     fn from(col: Col) -> Self {
         Stroke {
             color: col.into(),
-            width: 1.0,
+            width: Color::default_stroke_width(),
             pattern: style::LinePattern::default(),
             opacity: None,
         }
diff --git a/src/time.rs b/src/time.rs
index 04e21815..ef2617b4 100644
--- a/src/time.rs
+++ b/src/time.rs
@@ -338,7 +338,7 @@ impl DateTimeComps {
                 FmtToken::Milli => res.micro = parse_fraction(&mut input_chars, Some(3))?,
                 FmtToken::Micro => res.micro = parse_fraction(&mut input_chars, Some(6))?,
                 FmtToken::Nano => res.micro = parse_fraction(&mut input_chars, Some(9))?,
-                FmtToken::Frac => res.micro = parse_fraction(&mut input_chars, None)?,
+                FmtToken::Frac => res.micro = parse_fraction_opt(&mut input_chars, None)?,
                 FmtToken::Lit(s) => {
                     for c in s.chars() {
                         if c != input_chars.next().ok_or(ParseError::FormatMismatch)? {
@@ -641,7 +641,7 @@ impl TimeDeltaComps {
                 FmtToken::Milli => res.micro = parse_fraction(&mut input_chars, Some(3))?,
                 FmtToken::Micro => res.micro = parse_fraction(&mut input_chars, Some(6))?,
                 FmtToken::Nano => res.micro = parse_fraction(&mut input_chars, Some(9))?,
-                FmtToken::Frac => res.micro = parse_fraction(&mut input_chars, None)?,
+                FmtToken::Frac => res.micro = parse_fraction_opt(&mut input_chars, None)?,
                 FmtToken::Lit(s) => {
                     for c in s.chars() {
                         if c != input_chars.next().ok_or(ParseError::FormatMismatch)? {
@@ -1036,6 +1036,15 @@ fn parse_fraction(chars: &mut Peekable<Chars>, len: Option<usize>) -> Result<u32
     Ok(micro)
 }
 
+/// Parse the fractional seconds (microseconds), return 0 if it doesn't start by '.'
+fn parse_fraction_opt(chars: &mut Peekable<Chars>, len: Option<usize>) -> Result<u32, ParseError> {
+    if chars.peek() == Some(&'.') {
+        parse_fraction(chars, len)
+    } else {
+        Ok(0)
+    }
+}
+
 fn format_micro_opt<W: fmt::Write>(out: &mut W, mut micro: u32) -> fmt::Result {
     if micro != 0 {
         write!(out, ".")?;
@@ -1144,12 +1153,38 @@ mod tests {
         assert_eq!(result.micro, 123456);
     }
 
+    #[test]
+    fn test_format_datetime_comps_no_usecs() {
+        const FMT: &str = "%Y-%m-%d %H:%M:%S%.f";
+        let input = DateTimeComps {
+            year: 2025,
+            month: 1,
+            day: 13,
+            hour: 15,
+            minute: 46,
+            second: 32,
+            micro: 0,
+        };
+        let expected = "2025-01-13 15:46:32";
+        let result = input.fmt_to_string(FMT);
+        assert_eq!(result, expected);
+    }
+
     #[test]
     fn test_parse_datetime_comps_no_usecs() {
+        const FMT: &str = "%Y-%m-%d %H:%M:%S%.f";
         let input = "2025-01-13 15:46:32";
-        let fmt = "%Y-%m-%d %H:%M:%S%.f";
-        let result = DateTimeComps::fmt_parse(input, fmt);
-        assert!(matches!(result, Err(ParseError::FormatMismatch)));
+        let expected = DateTimeComps {
+            year: 2025,
+            month: 1,
+            day: 13,
+            hour: 15,
+            minute: 46,
+            second: 32,
+            micro: 0,
+        };
+        let result = DateTimeComps::fmt_parse(input, FMT).unwrap();
+        assert_eq!(result, expected);
     }
 
     #[test]
diff --git a/tests/Cargo.toml b/tests/Cargo.toml
index c96de2b7..24ba33c6 100644
--- a/tests/Cargo.toml
+++ b/tests/Cargo.toml
@@ -10,10 +10,11 @@ keywords.workspace = true
 publish = false
 
 [dependencies]
-plotive = { workspace = true, features=["time", "utils"] }
+plotive = { workspace = true, features=["serde", "time", "utils"] }
 plotive-pxl.workspace = true
 plotive-svg.workspace = true
 tiny-skia.workspace = true
+serde_json.workspace = true
 similar = "2.7.0"
 rand.workspace = true
 rand_distr.workspace = true
diff --git a/tests/src/harness.rs b/tests/src/harness.rs
index 78a7fe48..78b73e3d 100644
--- a/tests/src/harness.rs
+++ b/tests/src/harness.rs
@@ -28,6 +28,12 @@ pub trait TestHarness {
         Path::new(tests_dir).join("failed").join(file_name)
     }
 
+    fn failed_json_file_path(ref_name: &str) -> PathBuf {
+        let file_name = format!("{}.json", ref_name);
+        let tests_dir = env!("CARGO_MANIFEST_DIR");
+        Path::new(tests_dir).join("failed").join(file_name)
+    }
+
     fn failed_diff_file_path(ref_name: &str) -> PathBuf {
         let file_name = format!("{}{}", ref_name, Self::diff_file_suffix());
         let tests_dir = env!("CARGO_MANIFEST_DIR");
@@ -38,9 +44,9 @@ pub trait TestHarness {
 
     fn diff_fig(actual: &Self::DrawnFig, ref_: &Self::DrawnFig) -> Option<Self::DiffFig>;
 
-    fn serialize_fig(file: &Path, fig: &Self::DrawnFig);
-    fn deserialize_fig(file: &Path) -> Self::DrawnFig;
-    fn serialize_diff(file: &Path, diff: &Self::DiffFig);
+    fn save_fig(file: &Path, fig: &Self::DrawnFig);
+    fn load_fig(file: &Path) -> Self::DrawnFig;
+    fn save_diff(file: &Path, diff: &Self::DiffFig);
 
     fn regenerate_refs() -> bool;
 
@@ -48,12 +54,13 @@ pub trait TestHarness {
         let ref_file = Self::ref_file_path(&ref_name);
         let failed_file = Self::failed_file_path(&ref_name);
         let failed_diff_file = Self::failed_diff_file_path(&ref_name);
+        let failed_json_file = Self::failed_json_file_path(&ref_name);
 
         let actual_fig = Self::draw_fig(fig, style);
 
         if Self::regenerate_refs() {
             std::fs::create_dir_all(ref_file.parent().unwrap()).unwrap();
-            Self::serialize_fig(&ref_file, &actual_fig);
+            Self::save_fig(&ref_file, &actual_fig);
 
             if std::fs::exists(&failed_file).unwrap() {
                 std::fs::remove_file(&failed_file).unwrap();
@@ -67,7 +74,7 @@ pub trait TestHarness {
 
         if !std::fs::exists(&ref_file).unwrap() {
             std::fs::create_dir_all(failed_file.parent().unwrap()).unwrap();
-            Self::serialize_fig(failed_file.as_path(), &actual_fig);
+            Self::save_fig(failed_file.as_path(), &actual_fig);
             return Err(format!(
                 "No such {} ref: \"{}\"\n  Actual figure written to {}",
                 Self::id(),
@@ -76,30 +83,75 @@ pub trait TestHarness {
             ));
         }
 
-        let ref_fig = Self::deserialize_fig(&ref_file);
+        let ref_fig = Self::load_fig(&ref_file);
 
         if let Some(diff_fig) = Self::diff_fig(&actual_fig, &ref_fig) {
             std::fs::create_dir_all(failed_file.parent().unwrap()).unwrap();
             std::fs::create_dir_all(failed_diff_file.parent().unwrap()).unwrap();
-            Self::serialize_fig(failed_file.as_path(), &actual_fig);
-            Self::serialize_diff(failed_diff_file.as_path(), &diff_fig);
+            Self::save_fig(failed_file.as_path(), &actual_fig);
+            Self::save_diff(failed_diff_file.as_path(), &diff_fig);
 
-            Err(format!(
-                "{} assertion failed\n  Actual figure: {:?}\n     Ref figure: {:?}\n           Diff: {:?}",
+            return Err(format!(
+                "{} assertion failed\n  Actual figure: {}\n     Ref figure: {}\n           Diff: {}",
                 Self::id(),
-                failed_file,
-                ref_file,
-                failed_diff_file
-            ))
-        } else {
-            if std::fs::exists(&failed_file).unwrap() {
-                std::fs::remove_file(&failed_file).unwrap();
-            }
-            if std::fs::exists(&failed_diff_file).unwrap() {
-                std::fs::remove_file(&failed_diff_file).unwrap();
+                failed_file.display(),
+                ref_file.display(),
+                failed_diff_file.display(),
+            ));
+        }
+
+        let json = serde_json::to_string_pretty(fig)
+            .unwrap()
+            .replace("  ", "    ");
+        let des_fig: des::Figure = match serde_json::from_str(&json) {
+            Ok(fig) => fig,
+            Err(err) => {
+                std::fs::create_dir_all(failed_file.parent().unwrap()).unwrap();
+                std::fs::write(failed_json_file.as_path(), json).unwrap();
+                return Err(format!(
+                    "{} deserialization failed for ref \"{}\": {}\n  Failed JSON written to {}",
+                    Self::id(),
+                    ref_name,
+                    err,
+                    failed_json_file.display()
+                ));
             }
-            Ok(())
+        };
+        let des_drawn_fig = Self::draw_fig(&des_fig, style);
+        if let Some(diff_fig) = Self::diff_fig(&actual_fig, &des_drawn_fig) {
+            std::fs::create_dir_all(failed_file.parent().unwrap()).unwrap();
+            std::fs::create_dir_all(failed_diff_file.parent().unwrap()).unwrap();
+            std::fs::create_dir_all(failed_json_file.parent().unwrap()).unwrap();
+            Self::save_fig(failed_file.as_path(), &des_drawn_fig);
+            Self::save_diff(failed_diff_file.as_path(), &diff_fig);
+            std::fs::write(failed_json_file.as_path(), json).unwrap();
+
+            return Err(format!(
+                concat!(
+                    "{} serde round-trip assertion failed\n",
+                    "  Actual figure: {}\n",
+                    "     Ref figure: {}\n",
+                    "           Diff: {}\n",
+                    "    Failed JSON: {}",
+                ),
+                Self::id(),
+                failed_file.display(),
+                ref_file.display(),
+                failed_diff_file.display(),
+                failed_json_file.display(),
+            ));
+        }
+
+        if std::fs::exists(&failed_file).unwrap() {
+            std::fs::remove_file(&failed_file).unwrap();
+        }
+        if std::fs::exists(&failed_diff_file).unwrap() {
+            std::fs::remove_file(&failed_diff_file).unwrap();
+        }
+        if std::fs::exists(&failed_json_file).unwrap() {
+            std::fs::remove_file(&failed_json_file).unwrap();
         }
+        Ok(())
     }
 }
 
@@ -150,15 +202,15 @@ impl TestHarness for PxlHarness {
             || std::env::var("REGENERATE_PNG_REFS").is_ok()
     }
 
-    fn serialize_fig(file: &Path, fig: &Self::DrawnFig) {
+    fn save_fig(file: &Path, fig: &Self::DrawnFig) {
         fig.save_png(file).unwrap();
     }
 
-    fn deserialize_fig(file: &Path) -> Self::DrawnFig {
+    fn load_fig(file: &Path) -> Self::DrawnFig {
         tiny_skia::Pixmap::load_png(file).unwrap()
     }
 
-    fn serialize_diff(file: &Path, diff: &Self::DiffFig) {
+    fn save_diff(file: &Path, diff: &Self::DiffFig) {
         diff.save_png(file).unwrap();
     }
 }
@@ -206,16 +258,16 @@ impl TestHarness for SvgHarness {
             || std::env::var("REGENERATE_SVG_REFS").is_ok()
     }
 
-    fn serialize_fig(file: &Path, fig: &Self::DrawnFig) {
+    fn save_fig(file: &Path, fig: &Self::DrawnFig) {
         std::fs::write(file, fig).unwrap();
     }
 
-    fn deserialize_fig(file: &Path) -> Self::DrawnFig {
+    fn load_fig(file: &Path) -> Self::DrawnFig {
         let buf = std::fs::read(file).unwrap();
         String::from_utf8(buf).unwrap()
     }
 
-    fn serialize_diff(file: &Path, diff: &Self::DiffFig) {
+    fn save_diff(file: &Path, diff: &Self::DiffFig) {
         std::fs::write(file, diff).unwrap();
     }
 }
diff --git a/text/src/rich.rs b/text/src/rich.rs
index 4c54c823..dc1aac6e 100644
--- a/text/src/rich.rs
+++ b/text/src/rich.rs
@@ -346,7 +346,7 @@ impl<C> TextOptProps<C> {
 }
 
 /// A set of resolved properties for a text span
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct TextProps<C>
 where
     C: Clone,