diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 931d256a..a9431a21 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -44,6 +44,8 @@ jobs:
           components: clippy
           targets: wasm32-unknown-unknown
       # lint plotly_static for all features
+      - run: cargo check -p plotly_static
+      - run: cargo test -p plotly_static build_without_driver_feature_returns_error
       - run: cargo clippy -p plotly_static --features geckodriver,webdriver_download -- -D warnings -A deprecated
       - run: cargo clippy -p plotly_static --features chromedriver,webdriver_download -- -D warnings -A deprecated
       # lint the main library workspace for non-wasm target
diff --git a/CHANGELOG.md b/CHANGELOG.md
index f8f775e0..d1996a8d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,9 +7,14 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/) a
 
 ### Added
 
+- [[#412](https://github.com/plotly/plotly.rs/pull/412)] Add `Violin` trace type with box, mean line, KDE span, and split/grouped support
+- [[#413](https://github.com/plotly/plotly.rs/issues/413)] Add hover (`hovertext`/`hoverinfo`/`hovertemplate`/`customdata`/`hoverlabel`/`text`) and color-scale (`colorscale`/`colorbar`/`showscale`/`reversescale`/`autocolorscale`/`coloraxis`) support, plus `ids`/`meta`/`uirevision`/`below`, to `DensityMapbox`
 - [[#406](https://github.com/plotly/plotly.rs/issues/406)] Expose `plotly.js` 3.1–3.6 attributes
 - [[#410](https://github.com/plotly/plotly.rs/pull/410)] Add `Choropleth` (geo subplot) and `ChoroplethMap` (MapLibre `map` subplot) trace types, with a `LocationMode` enum and a dedicated `choropleth::Marker`; add the MapLibre `map` subplot via `LayoutMap`/`MapStyle`/`MapBounds`
 - [[#410](https://github.com/plotly/plotly.rs/pull/410)] Add `LayoutGeo` options: `fitbounds` (`GeoFitBounds`), `resolution` (`GeoResolution`, 1:110M/1:50M base-layer detail), and `bgcolor`
+- [[#414](https://github.com/plotly/plotly.rs/issues/414)] Add `DensityMap` (MapLibre `map` subplot) trace type — density heatmaps with full color-scale and hover support
+- Add `ScatterMap` (MapLibre `map` subplot) trace type — the modern counterpart to `ScatterMapbox`, with markers/lines, `Fill`/`Selection`, and full hover support
+- Add native point clustering to `ScatterMap` via a `Cluster` option (`enabled`/`color`/`maxzoom`/`opacity`/`size`/`step`) — a `scattermap`-only feature with no `ScatterMapbox` equivalent
 
 ### Changed
 
diff --git a/docs/book/src/SUMMARY.md b/docs/book/src/SUMMARY.md
index 866124fd..02e3609f 100644
--- a/docs/book/src/SUMMARY.md
+++ b/docs/book/src/SUMMARY.md
@@ -21,6 +21,7 @@
     - [Statistical Charts](./recipes/statistical_charts.md)
         - [Error Bars](./recipes/statistical_charts/error_bars.md)
         - [Box Plots](./recipes/statistical_charts/box_plots.md)
+        - [Violin Plots](./recipes/statistical_charts/violin_plots.md)
         - [Histograms](./recipes/statistical_charts/histograms.md)
     - [Scientific Charts](./recipes/scientific_charts.md)
        - [Contour Plots](./recipes/scientific_charts/contour_plots.md)
diff --git a/docs/book/src/recipes/img/violin_plot.png b/docs/book/src/recipes/img/violin_plot.png
new file mode 100644
index 00000000..d6c679ab
Binary files /dev/null and b/docs/book/src/recipes/img/violin_plot.png differ
diff --git a/docs/book/src/recipes/statistical_charts.md b/docs/book/src/recipes/statistical_charts.md
index 4f446d1d..136aa7bc 100644
--- a/docs/book/src/recipes/statistical_charts.md
+++ b/docs/book/src/recipes/statistical_charts.md
@@ -6,4 +6,5 @@ Kind | Link
 :---|:----:
 Error Bars |[![Scatter Plots](./img/error_bars.png)](./statistical_charts/error_bars.md)
 Box Plots | [![Line Charts](./img/box_plot.png)](./statistical_charts/box_plots.md)
+Violin Plots | [![Violin Plots](./img/violin_plot.png)](./statistical_charts/violin_plots.md)
 Histograms | [![Scatter Plots](./img/overlaid_histogram.png)](./statistical_charts/histograms.md)
diff --git a/docs/book/src/recipes/statistical_charts/violin_plots.md b/docs/book/src/recipes/statistical_charts/violin_plots.md
new file mode 100644
index 00000000..739886ad
--- /dev/null
+++ b/docs/book/src/recipes/statistical_charts/violin_plots.md
@@ -0,0 +1,36 @@
+# Violin Plots
+
+The following imports have been used to produce the plots below:
+
+```rust,no_run
+use plotly::common::{Line, Orientation};
+use plotly::layout::{Layout, ViolinMode};
+use plotly::violin::{MeanLine, ViolinBox, ViolinPoints, ViolinSide};
+use plotly::{color::NamedColor, Plot, Violin};
+```
+
+The `to_inline_html` method is used to produce the html plot displayed in this page.
+
+
+## Basic Violin Plot
+```rust,no_run
+{{#include ../../../../../examples/statistical_charts/src/main.rs:basic_violin_plot}}
+```
+
+{{#include ../../../../../examples/statistical_charts/output/inline_basic_violin_plot.html}}
+
+
+## Horizontal Violin Plot
+```rust,no_run
+{{#include ../../../../../examples/statistical_charts/src/main.rs:horizontal_violin_plot}}
+```
+
+{{#include ../../../../../examples/statistical_charts/output/inline_horizontal_violin_plot.html}}
+
+
+## Split Violin Plot
+```rust,no_run
+{{#include ../../../../../examples/statistical_charts/src/main.rs:split_violin_plot}}
+```
+
+{{#include ../../../../../examples/statistical_charts/output/inline_split_violin_plot.html}}
diff --git a/examples/statistical_charts/src/main.rs b/examples/statistical_charts/src/main.rs
index f4947cc7..2b4d2da9 100644
--- a/examples/statistical_charts/src/main.rs
+++ b/examples/statistical_charts/src/main.rs
@@ -6,8 +6,9 @@ use plotly::{
     color::{NamedColor, Rgb, Rgba},
     common::{ErrorData, ErrorType, Line, Marker, Mode, Orientation},
     histogram::{Bins, Cumulative, HistFunc, HistNorm},
-    layout::{Axis, BarMode, BoxMode, Layout, Margin},
-    Bar, BoxPlot, Histogram, Plot, Scatter,
+    layout::{Axis, BarMode, BoxMode, Layout, Margin, ViolinMode},
+    violin::{MeanLine, ViolinBox, ViolinPoints, ViolinSide},
+    Bar, BoxPlot, Histogram, Plot, Scatter, Violin,
 };
 use plotly_utils::write_example_to_html;
 use rand_distr::{Distribution, Normal, Uniform};
@@ -477,6 +478,98 @@ fn fully_styled_box_plot(show: bool, file_name: &str) {
 }
 // ANCHOR_END: fully_styled_box_plot
 
+// Violin Plots
+// ANCHOR: basic_violin_plot
+fn basic_violin_plot(show: bool, file_name: &str) {
+    let y = vec![
+        0.2, 0.2, 0.6, 1.0, 0.5, 0.4, 0.2, 0.7, 0.9, 0.1, 0.5, 0.3, 0.8, 0.4, 0.6,
+    ];
+
+    let trace = Violin::new(y)
+        .box_plot(ViolinBox::new().visible(true))
+        .mean_line(MeanLine::new().visible(true))
+        .name("Total");
+
+    let layout = Layout::new().title("Basic Violin Plot");
+
+    let mut plot = Plot::new();
+    plot.set_layout(layout);
+    plot.add_trace(trace);
+
+    let path = write_example_to_html(&plot, file_name);
+    if show {
+        plot.show_html(path);
+    }
+}
+// ANCHOR_END: basic_violin_plot
+
+// ANCHOR: horizontal_violin_plot
+fn horizontal_violin_plot(show: bool, file_name: &str) {
+    let x = vec![1.4, 2.1, 1.9, 3.2, 2.7, 2.2, 1.8, 2.5, 3.1, 2.0, 2.6, 1.7];
+
+    let trace = Violin::<f64, f64>::default()
+        .x(x)
+        .points(ViolinPoints::All)
+        .box_plot(ViolinBox::new().visible(true))
+        .mean_line(MeanLine::new().visible(true))
+        .orientation(Orientation::Horizontal)
+        .name("Score");
+
+    let layout = Layout::new().title("Horizontal Violin Plot");
+
+    let mut plot = Plot::new();
+    plot.set_layout(layout);
+    plot.add_trace(trace);
+
+    let path = write_example_to_html(&plot, file_name);
+    if show {
+        plot.show_html(path);
+    }
+}
+// ANCHOR_END: horizontal_violin_plot
+
+// ANCHOR: split_violin_plot
+fn split_violin_plot(show: bool, file_name: &str) {
+    let x = vec![
+        "Mon", "Mon", "Mon", "Mon", "Tue", "Tue", "Tue", "Tue", "Wed", "Wed", "Wed", "Wed",
+    ];
+
+    let trace1 = Violin::new_xy(
+        x.clone(),
+        vec![0.6, 0.9, 0.4, 0.7, 0.8, 1.1, 0.6, 0.9, 1.0, 1.3, 0.8, 1.1],
+    )
+    .legend_group("Yes")
+    .scale_group("Yes")
+    .name("Yes")
+    .side(ViolinSide::Negative)
+    .line(Line::new().color(NamedColor::Blue));
+
+    let trace2 = Violin::new_xy(
+        x,
+        vec![0.4, 0.7, 0.3, 0.5, 0.6, 0.9, 0.4, 0.7, 0.8, 1.1, 0.6, 0.9],
+    )
+    .legend_group("No")
+    .scale_group("No")
+    .name("No")
+    .side(ViolinSide::Positive)
+    .line(Line::new().color(NamedColor::Green));
+
+    let layout = Layout::new()
+        .title("Split Violin Plot")
+        .violin_mode(ViolinMode::Overlay);
+
+    let mut plot = Plot::new();
+    plot.set_layout(layout);
+    plot.add_trace(trace1);
+    plot.add_trace(trace2);
+
+    let path = write_example_to_html(&plot, file_name);
+    if show {
+        plot.show_html(path);
+    }
+}
+// ANCHOR_END: split_violin_plot
+
 // Histograms
 fn sample_normal_distribution(n: usize, mean: f64, std_dev: f64) -> Vec<f64> {
     let mut rng = rand::rng();
@@ -729,6 +822,11 @@ fn main() {
     grouped_horizontal_box_plot(false, "grouped_horizontal_box_plot");
     fully_styled_box_plot(false, "fully_styled_box_plot");
 
+    // Violin Plots
+    basic_violin_plot(false, "basic_violin_plot");
+    horizontal_violin_plot(false, "horizontal_violin_plot");
+    split_violin_plot(false, "split_violin_plot");
+
     // Histograms
     basic_histogram(false, "basic_histogram");
     horizontal_histogram(false, "horizontal_histogram");
diff --git a/plotly/Cargo.toml b/plotly/Cargo.toml
index a0840115..8d43567c 100644
--- a/plotly/Cargo.toml
+++ b/plotly/Cargo.toml
@@ -88,6 +88,5 @@ image = "0.25"
 itertools = ">=0.10, <0.16"
 itertools-num = "0.1"
 ndarray = "0.17"
-plotly_static = { path = "../plotly_static" }
 rand_distr = "0.6"
 base64 = "0.22"
diff --git a/plotly/src/common/mod.rs b/plotly/src/common/mod.rs
index 513440e5..2f60ecd8 100644
--- a/plotly/src/common/mod.rs
+++ b/plotly/src/common/mod.rs
@@ -212,6 +212,7 @@ pub enum PlotType {
     ScatterGL,
     Scatter3D,
     ScatterMapbox,
+    ScatterMap,
     ScatterGeo,
     ScatterPolar,
     ScatterPolarGL,
@@ -228,12 +229,14 @@ pub enum PlotType {
     Sankey,
     Surface,
     DensityMapbox,
+    DensityMap,
     Table,
     Pie,
     Treemap,
     Sunburst,
     Choropleth,
     ChoroplethMap,
+    Violin,
 }
 
 #[derive(Serialize, Clone, Debug)]
diff --git a/plotly/src/lib.rs b/plotly/src/lib.rs
index 01c83074..7086da40 100644
--- a/plotly/src/lib.rs
+++ b/plotly/src/lib.rs
@@ -60,14 +60,14 @@ pub use layout::Layout;
 pub use plot::{Plot, Trace, Traces};
 // Also provide easy access to modules which contain additional trace-specific types
 pub use traces::{
-    box_plot, choropleth, choropleth_map, contour, heat_map, histogram, image, mesh3d, sankey,
-    scatter, scatter3d, scatter_mapbox, sunburst, surface, treemap,
+    box_plot, choropleth, choropleth_map, contour, density_map, heat_map, histogram, image, mesh3d,
+    sankey, scatter, scatter3d, scatter_map, scatter_mapbox, sunburst, surface, treemap, violin,
 };
 // Bring the different trace types into the top-level scope
 pub use traces::{
-    Bar, BoxPlot, Candlestick, Choropleth, ChoroplethMap, Contour, DensityMapbox, HeatMap,
-    Histogram, Image, Mesh3D, Ohlc, Pie, Sankey, Scatter, Scatter3D, ScatterGeo, ScatterMapbox,
-    ScatterPolar, Sunburst, Surface, Table, Treemap,
+    Bar, BoxPlot, Candlestick, Choropleth, ChoroplethMap, Contour, DensityMap, DensityMapbox,
+    HeatMap, Histogram, Image, Mesh3D, Ohlc, Pie, Sankey, Scatter, Scatter3D, ScatterGeo,
+    ScatterMap, ScatterMapbox, ScatterPolar, Sunburst, Surface, Table, Treemap, Violin,
 };
 
 pub trait Restyle: serde::Serialize {}
diff --git a/plotly/src/traces/density_map.rs b/plotly/src/traces/density_map.rs
new file mode 100644
index 00000000..5cc32ae9
--- /dev/null
+++ b/plotly/src/traces/density_map.rs
@@ -0,0 +1,207 @@
+//! Density heatmap trace for the MapLibre `map` subplot.
+
+use plotly_derive::FieldSetter;
+use serde::Serialize;
+
+use crate::common::{
+    ColorBar, ColorScale, Dim, HoverInfo, Label, LegendGroupTitle, PlotType, Visible,
+};
+use crate::private::{NumOrString, NumOrStringCollection};
+use crate::Trace;
+
+/// Construct a density heatmap trace drawn on the MapLibre `map` subplot
+/// (configured via [`LayoutMap`](crate::layout::LayoutMap)).
+///
+/// `DensityMap` is the modern MapLibre-based counterpart to
+/// [`DensityMapbox`](crate::DensityMapbox): it draws a weighted kernel-density
+/// heatmap from `lat`/`lon` points (with an optional per-point weight `z`) onto
+/// the `layout.map` subplot.
+///
+/// # Examples
+///
+/// ```
+/// use plotly::DensityMap;
+///
+/// let trace = DensityMap::new(vec![45.5017], vec![-73.5673], vec![1.0])
+///     .radius(20)
+///     .name("montreal");
+/// ```
+#[serde_with::skip_serializing_none]
+#[derive(Serialize, Clone, Debug, FieldSetter)]
+#[field_setter(box_self, kind = "trace")]
+pub struct DensityMap<Lat, Lon, Z>
+where
+    Lat: Serialize + Clone,
+    Lon: Serialize + Clone,
+    Z: Serialize + Clone,
+{
+    #[field_setter(default = "PlotType::DensityMap")]
+    r#type: PlotType,
+    /// Sets the trace name. The trace name appears as the legend item and on
+    /// hover.
+    name: Option<String>,
+    /// Determines whether or not this trace is visible.
+    visible: Option<Visible>,
+    /// Determines whether or not an item corresponding to this trace is shown
+    /// in the legend.
+    #[serde(rename = "showlegend")]
+    show_legend: Option<bool>,
+    /// Sets the legend rank for this trace.
+    #[serde(rename = "legendrank")]
+    legend_rank: Option<usize>,
+    /// Sets the legend group for this trace.
+    #[serde(rename = "legendgroup")]
+    legend_group: Option<String>,
+    /// Set and style the title to appear for the legend group.
+    #[serde(rename = "legendgrouptitle")]
+    legend_group_title: Option<LegendGroupTitle>,
+    /// Assigns id labels to each datum.
+    ids: Option<Vec<String>>,
+
+    /// Sets the latitude coordinates (in degrees North).
+    lat: Option<Vec<Lat>>,
+    /// Sets the longitude coordinates (in degrees East).
+    lon: Option<Vec<Lon>>,
+    /// Sets the points' weight. For example, a value of 10 would be equivalent
+    /// to having 10 points of weight 1 in the same spot.
+    z: Option<Vec<Z>>,
+    /// Sets the radius of influence of one `lat`/`lon` point in pixels.
+    /// Increasing the value makes the density map smoother, but less detailed.
+    radius: Option<u8>,
+    /// Sets the opacity of the trace.
+    opacity: Option<f64>,
+
+    /// Sets the text elements associated with each (lat,lon,z) triplet.
+    text: Option<Dim<String>>,
+    /// Sets the hover text elements associated with each (lat,lon,z) triplet.
+    #[serde(rename = "hovertext")]
+    hover_text: Option<Dim<String>>,
+    /// Determines which trace information appears on hover.
+    #[serde(rename = "hoverinfo")]
+    hover_info: Option<HoverInfo>,
+    /// Template string used for rendering the information that appears on the
+    /// hover box.
+    #[serde(rename = "hovertemplate")]
+    hover_template: Option<Dim<String>>,
+    #[serde(rename = "hovertemplatefallback")]
+    hover_template_fallback: Option<Dim<String>>,
+    /// Properties of the hover label.
+    #[serde(rename = "hoverlabel")]
+    hover_label: Option<Label>,
+
+    /// Determines whether or not the color domain is computed with respect to
+    /// the input data (here in `z`) or the bounds set in `zmin` and `zmax`.
+    #[serde(rename = "zauto")]
+    z_auto: Option<bool>,
+    /// Sets the lower bound of the color domain.
+    #[serde(rename = "zmin")]
+    z_min: Option<f64>,
+    /// Sets the upper bound of the color domain.
+    #[serde(rename = "zmax")]
+    z_max: Option<f64>,
+    /// Sets the mid-point of the color domain.
+    #[serde(rename = "zmid")]
+    z_mid: Option<f64>,
+    /// Sets the colorscale.
+    #[serde(rename = "colorscale")]
+    color_scale: Option<ColorScale>,
+    /// Determines whether the colorscale is a default palette.
+    #[serde(rename = "autocolorscale")]
+    auto_color_scale: Option<bool>,
+    /// Reverses the color mapping if true.
+    #[serde(rename = "reversescale")]
+    reverse_scale: Option<bool>,
+    /// Determines whether or not a colorbar is displayed for this trace.
+    #[serde(rename = "showscale")]
+    show_scale: Option<bool>,
+    /// Properties of the colorbar.
+    #[serde(rename = "colorbar")]
+    color_bar: Option<ColorBar>,
+    /// Sets a reference to a shared color axis.
+    #[serde(rename = "coloraxis")]
+    color_axis: Option<String>,
+
+    /// Sets a reference to the `map` subplot this trace is drawn on. Defaults
+    /// to `"map"`.
+    subplot: Option<String>,
+    /// Determines if this trace's layer is inserted below the layer with the
+    /// specified ID. By default, the layer is inserted above every existing
+    /// layer.
+    below: Option<String>,
+
+    /// Assigns extra meta information associated with this trace.
+    meta: Option<NumOrString>,
+    /// Assigns extra data to each datum.
+    #[serde(rename = "customdata")]
+    custom_data: Option<NumOrStringCollection>,
+    /// Controls persistence of some user-driven changes to the trace.
+    #[serde(rename = "uirevision")]
+    ui_revision: Option<NumOrString>,
+}
+
+impl<Lat, Lon, Z> DensityMap<Lat, Lon, Z>
+where
+    Lat: Serialize + Clone + std::default::Default,
+    Lon: Serialize + Clone + std::default::Default,
+    Z: Serialize + Clone + std::default::Default,
+{
+    pub fn new(lat: Vec<Lat>, lon: Vec<Lon>, z: Vec<Z>) -> Box<Self> {
+        Box::new(Self {
+            lat: Some(lat),
+            lon: Some(lon),
+            z: Some(z),
+            ..Default::default()
+        })
+    }
+}
+
+impl<Lat, Lon, Z> Trace for DensityMap<Lat, Lon, Z>
+where
+    Lat: Serialize + Clone,
+    Lon: Serialize + Clone,
+    Z: Serialize + Clone,
+{
+    fn to_json(&self) -> String {
+        serde_json::to_string(&self).unwrap()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use serde_json::{json, to_value};
+
+    use super::*;
+    use crate::common::ColorScalePalette;
+
+    #[test]
+    fn serialize_density_map() {
+        let trace = DensityMap::new(vec![45.5017], vec![-73.5673], vec![1.0])
+            .name("montreal")
+            .radius(20)
+            .opacity(0.5)
+            .hover_text_array(vec!["Montreal"])
+            .hover_info(HoverInfo::Text)
+            .color_scale(ColorScale::Palette(ColorScalePalette::Viridis))
+            .show_scale(true)
+            .subplot("map")
+            .below("");
+
+        let expected = json!({
+            "type": "densitymap",
+            "lat": [45.5017],
+            "lon": [-73.5673],
+            "z": [1.0],
+            "name": "montreal",
+            "radius": 20,
+            "opacity": 0.5,
+            "hovertext": ["Montreal"],
+            "hoverinfo": "text",
+            "colorscale": "Viridis",
+            "showscale": true,
+            "subplot": "map",
+            "below": "",
+        });
+
+        assert_eq!(to_value(trace).unwrap(), expected);
+    }
+}
diff --git a/plotly/src/traces/density_mapbox.rs b/plotly/src/traces/density_mapbox.rs
index 30dac55a..f19b885c 100644
--- a/plotly/src/traces/density_mapbox.rs
+++ b/plotly/src/traces/density_mapbox.rs
@@ -3,7 +3,10 @@
 use plotly_derive::FieldSetter;
 use serde::Serialize;
 
-use crate::common::{LegendGroupTitle, Line, PlotType, Visible};
+use crate::common::{
+    ColorBar, ColorScale, Dim, HoverInfo, Label, LegendGroupTitle, Line, PlotType, Visible,
+};
+use crate::private::{NumOrString, NumOrStringCollection};
 use crate::Trace;
 
 #[serde_with::skip_serializing_none]
@@ -49,6 +52,10 @@ where
     /// Line display properties.
     line: Option<Line>,
 
+    /// Assigns id labels to each datum. These ids are for object constancy of
+    /// data points during animation.
+    ids: Option<Vec<String>>,
+
     lat: Option<Vec<Lat>>,
     lon: Option<Vec<Lon>>,
     z: Option<Vec<Z>>,
@@ -56,6 +63,48 @@ where
     /// Sets the opacity of the trace.
     opacity: Option<f64>,
 
+    /// Sets text elements associated with each (lat,lon,z) triplet. If a single
+    /// string, the same string appears over all the data points. If an array of
+    /// strings, the items are mapped in order to the data points. To be seen,
+    /// the trace `hover_info` must contain a "text" flag.
+    text: Option<Dim<String>>,
+
+    /// Sets hover text elements associated with each (lat,lon,z) triplet. If a
+    /// single string, the same string appears over all the data points. If an
+    /// array of strings, the items are mapped in order to the data points. To
+    /// be seen, the trace `hover_info` must contain a "text" flag.
+    #[serde(rename = "hovertext")]
+    hover_text: Option<Dim<String>>,
+
+    /// Determines which trace information appears on hover.
+    #[serde(rename = "hoverinfo")]
+    hover_info: Option<HoverInfo>,
+
+    /// Template string used for rendering the information that appear on hover
+    /// box. Note that this will override `hover_info`. Variables are inserted
+    /// using %{variable}, for example "y: %{y}".
+    #[serde(rename = "hovertemplate")]
+    hover_template: Option<Dim<String>>,
+
+    /// Fallback string used for rendering the information that appear on hover
+    /// box when the `hover_template` cannot be evaluated.
+    #[serde(rename = "hovertemplatefallback")]
+    hover_template_fallback: Option<Dim<String>>,
+
+    /// Properties of label displayed on mouse hover.
+    #[serde(rename = "hoverlabel")]
+    hover_label: Option<Label>,
+
+    /// Assigns extra meta information associated with this trace that can be
+    /// used in various text attributes.
+    meta: Option<NumOrString>,
+
+    /// Assigns extra data each datum. This may be useful when listening to
+    /// hover, click and selection events. Note that, "scatter" traces also
+    /// appends customdata items in the markers DOM elements.
+    #[serde(rename = "customdata")]
+    custom_data: Option<NumOrStringCollection>,
+
     /// Sets a reference between this trace's data coordinates and a mapbox
     /// subplot. If "mapbox" (the default value), the data refer to
     /// `layout.mapbox`. If "mapbox2", the data refer to `layout.mapbox2`, and
@@ -79,8 +128,46 @@ where
     zoom: Option<u8>,
 
     radius: Option<u8>,
-    //color_continuous_scale: Option<HashMap<Z, NamedColor>>,
-    //color_continuous_midpoint: Option<ContinuousColorScale>,
+
+    /// Sets the colorscale. The colorscale must be an array containing arrays
+    /// mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named
+    /// color string.
+    #[serde(rename = "colorscale")]
+    color_scale: Option<ColorScale>,
+
+    /// Determines whether the colorscale is a default palette
+    /// (`auto_color_scale: true`) or the palette determined by `color_scale`.
+    #[serde(rename = "autocolorscale")]
+    auto_color_scale: Option<bool>,
+
+    /// Reverses the color mapping if true. If true, `zmin` will correspond to
+    /// the last color in the array and `zmax` will correspond to the first
+    /// color.
+    #[serde(rename = "reversescale")]
+    reverse_scale: Option<bool>,
+
+    /// Determines whether or not a colorbar is displayed for this trace.
+    #[serde(rename = "showscale")]
+    show_scale: Option<bool>,
+
+    /// Sets the colorbar properties.
+    #[serde(rename = "colorbar")]
+    color_bar: Option<ColorBar>,
+
+    /// Sets a reference to a shared color axis (e.g. "coloraxis",
+    /// "coloraxis2").
+    #[serde(rename = "coloraxis")]
+    color_axis: Option<String>,
+
+    /// Determines if this trace's layer is displayed below the layer with the
+    /// given id. By default, density traces are placed below the first layer of
+    /// type symbol. Set `below` to "" to place it above every other layer.
+    below: Option<String>,
+
+    /// Controls persistence of some user-driven changes to the trace: `visible`
+    /// only. Defaults to `layout.uirevision`.
+    #[serde(rename = "uirevision")]
+    ui_revision: Option<NumOrString>,
 }
 
 impl<Lat, Lon, Z> DensityMapbox<Lat, Lon, Z>
@@ -115,6 +202,7 @@ mod tests {
     use serde_json::{json, to_value};
 
     use super::*;
+    use crate::common::ColorScalePalette;
 
     #[test]
     fn serialize_density_mapbox() {
@@ -126,7 +214,15 @@ mod tests {
             .legend_group("legend group")
             .zoom(5)
             .radius(20)
-            .opacity(0.5);
+            .opacity(0.5)
+            .hover_text_array(vec!["Montreal"])
+            .hover_info(HoverInfo::Text)
+            .hover_template("%{lat}, %{lon}")
+            .custom_data(vec!["Montreal"])
+            .color_scale(ColorScale::Palette(ColorScalePalette::Viridis))
+            .show_scale(true)
+            .reverse_scale(true)
+            .below("");
         let expected = json!({
             "type": "densitymapbox",
             "lat": [45.5017],
@@ -140,6 +236,14 @@ mod tests {
             "opacity": 0.5,
             "zoom": 5,
             "radius": 20,
+            "hovertext": ["Montreal"],
+            "hoverinfo": "text",
+            "hovertemplate": "%{lat}, %{lon}",
+            "customdata": ["Montreal"],
+            "colorscale": "Viridis",
+            "showscale": true,
+            "reversescale": true,
+            "below": "",
         });
         assert_eq!(to_value(density_mapbox.clone()).unwrap(), expected);
     }
diff --git a/plotly/src/traces/mod.rs b/plotly/src/traces/mod.rs
index bc51cef6..850dfe13 100644
--- a/plotly/src/traces/mod.rs
+++ b/plotly/src/traces/mod.rs
@@ -6,6 +6,7 @@ mod candlestick;
 pub mod choropleth;
 pub mod choropleth_map;
 pub mod contour;
+pub mod density_map;
 mod density_mapbox;
 pub mod heat_map;
 pub mod histogram;
@@ -17,12 +18,14 @@ pub mod sankey;
 pub mod scatter;
 pub mod scatter3d;
 pub mod scatter_geo;
+pub mod scatter_map;
 pub mod scatter_mapbox;
 mod scatter_polar;
 pub mod sunburst;
 pub mod surface;
 pub mod table;
 pub mod treemap;
+pub mod violin;
 
 pub use bar::Bar;
 pub use box_plot::BoxPlot;
@@ -30,6 +33,7 @@ pub use candlestick::Candlestick;
 pub use choropleth::Choropleth;
 pub use choropleth_map::ChoroplethMap;
 pub use contour::Contour;
+pub use density_map::DensityMap;
 pub use density_mapbox::DensityMapbox;
 pub use heat_map::HeatMap;
 pub use histogram::Histogram;
@@ -40,11 +44,13 @@ pub use sankey::Sankey;
 pub use scatter::Scatter;
 pub use scatter3d::Scatter3D;
 pub use scatter_geo::ScatterGeo;
+pub use scatter_map::ScatterMap;
 pub use scatter_mapbox::ScatterMapbox;
 pub use scatter_polar::ScatterPolar;
 pub use sunburst::Sunburst;
 pub use surface::Surface;
 pub use table::Table;
 pub use treemap::Treemap;
+pub use violin::Violin;
 
 pub use self::image::Image;
diff --git a/plotly/src/traces/scatter_map.rs b/plotly/src/traces/scatter_map.rs
new file mode 100644
index 00000000..d9f8708f
--- /dev/null
+++ b/plotly/src/traces/scatter_map.rs
@@ -0,0 +1,477 @@
+//! Scatter plot trace for the MapLibre `map` subplot.
+
+use plotly_derive::FieldSetter;
+use serde::Serialize;
+
+use crate::common::{
+    color::Color, Dim, Font, HoverInfo, Label, LegendGroupTitle, Line, Marker, Mode, PlotType,
+    Position, Visible,
+};
+use crate::private::{NumOrString, NumOrStringCollection};
+use crate::Trace;
+
+#[derive(Serialize, Clone, Debug)]
+#[serde(rename_all = "lowercase")]
+pub enum Fill {
+    None,
+    ToSelf,
+}
+
+#[serde_with::skip_serializing_none]
+#[derive(Serialize, Clone, Debug, Default)]
+pub struct SelectionMarker {
+    color: Option<Box<dyn Color>>,
+    opacity: Option<f64>,
+    size: Option<Dim<usize>>,
+}
+
+#[derive(Serialize, Clone, Debug, Default)]
+pub struct Selection {
+    marker: SelectionMarker,
+}
+
+impl Selection {
+    pub fn new() -> Self {
+        Default::default()
+    }
+
+    /// Sets the marker color of un/selected points.
+    pub fn color<C: Color>(mut self, color: C) -> Self {
+        self.marker.color = Some(Box::new(color));
+        self
+    }
+
+    /// Sets the marker opacity of un/selected points.
+    pub fn opacity(mut self, opacity: f64) -> Self {
+        self.marker.opacity = Some(opacity);
+        self
+    }
+
+    /// Sets the marker size of un/selected points.
+    pub fn size(mut self, size: usize) -> Self {
+        self.marker.size = Some(Dim::Scalar(size));
+        self
+    }
+}
+
+/// Native point-clustering options for a [`ScatterMap`] trace.
+///
+/// When enabled, nearby markers are grouped client-side (by MapLibre's
+/// supercluster) into cluster bubbles that progressively expand into individual
+/// points as the map is zoomed in. This declutters dense point maps without
+/// dropping any data — every point still ships in the trace and becomes
+/// individually visible/hoverable at higher zoom levels.
+///
+/// This is a `scattermap`-only feature: the deprecated Mapbox-based
+/// [`ScatterMapbox`](crate::ScatterMapbox) has no equivalent.
+///
+/// # Examples
+///
+/// ```
+/// use plotly::{traces::scatter_map::Cluster, ScatterMap};
+///
+/// let trace = ScatterMap::new(vec![45.5017], vec![-73.5673])
+///     .cluster(Cluster::new().enabled(true));
+/// ```
+#[serde_with::skip_serializing_none]
+#[derive(Serialize, Clone, Debug, FieldSetter)]
+pub struct Cluster {
+    /// Determines whether clustering is enabled or disabled. Defaults to
+    /// `false` unless `color`, `size`, or `step` is set, in which case it
+    /// defaults to `true`.
+    enabled: Option<bool>,
+    /// Sets the color for each cluster step. May be a single color or an array
+    /// of colors (one per step).
+    color: Option<Dim<Box<dyn Color>>>,
+    /// Sets the maximum zoom level (0-24) at which clustering applies. Past
+    /// this zoom, clusters expand into their individual points.
+    #[serde(rename = "maxzoom")]
+    max_zoom: Option<f64>,
+    /// Sets the marker opacity of the cluster bubbles.
+    opacity: Option<f64>,
+    /// Sets the size for each cluster step. May be a single size or an array
+    /// (one per step).
+    size: Option<Dim<usize>>,
+    /// Sets how many points it takes to create a cluster or advance to the next
+    /// cluster step. May be a single number or an array (one per step). A value
+    /// of `-1` (the default) lets MapLibre choose the step thresholds.
+    step: Option<Dim<i32>>,
+}
+
+impl Cluster {
+    pub fn new() -> Self {
+        Default::default()
+    }
+}
+
+/// Construct a scatter trace drawn on the MapLibre `map` subplot
+/// (configured via [`LayoutMap`](crate::layout::LayoutMap)).
+///
+/// `ScatterMap` is the modern MapLibre-based counterpart to
+/// [`ScatterMapbox`](crate::ScatterMapbox): it draws markers and/or lines from
+/// `lat`/`lon` coordinates onto the `layout.map` subplot.
+///
+/// # Examples
+///
+/// ```
+/// use plotly::ScatterMap;
+///
+/// let trace = ScatterMap::new(vec![45.5017], vec![-73.5673]).name("montreal");
+/// ```
+#[serde_with::skip_serializing_none]
+#[derive(Serialize, Clone, Debug, FieldSetter)]
+#[field_setter(box_self, kind = "trace")]
+pub struct ScatterMap<Lat, Lon>
+where
+    Lat: Serialize + Clone,
+    Lon: Serialize + Clone,
+{
+    #[field_setter(default = "PlotType::ScatterMap")]
+    r#type: PlotType,
+    /// Sets the trace name. The trace name appear as the legend item and on
+    /// hover.
+    name: Option<String>,
+    /// Determines whether or not this trace is visible. If
+    /// `Visible::LegendOnly`, the trace is not drawn, but can appear as a
+    /// legend item (provided that the legend itself is visible).
+    visible: Option<Visible>,
+
+    /// Determines whether or not an item corresponding to this trace is shown
+    /// in the legend.
+    #[serde(rename = "showlegend")]
+    show_legend: Option<bool>,
+    /// Sets the legend rank for this trace. Items and groups with smaller ranks
+    /// are presented on top/left side while with `"reversed"
+    /// `legend.trace_order` they are on bottom/right side. The default
+    /// legendrank is 1000, so that you can use ranks less than 1000 to
+    /// place certain items before all unranked items, and ranks greater
+    /// than 1000 to go after all unranked items.
+    #[serde(rename = "legendrank")]
+    legend_rank: Option<usize>,
+    /// Sets the legend group for this trace. Traces part of the same legend
+    /// group show/hide at the same time when toggling legend items.
+    #[serde(rename = "legendgroup")]
+    legend_group: Option<String>,
+    /// Set and style the title to appear for the legend group.
+    #[serde(rename = "legendgrouptitle")]
+    legend_group_title: Option<LegendGroupTitle>,
+
+    /// Sets the opacity of the trace.
+    opacity: Option<f64>,
+    /// Determines the drawing mode for this scatter trace. If the provided
+    /// `Mode` includes "Text" then the `text` elements appear at the
+    /// coordinates. Otherwise, the `text` elements appear on hover. If
+    /// there are less than 20 points and the trace is not stacked then the
+    /// default is `Mode::LinesMarkers`, otherwise it is `Mode::Lines`.
+    mode: Option<Mode>,
+    /// Assigns id labels to each datum. These ids for object constancy of data
+    /// points during animation. Should be an array of strings, not numbers
+    /// or any other type.
+    ids: Option<Vec<String>>,
+
+    lat: Option<Vec<Lat>>,
+    lon: Option<Vec<Lon>>,
+
+    /// Sets text elements associated with each (x,y) pair. If a single string,
+    /// the same string appears over all the data points. If an array of
+    /// strings, the items are mapped in order to the this trace's (x,y)
+    /// coordinates. If the trace `HoverInfo` contains a "text" flag and
+    /// `hover_text` is not set, these elements will be seen in the hover
+    /// labels.
+    text: Option<Dim<String>>,
+    /// Sets the positions of the `text` elements with respects to the (x,y)
+    /// coordinates.
+    #[serde(rename = "textposition")]
+    text_position: Option<Dim<Position>>,
+    /// Template string used for rendering the information text that appear on
+    /// points. Note that this will override `textinfo`. Variables are
+    /// inserted using %{variable}, for example "y: %{y}". Numbers are
+    /// formatted using d3-format's syntax %{variable:d3-format}, for example "Price: %{y:$.2f}". See [format](https://github.com/d3/d3-3.x-api-reference/blob/master/Formatting.md#d3)
+    /// for details on the formatting syntax. Dates are formatted using
+    /// d3-time-format's syntax %{variable|d3-time-format}, for example
+    /// "Day: %{2019-01-01|%A}". See [format](https://github.com/d3/d3-3.x-api-reference/blob/master/Time-Formatting.md#format) for details
+    /// on the date formatting syntax. Every attributes that can be specified
+    /// per-point (the ones that are `arrayOk: true`) are available.
+    #[serde(rename = "texttemplate")]
+    text_template: Option<Dim<String>>,
+    #[serde(rename = "texttemplatefallback")]
+    text_template_fallback: Option<Dim<String>>,
+    /// Sets hover text elements associated with each (x,y) pair. If a single
+    /// string, the same string appears over all the data points. If an
+    /// array of string, the items are mapped in order to the this trace's
+    /// (x,y) coordinates. To be seen, trace `HoverInfo` must contain a
+    /// "Text" flag.
+    #[serde(rename = "hovertext")]
+    hover_text: Option<Dim<String>>,
+    /// Determines which trace information appear on hover. If `HoverInfo::None`
+    /// or `HoverInfo::Skip` are set, no information is displayed upon
+    /// hovering. But, if `HoverInfo::None` is set, click and hover events
+    /// are still fired.
+    #[serde(rename = "hoverinfo")]
+    hover_info: Option<HoverInfo>,
+    /// Template string used for rendering the information that appear on hover
+    /// box. Note that this will override `HoverInfo`. Variables are
+    /// inserted using %{variable}, for example "y: %{y}". Numbers are
+    /// formatted using d3-format's syntax %{variable:d3-format}, for example
+    /// "Price: %{y:$.2f}".
+    /// <https://github.com/d3/d3-3.x-api-reference/blob/master/Formatting.md#d3_format> for details
+    /// on the formatting syntax. Dates are formatted using d3-time-format's
+    /// syntax %{variable|d3-time-format}, for example "Day:
+    /// %{2019-01-01|%A}". <https://github.com/d3/d3-3.x-api-reference/blob/master/Time-Formatting.md#format> for details
+    /// on the date formatting syntax. The variables available in
+    /// `hovertemplate` are the ones emitted as event data described at this link <https://plotly.com/javascript/plotlyjs-events/#event-data>.
+    /// Additionally, every attributes that can be specified per-point (the ones
+    /// that are `arrayOk: true`) are available. Anything contained in tag
+    /// `<extra>` is displayed in the secondary box, for example
+    /// "<extra>{fullData.name}</extra>". To hide the secondary box
+    /// completely, use an empty tag `<extra></extra>`.
+    #[serde(rename = "hovertemplate")]
+    hover_template: Option<Dim<String>>,
+    #[serde(rename = "hovertemplatefallback")]
+    hover_template_fallback: Option<Dim<String>>,
+
+    /// Assigns extra meta information associated with this trace that can be
+    /// used in various text attributes. Attributes such as trace `name`,
+    /// graph, axis and colorbar `title.text`, annotation `text`
+    /// `rangeselector`, `updatemenues` and `sliders` `label` text all support
+    /// `meta`. To access the trace `meta` values in an attribute in the same
+    /// trace, simply use `%{meta[i]}` where `i` is the index or key of the
+    /// `meta` item in question. To access trace `meta` in layout
+    /// attributes, use `%{data[n[.meta[i]}` where `i` is the index or key of
+    /// the `meta` and `n` is the trace index.
+    meta: Option<NumOrString>,
+    /// Assigns extra data each datum. This may be useful when listening to
+    /// hover, click and selection events. Note that, "scatter" traces also
+    /// appends customdata items in the markers DOM elements.
+    #[serde(rename = "customdata")]
+    custom_data: Option<NumOrStringCollection>,
+
+    /// Sets a reference between this trace's data coordinates and a `map`
+    /// subplot. If "map" (the default value), the data refer to `layout.map`.
+    /// If "map2", the data refer to `layout.map2`, and so on.
+    subplot: Option<String>,
+    /// Determines how points are displayed and joined.
+    marker: Option<Marker>,
+
+    /// Line display properties.
+    line: Option<Line>,
+
+    /// Native point-clustering options. When enabled, nearby markers are
+    /// grouped into clusters that expand into individual points as the map is
+    /// zoomed in.
+    cluster: Option<Cluster>,
+
+    /// Sets the text font.
+    #[serde(rename = "textfont")]
+    text_font: Option<Font>,
+
+    /// Vector containing integer indices of selected points. Has an effect only
+    /// for traces that support selections. Note that an empty vector means
+    /// an empty selection where the `unselected` are turned on for all
+    /// points.
+    #[serde(rename = "selectedpoints")]
+    selected_points: Option<Vec<usize>>,
+
+    /// Sets the style of selected points.
+    selected: Option<Selection>,
+    /// Sets the style of unselected points.
+    unselected: Option<Selection>,
+
+    /// Determines if this scattermap trace's layers are to be inserted before
+    /// the layer with the specified ID. By default, scattermap layers are
+    /// inserted above all the base layers. To place the scattermap layers
+    /// above every other layer, set `below` to "''".
+    below: Option<String>,
+    /// Determines whether or not gaps (i.e. {nan} or missing values) in the
+    /// provided data arrays are connected.
+    #[serde(rename = "connectgaps")]
+    connect_gaps: Option<bool>,
+
+    /// Sets the area to fill with a solid color. Defaults to "none" unless this
+    /// trace is stacked, then it gets "tonexty" ("tonextx") if
+    /// `orientation` is "v" ("h") Use with `fillcolor` if not
+    /// "none". "tozerox" and "tozeroy" fill to x=0 and y=0 respectively.
+    /// "tonextx" and "tonexty" fill between the endpoints of this trace and
+    /// the endpoints of the trace before it, connecting those endpoints
+    /// with straight lines (to make a stacked area graph); if there is
+    /// no trace before it, they behave like "tozerox" and "tozeroy". "toself"
+    /// connects the endpoints of the trace (or each segment of the trace if
+    /// it has gaps) into a closed shape. "tonext" fills the space between
+    /// two traces if one completely encloses the other (eg consecutive
+    /// contour lines), and behaves like "toself" if there is no trace before
+    /// it. "tonext" should not be used if one trace does not enclose the
+    /// other. Traces in a `stackgroup` will only fill to (or be filled to)
+    /// other traces in the same group. With multiple `stackgroup`s or some
+    /// traces stacked and some not, if fill-linked traces are not
+    /// already consecutive, the later ones will be pushed down in the drawing
+    /// order.
+    fill: Option<Fill>,
+    /// Sets the fill color. Defaults to a half-transparent variant of the line
+    /// color, marker color, or marker line color, whichever is available.
+    #[serde(rename = "fillcolor")]
+    fill_color: Option<Box<dyn Color>>,
+    /// Properties of label displayed on mouse hover.
+    #[serde(rename = "hoverlabel")]
+    hover_label: Option<Label>,
+
+    /// Controls persistence of some user-driven changes to the trace:
+    /// `constraintrange` in `parcoords` traces, as well as some `editable:
+    /// True` modifications such as `name` and `colorbar.title`. Defaults to
+    /// `layout.uirevision`. Note that other user-driven trace attribute changes
+    /// are controlled by `layout` attributes: `trace.visible` is controlled
+    /// by `layout.legend.uirevision`, `selectedpoints` is controlled
+    /// by `layout.selectionrevision`, and `colorbar.(x|y)` (accessible with
+    /// `config: {editable: True}`) is controlled by `layout.editrevision`.
+    /// Trace changes are tracked by `uid`, which only falls back on trace
+    /// index if no `uid` is provided. So if your app can add/remove traces
+    /// before the end of the `data` array, such that the same trace has a
+    /// different index, you can still preserve user-driven changes if you give
+    /// each trace a `uid` that stays with it as it moves.
+    #[serde(rename = "uirevision")]
+    ui_revision: Option<NumOrString>,
+}
+
+impl<Lat, Lon> ScatterMap<Lat, Lon>
+where
+    Lat: Serialize + Clone + std::default::Default,
+    Lon: Serialize + Clone + std::default::Default,
+{
+    pub fn new(lat: Vec<Lat>, lon: Vec<Lon>) -> Box<Self> {
+        Box::new(Self {
+            lat: Some(lat),
+            lon: Some(lon),
+            ..Default::default()
+        })
+    }
+}
+
+impl<Lat, Lon> Trace for ScatterMap<Lat, Lon>
+where
+    Lat: Serialize + Clone,
+    Lon: Serialize + Clone,
+{
+    fn to_json(&self) -> String {
+        serde_json::to_string(&self).unwrap()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use serde_json::{json, to_value};
+
+    use super::*;
+
+    #[test]
+    fn serialize_fill() {
+        assert_eq!(to_value(Fill::None).unwrap(), json!("none"));
+        assert_eq!(to_value(Fill::ToSelf).unwrap(), json!("toself"));
+    }
+
+    #[test]
+    fn serialize_selection() {
+        let selection = Selection::new().color("#123456").opacity(0.5).size(6);
+        let expected = json!({"marker": {"color": "#123456", "opacity": 0.5, "size": 6}});
+
+        assert_eq!(to_value(selection).unwrap(), expected);
+    }
+
+    #[test]
+    fn serialize_cluster() {
+        let cluster = Cluster::new()
+            .enabled(true)
+            .color("#112233")
+            .max_zoom(12.0)
+            .opacity(0.8)
+            .size(20)
+            .step(50);
+        let expected = json!({
+            "enabled": true,
+            "color": "#112233",
+            "maxzoom": 12.0,
+            "opacity": 0.8,
+            "size": 20,
+            "step": 50,
+        });
+
+        assert_eq!(to_value(cluster).unwrap(), expected);
+    }
+
+    #[test]
+    fn serialize_scatter_map() {
+        let scatter_map = ScatterMap::new(vec![45.5017], vec![-73.5673])
+            .name("name")
+            .visible(Visible::True)
+            .show_legend(true)
+            .legend_rank(1000)
+            .legend_group("legend group")
+            .legend_group_title("Legend Group Title")
+            .opacity(0.5)
+            .mode(Mode::LinesText)
+            .ids(vec!["one"])
+            .text("text")
+            .text_array(vec!["text"])
+            .text_position(Position::BottomLeft)
+            .text_position_array(vec![Position::TopCenter])
+            .text_template("text_template")
+            .text_template_array(vec!["text_template"])
+            .hover_text("hover_text")
+            .hover_text_array(vec!["hover_text"])
+            .hover_info(HoverInfo::XAndYAndZ)
+            .hover_template("hover_template")
+            .hover_template_array(vec!["hover_template"])
+            .meta("meta")
+            .custom_data(vec!["custom_data"])
+            .subplot("map")
+            .marker(Marker::new())
+            .line(Line::new())
+            .cluster(Cluster::new().enabled(true))
+            .text_font(Font::new())
+            .selected_points(vec![0])
+            .selected(Selection::new().color("#111111"))
+            .unselected(Selection::new().color("#777777"))
+            .below("")
+            .connect_gaps(false)
+            .fill(Fill::None)
+            .fill_color("#ff0000aa")
+            .hover_label(Label::new())
+            .ui_revision(6);
+        let expected = json!({
+            "type": "scattermap",
+            "lat": [45.5017],
+            "lon": [-73.5673],
+            "name": "name",
+            "visible": true,
+            "showlegend": true,
+            "legendrank": 1000,
+            "legendgroup": "legend group",
+            "legendgrouptitle": {"text": "Legend Group Title"},
+            "opacity": 0.5,
+            "mode": "lines+text",
+            "ids": ["one"],
+            "text": ["text"],
+            "textposition": ["top center"],
+            "texttemplate": ["text_template"],
+            "hovertext": ["hover_text"],
+            "hoverinfo": "x+y+z",
+            "hovertemplate": ["hover_template"],
+            "meta": "meta",
+            "customdata": ["custom_data"],
+            "subplot": "map",
+            "marker": {},
+            "line": {},
+            "cluster": {"enabled": true},
+            "textfont": {},
+            "selectedpoints": [0],
+            "selected": {"marker": {"color": "#111111"}},
+            "unselected": {"marker": {"color": "#777777"}},
+            "below": "",
+            "connectgaps": false,
+            "fill": "none",
+            "fillcolor": "#ff0000aa",
+            "hoverlabel": {},
+            "uirevision": 6,
+        });
+
+        assert_eq!(to_value(scatter_map).unwrap(), expected);
+    }
+}
diff --git a/plotly/src/traces/violin.rs b/plotly/src/traces/violin.rs
new file mode 100644
index 00000000..f5575b4b
--- /dev/null
+++ b/plotly/src/traces/violin.rs
@@ -0,0 +1,502 @@
+//! Violin trace
+
+use plotly_derive::FieldSetter;
+use serde::{Serialize, Serializer};
+
+// Re-use the box plot's quartile method, whose values (linear/exclusive/inclusive)
+// are identical to the violin trace's `quartilemethod` attribute.
+pub use super::box_plot::QuartileMethod;
+use crate::{
+    color::Color,
+    common::{
+        Dim, HoverInfo, Label, LegendGroupTitle, Line, Marker, Orientation, PlotType, Visible,
+        XAxisId, YAxisId,
+    },
+    private::{NumOrString, NumOrStringCollection},
+    Trace,
+};
+
+/// Determines which sample points are shown alongside the violin(s).
+#[derive(Debug, Clone)]
+pub enum ViolinPoints {
+    All,
+    Outliers,
+    SuspectedOutliers,
+    False,
+}
+
+impl Serialize for ViolinPoints {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match *self {
+            Self::All => serializer.serialize_str("all"),
+            Self::Outliers => serializer.serialize_str("outliers"),
+            Self::SuspectedOutliers => serializer.serialize_str("suspectedoutliers"),
+            Self::False => serializer.serialize_bool(false),
+        }
+    }
+}
+
+/// Sets the metric by which the width of each violin is determined.
+#[derive(Serialize, Debug, Clone)]
+#[serde(rename_all = "lowercase")]
+pub enum ScaleMode {
+    Width,
+    Count,
+}
+
+/// Sets the method by which the span in data space (where the density function
+/// is computed) is determined.
+#[derive(Serialize, Debug, Clone)]
+#[serde(rename_all = "lowercase")]
+pub enum SpanMode {
+    Soft,
+    Hard,
+    Manual,
+}
+
+/// Determines on which side of the position value the density function making
+/// up one half of a violin is plotted.
+#[derive(Serialize, Debug, Clone)]
+#[serde(rename_all = "lowercase")]
+pub enum ViolinSide {
+    Both,
+    Positive,
+    Negative,
+}
+
+/// Determines what the hover interactions highlight.
+#[derive(Serialize, Clone, Debug)]
+#[serde(rename_all = "lowercase")]
+pub enum HoverOn {
+    Violins,
+    Points,
+    Kde,
+    #[serde(rename = "violins+points")]
+    ViolinsAndPoints,
+    #[serde(rename = "violins+points+kde")]
+    ViolinsPointsAndKde,
+    All,
+}
+
+/// A miniature box plot drawn inside the violins.
+#[serde_with::skip_serializing_none]
+#[derive(Serialize, Clone, Debug, FieldSetter)]
+pub struct ViolinBox {
+    visible: Option<bool>,
+    width: Option<f64>,
+    #[serde(rename = "fillcolor")]
+    fill_color: Option<Box<dyn Color>>,
+    line: Option<Line>,
+}
+
+impl ViolinBox {
+    pub fn new() -> Self {
+        Default::default()
+    }
+}
+
+/// A line corresponding to the sample's mean, drawn inside the violins.
+#[serde_with::skip_serializing_none]
+#[derive(Serialize, Clone, Debug, FieldSetter)]
+pub struct MeanLine {
+    visible: Option<bool>,
+    color: Option<Box<dyn Color>>,
+    width: Option<f64>,
+}
+
+impl MeanLine {
+    pub fn new() -> Self {
+        Default::default()
+    }
+}
+
+/// Marker styling for selected or unselected points.
+#[serde_with::skip_serializing_none]
+#[derive(Serialize, Clone, Debug, FieldSetter)]
+pub struct SelectionMarker {
+    color: Option<Box<dyn Color>>,
+    size: Option<f64>,
+    opacity: Option<f64>,
+}
+
+impl SelectionMarker {
+    pub fn new() -> Self {
+        Default::default()
+    }
+}
+
+/// Sets the styling of selected or unselected points.
+#[serde_with::skip_serializing_none]
+#[derive(Serialize, Clone, Debug, FieldSetter)]
+pub struct Selection {
+    marker: Option<SelectionMarker>,
+}
+
+impl Selection {
+    pub fn new() -> Self {
+        Default::default()
+    }
+}
+
+/// Construct a violin trace.
+///
+/// # Examples
+///
+/// ```
+/// use plotly::Violin;
+///
+/// let trace = Violin::new(vec![0, 1, 2, 3, 4, 5])
+///     .box_plot(plotly::violin::ViolinBox::new().visible(true))
+///     .mean_line(plotly::violin::MeanLine::new().visible(true));
+///
+/// let expected = serde_json::json!({
+///     "type": "violin",
+///     "y": [0, 1, 2, 3, 4, 5],
+///     "box": {"visible": true},
+///     "meanline": {"visible": true}
+/// });
+///
+/// assert_eq!(serde_json::to_value(trace).unwrap(), expected);
+/// ```
+#[serde_with::skip_serializing_none]
+#[derive(Serialize, Debug, Clone, FieldSetter)]
+#[field_setter(box_self, kind = "trace")]
+pub struct Violin<X, Y>
+where
+    X: Serialize + Clone,
+    Y: Serialize + Clone,
+{
+    #[field_setter(default = "PlotType::Violin")]
+    r#type: PlotType,
+    x: Option<Vec<X>>,
+    y: Option<Vec<Y>>,
+    x0: Option<NumOrString>,
+    y0: Option<NumOrString>,
+    name: Option<String>,
+    visible: Option<Visible>,
+    #[serde(rename = "showlegend")]
+    show_legend: Option<bool>,
+    #[serde(rename = "legendgroup")]
+    legend_group: Option<String>,
+    #[serde(rename = "legendgrouptitle")]
+    legend_group_title: Option<LegendGroupTitle>,
+    opacity: Option<f64>,
+    ids: Option<Vec<String>>,
+    width: Option<f64>,
+    text: Option<Dim<String>>,
+    #[serde(rename = "hovertext")]
+    hover_text: Option<Dim<String>>,
+    #[serde(rename = "hoverinfo")]
+    hover_info: Option<HoverInfo>,
+    #[serde(rename = "hovertemplate")]
+    hover_template: Option<Dim<String>>,
+    #[serde(rename = "hovertemplatefallback")]
+    hover_template_fallback: Option<Dim<String>>,
+    #[serde(rename = "xhoverformat")]
+    x_hover_format: Option<String>,
+    #[serde(rename = "yhoverformat")]
+    y_hover_format: Option<String>,
+    #[serde(rename = "xaxis")]
+    x_axis: Option<XAxisId>,
+    #[serde(rename = "yaxis")]
+    y_axis: Option<YAxisId>,
+    orientation: Option<Orientation>,
+    #[serde(rename = "alignmentgroup")]
+    alignment_group: Option<String>,
+    #[serde(rename = "offsetgroup")]
+    offset_group: Option<String>,
+    marker: Option<Marker>,
+    line: Option<Line>,
+    #[serde(rename = "fillcolor")]
+    fill_color: Option<Box<dyn Color>>,
+    points: Option<ViolinPoints>,
+    jitter: Option<f64>,
+    #[serde(rename = "pointpos")]
+    point_pos: Option<f64>,
+    selected: Option<Selection>,
+    unselected: Option<Selection>,
+    #[serde(rename = "hoverlabel")]
+    hover_label: Option<Label>,
+    #[serde(rename = "hoveron")]
+    hover_on: Option<HoverOn>,
+    #[serde(rename = "box")]
+    box_plot: Option<ViolinBox>,
+    #[serde(rename = "meanline")]
+    mean_line: Option<MeanLine>,
+    bandwidth: Option<f64>,
+    #[serde(rename = "scalegroup")]
+    scale_group: Option<String>,
+    #[serde(rename = "scalemode")]
+    scale_mode: Option<ScaleMode>,
+    side: Option<ViolinSide>,
+    span: Option<NumOrStringCollection>,
+    #[serde(rename = "spanmode")]
+    span_mode: Option<SpanMode>,
+    #[serde(rename = "quartilemethod")]
+    quartile_method: Option<QuartileMethod>,
+    #[serde(rename = "zorder")]
+    z_order: Option<i32>,
+}
+
+impl<Y> Violin<f64, Y>
+where
+    Y: Serialize + Clone,
+{
+    pub fn new(y: Vec<Y>) -> Box<Violin<f64, Y>> {
+        Box::new(Violin {
+            y: Some(y),
+            ..Default::default()
+        })
+    }
+}
+
+impl<X, Y> Violin<X, Y>
+where
+    X: Serialize + Clone,
+    Y: Serialize + Clone,
+{
+    pub fn new_xy(x: Vec<X>, y: Vec<Y>) -> Box<Self> {
+        Box::new(Violin {
+            x: Some(x),
+            y: Some(y),
+            ..Default::default()
+        })
+    }
+}
+
+impl<X, Y> Trace for Violin<X, Y>
+where
+    X: Serialize + Clone,
+    Y: Serialize + Clone,
+{
+    fn to_json(&self) -> String {
+        serde_json::to_string(self).unwrap()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use serde_json::{json, to_value};
+
+    use super::*;
+
+    #[test]
+    #[rustfmt::skip]
+    fn serialize_violin_points() {
+        assert_eq!(to_value(ViolinPoints::All).unwrap(), json!("all"));
+        assert_eq!(to_value(ViolinPoints::Outliers).unwrap(), json!("outliers"));
+        assert_eq!(to_value(ViolinPoints::SuspectedOutliers).unwrap(), json!("suspectedoutliers"));
+        assert_eq!(to_value(ViolinPoints::False).unwrap(), json!(false));
+    }
+
+    #[test]
+    fn serialize_scale_mode() {
+        assert_eq!(to_value(ScaleMode::Width).unwrap(), json!("width"));
+        assert_eq!(to_value(ScaleMode::Count).unwrap(), json!("count"));
+    }
+
+    #[test]
+    fn serialize_span_mode() {
+        assert_eq!(to_value(SpanMode::Soft).unwrap(), json!("soft"));
+        assert_eq!(to_value(SpanMode::Hard).unwrap(), json!("hard"));
+        assert_eq!(to_value(SpanMode::Manual).unwrap(), json!("manual"));
+    }
+
+    #[test]
+    fn serialize_span_numeric_and_dates() {
+        // Numeric span (typical case).
+        let numeric = Violin::new(vec![1, 2, 3]).span(vec![0., 10.]);
+        assert_eq!(to_value(numeric).unwrap()["span"], json!([0.0, 10.0]));
+
+        // Date/string span for date-valued axes (plotly.js types `span` as `any`).
+        let dated = Violin::new(vec![1, 2, 3])
+            .span_mode(SpanMode::Manual)
+            .span(vec!["2020-01-01", "2020-12-31"]);
+        assert_eq!(
+            to_value(dated).unwrap()["span"],
+            json!(["2020-01-01", "2020-12-31"])
+        );
+    }
+
+    #[test]
+    fn serialize_violin_side() {
+        assert_eq!(to_value(ViolinSide::Both).unwrap(), json!("both"));
+        assert_eq!(to_value(ViolinSide::Positive).unwrap(), json!("positive"));
+        assert_eq!(to_value(ViolinSide::Negative).unwrap(), json!("negative"));
+    }
+
+    #[test]
+    #[rustfmt::skip]
+    fn serialize_hover_on() {
+        assert_eq!(to_value(HoverOn::Violins).unwrap(), json!("violins"));
+        assert_eq!(to_value(HoverOn::Points).unwrap(), json!("points"));
+        assert_eq!(to_value(HoverOn::Kde).unwrap(), json!("kde"));
+        assert_eq!(to_value(HoverOn::ViolinsAndPoints).unwrap(), json!("violins+points"));
+        assert_eq!(to_value(HoverOn::ViolinsPointsAndKde).unwrap(), json!("violins+points+kde"));
+        assert_eq!(to_value(HoverOn::All).unwrap(), json!("all"));
+    }
+
+    #[test]
+    fn serialize_violin_box() {
+        let violin_box = ViolinBox::new()
+            .visible(true)
+            .width(0.3)
+            .fill_color("#ff0000")
+            .line(Line::new());
+        let expected = json!({
+            "visible": true,
+            "width": 0.3,
+            "fillcolor": "#ff0000",
+            "line": {}
+        });
+
+        assert_eq!(to_value(violin_box).unwrap(), expected);
+    }
+
+    #[test]
+    fn serialize_mean_line() {
+        let mean_line = MeanLine::new().visible(true).color("#00ff00").width(2.0);
+        let expected = json!({
+            "visible": true,
+            "color": "#00ff00",
+            "width": 2.0
+        });
+
+        assert_eq!(to_value(mean_line).unwrap(), expected);
+    }
+
+    #[test]
+    fn serialize_selection() {
+        let selection = Selection::new().marker(
+            SelectionMarker::new()
+                .color("#0000ff")
+                .size(8.0)
+                .opacity(0.5),
+        );
+        let expected = json!({
+            "marker": {"color": "#0000ff", "size": 8.0, "opacity": 0.5}
+        });
+
+        assert_eq!(to_value(selection).unwrap(), expected);
+    }
+
+    #[test]
+    fn default_violin() {
+        let trace: Violin<i32, i32> = Violin::default();
+        let expected = json!({"type": "violin"}).to_string();
+
+        assert_eq!(trace.to_json(), expected);
+    }
+
+    #[test]
+    fn violin_new() {
+        let trace = Violin::new(vec![0.0, 0.1]);
+        let expected = json!({
+            "type": "violin",
+            "y": [0.0, 0.1]
+        });
+
+        assert_eq!(to_value(trace).unwrap(), expected);
+    }
+
+    #[test]
+    fn serialize_violin() {
+        let trace = Violin::new_xy(vec![1, 2, 3], vec![4, 5, 6])
+            .alignment_group("alignment_group")
+            .bandwidth(0.2)
+            .box_plot(ViolinBox::new().visible(true))
+            .fill_color("#522622")
+            .hover_info(HoverInfo::Name)
+            .hover_label(Label::new())
+            .hover_on(HoverOn::ViolinsPointsAndKde)
+            .hover_template("templ2")
+            .hover_template_array(vec!["templ1", "templ2"])
+            .hover_text("ok")
+            .hover_text_array(vec!["okey", "dokey"])
+            .ids(vec!["1", "2"])
+            .jitter(0.5)
+            .line(Line::new())
+            .legend_group("one")
+            .legend_group_title("Legend Group Title")
+            .marker(Marker::new())
+            .mean_line(MeanLine::new().visible(true))
+            .name("violin")
+            .offset_group("offset_group")
+            .opacity(0.6)
+            .orientation(Orientation::Horizontal)
+            .points(ViolinPoints::All)
+            .point_pos(-1.)
+            .quartile_method(QuartileMethod::Exclusive)
+            .scale_group("scale_group")
+            .scale_mode(ScaleMode::Count)
+            .selected(Selection::new().marker(SelectionMarker::new().color("#111111")))
+            .show_legend(false)
+            .side(ViolinSide::Positive)
+            .span(vec![0., 10.])
+            .span_mode(SpanMode::Manual)
+            .text("hi")
+            .text_array(vec!["hi", "there"])
+            .unselected(Selection::new().marker(SelectionMarker::new().opacity(0.1)))
+            .visible(Visible::LegendOnly)
+            .width(50.0)
+            .x0(1)
+            .x_axis("x1")
+            .x_hover_format("x_hover_format")
+            .y0(2)
+            .y_axis("y1")
+            .y_hover_format("y_hover_format")
+            .z_order(2);
+
+        let expected = json!({
+            "type": "violin",
+            "alignmentgroup": "alignment_group",
+            "bandwidth": 0.2,
+            "box": {"visible": true},
+            "fillcolor": "#522622",
+            "ids": ["1", "2"],
+            "hoverinfo": "name",
+            "hoverlabel": {},
+            "hoveron": "violins+points+kde",
+            "hovertemplate": ["templ1", "templ2"],
+            "hovertext": ["okey", "dokey"],
+            "jitter": 0.5,
+            "legendgroup": "one",
+            "legendgrouptitle": {"text": "Legend Group Title"},
+            "line": {},
+            "marker": {},
+            "meanline": {"visible": true},
+            "name": "violin",
+            "offsetgroup": "offset_group",
+            "opacity": 0.6,
+            "orientation": "h",
+            "points": "all",
+            "pointpos": -1.0,
+            "quartilemethod": "exclusive",
+            "scalegroup": "scale_group",
+            "scalemode": "count",
+            "selected": {"marker": {"color": "#111111"}},
+            "showlegend": false,
+            "side": "positive",
+            "span": [0.0, 10.0],
+            "spanmode": "manual",
+            "text": ["hi", "there"],
+            "unselected": {"marker": {"opacity": 0.1}},
+            "visible": "legendonly",
+            "width": 50.0,
+            "x": [1, 2, 3],
+            "x0": 1,
+            "xaxis": "x1",
+            "xhoverformat": "x_hover_format",
+            "y": [4, 5, 6],
+            "y0": 2,
+            "yaxis": "y1",
+            "yhoverformat": "y_hover_format",
+            "zorder": 2
+        });
+
+        assert_eq!(to_value(trace).unwrap(), expected);
+    }
+}
diff --git a/plotly_static/README.md b/plotly_static/README.md
index c2c20feb..eb10e334 100644
--- a/plotly_static/README.md
+++ b/plotly_static/README.md
@@ -63,6 +63,7 @@ serde_json = "1.0"
 
 ### Feature Flags
 
+- To use static export at runtime, enable exactly one of the driver features below.
 - `chromedriver`: Use Chromedriver and Chrome/Chromium browser for rendering and export
 - `geckodriver`: Use Geckodriver Firefox browser for rendering for rendering and export
 - `webdriver_download`: Auto-download the chosen WebDriver binary
diff --git a/plotly_static/build.rs b/plotly_static/build.rs
index 49f18a50..d192592f 100644
--- a/plotly_static/build.rs
+++ b/plotly_static/build.rs
@@ -1,3 +1,8 @@
+#![cfg_attr(
+    not(any(feature = "geckodriver", feature = "chromedriver")),
+    allow(unused)
+)]
+
 use std::env;
 use std::fs;
 use std::path::{Path, PathBuf};
@@ -12,10 +17,6 @@ use webdriver_downloader::prelude::*;
 #[cfg(all(feature = "geckodriver", feature = "chromedriver"))]
 compile_error!("Only one of 'geckodriver' or 'chromedriver' features can be enabled at a time.");
 
-// Enforce that at least one driver feature is enabled
-#[cfg(not(any(feature = "geckodriver", feature = "chromedriver")))]
-compile_error!("At least one of 'geckodriver' or 'chromedriver' features must be enabled.");
-
 #[cfg(target_os = "windows")]
 const DRIVER_EXT: &str = ".exe";
 #[cfg(not(target_os = "windows"))]
diff --git a/plotly_static/src/lib.rs b/plotly_static/src/lib.rs
index 42f23b86..347cdc1c 100644
--- a/plotly_static/src/lib.rs
+++ b/plotly_static/src/lib.rs
@@ -59,9 +59,10 @@
 //!
 //! ## Features and Dependencies
 //!
-//! ### Required Features
+//! ### Driver Features
 //!
-//! You must enable one of the following features:
+//! For compile time only, no specific feature must be provided. However, to use
+//! static export at runtime, one of the below features must be enabled.
 //!
 //! - `chromedriver`: Use Chrome/Chromium for rendering
 //! - `geckodriver`: Use Firefox for rendering
@@ -294,6 +295,7 @@ use fantoccini::{wd::Capabilities, Client, ClientBuilder};
 #[cfg(not(any(test, feature = "debug")))]
 use log::{debug, error, warn};
 use serde::Serialize;
+#[cfg(any(feature = "chromedriver", feature = "geckodriver"))]
 use serde_json::map::Map as JsonMap;
 use urlencoding::encode;
 use webdriver::WebDriver;
@@ -303,6 +305,9 @@ use crate::template::{image_export_js_script, pdf_export_js_script};
 mod template;
 mod webdriver;
 
+#[cfg(not(any(feature = "chromedriver", feature = "geckodriver")))]
+const DRIVER_FEATURE_REQUIRED: &str = "Static image export at runtime requires enabling either the 'chromedriver' or 'geckodriver' feature.";
+
 /// Supported image formats for static image export.
 ///
 /// This enum defines all the image formats that can be exported from Plotly
@@ -648,6 +653,7 @@ impl StaticExporterBuilder {
     }
 
     /// Create a new WebDriver instance based on the spawn_webdriver flag
+    #[cfg(any(feature = "chromedriver", feature = "geckodriver"))]
     fn create_webdriver(&self) -> Result<WebDriver> {
         let port = self.webdriver_port;
         let in_async = tokio::runtime::Handle::try_current().is_ok();
@@ -688,16 +694,22 @@ impl StaticExporterBuilder {
     ///     .expect("Failed to build AsyncStaticExporter");
     /// ```
     pub fn build_async(&self) -> Result<AsyncStaticExporter> {
-        let wd = self.create_webdriver()?;
-        Ok(AsyncStaticExporter {
-            webdriver_port: self.webdriver_port,
-            webdriver_url: self.webdriver_url.clone(),
-            webdriver: wd,
-            offline_mode: self.offline_mode,
-            pdf_export_timeout: self.pdf_export_timeout,
-            webdriver_browser_caps: self.webdriver_browser_caps.clone(),
-            webdriver_client: None,
-        })
+        #[cfg(not(any(feature = "chromedriver", feature = "geckodriver")))]
+        return Err(anyhow!(DRIVER_FEATURE_REQUIRED));
+
+        #[cfg(any(feature = "chromedriver", feature = "geckodriver"))]
+        {
+            let wd = self.create_webdriver()?;
+            Ok(AsyncStaticExporter {
+                webdriver_port: self.webdriver_port,
+                webdriver_url: self.webdriver_url.clone(),
+                webdriver: wd,
+                offline_mode: self.offline_mode,
+                pdf_export_timeout: self.pdf_export_timeout,
+                webdriver_browser_caps: self.webdriver_browser_caps.clone(),
+                webdriver_client: None,
+            })
+        }
     }
 }
 
@@ -927,6 +939,10 @@ pub struct AsyncStaticExporter {
     pdf_export_timeout: u32,
 
     /// Browser command-line flags (e.g., "--headless", "--no-sandbox")
+    #[cfg_attr(
+        not(any(feature = "chromedriver", feature = "geckodriver")),
+        allow(dead_code)
+    )]
     webdriver_browser_caps: Vec<String>,
 
     /// Cached WebDriver client for session reuse
@@ -1121,46 +1137,53 @@ impl AsyncStaticExporter {
     }
 
     fn build_webdriver_caps(&self) -> Result<Capabilities> {
-        // Define browser capabilities (copied to avoid reordering existing code)
-        let mut caps = JsonMap::new();
-        let mut browser_opts = JsonMap::new();
-        let browser_args = self.webdriver_browser_caps.clone();
-
-        browser_opts.insert("args".to_string(), serde_json::json!(browser_args));
-
-        // Add Chrome binary capability if BROWSER_PATH is set
-        #[cfg(feature = "chromedriver")]
-        if let Ok(chrome_path) = std::env::var("BROWSER_PATH") {
-            browser_opts.insert("binary".to_string(), serde_json::json!(chrome_path));
-            debug!("Added Chrome binary capability: {chrome_path}");
-        }
-        // Add Firefox binary capability if BROWSER_PATH is set
-        #[cfg(feature = "geckodriver")]
-        if let Ok(firefox_path) = std::env::var("BROWSER_PATH") {
-            browser_opts.insert("binary".to_string(), serde_json::json!(firefox_path));
-            debug!("Added Firefox binary capability: {firefox_path}");
-        }
-
-        // Add Firefox-specific preferences for CI environments
-        #[cfg(feature = "geckodriver")]
+        #[cfg(not(any(feature = "chromedriver", feature = "geckodriver")))]
         {
-            let prefs = common::get_firefox_ci_preferences();
-            browser_opts.insert("prefs".to_string(), serde_json::json!(prefs));
-            debug!("Added Firefox preferences for CI compatibility");
+            Err(anyhow!(DRIVER_FEATURE_REQUIRED))
         }
+        #[cfg(any(feature = "chromedriver", feature = "geckodriver"))]
+        {
+            // Define browser capabilities (copied to avoid reordering existing code)
+            let mut caps = JsonMap::new();
+            let mut browser_opts = JsonMap::new();
+            let browser_args = self.webdriver_browser_caps.clone();
+
+            browser_opts.insert("args".to_string(), serde_json::json!(browser_args));
+
+            // Add Chrome binary capability if BROWSER_PATH is set
+            #[cfg(feature = "chromedriver")]
+            if let Ok(chrome_path) = std::env::var("BROWSER_PATH") {
+                browser_opts.insert("binary".to_string(), serde_json::json!(chrome_path));
+                debug!("Added Chrome binary capability: {chrome_path}");
+            }
+            // Add Firefox binary capability if BROWSER_PATH is set
+            #[cfg(feature = "geckodriver")]
+            if let Ok(firefox_path) = std::env::var("BROWSER_PATH") {
+                browser_opts.insert("binary".to_string(), serde_json::json!(firefox_path));
+                debug!("Added Firefox binary capability: {firefox_path}");
+            }
 
-        caps.insert(
-            "browserName".to_string(),
-            serde_json::json!(get_browser_name()),
-        );
-        caps.insert(
-            get_options_key().to_string(),
-            serde_json::json!(browser_opts),
-        );
+            // Add Firefox-specific preferences for CI environments
+            #[cfg(feature = "geckodriver")]
+            {
+                let prefs = common::get_firefox_ci_preferences();
+                browser_opts.insert("prefs".to_string(), serde_json::json!(prefs));
+                debug!("Added Firefox preferences for CI compatibility");
+            }
+
+            caps.insert(
+                "browserName".to_string(),
+                serde_json::json!(get_browser_name()),
+            );
+            caps.insert(
+                get_options_key().to_string(),
+                serde_json::json!(browser_opts),
+            );
 
-        debug!("WebDriver capabilities: {caps:?}");
+            debug!("WebDriver capabilities: {caps:?}");
 
-        Ok(caps)
+            Ok(caps)
+        }
     }
 
     #[cfg(target_os = "windows")]
@@ -1334,6 +1357,15 @@ mod tests {
         let _ = env_logger::try_init();
     }
 
+    #[test]
+    #[cfg(not(any(feature = "chromedriver", feature = "geckodriver")))]
+    fn build_without_driver_feature_returns_error() {
+        match StaticExporterBuilder::default().build_async() {
+            Err(e) => assert_eq!(e.to_string(), DRIVER_FEATURE_REQUIRED),
+            Ok(_) => panic!("expected build to fail without a driver feature"),
+        }
+    }
+
     // Helper to generate unique ports for parallel tests
     #[cfg(not(feature = "debug"))]
     fn get_unique_port() -> u32 {
diff --git a/plotly_static/src/webdriver.rs b/plotly_static/src/webdriver.rs
index fa6f2e1c..830a3998 100644
--- a/plotly_static/src/webdriver.rs
+++ b/plotly_static/src/webdriver.rs
@@ -7,27 +7,19 @@
 //! - Support for both spawned and external WebDriver instances
 //!
 //! The module is designed to work safely in parallel environments.
-use std::io::prelude::*;
-use std::io::BufReader;
+
+#[cfg(any(feature = "chromedriver", feature = "geckodriver"))]
+mod launch;
+
 use std::path::PathBuf;
-use std::process::{Child, Command, Stdio};
+use std::process::Child;
 use std::sync::{Arc, Mutex};
-use std::thread;
 #[cfg(any(test, feature = "debug"))]
-use std::{println as info, println as error, println as debug, println as warn, println as trace};
+use std::{println as info, println as warn};
 
 use anyhow::{anyhow, Result};
 #[cfg(not(any(test, feature = "debug")))]
-use log::{debug, error, info, trace, warn};
-
-/// Environment variable for specifying the WebDriver binary path
-const WEBDRIVER_PATH_ENV: &str = "WEBDRIVER_PATH";
-
-#[cfg(feature = "geckodriver")]
-const WEBDRIVER_BIN: &str = "geckodriver";
-
-#[cfg(feature = "chromedriver")]
-const WEBDRIVER_BIN: &str = "chromedriver";
+use log::{info, warn};
 
 /// Default WebDriver port
 pub(crate) const WEBDRIVER_PORT: u32 = 4444;
@@ -124,346 +116,6 @@ pub struct WebDriver {
 }
 
 impl WebDriver {
-    /// Creates a new WebDriver instance for spawning.
-    ///
-    /// This method creates a WebDriver instance that will later spawn a new
-    /// process. It looks for the WebDriver binary in the following order:
-    /// 1. `WEBDRIVER_PATH` environment variable (should point to full
-    ///    executable path)
-    /// 2. Build-time downloaded path (if `webdriver_download` feature is
-    ///    enabled)
-    ///
-    /// Returns a `Result<WebDriver>` where:
-    /// - `Ok(webdriver)` - Successfully created the WebDriver instance
-    /// - `Err(e)` - Failed to create the instance (e.g., binary not found)
-    pub(crate) fn new(port: u32) -> Result<Self> {
-        let full_path = Self::get_webdriver_path()?;
-
-        Ok(Self {
-            inner: Arc::new(Mutex::new(WdInner {
-                webdriver_port: port,
-                driver_path: Some(full_path),
-                webdriver_child: None,
-                is_external: false, // mark it as spawned by us
-            })),
-        })
-    }
-
-    /// Spawn a new WebDriver instance, connecting to existing if available.
-    ///
-    /// This method provides WebDriver management:
-    /// 1. First checks if a WebDriver is already running on the specified port
-    /// 2. If found, connects to the existing session
-    /// 3. If not found, spawns a process of the current WebDriver instance
-    ///
-    /// This approach allows for efficient resource usage and supports both
-    /// scenarios where WebDriver is managed externally or needs to be spawned.
-    ///
-    /// Returns a `Result<WebDriver>` where:
-    /// - `Ok(webdriver)` - Successfully created or connected to WebDriver
-    /// - `Err(e)` - Failed to create or connect to WebDriver
-    pub(crate) fn connect_or_spawn(port: u32) -> Result<Self> {
-        match Self::try_connect(port) {
-            Some(active_instance) => Ok(active_instance),
-            None => Self::spawn(port)
-                .map_err(|e| anyhow!("Failed to spawn new WebDriver on port {}: {}", port, e)),
-        }
-    }
-
-    /// Try connecting to an existing WebDriver instance
-    pub(crate) fn try_connect(port: u32) -> Option<Self> {
-        if !Self::is_webdriver_running(port) {
-            return None;
-        }
-        info!("WebDriver already running on port {port}, connecting to existing session");
-        Self::no_spawn_instance(port).ok()
-    }
-
-    /// Create a new WebDriver instance without a path to the webdriver binary,
-    /// as it is used for connecting to an existing WebDriver session and not
-    /// spawning a new process.
-    pub(crate) fn no_spawn_instance(port: u32) -> Result<Self> {
-        Ok(Self {
-            inner: Arc::new(Mutex::new(WdInner {
-                webdriver_port: port,
-                driver_path: None,
-                webdriver_child: None,
-                is_external: true, // Mark as external since we didn't spawn it
-            })),
-        })
-    }
-
-    /// Spawns the WebDriver process
-    ///
-    /// This method starts the WebDriver process in a background thread and
-    /// captures its output for logging. The process is spawned with the
-    /// specified port and appropriate I/O redirection.
-    ///
-    /// The spawned process will be automatically managed and can be stopped
-    /// using the `stop()` method.
-    pub(crate) fn spawn(port: u32) -> Result<Self> {
-        debug!("No WebDriver running on port {port}, creating new instance and spawning");
-
-        let mut wd = Self::new(port)?;
-        wd.spawn_webdriver()?;
-
-        if Self::is_webdriver_running(port) {
-            info!("Successfully created and started WebDriver on port {port}");
-            Ok(wd)
-        } else {
-            let diagnostics = wd.get_diagnostics();
-            error!(
-                "WebDriver failed to start properly on port {port}. Diagnostics:\n{diagnostics}"
-            );
-            Err(anyhow!(
-                "WebDriver failed to start properly on port {}",
-                port
-            ))
-        }
-    }
-
-    pub(crate) fn spawn_webdriver(&mut self) -> Result<()> {
-        let port = self.inner.lock().unwrap().webdriver_port;
-        let driver_path = self.inner.lock().unwrap().driver_path.clone();
-
-        info!("Spawning {WEBDRIVER_BIN} on port {port} with path: {driver_path:?}");
-
-        if Self::is_webdriver_running(port) {
-            warn!("WebDriver already running on port {port}, attempting to connect instead");
-            return Ok(());
-        }
-
-        self.validate_spawn_prerequisites()?;
-
-        let mut child = self.spawn_process(&driver_path, port)?;
-
-        self.setup_output_monitoring(&mut child, port);
-
-        self.store_child_process(child);
-
-        self.wait_for_ready(port)
-    }
-
-    fn validate_spawn_prerequisites(&self) -> Result<()> {
-        let inner = self
-            .inner
-            .lock()
-            .map_err(|e| anyhow!("Failed to acquire lock: {}", e))?;
-
-        // Check if driver path exists
-        let driver_path = inner.driver_path.as_ref().ok_or_else(|| {
-            error!(
-                "WebDriver diagnostics after missing driver path:\n{}",
-                self.get_diagnostics()
-            );
-            anyhow!("No driver path available for spawning")
-        })?;
-
-        // Check if binary exists
-        if !driver_path.exists() {
-            error!(
-                "WebDriver diagnostics after missing binary:\n{}",
-                self.get_diagnostics()
-            );
-            return Err(anyhow!("WebDriver binary does not exist: {driver_path:?}"));
-        }
-
-        Ok(())
-    }
-
-    fn spawn_process(&self, driver_path: &Option<PathBuf>, port: u32) -> Result<Child> {
-        let driver_path = driver_path.as_ref().unwrap(); // Safe unwrap since we validated above
-
-        let mut command = Self::create_command(driver_path, port);
-        Self::log_command(&command);
-
-        match command.spawn() {
-            Ok(child) => Ok(child),
-            Err(e) => {
-                #[cfg(not(target_os = "windows"))]
-                {
-                    Err(self.handle_spawn_error(e, &command, "standard method"))
-                }
-                #[cfg(target_os = "windows")]
-                {
-                    self.spawn_with_fallback(driver_path, port, e)
-                }
-            }
-        }
-    }
-
-    /// Windows-specific fallback spawn method when CREATE_NO_WINDOW fails
-    #[cfg(target_os = "windows")]
-    fn spawn_with_fallback(
-        &self,
-        driver_path: &PathBuf,
-        port: u32,
-        original_error: std::io::Error,
-    ) -> Result<Child> {
-        // If CREATE_NO_WINDOW fails, try without any special flags
-        error!("Failed to spawn with CREATE_NO_WINDOW: {original_error}");
-        error!("Trying without special creation flags...");
-
-        let mut fallback_command = Self::standard_command(driver_path, port);
-        Self::log_command(&fallback_command);
-
-        match fallback_command.spawn() {
-            Ok(child) => {
-                info!("Successfully spawned WebDriver without special creation flags");
-                Ok(child)
-            }
-            Err(fallback_e) => {
-                error!("Original error: {original_error}");
-                error!("Fallback error: {fallback_e}");
-                Err(self.handle_spawn_error(fallback_e, &fallback_command, "fallback method"))
-            }
-        }
-    }
-
-    /// Creates a command with standard configuration (no Windows flags)
-    fn standard_command(driver_path: &PathBuf, port: u32) -> Command {
-        let mut command = Command::new(driver_path);
-        command.arg(format!("--port={port}"));
-
-        // Add verbose flag only for chromedriver
-        #[cfg(feature = "chromedriver")]
-        command.arg("--verbose");
-
-        command
-            .stdin(Stdio::piped())
-            .stdout(Stdio::piped())
-            .stderr(Stdio::piped());
-
-        command
-    }
-
-    /// Creates a command with Windows-specific flags
-    #[cfg(target_os = "windows")]
-    fn create_command(driver_path: &PathBuf, port: u32) -> Command {
-        use std::os::windows::process::CommandExt;
-
-        let mut command = Self::standard_command(driver_path, port);
-        // Try with CREATE_NO_WINDOW for headless operation
-        command.creation_flags(0x08000000); // CREATE_NO_WINDOW flag
-        command
-    }
-
-    #[cfg(not(target_os = "windows"))]
-    fn create_command(driver_path: &PathBuf, port: u32) -> Command {
-        Self::standard_command(driver_path, port)
-    }
-
-    /// Logs command execution details
-    fn log_command(command: &Command) {
-        info!(
-            "Executing command: {:?} {:?}",
-            command.get_program(),
-            command.get_args()
-        );
-    }
-
-    /// Handles spawn errors with appropriate logging and diagnostics
-    fn handle_spawn_error(
-        &self,
-        e: std::io::Error,
-        command: &Command,
-        attempt: &str,
-    ) -> anyhow::Error {
-        error!("Failed to spawn '{WEBDRIVER_BIN}' with {attempt}: {e}");
-        error!(
-            "Command was: {:?} {:?}",
-            command.get_program(),
-            command.get_args()
-        );
-
-        #[cfg(target_os = "windows")]
-        if attempt == "CREATE_NO_WINDOW" {
-            error!("Windows: Check if antivirus is blocking the process");
-            error!("Windows: Check if the binary has proper permissions");
-        }
-
-        error!(
-            "WebDriver diagnostics after spawn failure:\n{}",
-            self.get_diagnostics()
-        );
-
-        anyhow!("Failed to spawn '{WEBDRIVER_BIN}': {}", e)
-    }
-
-    fn setup_output_monitoring(&self, child: &mut Child, port: u32) {
-        // Monitor stderr
-        if let Some(stderr) = child.stderr.take() {
-            let port_for_logging = port;
-            thread::spawn(move || {
-                info!("Starting stderr monitoring for WebDriver on port {port_for_logging}");
-                let stderr_lines = BufReader::new(stderr).lines();
-                for line in stderr_lines.map_while(Result::ok) {
-                    trace!("WebDriver[{port_for_logging}] stderr: {line}");
-                }
-                info!("Stderr monitoring ended for WebDriver on port {port_for_logging}");
-            });
-        }
-
-        // Monitor stdout
-        if let Some(stdout) = child.stdout.take() {
-            let port_for_logging = port;
-            thread::spawn(move || {
-                info!("Starting stdout monitoring for WebDriver on port {port_for_logging}");
-                let stdout_lines = BufReader::new(stdout).lines();
-                for line in stdout_lines.map_while(Result::ok) {
-                    trace!("WebDriver[{port_for_logging}] stdout: {line}");
-                }
-                info!("Stdout monitoring ended for WebDriver on port {port_for_logging}");
-            });
-        }
-    }
-
-    fn store_child_process(&mut self, child: Child) {
-        let mut inner = self.inner.lock().unwrap();
-        inner.webdriver_child = Some(child);
-        info!("WebDriver process stored, waiting for it to become ready...");
-    }
-
-    fn wait_for_ready(&self, port: u32) -> Result<()> {
-        let start_time = std::time::Instant::now();
-        let timeout_duration = if cfg!(target_os = "windows") {
-            std::time::Duration::from_secs(60)
-        } else {
-            std::time::Duration::from_secs(30)
-        };
-
-        while start_time.elapsed() < timeout_duration {
-            if Self::is_webdriver_running(port) {
-                info!(
-                    "WebDriver is ready on port {} after {:?}",
-                    port,
-                    start_time.elapsed()
-                );
-                return Ok(());
-            }
-
-            // Check if process is still alive
-            if let Some(child) = self.inner.lock().unwrap().webdriver_child.as_mut() {
-                if let Ok(Some(_)) = child.try_wait() {
-                    error!("WebDriver process exited before becoming ready on port {port}");
-                    return Err(anyhow!(
-                        "WebDriver process exited before becoming ready on port {}",
-                        port
-                    ));
-                }
-            }
-
-            std::thread::sleep(std::time::Duration::from_millis(100));
-        }
-
-        error!("WebDriver failed to become ready on port {port} within {timeout_duration:?}");
-        Err(anyhow!(
-            "WebDriver failed to become ready on port {} within {:?}",
-            port,
-            timeout_duration
-        ))
-    }
-
     /// Stops the WebDriver process.
     ///
     /// This method manages WebDriver process termination:
@@ -482,7 +134,7 @@ impl WebDriver {
         // Only stop the process if we spawned it (not if it's external)
         if !inner.is_external {
             if let Some(child) = inner.webdriver_child.as_mut() {
-                info!("Stopping '{WEBDRIVER_BIN}' (PID: {})", child.id());
+                info!("Stopping WebDriver (PID: {})", child.id());
                 let _ = child.kill();
                 let _ = child.wait();
             }
@@ -633,37 +285,4 @@ impl WebDriver {
             .map(|text| text.contains("ready"))
             .unwrap_or(false)
     }
-
-    fn get_webdriver_path() -> Result<PathBuf> {
-        use std::env;
-
-        let path = match env::var(WEBDRIVER_PATH_ENV) {
-            Ok(runtime_env) => runtime_env,
-            Err(runtime_env_err) => match option_env!("WEBDRIVER_DOWNLOAD_PATH") {
-                Some(compile_time_path) => compile_time_path.to_string(),
-                None => {
-                    debug!("{WEBDRIVER_PATH_ENV}: {runtime_env_err}");
-                    warn!("Use the plotly_static's `webdriver_download` feature to automatically download, install and use the the chosen WebDriver for supported platforms. Or manually set {WEBDRIVER_PATH_ENV} to point to the WebDriver binary.");
-                    return Err(anyhow!(
-                        "WebDriver binary not available. Set {} environment variable or use the webdriver_download feature",
-                        WEBDRIVER_PATH_ENV
-                    ));
-                }
-            },
-        };
-
-        Self::full_path(&path).map_err(|e| anyhow!("Invalid WebDriver path '{}': {}", path, e))
-    }
-
-    fn full_path(path: &str) -> Result<PathBuf> {
-        let p = PathBuf::from(path);
-        if !p.exists() {
-            Err(anyhow!(
-                "WebDriver executable not found at provided path: '{}'",
-                p.display()
-            ))
-        } else {
-            Ok(p)
-        }
-    }
 }
diff --git a/plotly_static/src/webdriver/launch.rs b/plotly_static/src/webdriver/launch.rs
new file mode 100644
index 00000000..600ce1c9
--- /dev/null
+++ b/plotly_static/src/webdriver/launch.rs
@@ -0,0 +1,399 @@
+//! WebDriver process launch: spawn, connect-to-existing, and binary resolution.
+
+use std::io::prelude::*;
+use std::io::BufReader;
+use std::path::PathBuf;
+use std::process::{Child, Command, Stdio};
+use std::sync::{Arc, Mutex};
+use std::thread;
+#[cfg(any(test, feature = "debug"))]
+use std::{println as debug, println as error, println as info, println as trace, println as warn};
+
+use anyhow::{anyhow, Result};
+#[cfg(not(any(test, feature = "debug")))]
+use log::{debug, error, info, trace, warn};
+
+use super::{WdInner, WebDriver};
+
+const WEBDRIVER_PATH_ENV: &str = "WEBDRIVER_PATH";
+
+#[cfg(feature = "geckodriver")]
+const WEBDRIVER_BIN: &str = "geckodriver";
+
+#[cfg(feature = "chromedriver")]
+const WEBDRIVER_BIN: &str = "chromedriver";
+
+impl WebDriver {
+    /// Creates a new WebDriver instance for spawning.
+    ///
+    /// This method creates a WebDriver instance that will later spawn a new
+    /// process. It looks for the WebDriver binary in the following order:
+    /// 1. `WEBDRIVER_PATH` environment variable (should point to full
+    ///    executable path)
+    /// 2. Build-time downloaded path (if `webdriver_download` feature is
+    ///    enabled)
+    ///
+    /// Returns a `Result<WebDriver>` where:
+    /// - `Ok(webdriver)` - Successfully created the WebDriver instance
+    /// - `Err(e)` - Failed to create the instance (e.g., binary not found)
+    pub(crate) fn new(port: u32) -> Result<Self> {
+        let full_path = Self::get_webdriver_path()?;
+
+        Ok(Self {
+            inner: Arc::new(Mutex::new(WdInner {
+                webdriver_port: port,
+                driver_path: Some(full_path),
+                webdriver_child: None,
+                is_external: false, // mark it as spawned by us
+            })),
+        })
+    }
+
+    /// Spawn a new WebDriver instance, connecting to existing if available.
+    ///
+    /// This method provides WebDriver management:
+    /// 1. First checks if a WebDriver is already running on the specified port
+    /// 2. If found, connects to the existing session
+    /// 3. If not found, spawns a process of the current WebDriver instance
+    ///
+    /// This approach allows for efficient resource usage and supports both
+    /// scenarios where WebDriver is managed externally or needs to be spawned.
+    ///
+    /// Returns a `Result<WebDriver>` where:
+    /// - `Ok(webdriver)` - Successfully created or connected to WebDriver
+    /// - `Err(e)` - Failed to create or connect to WebDriver
+    pub(crate) fn connect_or_spawn(port: u32) -> Result<Self> {
+        match Self::try_connect(port) {
+            Some(active_instance) => Ok(active_instance),
+            None => Self::spawn(port)
+                .map_err(|e| anyhow!("Failed to spawn new WebDriver on port {}: {}", port, e)),
+        }
+    }
+
+    /// Try connecting to an existing WebDriver instance
+    pub(crate) fn try_connect(port: u32) -> Option<Self> {
+        if !Self::is_webdriver_running(port) {
+            return None;
+        }
+        info!("WebDriver already running on port {port}, connecting to existing session");
+        Self::no_spawn_instance(port).ok()
+    }
+
+    /// Create a new WebDriver instance without a path to the webdriver binary,
+    /// as it is used for connecting to an existing WebDriver session and not
+    /// spawning a new process.
+    pub(crate) fn no_spawn_instance(port: u32) -> Result<Self> {
+        Ok(Self {
+            inner: Arc::new(Mutex::new(WdInner {
+                webdriver_port: port,
+                driver_path: None,
+                webdriver_child: None,
+                is_external: true, // Mark as external since we didn't spawn it
+            })),
+        })
+    }
+
+    /// Spawns the WebDriver process
+    ///
+    /// This method starts the WebDriver process in a background thread and
+    /// captures its output for logging. The process is spawned with the
+    /// specified port and appropriate I/O redirection.
+    ///
+    /// The spawned process will be automatically managed and can be stopped
+    /// using the `stop()` method.
+    pub(crate) fn spawn(port: u32) -> Result<Self> {
+        debug!("No WebDriver running on port {port}, creating new instance and spawning");
+
+        let mut wd = Self::new(port)?;
+        wd.spawn_webdriver()?;
+
+        if Self::is_webdriver_running(port) {
+            info!("Successfully created and started WebDriver on port {port}");
+            Ok(wd)
+        } else {
+            let diagnostics = wd.get_diagnostics();
+            error!(
+                "WebDriver failed to start properly on port {port}. Diagnostics:\n{diagnostics}"
+            );
+            Err(anyhow!(
+                "WebDriver failed to start properly on port {}",
+                port
+            ))
+        }
+    }
+
+    pub(crate) fn spawn_webdriver(&mut self) -> Result<()> {
+        let port = self.inner.lock().unwrap().webdriver_port;
+        let driver_path = self.inner.lock().unwrap().driver_path.clone();
+
+        info!("Spawning {WEBDRIVER_BIN} on port {port} with path: {driver_path:?}");
+
+        if Self::is_webdriver_running(port) {
+            warn!("WebDriver already running on port {port}, attempting to connect instead");
+            return Ok(());
+        }
+
+        self.validate_spawn_prerequisites()?;
+
+        let mut child = self.spawn_process(&driver_path, port)?;
+
+        self.setup_output_monitoring(&mut child, port);
+
+        self.store_child_process(child);
+
+        self.wait_for_ready(port)
+    }
+
+    fn validate_spawn_prerequisites(&self) -> Result<()> {
+        let inner = self
+            .inner
+            .lock()
+            .map_err(|e| anyhow!("Failed to acquire lock: {}", e))?;
+
+        // Check if driver path exists
+        let driver_path = inner.driver_path.as_ref().ok_or_else(|| {
+            error!(
+                "WebDriver diagnostics after missing driver path:\n{}",
+                self.get_diagnostics()
+            );
+            anyhow!("No driver path available for spawning")
+        })?;
+
+        // Check if binary exists
+        if !driver_path.exists() {
+            error!(
+                "WebDriver diagnostics after missing binary:\n{}",
+                self.get_diagnostics()
+            );
+            return Err(anyhow!("WebDriver binary does not exist: {driver_path:?}"));
+        }
+
+        Ok(())
+    }
+
+    fn spawn_process(&self, driver_path: &Option<PathBuf>, port: u32) -> Result<Child> {
+        let driver_path = driver_path.as_ref().unwrap(); // Safe unwrap since we validated above
+
+        let mut command = Self::create_command(driver_path, port);
+        Self::log_command(&command);
+
+        match command.spawn() {
+            Ok(child) => Ok(child),
+            Err(e) => {
+                #[cfg(not(target_os = "windows"))]
+                {
+                    Err(self.handle_spawn_error(e, &command, "standard method"))
+                }
+                #[cfg(target_os = "windows")]
+                {
+                    self.spawn_with_fallback(driver_path, port, e)
+                }
+            }
+        }
+    }
+
+    /// Windows-specific fallback spawn method when CREATE_NO_WINDOW fails
+    #[cfg(target_os = "windows")]
+    fn spawn_with_fallback(
+        &self,
+        driver_path: &PathBuf,
+        port: u32,
+        original_error: std::io::Error,
+    ) -> Result<Child> {
+        // If CREATE_NO_WINDOW fails, try without any special flags
+        error!("Failed to spawn with CREATE_NO_WINDOW: {original_error}");
+        error!("Trying without special creation flags...");
+
+        let mut fallback_command = Self::standard_command(driver_path, port);
+        Self::log_command(&fallback_command);
+
+        match fallback_command.spawn() {
+            Ok(child) => {
+                info!("Successfully spawned WebDriver without special creation flags");
+                Ok(child)
+            }
+            Err(fallback_e) => {
+                error!("Original error: {original_error}");
+                error!("Fallback error: {fallback_e}");
+                Err(self.handle_spawn_error(fallback_e, &fallback_command, "fallback method"))
+            }
+        }
+    }
+
+    /// Creates a command with standard configuration (no Windows flags)
+    fn standard_command(driver_path: &PathBuf, port: u32) -> Command {
+        let mut command = Command::new(driver_path);
+        command.arg(format!("--port={port}"));
+
+        // Add verbose flag only for chromedriver
+        #[cfg(feature = "chromedriver")]
+        command.arg("--verbose");
+
+        command
+            .stdin(Stdio::piped())
+            .stdout(Stdio::piped())
+            .stderr(Stdio::piped());
+
+        command
+    }
+
+    /// Creates a command with Windows-specific flags
+    #[cfg(target_os = "windows")]
+    fn create_command(driver_path: &PathBuf, port: u32) -> Command {
+        use std::os::windows::process::CommandExt;
+
+        let mut command = Self::standard_command(driver_path, port);
+        // Try with CREATE_NO_WINDOW for headless operation
+        command.creation_flags(0x08000000); // CREATE_NO_WINDOW flag
+        command
+    }
+
+    #[cfg(not(target_os = "windows"))]
+    fn create_command(driver_path: &PathBuf, port: u32) -> Command {
+        Self::standard_command(driver_path, port)
+    }
+
+    /// Logs command execution details
+    fn log_command(command: &Command) {
+        info!(
+            "Executing command: {:?} {:?}",
+            command.get_program(),
+            command.get_args()
+        );
+    }
+
+    /// Handles spawn errors with appropriate logging and diagnostics
+    fn handle_spawn_error(
+        &self,
+        e: std::io::Error,
+        command: &Command,
+        attempt: &str,
+    ) -> anyhow::Error {
+        error!("Failed to spawn '{WEBDRIVER_BIN}' with {attempt}: {e}");
+        error!(
+            "Command was: {:?} {:?}",
+            command.get_program(),
+            command.get_args()
+        );
+
+        #[cfg(target_os = "windows")]
+        if attempt == "CREATE_NO_WINDOW" {
+            error!("Windows: Check if antivirus is blocking the process");
+            error!("Windows: Check if the binary has proper permissions");
+        }
+
+        error!(
+            "WebDriver diagnostics after spawn failure:\n{}",
+            self.get_diagnostics()
+        );
+
+        anyhow!("Failed to spawn '{WEBDRIVER_BIN}': {}", e)
+    }
+
+    fn setup_output_monitoring(&self, child: &mut Child, port: u32) {
+        // Monitor stderr
+        if let Some(stderr) = child.stderr.take() {
+            let port_for_logging = port;
+            thread::spawn(move || {
+                info!("Starting stderr monitoring for WebDriver on port {port_for_logging}");
+                let stderr_lines = BufReader::new(stderr).lines();
+                for line in stderr_lines.map_while(Result::ok) {
+                    trace!("WebDriver[{port_for_logging}] stderr: {line}");
+                }
+                info!("Stderr monitoring ended for WebDriver on port {port_for_logging}");
+            });
+        }
+
+        // Monitor stdout
+        if let Some(stdout) = child.stdout.take() {
+            let port_for_logging = port;
+            thread::spawn(move || {
+                info!("Starting stdout monitoring for WebDriver on port {port_for_logging}");
+                let stdout_lines = BufReader::new(stdout).lines();
+                for line in stdout_lines.map_while(Result::ok) {
+                    trace!("WebDriver[{port_for_logging}] stdout: {line}");
+                }
+                info!("Stdout monitoring ended for WebDriver on port {port_for_logging}");
+            });
+        }
+    }
+
+    fn store_child_process(&mut self, child: Child) {
+        let mut inner = self.inner.lock().unwrap();
+        inner.webdriver_child = Some(child);
+        info!("WebDriver process stored, waiting for it to become ready...");
+    }
+
+    fn wait_for_ready(&self, port: u32) -> Result<()> {
+        let start_time = std::time::Instant::now();
+        let timeout_duration = if cfg!(target_os = "windows") {
+            std::time::Duration::from_secs(60)
+        } else {
+            std::time::Duration::from_secs(30)
+        };
+
+        while start_time.elapsed() < timeout_duration {
+            if Self::is_webdriver_running(port) {
+                info!(
+                    "WebDriver is ready on port {} after {:?}",
+                    port,
+                    start_time.elapsed()
+                );
+                return Ok(());
+            }
+
+            // Check if process is still alive
+            if let Some(child) = self.inner.lock().unwrap().webdriver_child.as_mut() {
+                if let Ok(Some(_)) = child.try_wait() {
+                    error!("WebDriver process exited before becoming ready on port {port}");
+                    return Err(anyhow!(
+                        "WebDriver process exited before becoming ready on port {}",
+                        port
+                    ));
+                }
+            }
+
+            std::thread::sleep(std::time::Duration::from_millis(100));
+        }
+
+        error!("WebDriver failed to become ready on port {port} within {timeout_duration:?}");
+        Err(anyhow!(
+            "WebDriver failed to become ready on port {} within {:?}",
+            port,
+            timeout_duration
+        ))
+    }
+
+    fn get_webdriver_path() -> Result<PathBuf> {
+        use std::env;
+
+        let path = match env::var(WEBDRIVER_PATH_ENV) {
+            Ok(runtime_env) => runtime_env,
+            Err(runtime_env_err) => match option_env!("WEBDRIVER_DOWNLOAD_PATH") {
+                Some(compile_time_path) => compile_time_path.to_string(),
+                None => {
+                    debug!("{WEBDRIVER_PATH_ENV}: {runtime_env_err}");
+                    warn!("Use the plotly_static's `webdriver_download` feature to automatically download, install and use the the chosen WebDriver for supported platforms. Or manually set {WEBDRIVER_PATH_ENV} to point to the WebDriver binary.");
+                    return Err(anyhow!(
+                        "WebDriver binary not available. Set {} environment variable or use the webdriver_download feature",
+                        WEBDRIVER_PATH_ENV
+                    ));
+                }
+            },
+        };
+
+        Self::full_path(&path).map_err(|e| anyhow!("Invalid WebDriver path '{}': {}", path, e))
+    }
+
+    fn full_path(path: &str) -> Result<PathBuf> {
+        let p = PathBuf::from(path);
+        if !p.exists() {
+            Err(anyhow!(
+                "WebDriver executable not found at provided path: '{}'",
+                p.display()
+            ))
+        } else {
+            Ok(p)
+        }
+    }
+}