diff --git a/CHANGELOG.md b/CHANGELOG.md
index 01acd648..a47e4247 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -21,6 +21,10 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/) a
   - date-axis period positioning (`xperiod`/`xperiod0`/`xperiodalignment` and the `y` variants) on `Scatter`, `Bar`, `BoxPlot`, `HeatMap`, `Contour` (x-only on `Candlestick`, `Ohlc`), via a new `PeriodAlignment` enum
   - `fillpattern` (reusing `Pattern`) and `fillgradient` (new `FillGradient` struct) on `Scatter`
   - Consolidate the duplicated `Selection`/`SelectionMarker` structs into `common` (re-exported from their original modules for backward compatibility)
+- [[#422](https://github.com/plotly/plotly.rs/issues/422)] Add `Indicator` trace type (number / delta / gauge KPI displays) with `Gauge`, `Delta`, `Number` config
+- [[#422](https://github.com/plotly/plotly.rs/issues/422)] Add `Histogram2d` trace type (2D histogram heatmap) with `histfunc`/`histnorm`/`nbinsx`/`nbinsy`/`xbins`/`ybins`
+- [[#422](https://github.com/plotly/plotly.rs/issues/422)] Add `Icicle` trace type (hierarchical icicle chart; sibling of `Treemap`/`Sunburst`)
+- [[#422](https://github.com/plotly/plotly.rs/issues/422)] Add layout-level `uirevision` to preserve UI state (zoom/pan/selection) across re-renders (complements the trace-level `uirevision` added in #421)
 
 ### Changed
 
diff --git a/plotly/src/common/mod.rs b/plotly/src/common/mod.rs
index 05345710..b02792fc 100644
--- a/plotly/src/common/mod.rs
+++ b/plotly/src/common/mod.rs
@@ -224,8 +224,11 @@ pub enum PlotType {
     Contour,
     HeatMap,
     Histogram,
+    Histogram2d,
     Histogram2dContour,
+    Icicle,
     Image,
+    Indicator,
     Mesh3D,
     Ohlc,
     Sankey,
diff --git a/plotly/src/layout/mod.rs b/plotly/src/layout/mod.rs
index 1aef0bb0..027e3075 100644
--- a/plotly/src/layout/mod.rs
+++ b/plotly/src/layout/mod.rs
@@ -7,6 +7,7 @@ use update_menu::UpdateMenu;
 
 use crate::color::Color;
 use crate::common::{Calendar, ColorScale, Font, Label, Orientation, Title};
+use crate::private::NumOrString;
 
 pub mod themes;
 pub mod update_menu;
@@ -257,6 +258,12 @@ pub struct LayoutFields {
     color_axis: Option<ColorAxis>,
     #[serde(rename = "modebar")]
     mode_bar: Option<ModeBar>,
+    /// Controls persistence of user-driven UI changes (zoom, pan, selection,
+    /// legend visibility) across `Plotly.react`/`newPlot` calls: state is kept
+    /// while `uirevision` is unchanged. Trace-level `uirevision` overrides per
+    /// trace.
+    #[serde(rename = "uirevision")]
+    ui_revision: Option<NumOrString>,
     /// Determines the mode of hover interactions. If "closest", a single
     /// hoverlabel will appear for the "closest" point within the
     /// `hoverdistance`. If "x" (or "y"), multiple hoverlabels will appear for
@@ -654,6 +661,12 @@ mod tests {
         assert_eq!(to_value(template).unwrap(), expected);
     }
 
+    #[test]
+    fn serialize_layout_ui_revision() {
+        let layout = Layout::new().ui_revision("forever");
+        assert_eq!(to_value(layout).unwrap()["uirevision"], json!("forever"));
+    }
+
     #[test]
     fn serialize_layout() {
         let layout = Layout::new()
diff --git a/plotly/src/lib.rs b/plotly/src/lib.rs
index 7086da40..abe8e813 100644
--- a/plotly/src/lib.rs
+++ b/plotly/src/lib.rs
@@ -60,14 +60,16 @@ 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, density_map, heat_map, histogram, image, mesh3d,
-    sankey, scatter, scatter3d, scatter_map, scatter_mapbox, sunburst, surface, treemap, violin,
+    box_plot, choropleth, choropleth_map, contour, density_map, heat_map, histogram, histogram2d,
+    icicle, image, indicator, 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, DensityMap, DensityMapbox,
-    HeatMap, Histogram, Image, Mesh3D, Ohlc, Pie, Sankey, Scatter, Scatter3D, ScatterGeo,
-    ScatterMap, ScatterMapbox, ScatterPolar, Sunburst, Surface, Table, Treemap, Violin,
+    HeatMap, Histogram, Histogram2d, Icicle, Image, Indicator, 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/histogram2d.rs b/plotly/src/traces/histogram2d.rs
new file mode 100644
index 00000000..167f3747
--- /dev/null
+++ b/plotly/src/traces/histogram2d.rs
@@ -0,0 +1,296 @@
+//! 2D histogram trace
+
+use plotly_derive::FieldSetter;
+use serde::Serialize;
+
+use crate::{
+    common::{
+        Calendar, ColorBar, ColorScale, Dim, Font, HoverInfo, Label, LegendGroupTitle, PlotType,
+        Visible, XAxisId, YAxisId,
+    },
+    private::{NumOrString, NumOrStringCollection},
+    traces::heat_map::Smoothing,
+    traces::histogram::{Bins, HistFunc, HistNorm},
+    Trace,
+};
+
+/// Construct a 2D histogram trace.
+///
+/// A `Histogram2d` bins raw `x`/`y` samples into a 2D grid and renders the
+/// counts as a heatmap. Provide raw `x`/`y` data (and let Plotly.js bin it via
+/// `hist_func`/`n_bins_x`/`n_bins_y`/`x_bins`/`y_bins`), or supply a
+/// pre-computed `z` matrix.
+///
+/// # Examples
+///
+/// ```
+/// use plotly::Histogram2d;
+///
+/// let trace = Histogram2d::new(vec![1.0, 2.0, 2.0], vec![1.0, 1.0, 3.0]);
+///
+/// let expected = serde_json::json!({
+///     "type": "histogram2d",
+///     "x": [1.0, 2.0, 2.0],
+///     "y": [1.0, 1.0, 3.0],
+/// });
+///
+/// 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 Histogram2d<X, Y, Z>
+where
+    X: Serialize + Clone,
+    Y: Serialize + Clone,
+    Z: Serialize + Clone,
+{
+    #[field_setter(default = "PlotType::Histogram2d")]
+    r#type: PlotType,
+    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>,
+    x: Option<Vec<X>>,
+    y: Option<Vec<Y>>,
+    z: Option<Vec<Z>>,
+    #[serde(rename = "xaxis")]
+    x_axis: Option<XAxisId>,
+    #[serde(rename = "yaxis")]
+    y_axis: Option<YAxisId>,
+    /// Specifies the binning function used for this histogram trace.
+    #[serde(rename = "histfunc")]
+    hist_func: Option<HistFunc>,
+    /// Specifies the type of normalization used for this histogram trace.
+    #[serde(rename = "histnorm")]
+    hist_norm: Option<HistNorm>,
+    /// Determines whether or not the x-axis bin attributes are picked by an
+    /// algorithm.
+    #[serde(rename = "autobinx")]
+    auto_bin_x: Option<bool>,
+    /// Determines whether or not the y-axis bin attributes are picked by an
+    /// algorithm.
+    #[serde(rename = "autobiny")]
+    auto_bin_y: Option<bool>,
+    /// Specifies the maximum number of desired bins along the x axis.
+    #[serde(rename = "nbinsx")]
+    n_bins_x: Option<usize>,
+    /// Specifies the maximum number of desired bins along the y axis.
+    #[serde(rename = "nbinsy")]
+    n_bins_y: Option<usize>,
+    /// Sets the binning across the x axis.
+    #[serde(rename = "xbins")]
+    x_bins: Option<Bins>,
+    /// Sets the binning across the y axis.
+    #[serde(rename = "ybins")]
+    y_bins: Option<Bins>,
+    #[serde(rename = "autocolorscale")]
+    auto_color_scale: Option<bool>,
+    #[serde(rename = "colorbar")]
+    color_bar: Option<ColorBar>,
+    #[serde(rename = "colorscale")]
+    color_scale: Option<ColorScale>,
+    #[serde(rename = "reversescale")]
+    reverse_scale: Option<bool>,
+    #[serde(rename = "showscale")]
+    show_scale: Option<bool>,
+    zauto: Option<bool>,
+    zmin: Option<f64>,
+    zmax: Option<f64>,
+    zmid: Option<f64>,
+    #[serde(rename = "zhoverformat")]
+    zhover_format: Option<String>,
+    zsmooth: Option<Smoothing>,
+    #[serde(rename = "xgap")]
+    x_gap: Option<NumOrString>,
+    #[serde(rename = "ygap")]
+    y_gap: Option<NumOrString>,
+    #[serde(rename = "xcalendar")]
+    x_calendar: Option<Calendar>,
+    #[serde(rename = "ycalendar")]
+    y_calendar: Option<Calendar>,
+    #[serde(rename = "xhoverformat")]
+    x_hover_format: Option<String>,
+    #[serde(rename = "yhoverformat")]
+    y_hover_format: Option<String>,
+    #[serde(rename = "textfont")]
+    text_font: Option<Font>,
+    #[serde(rename = "texttemplate")]
+    text_template: Option<Dim<String>>,
+    #[serde(rename = "texttemplatefallback")]
+    text_template_fallback: Option<Dim<String>>,
+    #[serde(rename = "hoverinfo")]
+    hover_info: Option<HoverInfo>,
+    #[serde(rename = "hoverlabel")]
+    hover_label: Option<Label>,
+    #[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.
+    meta: Option<NumOrString>,
+    /// Assigns extra data to each datum that can be used in hover, click and
+    /// selection events.
+    #[serde(rename = "customdata")]
+    custom_data: Option<NumOrStringCollection>,
+    uid: Option<String>,
+    /// 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.
+    #[serde(rename = "legendrank")]
+    legend_rank: Option<usize>,
+    /// Sets the width (in px or fraction) of the legend for this trace.
+    #[serde(rename = "legendwidth")]
+    legend_width: Option<f64>,
+    /// Controls persistence of user-driven changes to the trace. Defaults to
+    /// `layout.uirevision`.
+    #[serde(rename = "uirevision")]
+    ui_revision: Option<NumOrString>,
+}
+
+impl<X, Y> Histogram2d<X, Y, f64>
+where
+    X: Serialize + Clone,
+    Y: Serialize + Clone,
+{
+    /// Build a new 2D histogram from raw `x` and `y` samples. Plotly.js bins
+    /// the samples into a 2D grid.
+    pub fn new(x: Vec<X>, y: Vec<Y>) -> Box<Self> {
+        Box::new(Self {
+            x: Some(x),
+            y: Some(y),
+            ..Default::default()
+        })
+    }
+}
+
+impl<X, Y, Z> Histogram2d<X, Y, Z>
+where
+    X: Serialize + Clone,
+    Y: Serialize + Clone,
+    Z: Serialize + Clone,
+{
+    /// Build a new 2D histogram from a pre-computed `z` matrix, with `x`/`y`
+    /// coordinates.
+    pub fn new_xyz(x: Vec<X>, y: Vec<Y>, z: Vec<Z>) -> Box<Self> {
+        Box::new(Self {
+            x: Some(x),
+            y: Some(y),
+            z: Some(z),
+            ..Default::default()
+        })
+    }
+}
+
+impl<X, Y, Z> Trace for Histogram2d<X, Y, Z>
+where
+    X: Serialize + Clone,
+    Y: 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_default_histogram2d() {
+        let trace = Histogram2d::<f64, f64, f64>::default();
+        let expected = json!({"type": "histogram2d"}).to_string();
+
+        assert_eq!(trace.to_json(), expected);
+    }
+
+    #[test]
+    fn serialize_histogram2d_raw() {
+        let trace = Histogram2d::new(vec![1.0, 2.0, 2.0], vec![1.0, 1.0, 3.0])
+            .hist_func(HistFunc::Count)
+            .hist_norm(HistNorm::Probability)
+            .auto_bin_x(false)
+            .auto_bin_y(false)
+            .n_bins_x(10)
+            .n_bins_y(10)
+            .x_bins(Bins::new(0.0, 4.0, 1.0))
+            .y_bins(Bins::new(0.0, 4.0, 1.0))
+            .color_scale(ColorScale::Palette(ColorScalePalette::Viridis))
+            .show_scale(true)
+            .name("hist2d");
+
+        let expected = json!({
+            "type": "histogram2d",
+            "x": [1.0, 2.0, 2.0],
+            "y": [1.0, 1.0, 3.0],
+            "histfunc": "count",
+            "histnorm": "probability",
+            "autobinx": false,
+            "autobiny": false,
+            "nbinsx": 10,
+            "nbinsy": 10,
+            "xbins": {"start": 0.0, "end": 4.0, "size": 1.0},
+            "ybins": {"start": 0.0, "end": 4.0, "size": 1.0},
+            "colorscale": "Viridis",
+            "showscale": true,
+            "name": "hist2d",
+        });
+
+        assert_eq!(to_value(trace).unwrap(), expected);
+    }
+
+    #[test]
+    fn serialize_histogram2d_z_matrix() {
+        let trace = Histogram2d::new_xyz(
+            vec![0.0, 1.0],
+            vec![2.0, 3.0],
+            vec![vec![4.0, 5.0], vec![6.0, 7.0]],
+        )
+        .zauto(true)
+        .zmin(0.0)
+        .zmax(10.0)
+        .zmid(5.0)
+        .zsmooth(Smoothing::Best)
+        .x_gap(1.0)
+        .y_gap("10");
+
+        let expected = json!({
+            "type": "histogram2d",
+            "x": [0.0, 1.0],
+            "y": [2.0, 3.0],
+            "z": [[4.0, 5.0], [6.0, 7.0]],
+            "zauto": true,
+            "zmin": 0.0,
+            "zmax": 10.0,
+            "zmid": 5.0,
+            "zsmooth": "best",
+            "xgap": 1.0,
+            "ygap": "10",
+        });
+
+        assert_eq!(to_value(trace).unwrap(), expected);
+    }
+
+    #[test]
+    fn serialize_histogram2d_legend_and_uirevision() {
+        let trace = Histogram2d::new(vec![1.0], vec![2.0])
+            .legend_rank(7)
+            .legend_width(2.0)
+            .ui_revision("rev");
+        let v = to_value(trace).unwrap();
+        assert_eq!(v["legendrank"], json!(7));
+        assert_eq!(v["legendwidth"], json!(2.0));
+        assert_eq!(v["uirevision"], json!("rev"));
+    }
+}
diff --git a/plotly/src/traces/icicle.rs b/plotly/src/traces/icicle.rs
new file mode 100644
index 00000000..9bec009f
--- /dev/null
+++ b/plotly/src/traces/icicle.rs
@@ -0,0 +1,511 @@
+//! Icicle trace
+
+use plotly_derive::FieldSetter;
+use serde::Serialize;
+
+use crate::color::{Color, ColorArray};
+use crate::private::{NumOrString, NumOrStringCollection};
+use crate::{
+    common::{
+        ColorBar, ColorScale, Dim, Domain, Font, HoverInfo, Label, Line, Orientation, Pattern,
+        PlotType, Position,
+    },
+    Trace,
+};
+
+/// Determines how the items in `values` are summed up the hierarchy.
+///
+/// When set to `Remainder`, the value of a parent sector is the sum of its
+/// `values` plus the values of its child sectors. When set to `Total`, the
+/// value of a parent sector is taken to be the total of its child sectors.
+#[derive(Serialize, Clone, Debug)]
+#[serde(rename_all = "lowercase")]
+pub enum BranchValues {
+    Remainder,
+    Total,
+}
+
+/// Determines on which side of the icicle the `pathbar` should be presented.
+#[derive(Serialize, Clone, Debug)]
+#[serde(rename_all = "lowercase")]
+pub enum Side {
+    Top,
+    Bottom,
+}
+
+/// Configures the tiling behaviour of an [`Icicle`].
+///
+/// Unlike the treemap tiling, the icicle tiling has no packing algorithm; it is
+/// laid out along a single `orientation` (`h`/`v`).
+#[serde_with::skip_serializing_none]
+#[derive(Serialize, Clone, Debug, FieldSetter)]
+pub struct Tiling {
+    /// Sets the orientation of the icicle. With `Horizontal` (`"h"`) the root
+    /// is on the left, with `Vertical` (`"v"`) the root is on top.
+    orientation: Option<Orientation>,
+    /// Determines if the positions obtained from solver are flipped on each
+    /// axis. Valid combinations of `"x"` and `"y"` (e.g. `"x"`, `"y"`,
+    /// `"x+y"`).
+    flip: Option<String>,
+    /// Sets the inner padding (in px) between sectors.
+    pad: Option<f64>,
+}
+
+impl Tiling {
+    pub fn new() -> Self {
+        Default::default()
+    }
+}
+
+/// Configures the `pathbar` (the breadcrumb header) of an [`Icicle`].
+#[serde_with::skip_serializing_none]
+#[derive(Serialize, Clone, Debug, FieldSetter)]
+pub struct PathBar {
+    /// Determines if the path bar is drawn.
+    visible: Option<bool>,
+    /// Determines on which side of the icicle the path bar is presented.
+    side: Option<Side>,
+    /// Determines which shape is used to draw the edges between the path bar's
+    /// sectors. One of `">"`, `"<"`, `"|"`, `"/"` or `"\\"`.
+    #[serde(rename = "edgeshape")]
+    edge_shape: Option<String>,
+    /// Sets the thickness of the path bar (in px).
+    thickness: Option<usize>,
+    /// Sets the font used inside the path bar.
+    #[serde(rename = "textfont")]
+    text_font: Option<Font>,
+}
+
+impl PathBar {
+    pub fn new() -> Self {
+        Default::default()
+    }
+}
+
+/// Configures the leaves (deepest sectors) of an [`Icicle`].
+#[serde_with::skip_serializing_none]
+#[derive(Serialize, Clone, Debug, FieldSetter)]
+pub struct Leaf {
+    /// Sets the opacity of the leaves.
+    opacity: Option<f64>,
+}
+
+impl Leaf {
+    pub fn new() -> Self {
+        Default::default()
+    }
+}
+
+/// Configures the root sector of an [`Icicle`].
+#[serde_with::skip_serializing_none]
+#[derive(Serialize, Clone, Debug, FieldSetter)]
+pub struct Root {
+    /// Sets the color of the root node. If not set, `"rgba(0,0,0,0)"` is used
+    /// (a transparent root).
+    #[serde(rename = "color")]
+    #[field_setter(skip)]
+    color: Option<Box<dyn Color>>,
+}
+
+impl Root {
+    pub fn new() -> Self {
+        Default::default()
+    }
+
+    /// Sets the color of the root node.
+    pub fn color<C: Color>(mut self, color: C) -> Self {
+        self.color = Some(Box::new(color));
+        self
+    }
+}
+
+/// Configures the appearance of the sectors of an [`Icicle`].
+///
+/// This is an icicle-specific marker: it exposes the shared color/colorscale
+/// machinery but, unlike the treemap marker, has no `pad`, `corner_radius` or
+/// `depth_fade`.
+#[serde_with::skip_serializing_none]
+#[derive(Serialize, Clone, Debug, FieldSetter)]
+pub struct Marker {
+    /// Sets the color of each sector of the icicle. If not specified, the
+    /// default trace color set is used to pick the sector colors.
+    #[field_setter(skip)]
+    colors: Option<Vec<Box<dyn Color>>>,
+    /// Determines whether the colorscale is a default palette (`true`) or the
+    /// palette determined by `cmin` and `cmax`.
+    cauto: Option<bool>,
+    /// Sets the lower bound of the color domain.
+    cmin: Option<f64>,
+    /// Sets the upper bound of the color domain.
+    cmax: Option<f64>,
+    /// Sets the mid-point of the color domain by scaling `cmin` and/or `cmax`
+    /// to be equidistant to this point.
+    cmid: Option<f64>,
+    /// Sets the colorscale.
+    #[serde(rename = "colorscale")]
+    color_scale: Option<ColorScale>,
+    /// Determines whether the colorscale is picked using the sign of the input
+    /// `colors`.
+    #[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.
+    #[serde(rename = "showscale")]
+    show_scale: Option<bool>,
+    /// Sets the colorbar.
+    #[serde(rename = "colorbar")]
+    color_bar: Option<ColorBar>,
+    /// Sets the outline of the sectors.
+    line: Option<Line>,
+    /// Sets the pattern within the sectors.
+    pattern: Option<Pattern>,
+}
+
+impl Marker {
+    pub fn new() -> Self {
+        Default::default()
+    }
+
+    /// Sets the color of each sector of the icicle.
+    pub fn colors<C: Color>(mut self, colors: Vec<C>) -> Self {
+        self.colors = Some(ColorArray(colors).into());
+        self
+    }
+}
+
+/// Construct an Icicle trace.
+///
+/// Icicle charts visualize hierarchical data using rectangular sectors laid out
+/// along a single orientation. The hierarchy is defined via the `labels` and
+/// `parents` fields (the root is the item whose parent is an empty string).
+///
+/// # Examples
+///
+/// ```
+/// use plotly::Icicle;
+///
+/// let trace = Icicle::new(
+///     vec!["Eve", "Cain", "Seth"],
+///     vec!["", "Eve", "Eve"],
+/// )
+/// .values(vec![10, 14, 12]);
+///
+/// let expected = serde_json::json!({
+///     "type": "icicle",
+///     "labels": ["Eve", "Cain", "Seth"],
+///     "parents": ["", "Eve", "Eve"],
+///     "values": [10, 14, 12],
+/// });
+///
+/// assert_eq!(serde_json::to_value(trace).unwrap(), expected);
+/// ```
+#[serde_with::skip_serializing_none]
+#[derive(Serialize, Clone, Debug, FieldSetter)]
+#[field_setter(box_self, kind = "trace")]
+pub struct Icicle<V>
+where
+    V: Serialize + Clone,
+{
+    #[field_setter(default = "PlotType::Icicle")]
+    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<bool>,
+    /// Sets the opacity of the trace.
+    opacity: Option<f64>,
+    /// Assigns id labels to each datum. These ids are for object constancy of
+    /// data points during animation.
+    ids: Option<Vec<String>>,
+    /// Sets the labels of each of the sectors.
+    labels: Option<Vec<String>>,
+    /// Sets the parent sectors for each of the sectors. Empty string items
+    /// `""` are understood to reference the root node in the hierarchy.
+    parents: Option<Vec<String>>,
+    /// Sets the values associated with each of the sectors. Use with
+    /// `branch_values` to determine how the values are summed.
+    values: Option<Vec<V>>,
+    /// Determines how the items in `values` are summed. When set to
+    /// `Remainder`, the value of a parent is the sum of its `values` plus those
+    /// of its children. When set to `Total`, the value of a parent is the total
+    /// of its children.
+    #[serde(rename = "branchvalues")]
+    branch_values: Option<BranchValues>,
+    /// Determines default for `values` when it is not provided, by inferring a
+    /// `count`, i.e. the number of `"branches"` or `"leaves"`.
+    count: Option<String>,
+    /// Sets the level from which this trace hierarchy is rendered. Set `level`
+    /// to `""` to start from the root node in the hierarchy.
+    level: Option<NumOrString>,
+    /// Sets the number of rendered sectors from any given `level`. Set
+    /// `max_depth` to `-1` to render all the levels in the hierarchy.
+    #[serde(rename = "maxdepth")]
+    max_depth: Option<i32>,
+    /// Sets the domain within which this trace is drawn.
+    domain: Option<Domain>,
+    marker: Option<Marker>,
+    /// Sets the tiling behaviour of the icicle.
+    tiling: Option<Tiling>,
+    /// Sets the path bar (breadcrumb header) of the icicle.
+    #[serde(rename = "pathbar")]
+    path_bar: Option<PathBar>,
+    /// Sets the styling of the leaves (deepest sectors).
+    leaf: Option<Leaf>,
+    /// Sets the styling of the root sector.
+    root: Option<Root>,
+    /// Determines whether or not the sectors are reordered from largest to
+    /// smallest.
+    sort: Option<bool>,
+    /// Sets text elements associated with each sector. If trace `text_info`
+    /// contains a `"text"` flag, these elements will be seen on the chart.
+    text: Option<Dim<String>>,
+    /// Determines which trace information appears on the graph.
+    #[serde(rename = "textinfo")]
+    text_info: Option<String>,
+    /// Template string used for rendering the information text that appears on
+    /// points.
+    #[serde(rename = "texttemplate")]
+    text_template: Option<Dim<String>>,
+    #[serde(rename = "texttemplatefallback")]
+    text_template_fallback: Option<Dim<String>>,
+    /// Sets the font used for `text_info`.
+    #[serde(rename = "textfont")]
+    text_font: Option<Font>,
+    /// Sets the positions of the `text` elements.
+    #[serde(rename = "textposition")]
+    text_position: Option<Position>,
+    /// Sets the font used for `text_info` lying inside the sector.
+    #[serde(rename = "insidetextfont")]
+    inside_text_font: Option<Font>,
+    /// Sets the font used for `text_info` lying outside the sector.
+    #[serde(rename = "outsidetextfont")]
+    outside_text_font: Option<Font>,
+    /// Determines which trace information appears on hover.
+    #[serde(rename = "hoverinfo")]
+    hover_info: Option<HoverInfo>,
+    #[serde(rename = "hoverlabel")]
+    hover_label: Option<Label>,
+    /// Sets hover text elements associated with each sector.
+    #[serde(rename = "hovertext")]
+    hover_text: Option<Dim<String>>,
+    /// 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>>,
+    /// Assigns extra meta information associated with this trace that can be
+    /// used in various text attributes.
+    meta: Option<NumOrString>,
+    /// Assigns extra data to each datum that can be used in hover, click and
+    /// selection events.
+    #[serde(rename = "customdata")]
+    custom_data: Option<NumOrStringCollection>,
+    /// Assign an id to this trace. Use this to provide object constancy between
+    /// traces during animations and transitions.
+    uid: Option<String>,
+    /// 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.
+    #[serde(rename = "legendrank")]
+    legend_rank: Option<usize>,
+    /// Sets the width (in px or fraction) of the legend for this trace.
+    #[serde(rename = "legendwidth")]
+    legend_width: Option<f64>,
+    /// Controls persistence of user-driven changes to the trace. Defaults to
+    /// `layout.uirevision`.
+    #[serde(rename = "uirevision")]
+    ui_revision: Option<NumOrString>,
+}
+
+impl<V> Icicle<V>
+where
+    V: Serialize + Clone + 'static,
+{
+    /// Build a new Icicle trace from its `labels` and `parents`.
+    ///
+    /// The root sector is the one whose parent is an empty string `""`.
+    pub fn new<L, P>(labels: Vec<L>, parents: Vec<P>) -> Box<Self>
+    where
+        L: Into<String>,
+        P: Into<String>,
+    {
+        Box::new(Self {
+            labels: Some(labels.into_iter().map(Into::into).collect()),
+            parents: Some(parents.into_iter().map(Into::into).collect()),
+            ..Default::default()
+        })
+    }
+}
+
+impl<V> Trace for Icicle<V>
+where
+    V: 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_branch_values() {
+        assert_eq!(
+            to_value(BranchValues::Remainder).unwrap(),
+            json!("remainder")
+        );
+        assert_eq!(to_value(BranchValues::Total).unwrap(), json!("total"));
+    }
+
+    #[test]
+    fn serialize_tiling() {
+        let tiling = Tiling::new()
+            .orientation(Orientation::Vertical)
+            .flip("x+y")
+            .pad(2.0);
+        let expected = json!({
+            "orientation": "v",
+            "flip": "x+y",
+            "pad": 2.0,
+        });
+        assert_eq!(to_value(tiling).unwrap(), expected);
+    }
+
+    #[test]
+    fn serialize_path_bar() {
+        let path_bar = PathBar::new()
+            .visible(true)
+            .side(Side::Top)
+            .edge_shape(">")
+            .thickness(20)
+            .text_font(Font::new());
+        let expected = json!({
+            "visible": true,
+            "side": "top",
+            "edgeshape": ">",
+            "thickness": 20,
+            "textfont": {},
+        });
+        assert_eq!(to_value(path_bar).unwrap(), expected);
+    }
+
+    #[test]
+    fn serialize_leaf_and_root() {
+        assert_eq!(
+            to_value(Leaf::new().opacity(0.5)).unwrap(),
+            json!({"opacity": 0.5})
+        );
+        assert_eq!(
+            to_value(Root::new().color("red")).unwrap(),
+            json!({"color": "red"})
+        );
+    }
+
+    #[test]
+    fn serialize_marker() {
+        let marker = Marker::new()
+            .colors(vec!["#1f77b4", "#ff7f0e"])
+            .show_scale(true)
+            .cmin(0.0)
+            .cmax(10.0)
+            .line(Line::new().width(2.0))
+            .pattern(Pattern::new());
+        let expected = json!({
+            "colors": ["#1f77b4", "#ff7f0e"],
+            "showscale": true,
+            "cmin": 0.0,
+            "cmax": 10.0,
+            "line": {"width": 2.0},
+            "pattern": {},
+        });
+        assert_eq!(to_value(marker).unwrap(), expected);
+    }
+
+    #[test]
+    fn serialize_icicle() {
+        let trace = Icicle::new(vec!["Eve", "Cain", "Seth"], vec!["", "Eve", "Eve"])
+            .values(vec![10, 14, 12])
+            .branch_values(BranchValues::Total)
+            .count("leaves")
+            .level("Eve")
+            .max_depth(3)
+            .name("family")
+            .visible(true)
+            .opacity(0.8)
+            .ids(vec!["eve", "cain", "seth"])
+            .domain(Domain::new())
+            .marker(Marker::new())
+            .tiling(Tiling::new().orientation(Orientation::Horizontal))
+            .path_bar(PathBar::new().visible(true).side(Side::Top))
+            .leaf(Leaf::new().opacity(0.7))
+            .root(Root::new().color("rgba(0,0,0,0)"))
+            .sort(true)
+            .text_info("label+value")
+            .text_font(Font::new())
+            .text_position(Position::TopCenter)
+            .inside_text_font(Font::new())
+            .outside_text_font(Font::new())
+            .hover_info(HoverInfo::All)
+            .hover_label(Label::new())
+            .hover_template("%{label}: %{value}")
+            .meta("meta")
+            .custom_data(vec!["custom_data"])
+            .uid("uid-1");
+        let expected = json!({
+            "type": "icicle",
+            "labels": ["Eve", "Cain", "Seth"],
+            "parents": ["", "Eve", "Eve"],
+            "values": [10, 14, 12],
+            "branchvalues": "total",
+            "count": "leaves",
+            "level": "Eve",
+            "maxdepth": 3,
+            "name": "family",
+            "visible": true,
+            "opacity": 0.8,
+            "ids": ["eve", "cain", "seth"],
+            "domain": {},
+            "marker": {},
+            "tiling": {"orientation": "h"},
+            "pathbar": {"visible": true, "side": "top"},
+            "leaf": {"opacity": 0.7},
+            "root": {"color": "rgba(0,0,0,0)"},
+            "sort": true,
+            "textinfo": "label+value",
+            "textfont": {},
+            "textposition": "top center",
+            "insidetextfont": {},
+            "outsidetextfont": {},
+            "hoverinfo": "all",
+            "hoverlabel": {},
+            "hovertemplate": "%{label}: %{value}",
+            "meta": "meta",
+            "customdata": ["custom_data"],
+            "uid": "uid-1",
+        });
+
+        assert_eq!(to_value(trace).unwrap(), expected);
+    }
+
+    #[test]
+    fn serialize_icicle_legend_and_uirevision() {
+        let trace = Icicle::new(vec!["Eve"], vec![""])
+            .values(vec![10])
+            .legend_rank(7)
+            .legend_width(2.0)
+            .ui_revision("rev");
+        let v = to_value(trace).unwrap();
+        assert_eq!(v["legendrank"], json!(7));
+        assert_eq!(v["legendwidth"], json!(2.0));
+        assert_eq!(v["uirevision"], json!("rev"));
+    }
+}
diff --git a/plotly/src/traces/indicator.rs b/plotly/src/traces/indicator.rs
new file mode 100644
index 00000000..3ed9e51e
--- /dev/null
+++ b/plotly/src/traces/indicator.rs
@@ -0,0 +1,665 @@
+//! Indicator trace
+
+use std::collections::HashMap;
+
+use plotly_derive::FieldSetter;
+use serde::Serialize;
+
+use crate::color::Color;
+use crate::layout::{ArrayShow, TicksDirection};
+use crate::private::{NumOrString, NumOrStringCollection};
+use crate::{
+    common::{Domain, ExponentFormat, Font, Line, PlotType, TickFormatStop, TickMode},
+    Trace,
+};
+
+/// Determines how the value is displayed: as a `number`, a `delta` relative to
+/// a reference, a `gauge`, or any combination of the three.
+#[derive(Serialize, Clone, Debug)]
+#[serde(rename_all = "lowercase")]
+pub enum Mode {
+    Number,
+    Delta,
+    Gauge,
+    #[serde(rename = "number+delta")]
+    NumberAndDelta,
+    #[serde(rename = "number+gauge")]
+    NumberAndGauge,
+    #[serde(rename = "delta+gauge")]
+    DeltaAndGauge,
+    #[serde(rename = "number+delta+gauge")]
+    NumberAndDeltaAndGauge,
+}
+
+/// Horizontal alignment of the number and delta within their container.
+#[derive(Serialize, Clone, Debug)]
+#[serde(rename_all = "lowercase")]
+pub enum Align {
+    Left,
+    Center,
+    Right,
+}
+
+/// Sets the position of the delta relative to the number.
+#[derive(Serialize, Clone, Debug)]
+#[serde(rename_all = "lowercase")]
+pub enum DeltaPosition {
+    Top,
+    Bottom,
+    Left,
+    Right,
+}
+
+/// Sets the shape of the gauge.
+#[derive(Serialize, Clone, Debug)]
+#[serde(rename_all = "lowercase")]
+pub enum GaugeShape {
+    Angular,
+    Bullet,
+}
+
+/// Sets the title of the indicator.
+#[serde_with::skip_serializing_none]
+#[derive(Serialize, Clone, Debug, FieldSetter)]
+pub struct IndicatorTitle {
+    /// Sets the title text.
+    text: Option<String>,
+    /// Sets the horizontal alignment of the title.
+    align: Option<Align>,
+    /// Sets the font used to display the title.
+    font: Option<Font>,
+}
+
+impl IndicatorTitle {
+    pub fn new() -> Self {
+        Default::default()
+    }
+}
+
+/// Configures how the displayed number is formatted.
+#[serde_with::skip_serializing_none]
+#[derive(Serialize, Clone, Debug, FieldSetter)]
+pub struct Number {
+    /// Sets the value formatting rule using d3 formatting mini-languages.
+    #[serde(rename = "valueformat")]
+    value_format: Option<String>,
+    /// Sets a prefix appearing before the number.
+    prefix: Option<String>,
+    /// Sets a suffix appearing after the number.
+    suffix: Option<String>,
+    /// Sets the font used to display the number.
+    font: Option<Font>,
+}
+
+impl Number {
+    pub fn new() -> Self {
+        Default::default()
+    }
+}
+
+/// Configures the styling of an increasing or decreasing delta.
+#[serde_with::skip_serializing_none]
+#[derive(Serialize, Clone, Debug, FieldSetter)]
+pub struct Direction {
+    /// Sets the symbol to display for this delta direction.
+    symbol: Option<String>,
+    /// Sets the color for this delta direction.
+    #[serde(rename = "color")]
+    #[field_setter(skip)]
+    color: Option<Box<dyn Color>>,
+}
+
+impl Direction {
+    pub fn new() -> Self {
+        Default::default()
+    }
+
+    /// Sets the color for this delta direction.
+    pub fn color<C: Color>(mut self, color: C) -> Self {
+        self.color = Some(Box::new(color));
+        self
+    }
+}
+
+/// Configures the delta (change relative to a reference value).
+#[serde_with::skip_serializing_none]
+#[derive(Serialize, Clone, Debug, FieldSetter)]
+pub struct Delta {
+    /// Sets the reference value against which the delta is computed.
+    reference: Option<f64>,
+    /// Shows the delta as a percentage of the reference if `true`.
+    relative: Option<bool>,
+    /// Sets the value formatting rule using d3 formatting mini-languages.
+    #[serde(rename = "valueformat")]
+    value_format: Option<String>,
+    /// Sets the position of the delta relative to the number.
+    position: Option<DeltaPosition>,
+    /// Sets a prefix appearing before the delta.
+    prefix: Option<String>,
+    /// Sets a suffix appearing after the delta.
+    suffix: Option<String>,
+    /// Sets the font used to display the delta.
+    font: Option<Font>,
+    /// Sets the styling used when the delta is increasing.
+    increasing: Option<Direction>,
+    /// Sets the styling used when the delta is decreasing.
+    decreasing: Option<Direction>,
+}
+
+impl Delta {
+    pub fn new() -> Self {
+        Default::default()
+    }
+}
+
+/// Configures the axis of a gauge (its range and ticks).
+///
+/// This mirrors the subset of a Cartesian axis that Plotly.js exposes on
+/// `indicator.gauge.axis`: a numeric `range` plus the full tick-styling
+/// machinery. It is intentionally distinct from [`crate::layout::Axis`], which
+/// carries many attributes (grid lines, spikes, range sliders, subplot
+/// anchoring, …) that a gauge axis does not support.
+#[serde_with::skip_serializing_none]
+#[derive(Serialize, Clone, Debug, FieldSetter)]
+pub struct GaugeAxis {
+    /// Sets the range of the gauge axis.
+    range: Option<[f64; 2]>,
+    /// Determines whether or not the gauge axis is visible.
+    visible: Option<bool>,
+    /// Sets the tick mode of the gauge axis.
+    #[serde(rename = "tickmode")]
+    tick_mode: Option<TickMode>,
+    /// Sets the number of ticks (with `tick_mode` [`TickMode::Auto`]).
+    #[serde(rename = "nticks")]
+    n_ticks: Option<usize>,
+    /// Sets the placement of the first tick (with `tick_mode`
+    /// [`TickMode::Linear`]).
+    tick0: Option<f64>,
+    /// Sets the step between ticks (with `tick_mode` [`TickMode::Linear`]).
+    dtick: Option<f64>,
+    /// Sets the values at which ticks are drawn (with `tick_mode`
+    /// [`TickMode::Array`]).
+    #[serde(rename = "tickvals")]
+    tick_vals: Option<Vec<f64>>,
+    /// Sets the text displayed at the tick values (with `tick_mode`
+    /// [`TickMode::Array`]).
+    #[serde(rename = "ticktext")]
+    tick_text: Option<Vec<String>>,
+    /// Determines whether ticks are drawn inside or outside the axis line.
+    ticks: Option<TicksDirection>,
+    /// Sets the tick length (in px).
+    #[serde(rename = "ticklen")]
+    tick_length: Option<usize>,
+    /// Sets the tick width (in px).
+    #[serde(rename = "tickwidth")]
+    tick_width: Option<usize>,
+    /// Sets the tick color.
+    #[serde(rename = "tickcolor")]
+    #[field_setter(skip)]
+    tick_color: Option<Box<dyn Color>>,
+    /// Determines whether or not the tick labels are drawn.
+    #[serde(rename = "showticklabels")]
+    show_tick_labels: Option<bool>,
+    /// Sets the font used for the tick labels.
+    #[serde(rename = "tickfont")]
+    tick_font: Option<Font>,
+    /// Sets the angle (in degrees) of the tick labels.
+    #[serde(rename = "tickangle")]
+    tick_angle: Option<f64>,
+    /// Sets a prefix appearing before each tick label.
+    #[serde(rename = "tickprefix")]
+    tick_prefix: Option<String>,
+    /// Determines on which ticks the prefix is shown.
+    #[serde(rename = "showtickprefix")]
+    show_tick_prefix: Option<ArrayShow>,
+    /// Sets a suffix appearing after each tick label.
+    #[serde(rename = "ticksuffix")]
+    tick_suffix: Option<String>,
+    /// Determines on which ticks the suffix is shown.
+    #[serde(rename = "showticksuffix")]
+    show_tick_suffix: Option<ArrayShow>,
+    /// Determines on which ticks the exponent is shown.
+    #[serde(rename = "showexponent")]
+    show_exponent: Option<ArrayShow>,
+    /// Determines the formatting of exponents.
+    #[serde(rename = "exponentformat")]
+    exponent_format: Option<ExponentFormat>,
+    /// Sets the smallest exponent that gets a suffix/prefix (with
+    /// `exponent_format` [`ExponentFormat::SI`]/[`ExponentFormat::B`]).
+    #[serde(rename = "minexponent")]
+    min_exponent: Option<usize>,
+    /// Determines whether thousands are separated (e.g. `1,000,000`).
+    #[serde(rename = "separatethousands")]
+    separate_thousands: Option<bool>,
+    /// Sets the tick label formatting rule using d3 formatting
+    /// mini-languages.
+    #[serde(rename = "tickformat")]
+    tick_format: Option<String>,
+    /// Sets conditional tick-label formatting rules by range.
+    #[serde(rename = "tickformatstops")]
+    tick_format_stops: Option<Vec<TickFormatStop>>,
+    /// Sets the spacing between tick labels: every n-th label is shown.
+    #[serde(rename = "ticklabelstep")]
+    tick_label_step: Option<usize>,
+    /// Replaces specific tick labels with the provided aliases.
+    #[serde(rename = "labelalias")]
+    label_alias: Option<HashMap<String, String>>,
+}
+
+impl GaugeAxis {
+    pub fn new() -> Self {
+        Default::default()
+    }
+
+    /// Sets the tick color.
+    pub fn tick_color<C: Color>(mut self, color: C) -> Self {
+        self.tick_color = Some(Box::new(color));
+        self
+    }
+}
+
+/// Configures the value bar drawn inside a gauge.
+#[serde_with::skip_serializing_none]
+#[derive(Serialize, Clone, Debug, FieldSetter)]
+pub struct GaugeBar {
+    /// Sets the background color of the value bar.
+    #[serde(rename = "color")]
+    #[field_setter(skip)]
+    color: Option<Box<dyn Color>>,
+    /// Sets the outline of the value bar.
+    line: Option<Line>,
+    /// Sets the thickness of the value bar relative to the gauge (0 to 1).
+    thickness: Option<f64>,
+}
+
+impl GaugeBar {
+    pub fn new() -> Self {
+        Default::default()
+    }
+
+    /// Sets the background color of the value bar.
+    pub fn color<C: Color>(mut self, color: C) -> Self {
+        self.color = Some(Box::new(color));
+        self
+    }
+}
+
+/// Configures a colored step (band) drawn along the gauge axis.
+#[serde_with::skip_serializing_none]
+#[derive(Serialize, Clone, Debug, FieldSetter)]
+pub struct Step {
+    /// Sets the range this step covers along the gauge axis.
+    range: Option<[f64; 2]>,
+    /// Sets the color of this step.
+    #[serde(rename = "color")]
+    #[field_setter(skip)]
+    color: Option<Box<dyn Color>>,
+    /// Sets the outline of this step.
+    line: Option<Line>,
+    /// Sets the thickness of this step relative to the gauge (0 to 1).
+    thickness: Option<f64>,
+}
+
+impl Step {
+    pub fn new() -> Self {
+        Default::default()
+    }
+
+    /// Sets the color of this step.
+    pub fn color<C: Color>(mut self, color: C) -> Self {
+        self.color = Some(Box::new(color));
+        self
+    }
+}
+
+/// Configures a threshold marker drawn across the gauge.
+#[serde_with::skip_serializing_none]
+#[derive(Serialize, Clone, Debug, FieldSetter)]
+pub struct Threshold {
+    /// Sets the line drawn at the threshold value.
+    line: Option<Line>,
+    /// Sets the thickness of the threshold line relative to the gauge (0 to 1).
+    thickness: Option<f64>,
+    /// Sets the value at which the threshold is drawn.
+    value: Option<f64>,
+}
+
+impl Threshold {
+    pub fn new() -> Self {
+        Default::default()
+    }
+}
+
+/// Configures the gauge (the angular or bullet visualization).
+#[serde_with::skip_serializing_none]
+#[derive(Serialize, Clone, Debug, FieldSetter)]
+pub struct Gauge {
+    /// Sets the shape of the gauge.
+    shape: Option<GaugeShape>,
+    /// Sets the gauge axis (range and ticks).
+    axis: Option<GaugeAxis>,
+    /// Sets the value bar drawn inside the gauge.
+    bar: Option<GaugeBar>,
+    /// Sets the gauge background color.
+    #[serde(rename = "bgcolor")]
+    #[field_setter(skip)]
+    background_color: Option<Box<dyn Color>>,
+    /// Sets the color of the gauge border.
+    #[serde(rename = "bordercolor")]
+    #[field_setter(skip)]
+    border_color: Option<Box<dyn Color>>,
+    /// Sets the width (in px) of the gauge border.
+    #[serde(rename = "borderwidth")]
+    border_width: Option<f64>,
+    /// Sets the colored steps (bands) along the gauge axis.
+    steps: Option<Vec<Step>>,
+    /// Sets the threshold marker.
+    threshold: Option<Threshold>,
+}
+
+impl Gauge {
+    pub fn new() -> Self {
+        Default::default()
+    }
+
+    /// Sets the gauge background color.
+    pub fn background_color<C: Color>(mut self, color: C) -> Self {
+        self.background_color = Some(Box::new(color));
+        self
+    }
+
+    /// Sets the color of the gauge border.
+    pub fn border_color<C: Color>(mut self, color: C) -> Self {
+        self.border_color = Some(Box::new(color));
+        self
+    }
+}
+
+/// Construct an Indicator trace.
+///
+/// Indicators display a single `value`, optionally with a `delta` relative to a
+/// reference and/or a `gauge`. They are commonly used for KPI tiles.
+///
+/// # Examples
+///
+/// ```
+/// use plotly::Indicator;
+/// use plotly::traces::indicator::{Delta, Mode};
+///
+/// let trace = Indicator::new(120.0)
+///     .mode(Mode::NumberAndDelta)
+///     .delta(Delta::new().reference(100.0));
+///
+/// let expected = serde_json::json!({
+///     "type": "indicator",
+///     "value": 120.0,
+///     "mode": "number+delta",
+///     "delta": {"reference": 100.0},
+/// });
+///
+/// assert_eq!(serde_json::to_value(trace).unwrap(), expected);
+/// ```
+#[serde_with::skip_serializing_none]
+#[derive(Serialize, Clone, Debug, FieldSetter)]
+#[field_setter(box_self, kind = "trace")]
+pub struct Indicator {
+    #[field_setter(default = "PlotType::Indicator")]
+    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<bool>,
+    /// Determines how the value is displayed (number, delta, gauge or a
+    /// combination).
+    mode: Option<Mode>,
+    /// Sets the number to be displayed.
+    value: Option<f64>,
+    /// Sets the horizontal alignment of the number and delta.
+    align: Option<Align>,
+    /// Sets the domain within which this trace is drawn.
+    domain: Option<Domain>,
+    /// Sets the title of the indicator.
+    title: Option<IndicatorTitle>,
+    /// Configures how the displayed number is formatted.
+    number: Option<Number>,
+    /// Configures the delta relative to a reference value.
+    delta: Option<Delta>,
+    /// Configures the gauge visualization.
+    gauge: Option<Gauge>,
+    /// Assigns extra meta information associated with this trace that can be
+    /// used in various text attributes.
+    meta: Option<NumOrString>,
+    /// Assigns extra data to each datum that can be used in hover, click and
+    /// selection events.
+    #[serde(rename = "customdata")]
+    custom_data: Option<NumOrStringCollection>,
+    /// Assign an id to this trace. Use this to provide object constancy between
+    /// traces during animations and transitions.
+    uid: Option<String>,
+    /// 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.
+    #[serde(rename = "legendrank")]
+    legend_rank: Option<usize>,
+    /// Sets the width (in px or fraction) of the legend for this trace.
+    #[serde(rename = "legendwidth")]
+    legend_width: Option<f64>,
+    /// Controls persistence of user-driven changes to the trace. Defaults to
+    /// `layout.uirevision`.
+    #[serde(rename = "uirevision")]
+    ui_revision: Option<NumOrString>,
+}
+
+impl Indicator {
+    /// Build a new Indicator trace displaying `value`.
+    pub fn new(value: f64) -> Box<Self> {
+        Box::new(Self {
+            value: Some(value),
+            ..Default::default()
+        })
+    }
+}
+
+impl Trace for Indicator {
+    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_mode() {
+        assert_eq!(to_value(Mode::Number).unwrap(), json!("number"));
+        assert_eq!(
+            to_value(Mode::NumberAndDelta).unwrap(),
+            json!("number+delta")
+        );
+        assert_eq!(
+            to_value(Mode::NumberAndDeltaAndGauge).unwrap(),
+            json!("number+delta+gauge")
+        );
+    }
+
+    #[test]
+    fn serialize_number_and_delta() {
+        let trace = Indicator::new(120.0)
+            .mode(Mode::NumberAndDelta)
+            .align(Align::Center)
+            .title(IndicatorTitle::new().text("Revenue"))
+            .number(Number::new().prefix("$").value_format(".2f"))
+            .delta(
+                Delta::new()
+                    .reference(100.0)
+                    .relative(true)
+                    .position(DeltaPosition::Top)
+                    .increasing(Direction::new().color("green").symbol("▲"))
+                    .decreasing(Direction::new().color("red").symbol("▼")),
+            )
+            .domain(Domain::new());
+
+        let expected = json!({
+            "type": "indicator",
+            "value": 120.0,
+            "mode": "number+delta",
+            "align": "center",
+            "title": {"text": "Revenue"},
+            "number": {"prefix": "$", "valueformat": ".2f"},
+            "delta": {
+                "reference": 100.0,
+                "relative": true,
+                "position": "top",
+                "increasing": {"color": "green", "symbol": "▲"},
+                "decreasing": {"color": "red", "symbol": "▼"},
+            },
+            "domain": {},
+        });
+
+        assert_eq!(to_value(trace).unwrap(), expected);
+    }
+
+    #[test]
+    fn serialize_gauge() {
+        let trace = Indicator::new(270.0).mode(Mode::Gauge).gauge(
+            Gauge::new()
+                .shape(GaugeShape::Angular)
+                .axis(GaugeAxis::new().range([0.0, 500.0]))
+                .bar(GaugeBar::new().color("darkblue").thickness(0.75))
+                .background_color("white")
+                .border_color("gray")
+                .border_width(1.0)
+                .steps(vec![
+                    Step::new().range([0.0, 250.0]).color("lightgray"),
+                    Step::new().range([250.0, 400.0]).color("gray"),
+                ])
+                .threshold(
+                    Threshold::new()
+                        .line(Line::new().color("red").width(4.0))
+                        .thickness(0.75)
+                        .value(490.0),
+                ),
+        );
+
+        let expected = json!({
+            "type": "indicator",
+            "value": 270.0,
+            "mode": "gauge",
+            "gauge": {
+                "shape": "angular",
+                "axis": {"range": [0.0, 500.0]},
+                "bar": {"color": "darkblue", "thickness": 0.75},
+                "bgcolor": "white",
+                "bordercolor": "gray",
+                "borderwidth": 1.0,
+                "steps": [
+                    {"range": [0.0, 250.0], "color": "lightgray"},
+                    {"range": [250.0, 400.0], "color": "gray"},
+                ],
+                "threshold": {
+                    "line": {"color": "red", "width": 4.0},
+                    "thickness": 0.75,
+                    "value": 490.0,
+                },
+            },
+        });
+
+        assert_eq!(to_value(trace).unwrap(), expected);
+    }
+
+    #[test]
+    fn serialize_gauge_axis() {
+        let axis = GaugeAxis::new()
+            .range([0.0, 100.0])
+            .visible(true)
+            .tick_mode(TickMode::Array)
+            .n_ticks(5)
+            .tick0(0.0)
+            .dtick(10.0)
+            .tick_vals(vec![0.0, 50.0, 100.0])
+            .tick_text(vec![
+                "low".to_string(),
+                "mid".to_string(),
+                "high".to_string(),
+            ])
+            .ticks(TicksDirection::Outside)
+            .tick_length(8)
+            .tick_width(2)
+            .tick_color("gray")
+            .show_tick_labels(true)
+            .tick_font(Font::new())
+            .tick_angle(45.0)
+            .tick_prefix("$")
+            .show_tick_prefix(ArrayShow::All)
+            .tick_suffix("k")
+            .show_tick_suffix(ArrayShow::Last)
+            .show_exponent(ArrayShow::First)
+            .exponent_format(ExponentFormat::SI)
+            .min_exponent(3)
+            .separate_thousands(true)
+            .tick_format(".2f")
+            .tick_label_step(2);
+
+        let expected = json!({
+            "range": [0.0, 100.0],
+            "visible": true,
+            "tickmode": "array",
+            "nticks": 5,
+            "tick0": 0.0,
+            "dtick": 10.0,
+            "tickvals": [0.0, 50.0, 100.0],
+            "ticktext": ["low", "mid", "high"],
+            "ticks": "outside",
+            "ticklen": 8,
+            "tickwidth": 2,
+            "tickcolor": "gray",
+            "showticklabels": true,
+            "tickfont": {},
+            "tickangle": 45.0,
+            "tickprefix": "$",
+            "showtickprefix": "all",
+            "ticksuffix": "k",
+            "showticksuffix": "last",
+            "showexponent": "first",
+            "exponentformat": "SI",
+            "minexponent": 3,
+            "separatethousands": true,
+            "tickformat": ".2f",
+            "ticklabelstep": 2,
+        });
+
+        assert_eq!(to_value(axis).unwrap(), expected);
+    }
+
+    #[test]
+    fn serialize_gauge_axis_label_alias_and_format_stops() {
+        use std::collections::HashMap;
+
+        let mut alias = HashMap::new();
+        alias.insert("0".to_string(), "min".to_string());
+        let axis = GaugeAxis::new()
+            .label_alias(alias)
+            .tick_format_stops(vec![TickFormatStop::new()]);
+
+        let v = to_value(axis).unwrap();
+        assert_eq!(v["labelalias"], json!({"0": "min"}));
+        assert!(v["tickformatstops"].is_array());
+    }
+
+    #[test]
+    fn serialize_indicator_legend_and_uirevision() {
+        let trace = Indicator::new(1.0)
+            .legend_rank(7)
+            .legend_width(2.0)
+            .ui_revision("rev");
+        let v = to_value(trace).unwrap();
+        assert_eq!(v["legendrank"], json!(7));
+        assert_eq!(v["legendwidth"], json!(2.0));
+        assert_eq!(v["uirevision"], json!("rev"));
+    }
+}
diff --git a/plotly/src/traces/mod.rs b/plotly/src/traces/mod.rs
index 850dfe13..79e7dca4 100644
--- a/plotly/src/traces/mod.rs
+++ b/plotly/src/traces/mod.rs
@@ -10,7 +10,10 @@ pub mod density_map;
 mod density_mapbox;
 pub mod heat_map;
 pub mod histogram;
+pub mod histogram2d;
+pub mod icicle;
 pub mod image;
+pub mod indicator;
 pub mod mesh3d;
 mod ohlc;
 pub mod pie;
@@ -37,6 +40,9 @@ pub use density_map::DensityMap;
 pub use density_mapbox::DensityMapbox;
 pub use heat_map::HeatMap;
 pub use histogram::Histogram;
+pub use histogram2d::Histogram2d;
+pub use icicle::Icicle;
+pub use indicator::Indicator;
 pub use mesh3d::Mesh3D;
 pub use ohlc::Ohlc;
 pub use pie::Pie;