diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index a9431a21..8ebaac0b 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -51,7 +51,7 @@ jobs:
       # lint the main library workspace for non-wasm target
       - run: cargo clippy --features all -- -D warnings -A deprecated
       # lint the non-wasm examples
-      - run: cd ${{ github.workspace }}/examples && cargo clippy --workspace --exclude "wasm*" --exclude "kaleido" -- -D warnings
+      - run: cd ${{ github.workspace }}/examples && cargo clippy --workspace --exclude "wasm*" -- -D warnings
       # lint the plotly library for wasm target
       - run: cargo clippy --package plotly --target wasm32-unknown-unknown -- -D warnings
       # lint the wasm examples
@@ -67,9 +67,8 @@ jobs:
         with:
           package: plotly
           feature-group: only-explicit-features
-          features: kaleido
+          features: static_export_chromedriver
           rust-toolchain: stable
-          release-type: minor
 
   test:
     name: Tests
@@ -135,7 +134,7 @@ jobs:
       # Run tests on Ubuntu with Chrome
       - name: Run tests (${{ matrix.os }} - Chrome)
         if: matrix.os == 'ubuntu-latest' && matrix.browser == 'chrome'
-        run: cargo test --workspace --features ${{ matrix.features }} --exclude plotly_kaleido
+        run: cargo test --workspace --features ${{ matrix.features }}
 
       # Install xvfb for Firefox WebGL support
       - name: Install xvfb
@@ -157,12 +156,12 @@ jobs:
           echo "BROWSER_PATH: $BROWSER_PATH"
           echo "RUST_LOG: $RUST_LOG"
           
-          xvfb-run -s "-screen 0 1920x1080x24" cargo test --workspace --features ${{ matrix.features }} --exclude plotly_kaleido
+          xvfb-run -s "-screen 0 1920x1080x24" cargo test --workspace --features ${{ matrix.features }}
 
       # Run tests on macOS with Chrome
       - name: Run tests (${{ matrix.os }} - Chrome)
         if: matrix.os == 'macos-latest' && matrix.browser == 'chrome'
-        run: cargo test --workspace --features ${{ matrix.features }} --exclude plotly_kaleido
+        run: cargo test --workspace --features ${{ matrix.features }}
 
       # Run tests on Windows with Chrome WebDriver
       - name: Run tests (${{ matrix.os }} - Chrome)
@@ -180,7 +179,7 @@ jobs:
           Write-Host "WEBDRIVER_PATH: $env:WEBDRIVER_PATH"
           Write-Host "BROWSER_PATH: $env:BROWSER_PATH"
 
-          cargo test --workspace --features ${{ matrix.features }} --exclude plotly_kaleido          
+          cargo test --workspace --features ${{ matrix.features }}          
 
       - name: Upload static image(s) artifact
         uses: actions/upload-artifact@v4
@@ -218,7 +217,6 @@ jobs:
           customization/multiple_plots_example,
           financial_charts,
           images,
-          kaleido,
           maps,
           ndarray,
           scientific_charts,
diff --git a/.github/workflows/publish_plotly_kaleido.yml b/.github/workflows/publish_plotly_kaleido.yml
deleted file mode 100644
index 6c68c821..00000000
--- a/.github/workflows/publish_plotly_kaleido.yml
+++ /dev/null
@@ -1,16 +0,0 @@
-name: Publish plotly-kaleido
-
-on:
-  workflow_dispatch:
-
-jobs:
-  create-crates-io-release:
-    name: Deploy to crates.io
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v4
-    - uses: dtolnay/rust-toolchain@stable
-    - run: cargo login ${{ env.CRATES_IO_TOKEN }}
-      env:
-        CRATES_IO_TOKEN: ${{ secrets.CRATES_IO_TOKEN }}
-    - run: cargo publish --allow-dirty -p plotly_kaleido
\ No newline at end of file
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index e32ec3a8..df2f88ab 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -22,8 +22,6 @@ jobs:
         install-chromedriver: true        
     - run: cargo publish --allow-dirty -p plotly_derive
     - run: sleep 10
-    - run: cargo publish --allow-dirty -p plotly_kaleido
-    - run: sleep 10
     - run: cargo publish --allow-dirty -p plotly
     # plotly_static is not part of the same ecosystem yet so it doesn't use the same TOKEN
     # - run: sleep 10
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6913daa1..194d2218 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,12 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/) a
 
 ## [Unreleased]
 
+## [0.15.0] - 2026-10-18
+
+This is the last release bundling plotly.js 3.x; the upgrade to plotly.js 4.x is planned for 0.16.0 ([#437](https://github.com/plotly/plotly.rs/issues/437)).
+
+Highlights: plotly.rs now exposes every non-deprecated plotly.js 3.7 trace type ([#422](https://github.com/plotly/plotly.rs/issues/422)) — 27 trace types are new since 0.14.1 — adds the MapLibre `map`, ternary and Smith chart subplots, and drops the deprecated Kaleido backend. Breaking changes are marked **Breaking** below.
+
 ### Added
 
 - [[#406](https://github.com/plotly/plotly.rs/issues/406)] Expose `plotly.js` 3.1–3.6 attributes
@@ -13,19 +19,42 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/) a
 - [[#412](https://github.com/plotly/plotly.rs/pull/412)] Add `Violin` trace type with box, mean line, KDE span, and split/grouped support
 - [[#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
 - [[#417](https://github.com/plotly/plotly.rs/issues/417)] Add `ScatterMap` (MapLibre `map` subplot) trace type — the modern counterpart to `ScatterMapbox`
-- Add `Funnel` trace type (bar-like, cartesian) with `Connector` and `FunnelHoverInfo` options, plus the layout-level `funnelmode`/`funnelgap`/`funnelgroupgap` attributes and a `FunnelMode` enum
-- Add `Waterfall` trace type (bar-like, cartesian) with a typed `Measure` enum (`absolute`/`relative`/`total`), per-class `increasing`/`decreasing`/`totals` styling via `MeasureStyle`, a `Connector` with `ConnectorMode`, and a `WaterfallHoverInfo` enum. The layout-level `waterfallmode`/`waterfallgap`/`waterfallgroupgap` attributes and the `WaterfallMode` enum already existed
 - [[#418](https://github.com/plotly/plotly.rs/issues/418)] Add native point clustering to `ScatterMap` via a `Cluster` option
 - [[#421](https://github.com/plotly/plotly.rs/pull/421)] Backfill trace attributes for trace types to bring them to parity with  plotly.js 3.7 
 - [[#422](https://github.com/plotly/plotly.rs/issues/422)] Add `Indicator`, `Histogram2d`, `Icicle` trace types 
 - [[#425](https://github.com/plotly/plotly.rs/issues/425)] Add `Splom` and `Parcats` trace types (scatter-plot matrix and parallel categories) 
 - [[#432](https://github.com/plotly/plotly.rs/issues/432)] Add `Funnel` and `Waterfall` trace types
+- [[#422](https://github.com/plotly/plotly.rs/issues/422)] Complete trace-type coverage for plotly.js 3.7: add `BarPolar`, `FunnelArea`, `Cone`, `StreamTube`, `IsoSurface`, `Volume`, `Parcoords`, `ScatterTernary`, `ScatterSmith`, `Carpet`, `ScatterCarpet`, `ContourCarpet` and `Histogram2dContour` (which previously had a `PlotType` variant but no trace to emit it). Every non-deprecated plotly.js 3.7 trace type is now exposed. The new traces omit Chart Studio `*src` attributes, which plotly.js 4 removes
+- [[#422](https://github.com/plotly/plotly.rs/issues/422)] Add the ternary and Smith chart subplots (`LayoutTernary`/`TernaryAxis`, `LayoutSmith`/`RealAxis`/`ImaginaryAxis`), polar-subplot `bar_mode`/`bar_gap` (`PolarBarMode`) for `BarPolar`, the `funnelareacolorway`/`extendfunnelareacolors`/`hiddenlabels` layout attributes, and `ThetaUnit::Gradians` (breaking for exhaustive matches on `ThetaUnit`)
+- [[#422](https://github.com/plotly/plotly.rs/issues/422)] Examples and mdBook recipe pages for every new trace type: polar bar, parallel coordinates, funnel area, vector field (cone/streamtube), isosurface/volume, ternary, Smith and carpet charts, and 2D histogram contours
 
 ### Changed
 
 - [[#406](https://github.com/plotly/plotly.rs/issues/406)] Upgrade bundled plotly.js from 3.0.1 to 3.6.0
 - [[#419](https://github.com/plotly/plotly.rs/issues/419)] Upgrade bundled plotly.js from 3.6.0 to 3.7.0
 - [[#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)
+- `plotly_static` bumped to 0.2.0 (breaking: `ImageFormat::EPS` removed)
+- Bump `darling` to 0.24 and `syn` to 3 in `plotly_derive`, and `dirs` to 7 in `plotly_static`
+- Bump example dependencies: `reqwest` 0.13, `env_logger` 0.11, `itertools` 0.15, `ndarray` 0.17, `rand`/`rand_chacha` 0.10
+- Theme statics in `plotly::layout::themes` (`DEFAULT`, `PLOTLY_WHITE`, `PLOTLY_DARK`, …) are now `std::sync::LazyLock<Template>` instead of `once_cell::sync::Lazy<Template>`; the `once_cell` dependency is dropped. Code that only dereferences them is unaffected
+- Add `# Errors`/`# Panics` sections to public fallible APIs and tidy doc formatting (clippy `missing_errors_doc`, `missing_panics_doc`, `doc_markdown`)
+- **Breaking**: `mesh3d::LightPosition` fields `x`/`y`/`z` are now `f64` instead of `Vec<f64>`. plotly.js expects a single number per coordinate and silently ignored the arrays, so `Mesh3D` light positions never took effect. Replace e.g. `.x(vec![10.0])` with `.x(10.0)`. `LightPosition` and `Lighting` are now also used by the new `Cone`, `StreamTube`, `IsoSurface` and `Volume` traces
+
+### Removed
+
+- The deprecated Kaleido static export backend: the `plotly_kaleido` crate is no longer part of the workspace, and the `kaleido` and `kaleido_download` features are gone. Use the `static_export_*` features (`plotly_static`) instead
+- The deprecated `ImageFormat::EPS` variant. Use `ImageFormat::SVG` or `ImageFormat::PDF` for vector output
+
+### Fixed
+
+- `Plot::add_frames` no longer adds every frame twice when the plot has no frames yet
+- `LayoutPolar`, its axes, `PolarTickMode` and the geo `Rotation` no longer serialize unset fields as `null`, so the JSON carries only the attributes that were set
+- The `plotly_dark` template now styles polar and ternary subplots (dark background, grid and axis lines, matching plotly.py's `plotly_dark`); polar and ternary charts drew a white background on it
+
+### Security
+
+- Remove the unused `zip` build-dependency from `plotly_static`; with `plotly_kaleido` gone, no workspace crate depends on `zip` directly
+- Known issue: `zip` 8.x is still pulled in transitively by `webdriver-downloader` 0.17 (used at build time to fetch chromedriver/geckodriver) and is flagged by RUSTSEC-2026-0367/0368/0369. Those advisories concern `ZipArchive::extract()`, which `webdriver-downloader` does not call (it reads the driver entry with `by_name`). It will be resolved once [ik1ne/webdriver-downloader#67](https://github.com/ik1ne/webdriver-downloader/pull/67) is released
 
 ## [0.14.1] - 2026-02-15
 
diff --git a/Cargo.toml b/Cargo.toml
index 4d31d6d4..955935f8 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,3 +1,3 @@
 [workspace]
 resolver = "2"
-members = ["plotly", "plotly_derive", "plotly_kaleido", "plotly_static"]
+members = ["plotly", "plotly_derive", "plotly_static"]
diff --git a/README.md b/README.md
index ad9fb845..21d7ff98 100644
--- a/README.md
+++ b/README.md
@@ -41,7 +41,6 @@
 * [Basic Usage](#basic-usage)
     * [Exporting a single Interactive Plot](#exporting-a-single-interactive-plot)
     * [Exporting Static Images with plotly_static (Recommended)](#exporting-static-images-with-plotly_static-recommended)
-    * [Exporting Static Images with Kaleido (legacy)](#exporting-static-images-with-kaleido-legacy)
     * [Usage Within a WASM Environment](#usage-within-a-wasm-environment)
     * [Timeseries Downsampling](#timeseries-downsampling)
 * [Crate Feature Flags](#crate-feature-flags)
@@ -63,7 +62,7 @@ Add this to your `Cargo.toml`:
 
 ```toml
 [dependencies]
-plotly = "0.14"
+plotly = "0.15"
 ```
 
 ## Exporting a single Interactive Plot
@@ -103,7 +102,7 @@ The recommended way to export static images is using the `plotly_static` backend
 
 ```toml
 [dependencies]
-plotly = { version = "0.14", features = ["static_export_default"] }
+plotly = { version = "0.15", features = ["static_export_default"] }
 ```
 
 This supports PNG, JPEG, WEBP, SVG, and PDF formats:
@@ -122,56 +121,15 @@ let svg_string = plot.to_svg(800, 600, 1.0)?;
 
 **Note:** This feature requires a WebDriver-compatible browser (Chrome or Firefox) as well as a Webdriver (chromedriver/geckodriver) to be available on the system.
 
-The above example uses the legacy API that is backwards compatible with the Kaleido API. However, for more efficient workflows a `StaticExporter` object can be built and reused between calls to `write_image`. 
+The above example uses the one-shot `Plot` API, which creates a new exporter for every call. However, for more efficient workflows a `StaticExporter` object can be built and reused between calls to `write_image`. 
 
 More specifically, enabling any of the `plotly` features `static_export_chromedriver`, `static_export_geckodriver`, or `static_export_default` gives access to both the synchronous `StaticExporter` and the asynchronous `AsyncStaticExporter` (available via `plotly::plotly_static`). For exporter reuse and up-to-date sync/async usage patterns, please see the dedicated example in `examples/static_export`, which demonstrates both synchronous and asynchronous exporters and how to reuse a single exporter instance across multiple exports.
 
  For further details see [`plotly_static` crate documentation](https://docs.rs/plotly_static/).
 
-## Exporting Static Images with Kaleido (legacy)
-
-Enable the `kaleido` feature and opt in for automatic downloading of the `kaleido` binaries by doing the following
-
-```toml
-# Cargo.toml
-
-[dependencies]
-plotly = { version = "0.14", features = ["kaleido", "kaleido_download"] }
-```
-
-Alternatively, enable only the `kaleido` feature and manually install Kaleido.
-```toml
-# Cargo.toml
-
-[dependencies]
-plotly = { version = "0.14", features = ["kaleido"] }
-```
-
-With the feature enabled, plots can be saved as any of `png`, `jpeg`, `webp`, `svg`, `pdf` and `eps`. Note that the plot will be a static image, i.e. they will be non-interactive.
-
-Exporting a simple plot looks like this:
-
-```rust
-use plotly::{ImageFormat, Plot};
-
-let mut plot = Plot::new();
-let trace = Scatter::new(vec![0, 1, 2], vec![2, 1, 0]);
-plot.add_trace(trace);
-
-plot.write_image("out.png", ImageFormat::PNG, 800, 600, 1.0);
-```
-
-### Kaleido external dependency
-
-When developing applications for your host, enabling both `kaleido` and `kaleido_download` features will ensure that the `kaleido` binary is downloaded for your system's architecture at compile time. After download, it is unpacked into a specific path, e.g., on Linux this is `/home/USERNAME/.config/kaleido`. With these two features enabled, static images can be exported as described in the next section as long as the application runs on the same machine where it has been compiled on.
-
-When the applications developed with `plotly.rs` are intended for other targets or when the user wants to control where the `kaleido` binary is installed then Kaleido must be manually downloaded and installed. Setting the environment variable `KALEIDO_PATH=/path/installed/kaleido/` will ensure that applications that were built with the `kaleido` feature enabled can locate the `kaleido` executable and use it to generate static images.
-
-Kaleido binaries are available on Github [release page](https://github.com/plotly/Kaleido/releases). It currently supports Linux(`x86_64`), Windows(`x86_64`) and MacOS(`x86_64`/`aarch64`).
-
 ## Usage Within a WASM Environment
 
-`Plotly.rs` can be used with a WASM-based frontend framework. Note that the `kaleido` and `plotly_static` static export features are not supported in WASM environments and will throw a compilation error if used. 
+`Plotly.rs` can be used with a WASM-based frontend framework. Note that the `plotly_static` static export features are not supported in WASM environments and will throw a compilation error if used. 
 
 The needed dependencies are automatically enabled for `wasm32` targets at compile time and there is no longer a need for the custom `wasm` flag in this crate.
 
@@ -184,7 +142,7 @@ First, make sure that you have the Plotly JavaScript library in your base HTML t
 <html lang="en">
     <head>
         <!-- snip -->
-        <script src="https://cdn.plot.ly/plotly-2.14.0.min.js"></script>
+        <script src="https://cdn.plot.ly/plotly-3.7.0.min.js"></script>
     </head>
     <!-- snip -->
 </html>
@@ -263,17 +221,6 @@ When the feature is enabled, users can still opt in for the CDN version by using
 
 Note that when using `Plot::to_inline_html()`, it is assumed that the `plotly.js` library is already in scope within the HTML file, so enabling this feature flag will have no effect.
 
-### `kaleido` (legacy)
-
-Adds plot save functionality to the following formats: `png`, `jpeg`, `webp`, `svg`, `pdf` and `eps`.
-
-Requires `Kaleido` to have been previously installed on the host machine. See the following feature flag and [Kaleido external dependency](#kaleido-external-dependency).
-
-### `kaleido_download` (legacy)
-
-Enable download and install of Kaleido binary at build time from [Kaleido releases](https://github.com/plotly/Kaleido/releases/) on the host machine.
-See [Kaleido external dependency](#kaleido-external-dependency) for more details.
-
 # Contributing
 
 * If you've spotted a bug or would like to see a new feature, please submit an issue on the [issue tracker](https://github.com/plotly/plotly.rs/issues).
diff --git a/clippy.toml b/clippy.toml
new file mode 100644
index 00000000..d3144897
--- /dev/null
+++ b/clippy.toml
@@ -0,0 +1 @@
+doc-valid-idents = ["WebDriver", "MapLibre", "GeoJSON", "MathJax", "ModeBar", ".."]
diff --git a/docs/book/src/SUMMARY.md b/docs/book/src/SUMMARY.md
index de051e4b..c7e3487d 100644
--- a/docs/book/src/SUMMARY.md
+++ b/docs/book/src/SUMMARY.md
@@ -21,6 +21,8 @@
         - [Icicle Charts](./recipes/basic_charts/icicle_charts.md)
         - [Sankey Diagrams](./recipes/basic_charts/sankey_diagrams.md)
         - [Parallel Categories](./recipes/basic_charts/parcats_charts.md)
+        - [Parallel Coordinates](./recipes/basic_charts/parcoords_charts.md)
+        - [Polar Bar Charts](./recipes/basic_charts/polar_bar_charts.md)
         - [Indicator Charts](./recipes/basic_charts/indicator_charts.md)
     - [Statistical Charts](./recipes/statistical_charts.md)
         - [Error Bars](./recipes/statistical_charts/error_bars.md)
@@ -32,6 +34,9 @@
     - [Scientific Charts](./recipes/scientific_charts.md)
        - [Contour Plots](./recipes/scientific_charts/contour_plots.md)
        - [Heatmaps](./recipes/scientific_charts/heatmaps.md)
+       - [Ternary Plots](./recipes/scientific_charts/ternary_plots.md)
+       - [Smith Charts](./recipes/scientific_charts/smith_charts.md)
+       - [Carpet Plots](./recipes/scientific_charts/carpet_plots.md)
     - [Financial Charts](./recipes/financial_charts.md)
        - [Time Series and Date Axes](./recipes/financial_charts/time_series_and_date_axes.md)
        - [Candlestick Charts](./recipes/financial_charts/candlestick_charts.md)
@@ -43,6 +48,8 @@
         - [Scatter 3D](./recipes/3dcharts/3dcharts.md)
         - [Surface Plots](./recipes/3dcharts/surface_plots.md)
         - [Mesh3D](./recipes/3dcharts/mesh3d_plots.md)
+        - [Vector Field Plots](./recipes/3dcharts/vector_field_plots.md)
+        - [Isosurface and Volume Plots](./recipes/3dcharts/volume_plots.md)
     - [Maps](./recipes/maps.md)
         - [Scatter Maps](./recipes/maps/scatter_maps.md)
         - [Density Maps](./recipes/maps/density_maps.md)
diff --git a/docs/book/src/fundamentals/jupyter_support.md b/docs/book/src/fundamentals/jupyter_support.md
index 52927e54..937a7373 100644
--- a/docs/book/src/fundamentals/jupyter_support.md
+++ b/docs/book/src/fundamentals/jupyter_support.md
@@ -46,7 +46,7 @@ display a plot:
 
 **Cell 1**
 ```
-:dep plotly = "0.14"
+:dep plotly = "0.15"
 ```
 
 **Cell 2**
diff --git a/docs/book/src/fundamentals/static_image_export.md b/docs/book/src/fundamentals/static_image_export.md
index 931fa777..a3642ae1 100644
--- a/docs/book/src/fundamentals/static_image_export.md
+++ b/docs/book/src/fundamentals/static_image_export.md
@@ -23,15 +23,15 @@ The static export functionality is controlled by feature flags in the main `plot
 ```toml
 # Basic usage with manual Chromedriver installation
 [dependencies]
-plotly = { version = "0.14", features = ["static_export_chromedriver"] }
+plotly = { version = "0.15", features = ["static_export_chromedriver"] }
 
 # With automatic Chromedriver download
 [dependencies]
-plotly = { version = "0.14", features = ["static_export_chromedriver", "static_export_wd_download"] }
+plotly = { version = "0.15", features = ["static_export_chromedriver", "static_export_wd_download"] }
 
 # Recommended: Default configuration with Chromedriver + auto-download
 [dependencies]
-plotly = { version = "0.14", features = ["static_export_default"] }
+plotly = { version = "0.15", features = ["static_export_default"] }
 ```
 
 > Enabling any of the static export features in `plotly` (`static_export_chromedriver`, `static_export_geckodriver`, or `static_export_default`) enables both APIs from `plotly_static`: the sync `StaticExporter` and the async `AsyncStaticExporter` (reachable as `plotly::plotly_static::AsyncStaticExporter`). Prefer the async API inside async code.
@@ -110,9 +110,6 @@ exporter.close();
 - **SVG**: Scalable Vector Graphics
 - **PDF**: Portable Document Format
 
-### Deprecated
-- **EPS**: Encapsulated PostScript (will be removed in version 0.15.0)
-
 ## String Export
 
 For web applications or APIs, you can export to strings:
diff --git a/docs/book/src/getting_started.md b/docs/book/src/getting_started.md
index 5fa95ddc..9cd802f6 100644
--- a/docs/book/src/getting_started.md
+++ b/docs/book/src/getting_started.md
@@ -22,7 +22,7 @@ To start using [plotly.rs](https://github.com/plotly/plotly.rs) in your project
 
 ```toml
 [dependencies]
-plotly = "0.14"
+plotly = "0.15"
 ```
 
 [Plotly.rs](https://github.com/plotly/plotly.rs) is ultimately a thin wrapper around the `plotly.js` library. The main job of this library is to provide `structs` and `enums` which get serialized to `json` and passed to the `plotly.js` library to actually do the heavy lifting. As such, if you are familiar with `plotly.js` or its derivatives (e.g. the equivalent Python library), then you should find [`plotly.rs`](https://github.com/plotly/plotly.rs) intuitive to use.
@@ -83,7 +83,7 @@ plot.show_image(ImageFormat::PNG, 1280, 900);
 
 will display in the browser the rasterised plot; 1280 pixels wide and 900 pixels tall, in png format.
 
-Once a satisfactory result is achieved, and assuming the [`kaleido`](#saving-plots) feature is enabled, the plot can be saved using the following:
+Once a satisfactory result is achieved, and assuming one of the [static export](#static-image-export-with-webdriver-recommended) features is enabled, the plot can be saved using the following:
 
 ```rust
 plot.write_image("/home/user/plot_name.ext", ImageFormat::PNG, 1280, 900, 1.0);
@@ -91,22 +91,13 @@ plot.write_image("/home/user/plot_name.ext", ImageFormat::PNG, 1280, 900, 1.0);
 
 The extension in the file-name path is optional as the appropriate extension (`ImageFormat::PNG`) will be included. Note that in all functions that save files to disk, both relative and absolute paths are supported.
 
-## Saving Plots with Kaleido (legacy)
-
-To add the ability to save plots in the following formats: png, jpeg, webp, svg, pdf and eps, you can use the `kaleido` feature. This feature depends on [plotly/Kaleido](https://github.com/plotly/Kaleido): a cross-platform open source library for generating static images. All the necessary binaries have been included with `plotly_kaleido` for `Linux`, `Windows` and `MacOS`. Previous versions of [plotly.rs](https://github.com/plotly/plotly.rs) used the `orca` feature, however, this has been deprecated as it provided the same functionality but required additional installation steps. To enable the `kaleido` feature add the following to your `Cargo.toml`:
-
-```toml
-[dependencies]
-plotly = { version = "0.14", features = ["kaleido"] }
-```
-
 ## Static Image Export with WebDriver (recommended)
 
-For static image export using WebDriver and headless browsers, you can use the `plotly_static` feature. This feature supports the same formats as Kaleido (png, jpeg, webp, svg, pdf) but uses WebDriver for the static export process. To enable static export, add the following to your `Cargo.toml`:
+For static image export using WebDriver and headless browsers, you can use the `plotly_static` feature. It supports png, jpeg, webp, svg and pdf, and uses WebDriver for the static export process. To enable static export, add the following to your `Cargo.toml`:
 
 ```toml
 [dependencies]
-plotly = { version = "0.14", features = ["static_export_default"] }
+plotly = { version = "0.15", features = ["static_export_default"] }
 ```
 
 The `static_export_default` feature includes Chrome WebDriver support with automatic download. For Firefox support, use `static_export_geckodriver` instead. See the [Static Image Export](../fundamentals/static_image_export.md) chapter for a detailed usage example.
diff --git a/docs/book/src/recipes/3dcharts.md b/docs/book/src/recipes/3dcharts.md
index a95eae43..30bc754c 100644
--- a/docs/book/src/recipes/3dcharts.md
+++ b/docs/book/src/recipes/3dcharts.md
@@ -7,3 +7,5 @@ Kind | Link
 Scatter3D |[![Scatter 3D Charts](./img/basic_scatter3d.png)](./3dcharts/3dcharts.md)
 Surface Plots | [![Surface Plots](./img/surface_plot.png)](./3dcharts/surface_plots.md)
 Mesh3D | [![Mesh3D](./img/mesh3d.png)](./3dcharts/mesh3d_plots.md)
+Vector Fields (Cone, Streamtube) | [Vector Field Plots](./3dcharts/vector_field_plots.md)
+Isosurface and Volume | [Isosurface and Volume Plots](./3dcharts/volume_plots.md)
diff --git a/docs/book/src/recipes/3dcharts/vector_field_plots.md b/docs/book/src/recipes/3dcharts/vector_field_plots.md
new file mode 100644
index 00000000..73c2723e
--- /dev/null
+++ b/docs/book/src/recipes/3dcharts/vector_field_plots.md
@@ -0,0 +1,39 @@
+# Vector Field Plots
+
+A `Cone` trace draws a 3D vector field as cones: each cone sits at an `(x, y, z)` position and
+points along the `(u, v, w)` vector, colored by the vector norm. `anchor` sets which part of the
+cone sits on the position, and `size_mode`/`size_ref` control how the vector norm maps to cone size.
+
+A `StreamTube` trace follows the flow of the same kind of field: tubes start from the `starts`
+positions (or, when unset, the interior grid points of the x-z plane at the lowest `y`) and their diameter reflects the local divergence of the field.
+
+The following imports have been used to produce the plots below:
+
+```rust,no_run
+use plotly::common::{ColorBar, ColorScale, ColorScalePalette};
+use plotly::layout::{Camera, Layout, LayoutScene};
+use plotly::stream_tube::Starts;
+use plotly::{Cone, Plot, StreamTube};
+```
+
+The examples on this page build their grid with the following helper:
+
+```rust,no_run
+{{#include ../../../../../examples/3d_charts/src/main.rs:grid_3d}}
+```
+
+The `to_inline_html` method is used to produce the html plot displayed in this page.
+
+## Cone Plot
+```rust,no_run
+{{#include ../../../../../examples/3d_charts/src/main.rs:cone_plot}}
+```
+
+{{#include ../../../../../examples/3d_charts/output/inline_cone_plot.html}}
+
+## Streamtube Plot
+```rust,no_run
+{{#include ../../../../../examples/3d_charts/src/main.rs:streamtube_plot}}
+```
+
+{{#include ../../../../../examples/3d_charts/output/inline_streamtube_plot.html}}
diff --git a/docs/book/src/recipes/3dcharts/volume_plots.md b/docs/book/src/recipes/3dcharts/volume_plots.md
new file mode 100644
index 00000000..bc1f6493
--- /dev/null
+++ b/docs/book/src/recipes/3dcharts/volume_plots.md
@@ -0,0 +1,41 @@
+# Isosurface and Volume Plots
+
+`IsoSurface` and `Volume` traces both visualize a scalar `value` sampled on a 3D `(x, y, z)` grid.
+An isosurface draws a few opaque surfaces of constant value between `iso_min` and `iso_max`
+(the number is set by `IsoSurfaceSurface::count`), while a volume rendering stacks many
+semi-transparent surfaces — use a low `opacity` and an `OpacityScale` to see inside the volume.
+
+Both traces share the `Caps`, `Slices`, `SpaceFrame` and `IsoSurfaceSurface` settings from
+`plotly::isosurface`. The grid points are given flattened, with x varying fastest.
+
+The following imports have been used to produce the plots below:
+
+```rust,no_run
+use plotly::common::{ColorScale, ColorScalePalette};
+use plotly::isosurface::{Cap, Caps, IsoSurfaceSurface};
+use plotly::layout::Layout;
+use plotly::volume::OpacityScale;
+use plotly::{IsoSurface, Plot, Volume};
+```
+
+The examples on this page build their grid with the following helper:
+
+```rust,no_run
+{{#include ../../../../../examples/3d_charts/src/main.rs:grid_3d}}
+```
+
+The `to_inline_html` method is used to produce the html plot displayed in this page.
+
+## Isosurface Plot
+```rust,no_run
+{{#include ../../../../../examples/3d_charts/src/main.rs:isosurface_plot}}
+```
+
+{{#include ../../../../../examples/3d_charts/output/inline_isosurface_plot.html}}
+
+## Volume Plot
+```rust,no_run
+{{#include ../../../../../examples/3d_charts/src/main.rs:volume_plot}}
+```
+
+{{#include ../../../../../examples/3d_charts/output/inline_volume_plot.html}}
diff --git a/docs/book/src/recipes/basic_charts.md b/docs/book/src/recipes/basic_charts.md
index b217e777..0e517bfe 100644
--- a/docs/book/src/recipes/basic_charts.md
+++ b/docs/book/src/recipes/basic_charts.md
@@ -15,3 +15,5 @@ Icicle Charts | [![Icicle Charts](./img/icicle.png)](./basic_charts/icicle_chart
 Sankey Diagrams | [![Sankey Diagrams](./img/basic_sankey.png)](./basic_charts/sankey_diagrams.md)
 Parallel Categories | [![Parallel Categories](./img/parallelcat.png)](./basic_charts/parcats_charts.md)
 Indicator Charts | [![Indicator Charts](./img/indicator.png)](./basic_charts/indicator_charts.md)
+Polar Bar Charts | [Polar Bar Charts](./basic_charts/polar_bar_charts.md)
+Parallel Coordinates | [Parallel Coordinates](./basic_charts/parcoords_charts.md)
diff --git a/docs/book/src/recipes/basic_charts/parcoords_charts.md b/docs/book/src/recipes/basic_charts/parcoords_charts.md
new file mode 100644
index 00000000..71cc0728
--- /dev/null
+++ b/docs/book/src/recipes/basic_charts/parcoords_charts.md
@@ -0,0 +1,26 @@
+# Parallel Coordinates
+
+A parallel coordinates (`parcoords`) chart draws each row of numeric data as a polyline across a
+set of vertical axes, one per `Dimension`. Lines can be colored by a value through
+`ParcoordsLine`, and a `ConstraintRange` pre-selects (brushes) an interval on an axis — the
+same selection users can make interactively by dragging along an axis.
+
+For categorical data, see [Parallel Categories](./parcats_charts.md).
+
+The following imports have been used to produce the plots below:
+
+```rust,no_run
+use plotly::common::{ColorScale, ColorScalePalette};
+use plotly::layout::Layout;
+use plotly::parcoords::{ConstraintRange, Dimension, ParcoordsLine};
+use plotly::{Parcoords, Plot};
+```
+
+The `to_inline_html` method is used to produce the html plot displayed in this page.
+
+## Basic Parallel Coordinates
+```rust,no_run
+{{#include ../../../../../examples/basic_charts/src/main.rs:basic_parcoords}}
+```
+
+{{#include ../../../../../examples/basic_charts/output/inline_basic_parcoords.html}}
diff --git a/docs/book/src/recipes/basic_charts/polar_bar_charts.md b/docs/book/src/recipes/basic_charts/polar_bar_charts.md
new file mode 100644
index 00000000..eeebb3c6
--- /dev/null
+++ b/docs/book/src/recipes/basic_charts/polar_bar_charts.md
@@ -0,0 +1,24 @@
+# Polar Bar Charts
+
+A `BarPolar` trace draws bars on a polar subplot: `r` sets the radial length of each bar and
+`theta` its angular position. Stacking several traces gives a *wind rose*. Unlike cartesian bars,
+the stacking mode and the gap between bars are set per polar subplot with
+`LayoutPolar::bar_mode` and `LayoutPolar::bar_gap`.
+
+The following imports have been used to produce the plots below:
+
+```rust,no_run
+use plotly::color::NamedColor;
+use plotly::common::Marker;
+use plotly::layout::{AngularAxis, Layout, LayoutPolar, PolarBarMode, PolarDirection};
+use plotly::{BarPolar, Plot};
+```
+
+The `to_inline_html` method is used to produce the html plot displayed in this page.
+
+## Wind Rose
+```rust,no_run
+{{#include ../../../../../examples/basic_charts/src/main.rs:wind_rose}}
+```
+
+{{#include ../../../../../examples/basic_charts/output/inline_wind_rose.html}}
diff --git a/docs/book/src/recipes/financial_charts/funnel_charts.md b/docs/book/src/recipes/financial_charts/funnel_charts.md
index 9b5afde8..147035b7 100644
--- a/docs/book/src/recipes/financial_charts/funnel_charts.md
+++ b/docs/book/src/recipes/financial_charts/funnel_charts.md
@@ -20,8 +20,9 @@ The following imports have been used to produce the plots below:
 use plotly::color::NamedColor;
 use plotly::common::Marker;
 use plotly::funnel::Connector as FunnelConnector;
+use plotly::funnel_area::{FunnelAreaTitle, FunnelAreaTitlePosition};
 use plotly::layout::Layout;
-use plotly::{Funnel, Plot};
+use plotly::{Funnel, FunnelArea, Plot};
 ```
 
 The `to_inline_html` method is used to produce the html plot displayed in this page.
@@ -32,3 +33,15 @@ The `to_inline_html` method is used to produce the html plot displayed in this p
 ```
 
 {{#include ../../../../../examples/financial_charts/output/inline_basic_funnel.html}}
+
+## Funnel Area
+
+A `FunnelArea` trace is the pie-like sibling of `Funnel`: stages are drawn as slices of a funnel
+whose *area* is proportional to each value, with no value axis. `base_ratio` sets how narrow the
+bottom is relative to the top, and `aspect_ratio` sets the funnel's height-to-width ratio.
+
+```rust,no_run
+{{#include ../../../../../examples/financial_charts/src/main.rs:basic_funnel_area}}
+```
+
+{{#include ../../../../../examples/financial_charts/output/inline_basic_funnel_area.html}}
diff --git a/docs/book/src/recipes/scientific_charts.md b/docs/book/src/recipes/scientific_charts.md
index 36549951..4a9bc74b 100644
--- a/docs/book/src/recipes/scientific_charts.md
+++ b/docs/book/src/recipes/scientific_charts.md
@@ -6,3 +6,6 @@ Kind | Link
 :---|:----:
 Contour Plots |[![Contour Plots](./img/contour_plot.png)](./scientific_charts/contour_plots.md)
 Heatmaps | [![Heatmaps](./img/heatmap.png)](./scientific_charts/heatmaps.md)
+Ternary Plots | [Ternary Plots](./scientific_charts/ternary_plots.md)
+Smith Charts | [Smith Charts](./scientific_charts/smith_charts.md)
+Carpet Plots | [Carpet Plots](./scientific_charts/carpet_plots.md)
diff --git a/docs/book/src/recipes/scientific_charts/carpet_plots.md b/docs/book/src/recipes/scientific_charts/carpet_plots.md
new file mode 100644
index 00000000..097772a0
--- /dev/null
+++ b/docs/book/src/recipes/scientific_charts/carpet_plots.md
@@ -0,0 +1,34 @@
+# Carpet Plots
+
+A `Carpet` trace defines a 2D coordinate system from two parameters `a` and `b`, mapped onto
+cartesian `x`/`y` positions (when `x` is omitted, a *cheater plot* is drawn). Carpets are used to
+show how a quantity depends on two independent variables.
+
+`ScatterCarpet` and `ContourCarpet` traces are then drawn *on* a carpet: they take `a`/`b`
+coordinates and refer to the carpet by its `carpet` id (or use the first carpet when no id is
+given). The `a` and `b` axes are styled with `CarpetAxis`.
+
+The following imports have been used to produce the plots below:
+
+```rust,no_run
+use plotly::carpet::{CarpetAxis, CarpetAxisTitle};
+use plotly::common::{ColorScale, ColorScalePalette, Mode};
+use plotly::contour::{Coloring, Contours};
+use plotly::{Carpet, ContourCarpet, Layout, Plot, ScatterCarpet};
+```
+
+The `to_inline_html` method is used to produce the html plot displayed in this page.
+
+## Scatter on a Carpet
+```rust,no_run
+{{#include ../../../../../examples/scientific_charts/src/main.rs:carpet_with_scatter}}
+```
+
+{{#include ../../../../../examples/scientific_charts/output/inline_carpet_with_scatter.html}}
+
+## Contour Carpet
+```rust,no_run
+{{#include ../../../../../examples/scientific_charts/src/main.rs:contour_carpet}}
+```
+
+{{#include ../../../../../examples/scientific_charts/output/inline_contour_carpet.html}}
diff --git a/docs/book/src/recipes/scientific_charts/smith_charts.md b/docs/book/src/recipes/scientific_charts/smith_charts.md
new file mode 100644
index 00000000..1416b582
--- /dev/null
+++ b/docs/book/src/recipes/scientific_charts/smith_charts.md
@@ -0,0 +1,22 @@
+# Smith Charts
+
+A `ScatterSmith` trace plots complex values — typically normalized impedances in RF engineering —
+on a Smith chart, given by their `real` and `imag` parts. The chart's real and imaginary axes are
+configured with `LayoutSmith`, `RealAxis` and `ImaginaryAxis`.
+
+The following imports have been used to produce the plots below:
+
+```rust,no_run
+use plotly::common::Mode;
+use plotly::layout::{Layout, LayoutSmith};
+use plotly::{Plot, ScatterSmith};
+```
+
+The `to_inline_html` method is used to produce the html plot displayed in this page.
+
+## Smith Chart
+```rust,no_run
+{{#include ../../../../../examples/scientific_charts/src/main.rs:smith_chart}}
+```
+
+{{#include ../../../../../examples/scientific_charts/output/inline_smith_chart.html}}
diff --git a/docs/book/src/recipes/scientific_charts/ternary_plots.md b/docs/book/src/recipes/scientific_charts/ternary_plots.md
new file mode 100644
index 00000000..104279e6
--- /dev/null
+++ b/docs/book/src/recipes/scientific_charts/ternary_plots.md
@@ -0,0 +1,22 @@
+# Ternary Plots
+
+A `ScatterTernary` trace plots three-component mixtures on a triangle: each point is given by its
+`a`, `b` and `c` components, which are normalized to add up to the subplot's `sum`. The triangle
+and its three axes are configured with `LayoutTernary` and `TernaryAxis`.
+
+The following imports have been used to produce the plots below:
+
+```rust,no_run
+use plotly::common::{Marker, Mode};
+use plotly::layout::{Layout, LayoutTernary, TernaryAxis};
+use plotly::{Plot, ScatterTernary};
+```
+
+The `to_inline_html` method is used to produce the html plot displayed in this page.
+
+## Ternary Scatter Plot
+```rust,no_run
+{{#include ../../../../../examples/scientific_charts/src/main.rs:ternary_plot}}
+```
+
+{{#include ../../../../../examples/scientific_charts/output/inline_ternary_plot.html}}
diff --git a/docs/book/src/recipes/statistical_charts/histogram2d.md b/docs/book/src/recipes/statistical_charts/histogram2d.md
index 6fea6406..39b8a926 100644
--- a/docs/book/src/recipes/statistical_charts/histogram2d.md
+++ b/docs/book/src/recipes/statistical_charts/histogram2d.md
@@ -6,7 +6,7 @@ The following imports have been used to produce the plots below:
 use plotly::common::{ColorScale, ColorScalePalette};
 use plotly::histogram::{Bins, HistFunc, HistNorm};
 use plotly::layout::{Axis, Layout};
-use plotly::{Histogram2d, Plot};
+use plotly::{Histogram2d, Histogram2dContour, Plot};
 ```
 
 The `to_inline_html` method is used to produce the html plot displayed in this page.
@@ -33,3 +33,15 @@ The `to_inline_html` method is used to produce the html plot displayed in this p
 ```
 
 {{#include ../../../../../examples/statistical_charts/output/inline_histogram2d_aggregation.html}}
+
+
+## 2D Histogram Contour
+A `Histogram2dContour` bins the samples exactly like a `Histogram2d`, but draws the binned counts as
+contour levels instead of heatmap cells. `n_contours` sets the maximum number of levels; pass a
+`Contours` value to set them explicitly.
+
+```rust,no_run
+{{#include ../../../../../examples/statistical_charts/src/main.rs:histogram2d_contour}}
+```
+
+{{#include ../../../../../examples/statistical_charts/output/inline_histogram2d_contour.html}}
diff --git a/examples/3d_charts/src/main.rs b/examples/3d_charts/src/main.rs
index c6765c05..71245482 100644
--- a/examples/3d_charts/src/main.rs
+++ b/examples/3d_charts/src/main.rs
@@ -4,8 +4,11 @@ use ndarray::Array;
 use plotly::{
     color::Rgb,
     common::{ColorBar, ColorScale, ColorScalePalette, Font, Marker, MarkerSymbol, Mode},
+    isosurface::{Cap, Caps, IsoSurfaceSurface},
     layout::{Axis, Camera, Layout, LayoutScene, Legend, Margin, ProjectionType},
-    Mesh3D, Plot, Scatter3D, Surface,
+    stream_tube::Starts,
+    volume::OpacityScale,
+    Cone, IsoSurface, Mesh3D, Plot, Scatter3D, StreamTube, Surface, Volume,
 };
 use plotly_utils::write_example_to_html;
 use rand::RngExt;
@@ -260,6 +263,150 @@ fn colorscale_plot(show: bool, file_name: &str) {
 }
 // ANCHOR_END: colorscale_plot
 
+// ANCHOR: grid_3d
+/// Flattened coordinates of an `n`x`n`x`n` grid spanning `[lo, hi]` on each
+/// axis, in the x-fastest order expected by volumetric traces.
+fn grid_3d(n: usize, lo: f64, hi: f64) -> (Vec<f64>, Vec<f64>, Vec<f64>) {
+    let step = (hi - lo) / (n - 1) as f64;
+    let (mut x, mut y, mut z) = (Vec::new(), Vec::new(), Vec::new());
+    for k in 0..n {
+        for j in 0..n {
+            for i in 0..n {
+                x.push(lo + i as f64 * step);
+                y.push(lo + j as f64 * step);
+                z.push(lo + k as f64 * step);
+            }
+        }
+    }
+    (x, y, z)
+}
+// ANCHOR_END: grid_3d
+
+// Cone Plots
+// ANCHOR: cone_plot
+fn cone_plot(show: bool, file_name: &str) {
+    // A vortex: vectors rotate around the z axis and drift upwards.
+    let (x, y, z) = grid_3d(5, -1.0, 1.0);
+    let u: Vec<f64> = y.iter().map(|y| -y).collect();
+    let v: Vec<f64> = x.clone();
+    let w: Vec<f64> = vec![0.3; x.len()];
+
+    let trace = Cone::new(x, y, z, u, v, w)
+        .color_scale(ColorScale::Palette(ColorScalePalette::Viridis))
+        .size_ref(0.5)
+        .color_bar(ColorBar::new().title("Norm"));
+
+    let mut plot = Plot::new();
+    plot.add_trace(trace);
+    plot.set_layout(
+        Layout::new()
+            .title("Cone plot of a vortex")
+            .scene(LayoutScene::new().camera(Camera::new())),
+    );
+
+    let path = write_example_to_html(&plot, file_name);
+    if show {
+        plot.show_html(path);
+    }
+}
+// ANCHOR_END: cone_plot
+
+// Streamtube Plots
+// ANCHOR: streamtube_plot
+fn streamtube_plot(show: bool, file_name: &str) {
+    // Flow along x with a sinusoidal swirl in y and z.
+    let (x, y, z) = grid_3d(8, 0.0, 4.0);
+    let u: Vec<f64> = vec![1.0; x.len()];
+    let v: Vec<f64> = x.iter().map(|x| 0.5 * x.sin()).collect();
+    let w: Vec<f64> = x.iter().map(|x| 0.5 * x.cos()).collect();
+
+    let starts = Starts::new()
+        .x(vec![0.0; 4])
+        .y(vec![1.0, 1.0, 3.0, 3.0])
+        .z(vec![1.0, 3.0, 1.0, 3.0]);
+
+    let trace = StreamTube::new(x, y, z, u, v, w)
+        .starts(starts)
+        .size_ref(0.5)
+        .color_scale(ColorScale::Palette(ColorScalePalette::Portland))
+        .show_scale(false);
+
+    let mut plot = Plot::new();
+    plot.add_trace(trace);
+    plot.set_layout(Layout::new().title("Streamtubes following a swirling flow"));
+
+    let path = write_example_to_html(&plot, file_name);
+    if show {
+        plot.show_html(path);
+    }
+}
+// ANCHOR_END: streamtube_plot
+
+// Isosurface Plots
+// ANCHOR: isosurface_plot
+fn isosurface_plot(show: bool, file_name: &str) {
+    let (x, y, z) = grid_3d(20, -1.0, 1.0);
+    let value: Vec<f64> = x
+        .iter()
+        .zip(&y)
+        .zip(&z)
+        .map(|((x, y), z)| x * x + y * y + z * z)
+        .collect();
+
+    let trace = IsoSurface::new(x, y, z, value)
+        .iso_min(0.2)
+        .iso_max(0.8)
+        .surface(IsoSurfaceSurface::new().count(3))
+        .caps(
+            Caps::new()
+                .x(Cap::new().show(false))
+                .y(Cap::new().show(false))
+                .z(Cap::new().show(false)),
+        )
+        .opacity(0.6)
+        .color_scale(ColorScale::Palette(ColorScalePalette::Blues));
+
+    let mut plot = Plot::new();
+    plot.add_trace(trace);
+    plot.set_layout(Layout::new().title("Nested spherical isosurfaces"));
+
+    let path = write_example_to_html(&plot, file_name);
+    if show {
+        plot.show_html(path);
+    }
+}
+// ANCHOR_END: isosurface_plot
+
+// Volume Plots
+// ANCHOR: volume_plot
+fn volume_plot(show: bool, file_name: &str) {
+    let (x, y, z) = grid_3d(20, -1.0, 1.0);
+    let value: Vec<f64> = x
+        .iter()
+        .zip(&y)
+        .zip(&z)
+        .map(|((x, y), z)| (3.0 * x).sin() * (3.0 * y).cos() * (3.0 * z).sin())
+        .collect();
+
+    let trace = Volume::new(x, y, z, value)
+        .iso_min(-0.5)
+        .iso_max(0.5)
+        .opacity(0.1)
+        .opacity_scale(OpacityScale::Extremes)
+        .surface(IsoSurfaceSurface::new().count(15))
+        .color_scale(ColorScale::Palette(ColorScalePalette::RdBu));
+
+    let mut plot = Plot::new();
+    plot.add_trace(trace);
+    plot.set_layout(Layout::new().title("Volume rendering"));
+
+    let path = write_example_to_html(&plot, file_name);
+    if show {
+        plot.show_html(path);
+    }
+}
+// ANCHOR_END: volume_plot
+
 fn main() {
     // Change false to true on any of these lines to display the example.
     // Scatter3D Plots
@@ -273,4 +420,12 @@ fn main() {
 
     // Mesh Plots
     mesh_3d_plot(false, "mesh_3d_plot");
+
+    // Vector Field Plots
+    cone_plot(false, "cone_plot");
+    streamtube_plot(false, "streamtube_plot");
+
+    // Volume Plots
+    isosurface_plot(false, "isosurface_plot");
+    volume_plot(false, "volume_plot");
 }
diff --git a/examples/Cargo.toml b/examples/Cargo.toml
index 17dcd263..d82d5a5a 100644
--- a/examples/Cargo.toml
+++ b/examples/Cargo.toml
@@ -9,7 +9,6 @@ members = [
     "downsampling",
     "financial_charts",
     "images",
-    "kaleido",
     "maps",
     "ndarray",
     "plotly_utils",
diff --git a/examples/basic_charts/src/main.rs b/examples/basic_charts/src/main.rs
index a7d872ad..0a923dce 100644
--- a/examples/basic_charts/src/main.rs
+++ b/examples/basic_charts/src/main.rs
@@ -30,8 +30,12 @@ use plotly::{
         Align as TableAlign, Cells, Fill as TableFill, Font as TableFont, Header, Line as TableLine,
     },
     treemap::{BranchValues, Marker as TreemapMarker, Packing, PathBar, Side, Tiling},
-    Bar, Icicle, Indicator, Parcats, Pie, Plot, Sankey, Scatter, ScatterPolar, Sunburst, Table,
-    Treemap,
+    Bar, BarPolar, Icicle, Indicator, Parcats, Parcoords, Pie, Plot, Sankey, Scatter, ScatterPolar,
+    Sunburst, Table, Treemap,
+};
+use plotly::{
+    layout::PolarBarMode,
+    parcoords::{ConstraintRange, Dimension, ParcoordsLine},
 };
 use plotly_utils::write_example_to_html;
 use rand_distr::{Distribution, Normal, Uniform};
@@ -1476,6 +1480,87 @@ fn indicator_gauge(show: bool, file_name: &str) {
 }
 // ANCHOR_END: indicator_gauge
 
+// Polar Bar Charts
+// ANCHOR: wind_rose
+fn wind_rose(show: bool, file_name: &str) {
+    let directions = vec!["N", "NE", "E", "SE", "S", "SW", "W", "NW"];
+    let bands = [
+        (
+            "< 5 m/s",
+            vec![7.0, 5.5, 4.5, 6.0, 5.0, 6.5, 7.5, 6.0],
+            NamedColor::LightSkyBlue,
+        ),
+        (
+            "5-10 m/s",
+            vec![5.0, 3.5, 2.5, 4.0, 3.0, 4.5, 6.0, 4.5],
+            NamedColor::DodgerBlue,
+        ),
+        (
+            "> 10 m/s",
+            vec![2.5, 1.5, 1.0, 2.0, 1.5, 2.5, 3.5, 2.0],
+            NamedColor::DarkBlue,
+        ),
+    ];
+
+    let mut plot = Plot::new();
+    for (name, frequency, color) in bands {
+        let trace = BarPolar::new(directions.clone(), frequency)
+            .name(name)
+            .marker(Marker::new().color(color));
+        plot.add_trace(trace);
+    }
+
+    let layout = Layout::new().title("Wind Rose").polar(
+        LayoutPolar::new()
+            .bar_mode(PolarBarMode::Stack)
+            .bar_gap(0.1)
+            .angular_axis(AngularAxis::new().direction(PolarDirection::Clockwise)),
+    );
+    plot.set_layout(layout);
+
+    let path = write_example_to_html(&plot, file_name);
+    if show {
+        plot.show_html(path);
+    }
+}
+// ANCHOR_END: wind_rose
+
+// Parallel Coordinates
+// ANCHOR: basic_parcoords
+fn basic_parcoords(show: bool, file_name: &str) {
+    let trace = Parcoords::new(vec![
+        Dimension::new()
+            .label("Sepal length")
+            .values(vec![5.1, 4.9, 7.0, 6.4, 6.3, 5.8]),
+        Dimension::new()
+            .label("Sepal width")
+            .values(vec![3.5, 3.0, 3.2, 3.2, 3.3, 2.7]),
+        Dimension::new()
+            .label("Petal length")
+            .values(vec![1.4, 1.4, 4.7, 4.5, 6.0, 5.1])
+            .constraint_range(ConstraintRange::Single([4.0, 6.5])),
+        Dimension::new()
+            .label("Petal width")
+            .values(vec![0.2, 0.2, 1.4, 1.5, 2.5, 1.9]),
+    ])
+    .line(
+        ParcoordsLine::new()
+            .color_array(vec![0.0, 0.0, 1.0, 1.0, 2.0, 2.0])
+            .color_scale(ColorScale::Palette(ColorScalePalette::Viridis))
+            .show_scale(true),
+    );
+
+    let mut plot = Plot::new();
+    plot.add_trace(trace);
+    plot.set_layout(Layout::new().title("Parallel Coordinates"));
+
+    let path = write_example_to_html(&plot, file_name);
+    if show {
+        plot.show_html(path);
+    }
+}
+// ANCHOR_END: basic_parcoords
+
 fn main() {
     // Change false to true on any of these lines to display the example.
 
@@ -1535,6 +1620,12 @@ fn main() {
     basic_parcats(false, "basic_parcats");
     styled_parcats(false, "styled_parcats");
 
+    // Polar Bar Charts
+    wind_rose(false, "wind_rose");
+
+    // Parallel Coordinates
+    basic_parcoords(false, "basic_parcoords");
+
     // Indicator Charts
     basic_indicator(false, "basic_indicator");
     indicator_gauge(false, "indicator_gauge");
diff --git a/examples/custom_controls/Cargo.toml b/examples/custom_controls/Cargo.toml
index d0d4da93..b3abdeee 100644
--- a/examples/custom_controls/Cargo.toml
+++ b/examples/custom_controls/Cargo.toml
@@ -5,11 +5,11 @@ authors = ["Michael Freeborn <michaelfreeborn1@gmail.com>"]
 edition = "2021"
 
 [dependencies]
-itertools = "0.12"
+itertools = "0.15"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 csv = "1.3"
-ndarray = "0.15"
+ndarray = "0.17"
 
 plotly = { path = "../../plotly" }
 plotly_utils = { path = "../plotly_utils" }
\ No newline at end of file
diff --git a/examples/custom_controls/src/main.rs b/examples/custom_controls/src/main.rs
index 1643b69d..71051475 100644
--- a/examples/custom_controls/src/main.rs
+++ b/examples/custom_controls/src/main.rs
@@ -269,9 +269,9 @@ fn sinusoidal_slider_example(show: bool, file_name: &str) {
     let num_steps = 51; // 0..=50 for frequencies 0.0 to 5.0 in 0.1 steps
 
     // Add traces, one for each slider step (frequency parameter)
-    for step in 0..=num_steps {
+    for step in 0..num_steps {
         let frequency = step as f64 / 10.0; // 0.0, 0.1, ..., 5.0
-        let x: Vec<f64> = Array::linspace(0.0, 10.0, 1001).into_raw_vec().to_vec();
+        let x: Vec<f64> = Array::linspace(0.0, 10.0, 1001).to_vec();
         let y: Vec<f64> = x.iter().map(|&x_val| (frequency * x_val).sin()).collect();
         let trace = Scatter::new(x, y)
             .visible(if step == 10 {
diff --git a/examples/customization/consistent_static_format_export/Cargo.toml b/examples/customization/consistent_static_format_export/Cargo.toml
index 937c6512..70cf9d14 100644
--- a/examples/customization/consistent_static_format_export/Cargo.toml
+++ b/examples/customization/consistent_static_format_export/Cargo.toml
@@ -7,5 +7,5 @@ description = "This example demonstrates exporting a plot to SVG, PNG, and PDF a
 
 [dependencies]
 plotly = { path = "../../../plotly", features = ["static_export_default"] }
-env_logger = "0.10"
+env_logger = "0.11"
 log = "0.4"
diff --git a/examples/financial_charts/Cargo.toml b/examples/financial_charts/Cargo.toml
index 0ceab75f..e432edc6 100644
--- a/examples/financial_charts/Cargo.toml
+++ b/examples/financial_charts/Cargo.toml
@@ -10,5 +10,5 @@ plotly = { path = "../../plotly" }
 plotly_utils = { path = "../plotly_utils" }
 serde = "1.0"
 chrono = "0.4"
-rand = "0.8"
-rand_chacha = "0.3"
+rand = "0.10"
+rand_chacha = "0.10"
diff --git a/examples/financial_charts/src/main.rs b/examples/financial_charts/src/main.rs
index 2e25c92d..419b2844 100644
--- a/examples/financial_charts/src/main.rs
+++ b/examples/financial_charts/src/main.rs
@@ -7,9 +7,10 @@ use chrono::{DateTime, Duration};
 use plotly::color::NamedColor;
 use plotly::common::{Marker, TickFormatStop};
 use plotly::funnel::Connector as FunnelConnector;
+use plotly::funnel_area::{FunnelAreaTitle, FunnelAreaTitlePosition};
 use plotly::layout::{Axis, RangeSelector, RangeSlider, SelectorButton, SelectorStep, StepMode};
 use plotly::waterfall::{Marker as WaterfallMarker, Measure, MeasureStyle};
-use plotly::{Candlestick, Funnel, Layout, Ohlc, Plot, Scatter, Waterfall};
+use plotly::{Candlestick, Funnel, FunnelArea, Layout, Ohlc, Plot, Scatter, Waterfall};
 use plotly_utils::write_example_to_html;
 use serde::Deserialize;
 
@@ -377,6 +378,42 @@ fn basic_funnel(show: bool, file_name: &str) {
 }
 // ANCHOR_END: basic_funnel
 
+// ANCHOR: basic_funnel_area
+fn basic_funnel_area(show: bool, file_name: &str) {
+    let trace = FunnelArea::new(vec![5000, 3200, 1800, 900, 400])
+        .labels(vec![
+            "Visited",
+            "Signed up",
+            "Activated",
+            "Subscribed",
+            "Renewed",
+        ])
+        .text_info("label+value+percent")
+        .marker(Marker::new().colors(vec![
+            NamedColor::RoyalBlue,
+            NamedColor::DodgerBlue,
+            NamedColor::DeepSkyBlue,
+            NamedColor::LightSkyBlue,
+            NamedColor::LightBlue,
+        ]))
+        .title(
+            FunnelAreaTitle::new()
+                .text("Subscription funnel")
+                .position(FunnelAreaTitlePosition::TopCenter),
+        )
+        .base_ratio(0.2);
+
+    let mut plot = Plot::new();
+    plot.add_trace(trace);
+    plot.set_layout(Layout::new().title("Funnel Area"));
+
+    let path = write_example_to_html(&plot, file_name);
+    if show {
+        plot.show_html(path);
+    }
+}
+// ANCHOR_END: basic_funnel_area
+
 // ANCHOR: series_with_gaps_for_weekends_and_holidays
 fn series_with_gaps_for_weekends_and_holidays(show: bool, file_name: &str) {
     let data = load_apple_data();
@@ -453,7 +490,7 @@ fn hiding_weekends_and_holidays_with_rangebreaks(show: bool, file_name: &str) {
 
 // Helper to generate random walk data for all hours in a week
 fn generate_business_hours_data() -> (Vec<String>, Vec<f64>) {
-    use rand::Rng;
+    use rand::RngExt;
     use rand::SeedableRng;
     use rand_chacha::ChaCha8Rng;
 
@@ -467,7 +504,7 @@ fn generate_business_hours_data() -> (Vec<String>, Vec<f64>) {
         for hour in 0..24 {
             let current_date = start_date + Duration::days(day) + Duration::hours(hour);
             dates.push(current_date.format("%Y-%m-%d %H:%M:%S").to_string());
-            current_value += (rng.gen::<f64>() - 0.5) * 2.0;
+            current_value += (rng.random::<f64>() - 0.5) * 2.0;
             values.push(current_value);
         }
     }
@@ -565,6 +602,7 @@ fn main() {
 
     // Funnel Charts
     basic_funnel(false, "basic_funnel");
+    basic_funnel_area(false, "basic_funnel_area");
 
     // Rangebreaks usage
     series_with_gaps_for_weekends_and_holidays(false, "series_with_gaps_for_weekends_and_holidays");
diff --git a/examples/kaleido/Cargo.toml b/examples/kaleido/Cargo.toml
deleted file mode 100644
index 5dc65140..00000000
--- a/examples/kaleido/Cargo.toml
+++ /dev/null
@@ -1,11 +0,0 @@
-[package]
-name = "kaleido"
-version = "0.1.0"
-authors = [
-    "Michael Freeborn <michaelfreeborn1@gmail.com>",
-    "Andrei Gherghescu andrei-ng@protonmail.com",
-]
-edition = "2021"
-
-[dependencies]
-plotly = { path = "../../plotly", features = ["kaleido", "kaleido_download"] }
diff --git a/examples/kaleido/src/main.rs b/examples/kaleido/src/main.rs
deleted file mode 100644
index de855bf7..00000000
--- a/examples/kaleido/src/main.rs
+++ /dev/null
@@ -1,31 +0,0 @@
-use plotly::{ImageFormat, Plot, Scatter};
-
-fn main() {
-    let mut plot = Plot::new();
-    let trace = Scatter::new(vec![0, 1, 2], vec![2, 1, 0]);
-    plot.add_trace(trace);
-
-    // Adjust these arguments to set the width and height of the
-    // output image.
-    let width = 800;
-    let height = 600;
-    let scale = 1.0;
-
-    std::fs::create_dir_all("./output").unwrap();
-    let filename = "./output/inline_image".to_string();
-
-    // The image will be saved to format!("output/image.{image_format}") relative to
-    // the current working directory.
-    #[allow(deprecated)]
-    {
-        plot.write_image(&filename, ImageFormat::EPS, width, height, scale);
-        plot.write_image(&filename, ImageFormat::JPEG, width, height, scale);
-        plot.write_image(&filename, ImageFormat::PDF, width, height, scale);
-        plot.write_image(&filename, ImageFormat::PNG, width, height, scale);
-        plot.write_image(&filename, ImageFormat::SVG, width, height, scale);
-        plot.write_image(&filename, ImageFormat::WEBP, width, height, scale);
-
-        let svg_string = plot.to_svg(width, height, scale);
-        println!("SVG plot string: {svg_string}");
-    }
-}
diff --git a/examples/maps/Cargo.toml b/examples/maps/Cargo.toml
index cb3b2b26..465b22c3 100644
--- a/examples/maps/Cargo.toml
+++ b/examples/maps/Cargo.toml
@@ -8,6 +8,6 @@ edition = "2021"
 plotly = { path = "../../plotly" }
 plotly_utils = { path = "../plotly_utils" }
 csv = "1.3"
-reqwest = { version = "0.11", features = ["blocking"] }
+reqwest = { version = "0.13", features = ["blocking"] }
 serde_json = "1"
 
diff --git a/examples/scientific_charts/src/main.rs b/examples/scientific_charts/src/main.rs
index 695fcbc6..9fdf1eb2 100644
--- a/examples/scientific_charts/src/main.rs
+++ b/examples/scientific_charts/src/main.rs
@@ -2,9 +2,16 @@
 
 use std::f64::consts::PI;
 
+use plotly::carpet::{CarpetAxis, CarpetAxisTitle};
 use plotly::common::{ColorScale, ColorScalePalette, Font, HoverInfo};
+use plotly::common::{Marker, Mode};
+use plotly::contour::Coloring;
 use plotly::contour::Contours;
-use plotly::{Contour, HeatMap, Layout, Plot};
+use plotly::layout::{LayoutSmith, LayoutTernary, TernaryAxis};
+use plotly::{
+    Carpet, Contour, ContourCarpet, HeatMap, Layout, Plot, ScatterCarpet, ScatterSmith,
+    ScatterTernary,
+};
 use plotly_utils::write_example_to_html;
 
 // Contour Plots
@@ -185,6 +192,135 @@ fn customized_heat_map(show: bool, file_name: &str) {
 }
 // ANCHOR_END: customized_heat_map
 
+// Ternary Plots
+// ANCHOR: ternary_plot
+fn ternary_plot(show: bool, file_name: &str) {
+    // Soil composition: each sample is a mix of clay, sand and silt (in %).
+    let clay = vec![30.0, 10.0, 55.0, 20.0, 40.0];
+    let sand = vec![50.0, 70.0, 15.0, 30.0, 20.0];
+    let silt = vec![20.0, 20.0, 30.0, 50.0, 40.0];
+
+    let trace = ScatterTernary::new(clay, sand, silt)
+        .mode(Mode::MarkersText)
+        .text_array(vec!["Loam", "Sandy loam", "Clay", "Silt loam", "Clay loam"])
+        .marker(Marker::new().size(12));
+
+    let layout = Layout::new().title("Soil composition").ternary(
+        LayoutTernary::new()
+            .sum(100.0)
+            .a_axis(TernaryAxis::new().title("Clay"))
+            .b_axis(TernaryAxis::new().title("Sand"))
+            .c_axis(TernaryAxis::new().title("Silt")),
+    );
+
+    let mut plot = Plot::new();
+    plot.add_trace(trace);
+    plot.set_layout(layout);
+
+    let path = write_example_to_html(&plot, file_name);
+    if show {
+        plot.show_html(path);
+    }
+}
+// ANCHOR_END: ternary_plot
+
+// Smith Charts
+// ANCHOR: smith_chart
+fn smith_chart(show: bool, file_name: &str) {
+    // Normalized impedance of a load swept in frequency.
+    let real = vec![0.5, 1.0, 2.0, 3.0, 2.0, 1.0, 0.5];
+    let imag = vec![0.5, 1.0, 1.5, 0.0, -1.5, -1.0, -0.5];
+
+    let trace = ScatterSmith::new(real, imag)
+        .mode(Mode::LinesMarkers)
+        .name("Load impedance");
+
+    let mut plot = Plot::new();
+    plot.add_trace(trace);
+    plot.set_layout(Layout::new().title("Smith Chart").smith(LayoutSmith::new()));
+
+    let path = write_example_to_html(&plot, file_name);
+    if show {
+        plot.show_html(path);
+    }
+}
+// ANCHOR_END: smith_chart
+
+// Carpet Plots
+// ANCHOR: carpet_with_scatter
+fn carpet_with_scatter(show: bool, file_name: &str) {
+    let carpet = Carpet::new(
+        vec![4.0, 4.0, 4.0, 4.5, 4.5, 4.5, 5.0, 5.0, 5.0, 6.0, 6.0, 6.0],
+        vec![1.0, 2.0, 3.0, 1.0, 2.0, 3.0, 1.0, 2.0, 3.0, 1.0, 2.0, 3.0],
+    )
+    .y(vec![
+        2.0, 3.5, 4.0, 3.0, 4.5, 5.0, 5.5, 6.5, 7.5, 8.0, 8.5, 10.0,
+    ])
+    .a_axis(
+        CarpetAxis::new()
+            .title(CarpetAxisTitle::new().text("a"))
+            .tick_prefix("a = "),
+    )
+    .b_axis(
+        CarpetAxis::new()
+            .title(CarpetAxisTitle::new().text("b"))
+            .tick_prefix("b = "),
+    )
+    .carpet("c1");
+
+    let scatter = ScatterCarpet::new(vec![4.0, 4.5, 5.0, 6.0], vec![2.5, 2.5, 2.5, 2.5])
+        .carpet("c1")
+        .mode(Mode::LinesMarkers)
+        .name("b = 2.5");
+
+    let mut plot = Plot::new();
+    plot.add_trace(carpet);
+    plot.add_trace(scatter);
+    plot.set_layout(Layout::new().title("Scatter on a Carpet"));
+
+    let path = write_example_to_html(&plot, file_name);
+    if show {
+        plot.show_html(path);
+    }
+}
+// ANCHOR_END: carpet_with_scatter
+
+// ANCHOR: contour_carpet
+fn contour_carpet(show: bool, file_name: &str) {
+    let a = vec![0.0, 1.0, 2.0, 3.0, 0.0, 1.0, 2.0, 3.0, 0.0, 1.0, 2.0, 3.0];
+    let b = vec![4.0, 4.0, 4.0, 4.0, 5.0, 5.0, 5.0, 5.0, 6.0, 6.0, 6.0, 6.0];
+
+    let carpet = Carpet::new(a.clone(), b.clone())
+        .x(vec![
+            2.0, 3.0, 4.0, 5.0, 2.2, 3.1, 4.1, 5.1, 1.5, 2.5, 3.5, 4.5,
+        ])
+        .y(vec![
+            1.0, 1.4, 1.6, 1.75, 2.0, 2.5, 2.7, 2.75, 3.0, 3.5, 3.7, 3.75,
+        ])
+        .a_axis(CarpetAxis::new().tick_prefix("a = ").smoothing(0.0))
+        .b_axis(CarpetAxis::new().tick_prefix("b = ").smoothing(0.0));
+
+    let z = vec![
+        1.0, 1.96, 2.56, 3.0625, 4.0, 5.0625, 1.0, 7.5625, 9.0, 12.25, 15.21, 14.0625,
+    ];
+    let contour = ContourCarpet::new(z)
+        .a(a)
+        .b(b)
+        .contours(Contours::new().coloring(Coloring::Fill))
+        .color_scale(ColorScale::Palette(ColorScalePalette::Viridis));
+
+    let mut plot = Plot::new();
+    plot.add_trace(carpet);
+    plot.add_trace(contour);
+    plot.set_layout(Layout::new().title("Contour Carpet"));
+
+    let path = write_example_to_html(&plot, file_name);
+    if show {
+        plot.show_html(path);
+    }
+}
+// ANCHOR_END: contour_carpet
+
 fn main() {
     // Change false to true on any of these lines to display the example.
     // Contour Plots
@@ -199,4 +335,14 @@ fn main() {
     // Heatmaps
     basic_heat_map(false, "basic_heat_map");
     customized_heat_map(false, "customized_heat_map");
+
+    // Ternary Plots
+    ternary_plot(false, "ternary_plot");
+
+    // Smith Charts
+    smith_chart(false, "smith_chart");
+
+    // Carpet Plots
+    carpet_with_scatter(false, "carpet_with_scatter");
+    contour_carpet(false, "contour_carpet");
 }
diff --git a/examples/static_export/README.md b/examples/static_export/README.md
index 12c4ef27..e09825f3 100644
--- a/examples/static_export/README.md
+++ b/examples/static_export/README.md
@@ -4,7 +4,7 @@ This example demonstrates how to use the `plotly_static` crate for exporting Plo
 
 The `plotly_static` provides a interface for converting Plotly plots into various static image formats (PNG, JPEG, WEBP, SVG, PDF) using WebDriver and headless browsers.
 
-In this example it is shown how to use the `StaticExporter` with the old style Kaleido API and also with the new style API. Using the former API is fine for one time static exports, but that API will crate an instance of the `StaticExporter` for each `write_image` call. The new style API is recommended for performance as the same instance of the `StaticExporter` can be reused across multiple exports.  
+In this example it is shown how to use the `StaticExporter` with the one-shot `Plot::write_image` API (the style of the former Kaleido backend) and also with the new style API. Using the former API is fine for one time static exports, but that API will crate an instance of the `StaticExporter` for each `write_image` call. The new style API is recommended for performance as the same instance of the `StaticExporter` can be reused across multiple exports.  
 
 When any of the `plotly` static export features are enabled (`static_export_chromedriver`, `static_export_geckodriver`, or `static_export_default`), both `StaticExporter` (sync) and `AsyncStaticExporter` (async) are available via `plotly::plotly_static`. This example includes separate `sync` and `async` bins demonstrating both.  Refer to the [`plotly_static` API Documentation](https://docs.rs/plotly_static/) a more detailed description.
 
diff --git a/examples/static_export/src/bin/sync.rs b/examples/static_export/src/bin/sync.rs
index 8cb93a98..2b7877dd 100644
--- a/examples/static_export/src/bin/sync.rs
+++ b/examples/static_export/src/bin/sync.rs
@@ -19,7 +19,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     std::fs::create_dir_all("./output").unwrap();
 
-    info!("Exporting multiple plots using a Kaleido style API ...");
+    info!("Exporting multiple plots using the one-shot Plot::write_image API ...");
     plot1.write_image("./output/plot1_legacy_api", ImageFormat::PNG, 800, 600, 1.0)?;
     plot2.write_image(
         "./output/plot2_legacy_api",
@@ -42,8 +42,8 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         .expect("Failed to create StaticExporter");
 
     info!("Exporting multiple plots using a single StaticExporter...");
-    // Export all plots using the same exporter (new unified naming via extension
-    // trait)
+    // Export all plots using the same exporter (new unified naming via
+    // extension trait)
     exporter.write_image(
         &plot1,
         "./output/plot1_new_api",
diff --git a/examples/statistical_charts/src/main.rs b/examples/statistical_charts/src/main.rs
index b81c8a8f..ad4b9582 100644
--- a/examples/statistical_charts/src/main.rs
+++ b/examples/statistical_charts/src/main.rs
@@ -11,7 +11,7 @@ use plotly::{
     layout::{Axis, BarMode, BoxMode, Layout, Margin, ViolinMode},
     splom::{SplomDiagonal, SplomDimension},
     violin::{MeanLine, ViolinBox, ViolinPoints, ViolinSide},
-    Bar, BoxPlot, Histogram, Histogram2d, Plot, Scatter, Splom, Violin,
+    Bar, BoxPlot, Histogram, Histogram2d, Histogram2dContour, Plot, Scatter, Splom, Violin,
 };
 use plotly_utils::write_example_to_html;
 use rand_distr::{Distribution, Normal, Uniform};
@@ -869,6 +869,27 @@ fn histogram2d_aggregation(show: bool, file_name: &str) {
 }
 // ANCHOR_END: histogram2d_aggregation
 
+// ANCHOR: histogram2d_contour
+fn histogram2d_contour(show: bool, file_name: &str) {
+    let n = 5_000;
+    let x = sample_normal_distribution(n, 0.0, 1.0);
+    let y = sample_normal_distribution(n, 0.0, 1.0);
+
+    let trace = Histogram2dContour::new(x, y)
+        .name("2d histogram contour")
+        .n_contours(10)
+        .color_scale(ColorScale::Palette(ColorScalePalette::Blues))
+        .reverse_scale(true);
+    let mut plot = Plot::new();
+    plot.add_trace(trace);
+
+    let path = write_example_to_html(&plot, file_name);
+    if show {
+        plot.show_html(path);
+    }
+}
+// ANCHOR_END: histogram2d_contour
+
 // SPLOM
 fn splom_axis() -> Axis {
     Axis::new()
@@ -1038,6 +1059,7 @@ fn main() {
     basic_histogram2d(false, "basic_histogram2d");
     styled_histogram2d(false, "styled_histogram2d");
     histogram2d_aggregation(false, "histogram2d_aggregation");
+    histogram2d_contour(false, "histogram2d_contour");
 
     // SPLOM
     basic_splom(false, "basic_splom");
diff --git a/plotly/Cargo.toml b/plotly/Cargo.toml
index 723576fd..4becb37a 100644
--- a/plotly/Cargo.toml
+++ b/plotly/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "plotly"
-version = "0.14.1"
+version = "0.15.0"
 description = "A plotting library powered by Plotly.js"
 authors = [
     "Ioannis Giagkiozis <i.giagkiozis@gmail.com>",
@@ -8,7 +8,6 @@ authors = [
 ]
 license = "MIT"
 readme = "../README.md"
-homepage = "https://github.com/plotly/plotly.rs"
 documentation = "https://docs.rs/plotly"
 repository = "https://github.com/plotly/plotly.rs"
 edition = "2021"
@@ -49,22 +48,14 @@ all = [
 # This is used for enabling extra debugging messages and debugging functionality
 debug = ["plotly_static?/debug"]
 
-# DEPRECATED: kaleido feature will be removed in version 0.15.0. Use `static_export_*` features instead.
-kaleido = ["plotly_kaleido"]
-# DEPRECATED: kaleido_download feature will be removed in version 0.15.0. Use `static_export_wd_download` instead.
-kaleido_download = ["plotly_kaleido/download"]
-
-
 [dependencies]
 askama = { version = "0.16.0", features = ["serde_json"] }
 dyn-clone = "1"
 erased-serde = "0.4"
 image = { version = "0.25", optional = true }
-plotly_derive = { version = "0.14", path = "../plotly_derive" }
-plotly_static = { version = "0.1", path = "../plotly_static", optional = true }
-plotly_kaleido = { version = "0.13", path = "../plotly_kaleido", optional = true }
+plotly_derive = { version = "0.15", path = "../plotly_derive" }
+plotly_static = { version = "0.2", path = "../plotly_static", optional = true }
 ndarray = { version = "0.17", optional = true }
-once_cell = "1"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 serde_repr = "0.1"
diff --git a/plotly/src/bindings.rs b/plotly/src/bindings.rs
index 9b86c05d..5bffee02 100644
--- a/plotly/src/bindings.rs
+++ b/plotly/src/bindings.rs
@@ -22,6 +22,11 @@ extern "C" {
 /// The function signature is slightly constrained in that `id` is a `&str`
 /// which represents the `id` of an existing HTML `div` element, rather than
 /// also allowing an instance of a `div` element, itself.
+///
+/// # Panics
+///
+/// Panics if plotly.js rejects the plot (e.g. no element with the given `id`
+/// exists).
 pub async fn new_plot(id: &str, plot: &Plot) {
     let plot_obj = &plot.to_js_object();
 
@@ -37,6 +42,11 @@ pub async fn new_plot(id: &str, plot: &Plot) {
 /// The function signature is slightly constrained in that `id` is a `&str`
 /// which represents the `id` of an existing HTML `div` element, rather than
 /// also allowing an instance of a `div` element, itself.
+///
+/// # Panics
+///
+/// Panics if plotly.js rejects the plot (e.g. no element with the given `id`
+/// exists).
 pub async fn react(id: &str, plot: &Plot) {
     let plot_obj = &plot.to_js_object();
 
diff --git a/plotly/src/callbacks.rs b/plotly/src/callbacks.rs
index 4a47b562..331cbea5 100644
--- a/plotly/src/callbacks.rs
+++ b/plotly/src/callbacks.rs
@@ -57,6 +57,12 @@ extern "C" {
 ///     web_sys::console::log_1(&format!("{:?}", evt).into());
 /// });
 /// ```
+///
+/// # Panics
+///
+/// Panics if no element with the given `div_id` exists. The registered
+/// listener panics if a click event cannot be deserialized into
+/// `ClickEvent`.
 pub fn bind_click<F>(div_id: &str, mut cb: F)
 where
     F: 'static + FnMut(ClickEvent),
diff --git a/plotly/src/common/color.rs b/plotly/src/common/color.rs
index dbbecc32..b6eb2015 100644
--- a/plotly/src/common/color.rs
+++ b/plotly/src/common/color.rs
@@ -49,9 +49,9 @@ impl Color for i16 {}
 impl Color for i8 {}
 impl Color for usize {}
 
-/// ColorArray is only used internally to provide a helper method for converting
-/// Vec<impl Color> to Vec<Box<dyn Color>>, as we would otherwise fall foul of
-/// the orphan rules.
+/// `ColorArray` is only used internally to provide a helper method for
+/// converting Vec<impl Color> to Vec<Box<dyn Color>>, as we would otherwise
+/// fall foul of the orphan rules.
 pub(crate) struct ColorArray<C: Color>(pub(crate) Vec<C>);
 
 #[allow(clippy::from_over_into)]
diff --git a/plotly/src/common/mod.rs b/plotly/src/common/mod.rs
index 5b0e8375..16177ed7 100644
--- a/plotly/src/common/mod.rs
+++ b/plotly/src/common/mod.rs
@@ -217,12 +217,14 @@ pub enum PlotType {
     ScatterPolar,
     ScatterPolarGL,
     Bar,
+    BarPolar,
     Box,
     Candlestick,
     Choropleth,
     ChoroplethMap,
     Contour,
     Funnel,
+    FunnelArea,
     HeatMap,
     Histogram,
     Histogram2d,
@@ -244,6 +246,16 @@ pub enum PlotType {
     Sunburst,
     Violin,
     Waterfall,
+    Cone,
+    StreamTube,
+    IsoSurface,
+    Volume,
+    Parcoords,
+    ScatterTernary,
+    ScatterSmith,
+    Carpet,
+    ScatterCarpet,
+    ContourCarpet,
 }
 
 #[derive(Serialize, Clone, Debug)]
@@ -1177,8 +1189,8 @@ mod tests {
 
     #[test]
     fn serialize_direction() {
-        // TODO: I think `Direction` would be better as a struct, with `fillcolor` and
-        // `line` attributes
+        // TODO: I think `Direction` would be better as a struct, with
+        // `fillcolor` and `line` attributes
         let inc = Direction::Increasing { line: Line::new() };
         let expected = json!({"line": {}});
         assert_eq!(to_value(inc).unwrap(), expected);
diff --git a/plotly/src/configuration.rs b/plotly/src/configuration.rs
index f319e197..0052414c 100644
--- a/plotly/src/configuration.rs
+++ b/plotly/src/configuration.rs
@@ -211,8 +211,8 @@ impl Configuration {
 
     /// When set it determines base URL for the "Edit in Chart Studio"
     /// `show_edit_in_chart_studio`/`show_send_to_cloud` mode bar button and
-    /// the show_link/send_data on-graph link. To enable sending your data to
-    /// Chart Studio Cloud, you need to set both `plotly_server_url` to <https://chart-studio.plotly.com> and
+    /// the `show_link`/`send_data` on-graph link. To enable sending your data
+    /// to Chart Studio Cloud, you need to set both `plotly_server_url` to <https://chart-studio.plotly.com> and
     /// also set `showSendToCloud` to `true`.
     pub fn plotly_server_url(mut self, plotly_server_url: &str) -> Self {
         self.plotly_server_url = Some(plotly_server_url.to_string());
@@ -228,7 +228,7 @@ impl Configuration {
     }
 
     /// Determines whether the graphs are plotted with respect to
-    /// layout.auto_size: true and infer its container size.
+    /// `layout.auto_size: true` and infer its container size.
     pub fn autosizable(mut self, autosizable: bool) -> Self {
         self.autosizable = Some(autosizable);
         self
diff --git a/plotly/src/export.rs b/plotly/src/export.rs
index c91ea41f..62abace3 100644
--- a/plotly/src/export.rs
+++ b/plotly/src/export.rs
@@ -7,9 +7,9 @@ pub mod sync {
     /// Extension methods for exporting plots using a synchronous exporter.
     pub trait ExporterSyncExt {
         /// Convert the `Plot` to a static image of the given image format and
-        /// save at the given location using a provided StaticExporter.
+        /// save at the given location using a provided `StaticExporter`.
         ///
-        /// This method allows you to reuse a StaticExporter instance across
+        /// This method allows you to reuse a `StaticExporter` instance across
         /// multiple plots, which is more efficient than creating a new one for
         /// each operation.
         ///
@@ -18,7 +18,7 @@ pub mod sync {
         ///
         /// # Arguments
         ///
-        /// * `exporter` - A mutable reference to a StaticExporter instance
+        /// * `exporter` - A mutable reference to a `StaticExporter` instance
         /// * `filename` - The destination path for the output file
         /// * `format` - The desired output image format
         /// * `width` - The width of the output image in pixels
@@ -45,6 +45,11 @@ pub mod sync {
         ///
         /// exporter.close();
         /// ```
+        ///
+        /// # Errors
+        ///
+        /// Returns an error if the export fails, if the image file cannot be
+        /// written, or if called from within an async (Tokio) context.
         fn write_image<P: AsRef<Path>>(
             &mut self,
             plot: &Plot,
@@ -56,10 +61,10 @@ pub mod sync {
         ) -> Result<(), Box<dyn std::error::Error>>;
 
         /// Convert the `Plot` to a static image and return the image as a
-        /// `base64` string. Supported formats are [ImageFormat::JPEG],
-        /// [ImageFormat::PNG] and [ImageFormat::WEBP].
+        /// `base64` string. Supported formats are [`ImageFormat::JPEG`],
+        /// [`ImageFormat::PNG`] and [`ImageFormat::WEBP`].
         ///
-        /// This method allows you to reuse the same StaticExporter instance
+        /// This method allows you to reuse the same `StaticExporter` instance
         /// across multiple plots, which is more efficient than creating
         /// a new one for each operation.
         ///
@@ -91,6 +96,11 @@ pub mod sync {
         ///
         /// exporter.close();
         /// ```
+        ///
+        /// # Errors
+        ///
+        /// Returns an error if `format` is not JPEG, PNG or WEBP, if the export
+        /// fails, or if called from within an async (Tokio) context.
         fn to_base64(
             &mut self,
             plot: &Plot,
@@ -102,7 +112,7 @@ pub mod sync {
 
         /// Convert the `Plot` to SVG and return it as a String.
         ///
-        /// This method allows you to reuse the same StaticExporter instance
+        /// This method allows you to reuse the same `StaticExporter` instance
         /// across multiple plots, which is more efficient than creating
         /// a new one for each operation.
         ///
@@ -133,6 +143,11 @@ pub mod sync {
         ///
         /// exporter.close();
         /// ```
+        ///
+        /// # Errors
+        ///
+        /// Returns an error if the export fails, or if called from within an
+        /// async (Tokio) context.
         fn to_svg(
             &mut self,
             plot: &Plot,
@@ -218,7 +233,7 @@ pub mod r#async {
         /// the given location using the asynchronous exporter.
         ///
         /// The exporter must have been built with the `build_async` method of
-        /// the StaticExporterBuilder.
+        /// the `StaticExporterBuilder`.
         ///
         /// Functionally signature equivalent to the sync version in
         /// [`crate::export::sync::ExporterSyncExt::write_image`], but meant for
@@ -239,7 +254,7 @@ pub mod r#async {
         /// `base64` string using the asynchronous exporter.
         ///
         /// The exporter must have been built with the `build_async` method of
-        /// the StaticExporterBuilder.
+        /// the `StaticExporterBuilder`.
         ///
         /// Functionally signature equivalent to the sync version in
         /// [`crate::export::sync::ExporterSyncExt::to_base64`], but meant for
diff --git a/plotly/src/layout/animation.rs b/plotly/src/layout/animation.rs
index 06fa666d..c80eb5b1 100644
--- a/plotly/src/layout/animation.rs
+++ b/plotly/src/layout/animation.rs
@@ -11,7 +11,7 @@ use serde::Serialize;
 use crate::{Layout, Traces};
 
 /// A frame represents a single state in an animation sequence.
-/// Based on Plotly.js frame_attributes.js specification
+/// Based on Plotly.js `frame_attributes.js` specification
 #[serde_with::skip_serializing_none]
 #[derive(Serialize, Clone, FieldSetter)]
 pub struct Frame {
@@ -63,7 +63,7 @@ impl Default for Animation {
 
 impl Animation {
     /// Create a new animation args with default values for options and
-    /// FramesMode set to all frames
+    /// `FramesMode` set to all frames
     pub fn new() -> Self {
         Self::default()
     }
@@ -139,7 +139,7 @@ impl Serialize for FrameListMode {
 }
 
 /// Animation configuration options
-/// Based on actual Plotly.js animation API from animation_attributes.js
+/// Based on actual Plotly.js animation API from `animation_attributes.js`
 #[serde_with::skip_serializing_none]
 #[derive(Serialize, Clone, Debug, FieldSetter)]
 pub struct AnimationOptions {
diff --git a/plotly/src/layout/axis.rs b/plotly/src/layout/axis.rs
index 44c637de..d463fd3a 100644
--- a/plotly/src/layout/axis.rs
+++ b/plotly/src/layout/axis.rs
@@ -622,7 +622,7 @@ impl Axis {
 
     /// Set the range of the axis. This method accepts various types and
     /// converts them to `AxisRange` while also keeping backward compatibility
-    /// with API prior to AxisRange introduction.
+    /// with API prior to `AxisRange` introduction.
     pub fn range(mut self, range: impl Into<AxisRange>) -> Self {
         self.range = Some(range.into());
         self
diff --git a/plotly/src/layout/geo.rs b/plotly/src/layout/geo.rs
index 071be2c0..968604bb 100644
--- a/plotly/src/layout/geo.rs
+++ b/plotly/src/layout/geo.rs
@@ -191,4 +191,10 @@ mod tests {
         let geo = LayoutGeo::new().resolution(GeoResolution::OneOverOneHundredTenMillion);
         assert_eq!(to_value(geo).unwrap(), json!({ "resolution": 110 }));
     }
+
+    #[test]
+    fn serialize_rotation_omits_unset_fields() {
+        let json = serde_json::to_value(Rotation::new().lon(2.0)).unwrap();
+        assert_eq!(json, json!({"lon": 2.0}));
+    }
 }
diff --git a/plotly/src/layout/mod.rs b/plotly/src/layout/mod.rs
index b46c9f65..94aa3660 100644
--- a/plotly/src/layout/mod.rs
+++ b/plotly/src/layout/mod.rs
@@ -26,6 +26,8 @@ mod rangebreaks;
 mod scene;
 mod shape;
 mod slider;
+mod smith;
+mod ternary;
 
 // Re-export layout sub-module types
 pub use self::animation::{
@@ -51,7 +53,7 @@ pub use self::modes::{
 pub use self::polar::{
     AngularAxis, AngularAxisType, AutoRange, AutoRangeOptions, AutoTypeNumbers, AxisLayer,
     GridShape, Hole, LayoutPolar, MinorLogLabels, PolarAxisAttributes, PolarAxisTicks,
-    PolarDirection, PolarTickMode, RadialAxis, RadialAxisType, ThetaUnit,
+    PolarBarMode, PolarDirection, PolarTickMode, RadialAxis, RadialAxisType, ThetaUnit,
 };
 pub use self::rangebreaks::RangeBreak;
 pub use self::scene::{
@@ -66,8 +68,10 @@ pub use self::slider::{
     Slider, SliderCurrentValue, SliderCurrentValueXAnchor, SliderMethod, SliderStep,
     SliderStepBuilder, SliderTransition, SliderTransitionEasing,
 };
+pub use self::smith::{ImaginaryAxis, LayoutSmith, RealAxis, RealAxisSide, RealAxisTicks};
+pub use self::ternary::{LayoutTernary, TernaryAxis};
 
-/// Error type for ControlBuilder operations
+/// Error type for `ControlBuilder` operations
 #[derive(Debug)]
 pub enum ControlBuilderError {
     RestyleSerializationError(String),
@@ -227,11 +231,11 @@ impl Into<Cow<'static, Template>> for &'static Template {
     }
 }
 
-/// Generates Layout and LayoutTemplate
-/// LayoutTemplate matches Layout except it lacks a field for template
+/// Generates Layout and `LayoutTemplate`
+/// `LayoutTemplate` matches Layout except it lacks a field for template
 /// See layout/layout.rs for the full field list and doc comments.
-/// Layout is identical to LayoutTemplate except it has a `template` field and
-/// #[field_setter(kind = "layout")] See layout/layout.rs for the full field
+/// Layout is identical to `LayoutTemplate` except it has a `template` field and
+/// `#[field_setter(kind = "layout")]` See layout/layout.rs for the full field
 /// list and doc comments.
 #[layout_structs]
 pub struct LayoutFields {
@@ -350,7 +354,8 @@ pub struct LayoutFields {
     y_axis8: Option<Box<Axis>>,
     #[serde(rename = "zaxis8")]
     z_axis8: Option<Box<Axis>>,
-    // ternary: Option<LayoutTernary>,
+    ternary: Option<LayoutTernary>,
+    smith: Option<LayoutSmith>,
     scene: Option<LayoutScene>,
     geo: Option<LayoutGeo>,
     map: Option<LayoutMap>,
@@ -405,6 +410,13 @@ pub struct LayoutFields {
     treemap_colorway: Option<Vec<Box<dyn Color>>>,
     #[serde(rename = "extendtreemapcolors")]
     extend_treemap_colors: Option<bool>,
+    #[serde(rename = "funnelareacolorway")]
+    funnel_area_colorway: Option<Vec<Box<dyn Color>>>,
+    #[serde(rename = "extendfunnelareacolors")]
+    extend_funnel_area_colors: Option<bool>,
+    /// Hides the pie / funnel area sectors whose labels are listed here.
+    #[serde(rename = "hiddenlabels")]
+    hidden_labels: Option<Vec<String>>,
     mapbox: Option<Mapbox>,
     #[serde(rename = "updatemenus")]
     update_menus: Option<Vec<UpdateMenu>>,
@@ -674,6 +686,26 @@ mod tests {
         assert_eq!(to_value(layout).unwrap()["uirevision"], json!("forever"));
     }
 
+    #[test]
+    fn serialize_layout_subplots_and_funnel_area_colors() {
+        let layout = Layout::new()
+            .ternary(LayoutTernary::new().sum(1.0))
+            .smith(LayoutSmith::new())
+            .funnel_area_colorway(vec!["#111111"])
+            .extend_funnel_area_colors(false)
+            .hidden_labels(vec!["a"]);
+
+        let expected = json!({
+            "ternary": {"sum": 1.0},
+            "smith": {},
+            "funnelareacolorway": ["#111111"],
+            "extendfunnelareacolors": false,
+            "hiddenlabels": ["a"],
+        });
+
+        assert_eq!(to_value(layout).unwrap(), expected);
+    }
+
     #[test]
     fn serialize_layout() {
         let layout = Layout::new()
diff --git a/plotly/src/layout/polar.rs b/plotly/src/layout/polar.rs
index d8e44ea8..43973b85 100644
--- a/plotly/src/layout/polar.rs
+++ b/plotly/src/layout/polar.rs
@@ -14,6 +14,7 @@ use crate::{
 /// (distance from the center) and an angular axis Theta (distance around the
 /// circumference). See [`ScatterPolar`](crate::traces::ScatterPolar) for
 /// details on traces.
+#[serde_with::skip_serializing_none]
 #[derive(Clone, Debug, FieldSetter, Serialize)]
 pub struct LayoutPolar {
     /// Sets the angular span of the polar subplot using two angles (in
@@ -44,6 +45,14 @@ pub struct LayoutPolar {
     /// configuration.
     #[serde(rename = "uirevision")]
     ui_revision: Option<NumOrString>,
+    /// Determines how [`BarPolar`](crate::traces::BarPolar) traces on this
+    /// subplot are displayed relative to one another.
+    #[serde(rename = "barmode")]
+    bar_mode: Option<PolarBarMode>,
+    /// Sets the gap between bars of adjacent locations on this subplot, as a
+    /// fraction of the bar width (between 0.0 and 1.0).
+    #[serde(rename = "bargap")]
+    bar_gap: Option<f64>,
 }
 
 impl LayoutPolar {
@@ -55,6 +64,7 @@ impl LayoutPolar {
 
 /// Describes the radial axis of the plot, extending from the center to the
 /// periphery.
+#[serde_with::skip_serializing_none]
 #[derive(Clone, Debug, FieldSetter, Serialize)]
 pub struct RadialAxis {
     visible: Option<bool>,
@@ -140,6 +150,7 @@ impl RadialAxis {
 }
 
 /// Describes the angular (circular) axis of the plot.
+#[serde_with::skip_serializing_none]
 #[derive(Clone, Debug, FieldSetter, Serialize)]
 pub struct AngularAxis {
     visible: Option<bool>,
@@ -197,6 +208,7 @@ impl AngularAxis {
 
 /// Provides styles for an axis in [`LayoutPolar`]. May be applied to
 /// [`RadialAxis`] or [`AngularAxis`].
+#[serde_with::skip_serializing_none]
 #[derive(Clone, Debug, FieldSetter, Serialize)]
 pub struct PolarAxisAttributes {
     color: Option<Box<dyn Color>>,
@@ -229,6 +241,7 @@ impl PolarAxisAttributes {
 
 /// Provides styles for the axis ticks in [`LayoutPolar`]. May be applied to
 /// [`RadialAxis`] or [`AngularAxis`].
+#[serde_with::skip_serializing_none]
 #[derive(Clone, Debug, FieldSetter, Serialize)]
 pub struct PolarAxisTicks {
     #[serde(flatten)]
@@ -253,9 +266,9 @@ pub struct PolarAxisTicks {
     /// Applies a label alias to tick or hover labels matching specific
     /// patterns. For example using { US: \'USA\', CA: \'Canada\' } changes US
     /// to USA, and CA to Canada. The labels we would have shown must match the
-    /// keys exactly, after adding any tick_prefix or tick_suffix. `label_alias`
-    /// can be used with any axis type, and both keys and values can include
-    /// html-like tags or MathJax.
+    /// keys exactly, after adding any `tick_prefix` or `tick_suffix`.
+    /// `label_alias` can be used with any axis type, and both keys and
+    /// values can include html-like tags or MathJax.
     #[serde(rename = "labelalias")]
     label_alias: Option<String>,
     #[serde(rename = "minorloglabels")]
@@ -337,6 +350,7 @@ pub enum AutoRange {
 }
 
 /// Controls how the maximum and minimum values are calculated by autorange.
+#[serde_with::skip_serializing_none]
 #[derive(Clone, Debug, FieldSetter, Serialize)]
 pub struct AutoRangeOptions {
     /// Use this value as the autorange minimum.
@@ -398,6 +412,10 @@ pub struct Hole(f64);
 
 impl Hole {
     /// Create a new hole from the given value.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if `value` is not within `0.0..=1.0`.
     pub fn new(value: f64) -> Result<Self, Box<dyn std::error::Error>> {
         if (0.0..=1.0).contains(&value) {
             Ok(Self(value))
@@ -453,6 +471,7 @@ pub enum PolarDirection {
 /// - [`Array`](PolarTickMode::Array): the placement of the ticks is set via
 ///   [`tick_values`](PolarTickMode::Array::tick_values), and the tick text is
 ///   set via [`tick_text`](PolarTickMode::Array::tick_text).
+#[serde_with::skip_serializing_none]
 #[derive(Clone, Debug, Serialize)]
 #[serde(rename_all = "lowercase")]
 #[serde(tag = "tickmode")]
@@ -483,10 +502,11 @@ pub enum PolarTickMode {
         /// Sets the step size between ticks on this axis. Must be a positive
         /// number or a string suitable for *log* or *date* axes. If the axis
         /// type is set to [`RadialAxisType::Log`], ticks will be set every
-        /// 10^(n*d_tick) where n is the tick number. For example, to set a tick
-        /// mark at 1, 10, 100, 1000, ... set d_tick to 1. To set tick marks at
-        /// 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25,
-        /// 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433.
+        /// `10^(n*d_tick)` where n is the tick number. For example, to set a
+        /// tick mark at 1, 10, 100, 1000, ... set `d_tick` to 1. To set
+        /// tick marks at 1, 100, 10000, ... set dtick to 2. To set tick
+        /// marks at 1, 5, 25, 125, 625, 3125, ... set dtick to
+        /// `log_10(5)`, or 0.69897000433.
         ///
         /// [`RadialAxisType::Log`] has several special values:
         ///
@@ -544,6 +564,18 @@ pub enum RadialAxisType {
 pub enum ThetaUnit {
     Degrees,
     Radians,
+    Gradians,
+}
+
+/// Determines how [`BarPolar`](crate::traces::BarPolar) traces on the same
+/// polar subplot are displayed relative to one another.
+#[derive(Clone, Debug, Serialize)]
+#[serde(rename_all = "lowercase")]
+pub enum PolarBarMode {
+    /// Bars are stacked on top of one another.
+    Stack,
+    /// Bars are plotted over one another.
+    Overlay,
 }
 
 #[cfg(test)]
@@ -552,8 +584,8 @@ mod tests {
     use crate::Layout;
 
     // The focus of the test is serialization, so we test all options for
-    // [`LayoutPolar`], even though some of those options would normally be mutually
-    // exclusive.
+    // [`LayoutPolar`], even though some of those options would normally be
+    // mutually exclusive.
     #[test]
     fn serialize_layout_polar() {
         let ticks = PolarAxisTicks::new()
@@ -610,13 +642,34 @@ mod tests {
             .bg_color("#dddddd")
             .radial_axis(radial_axis)
             .angular_axis(angular_axis)
-            .grid_shape(GridShape::Circular);
+            .grid_shape(GridShape::Circular)
+            .bar_mode(PolarBarMode::Overlay)
+            .bar_gap(0.3);
 
         let layout = Layout::new().polar(layout_polar);
         let json = serde_json::to_string(&layout).unwrap();
 
-        let expected = r##"{"polar":{"sector":[0.0,270.0],"hole":0.2,"bgcolor":"#dddddd","radialaxis":{"visible":true,"type":"linear","autotypenumbers":"strict","autorangeoptions":{"minallowed":1,"maxallowed":null,"clipmin":null,"clipmax":null,"include":null},"autorange":true,"rangemode":"normal","minallowed":0,"maxallowed":105,"range":[5,100],"categoryorder":"trace","categoryarray":["category 1","category 2"],"angle":0.0,"autotickangles":[0.0,12.2,30.85],"side":"counterclockwise","title":{"text":"My Title"},"hoverformat":"%{label}: <br>Popularity: %{percent} </br> %{text}","uirevision":null,"color":"#111111","showline":true,"linecolor":"#ffff00","linewidth":5,"showgrid":true,"gridcolor":"#444444","gridwidth":2,"griddash":"solid","tickmode":"auto","nticks":null,"ticks":null,"ticklen":null,"tickwidth":null,"tickcolor":"#dddddd","ticklabelstep":null,"showticklabels":null,"labelalias":null,"minorloglabels":null,"showtickprefix":null,"tickprefix":null,"showticksuffix":null,"ticksuffix":null,"showexponent":null,"exponentformat":null,"minexponent":null,"separatethousands":null,"tickfont":{"color":"#eeeeee"},"tickangle":null,"tickformat":null,"tickformatstops":null,"layer":null},"angularaxis":{"visible":true,"type":"-","autotypenumbers":"convert types","categoryorder":"category ascending","categoryarray":["category 3","category 4"],"thetaunit":"radians","period":10,"direction":"counterclockwise","rotation":5.0,"hoverformat":"GDP: %{x} <br>Life Expectancy: %{y}","uirevision":null,"color":"#111111","showline":true,"linecolor":"#ffff00","linewidth":5,"showgrid":true,"gridcolor":"#444444","gridwidth":2,"griddash":"solid","tickmode":"auto","nticks":null,"ticks":null,"ticklen":null,"tickwidth":null,"tickcolor":"#dddddd","ticklabelstep":null,"showticklabels":null,"labelalias":null,"minorloglabels":null,"showtickprefix":null,"tickprefix":null,"showticksuffix":null,"ticksuffix":null,"showexponent":null,"exponentformat":null,"minexponent":null,"separatethousands":null,"tickfont":{"color":"#eeeeee"},"tickangle":null,"tickformat":null,"tickformatstops":null,"layer":null},"gridshape":"circular","uirevision":null}}"##;
+        let expected = r##"{"polar":{"sector":[0.0,270.0],"hole":0.2,"bgcolor":"#dddddd","radialaxis":{"visible":true,"type":"linear","autotypenumbers":"strict","autorangeoptions":{"minallowed":1},"autorange":true,"rangemode":"normal","minallowed":0,"maxallowed":105,"range":[5,100],"categoryorder":"trace","categoryarray":["category 1","category 2"],"angle":0.0,"autotickangles":[0.0,12.2,30.85],"side":"counterclockwise","title":{"text":"My Title"},"hoverformat":"%{label}: <br>Popularity: %{percent} </br> %{text}","color":"#111111","showline":true,"linecolor":"#ffff00","linewidth":5,"showgrid":true,"gridcolor":"#444444","gridwidth":2,"griddash":"solid","tickmode":"auto","tickcolor":"#dddddd","tickfont":{"color":"#eeeeee"}},"angularaxis":{"visible":true,"type":"-","autotypenumbers":"convert types","categoryorder":"category ascending","categoryarray":["category 3","category 4"],"thetaunit":"radians","period":10,"direction":"counterclockwise","rotation":5.0,"hoverformat":"GDP: %{x} <br>Life Expectancy: %{y}","color":"#111111","showline":true,"linecolor":"#ffff00","linewidth":5,"showgrid":true,"gridcolor":"#444444","gridwidth":2,"griddash":"solid","tickmode":"auto","tickcolor":"#dddddd","tickfont":{"color":"#eeeeee"}},"gridshape":"circular","barmode":"overlay","bargap":0.3}}"##;
 
         assert_eq!(json, expected);
     }
+
+    // Unset fields must be omitted, not written as `null`: plotly.js applies
+    // the layout template (e.g. a dark theme's polar `bgcolor` and grid
+    // colors) only to attributes that are absent, so an explicit `null`
+    // silently overrides the theme.
+    #[test]
+    fn serialize_layout_polar_omits_unset_fields() {
+        let layout_polar = LayoutPolar::new()
+            .bar_mode(PolarBarMode::Stack)
+            .angular_axis(AngularAxis::new().direction(PolarDirection::Clockwise))
+            .radial_axis(
+                RadialAxis::new().auto_range_options(AutoRangeOptions::default().min_allowed(0)),
+            );
+        let json = serde_json::to_string(&layout_polar).unwrap();
+        assert_eq!(
+            json,
+            r#"{"radialaxis":{"autorangeoptions":{"minallowed":0}},"angularaxis":{"direction":"clockwise"},"barmode":"stack"}"#
+        );
+    }
 }
diff --git a/plotly/src/layout/scene.rs b/plotly/src/layout/scene.rs
index 919e0f54..f3bda1d5 100644
--- a/plotly/src/layout/scene.rs
+++ b/plotly/src/layout/scene.rs
@@ -37,8 +37,8 @@ impl From<(f64, f64, f64)> for AspectRatio {
 
 #[serde_with::skip_serializing_none]
 #[derive(Serialize, Debug, Clone, FieldSetter)]
-/// Container for CameraCenter, Eye, Up, and Projection objects. The camera of a
-/// 3D scene.
+/// Container for `CameraCenter`, Eye, Up, and Projection objects. The camera of
+/// a 3D scene.
 pub struct Camera {
     center: Option<CameraCenter>,
     eye: Option<Eye>,
@@ -334,6 +334,7 @@ impl From<ProjectionType> for Projection {
 }
 
 /// Sets the rotation of the map projection.
+#[serde_with::skip_serializing_none]
 #[derive(Serialize, Clone, Debug, FieldSetter)]
 pub struct Rotation {
     /// Rotates the map along meridians (in degrees North).
diff --git a/plotly/src/layout/slider.rs b/plotly/src/layout/slider.rs
index 4ffd6af4..e2359623 100644
--- a/plotly/src/layout/slider.rs
+++ b/plotly/src/layout/slider.rs
@@ -163,7 +163,7 @@ impl SliderStepBuilder {
     }
 
     /// Sets the value of the slider step using any type that can be converted
-    /// into NumOrString.
+    /// into `NumOrString`.
     pub fn value<T: Into<NumOrString>>(mut self, value: T) -> Self {
         if self.error.is_none() {
             if let Err(e) = self.try_set_value(value) {
@@ -186,6 +186,14 @@ impl SliderStepBuilder {
         self.animation = Some(animation);
         self
     }
+    /// Build the [`SliderStep`].
+    ///
+    /// # Errors
+    ///
+    /// Returns the first error recorded by an earlier builder call (a restyle,
+    /// relayout or value that failed to serialize or was not a JSON object), or
+    /// [`ControlBuilderError::AnimationSerializationError`] if the animation
+    /// cannot be serialized.
     pub fn build(self) -> Result<SliderStep, ControlBuilderError> {
         if let Some(error) = self.error {
             return Err(error);
diff --git a/plotly/src/layout/smith.rs b/plotly/src/layout/smith.rs
new file mode 100644
index 00000000..e5351cf5
--- /dev/null
+++ b/plotly/src/layout/smith.rs
@@ -0,0 +1,262 @@
+use std::collections::HashMap;
+
+use plotly_derive::FieldSetter;
+use serde::Serialize;
+
+use crate::{
+    color::Color,
+    common::{DashType, Domain, Font, Ticks},
+    layout::{ArrayShow, AxisLayer},
+};
+
+/// Which side of the real axis its tick labels are drawn on.
+#[derive(Serialize, Clone, Debug)]
+#[serde(rename_all = "lowercase")]
+pub enum RealAxisSide {
+    Top,
+    Bottom,
+}
+
+/// Whether ticks on the real axis of a Smith chart are drawn, and on which
+/// side.
+#[derive(Serialize, Clone, Debug)]
+#[serde(rename_all = "lowercase")]
+pub enum RealAxisTicks {
+    Top,
+    Bottom,
+    #[serde(rename = "")]
+    None,
+}
+
+/// The real (resistance) axis of a Smith chart.
+#[serde_with::skip_serializing_none]
+#[derive(Serialize, Clone, Debug, FieldSetter)]
+pub struct RealAxis {
+    visible: Option<bool>,
+    side: Option<RealAxisSide>,
+    color: Option<Box<dyn Color>>,
+    #[serde(rename = "showline")]
+    show_line: Option<bool>,
+    #[serde(rename = "linecolor")]
+    line_color: Option<Box<dyn Color>>,
+    #[serde(rename = "linewidth")]
+    line_width: Option<f64>,
+    #[serde(rename = "showgrid")]
+    show_grid: Option<bool>,
+    #[serde(rename = "gridcolor")]
+    grid_color: Option<Box<dyn Color>>,
+    #[serde(rename = "gridwidth")]
+    grid_width: Option<f64>,
+    #[serde(rename = "griddash")]
+    grid_dash: Option<DashType>,
+    layer: Option<AxisLayer>,
+    /// The values at which ticks (and grid circles) appear.
+    #[serde(rename = "tickvals")]
+    tick_values: Option<Vec<f64>>,
+    ticks: Option<RealAxisTicks>,
+    #[serde(rename = "ticklen")]
+    tick_length: Option<f64>,
+    #[serde(rename = "tickwidth")]
+    tick_width: Option<f64>,
+    #[serde(rename = "tickcolor")]
+    tick_color: Option<Box<dyn Color>>,
+    #[serde(rename = "tickangle")]
+    tick_angle: Option<f64>,
+    #[serde(rename = "tickfont")]
+    tick_font: Option<Font>,
+    #[serde(rename = "tickformat")]
+    tick_format: Option<String>,
+    #[serde(rename = "tickprefix")]
+    tick_prefix: Option<String>,
+    #[serde(rename = "showtickprefix")]
+    show_tick_prefix: Option<ArrayShow>,
+    #[serde(rename = "ticksuffix")]
+    tick_suffix: Option<String>,
+    #[serde(rename = "showticksuffix")]
+    show_tick_suffix: Option<ArrayShow>,
+    #[serde(rename = "showticklabels")]
+    show_tick_labels: Option<bool>,
+    /// Replacement text for specific tick labels, keyed by the original
+    /// label (e.g. `{"0.5": "half"}`).
+    #[serde(rename = "labelalias")]
+    label_alias: Option<HashMap<String, String>>,
+    #[serde(rename = "hoverformat")]
+    hover_format: Option<String>,
+}
+
+impl RealAxis {
+    pub fn new() -> Self {
+        Default::default()
+    }
+}
+
+/// The imaginary (reactance) axis of a Smith chart.
+#[serde_with::skip_serializing_none]
+#[derive(Serialize, Clone, Debug, FieldSetter)]
+pub struct ImaginaryAxis {
+    visible: Option<bool>,
+    color: Option<Box<dyn Color>>,
+    #[serde(rename = "showline")]
+    show_line: Option<bool>,
+    #[serde(rename = "linecolor")]
+    line_color: Option<Box<dyn Color>>,
+    #[serde(rename = "linewidth")]
+    line_width: Option<f64>,
+    #[serde(rename = "showgrid")]
+    show_grid: Option<bool>,
+    #[serde(rename = "gridcolor")]
+    grid_color: Option<Box<dyn Color>>,
+    #[serde(rename = "gridwidth")]
+    grid_width: Option<f64>,
+    #[serde(rename = "griddash")]
+    grid_dash: Option<DashType>,
+    layer: Option<AxisLayer>,
+    /// The values at which ticks (and grid arcs) appear.
+    #[serde(rename = "tickvals")]
+    tick_values: Option<Vec<f64>>,
+    ticks: Option<Ticks>,
+    #[serde(rename = "ticklen")]
+    tick_length: Option<f64>,
+    #[serde(rename = "tickwidth")]
+    tick_width: Option<f64>,
+    #[serde(rename = "tickcolor")]
+    tick_color: Option<Box<dyn Color>>,
+    #[serde(rename = "tickfont")]
+    tick_font: Option<Font>,
+    #[serde(rename = "tickformat")]
+    tick_format: Option<String>,
+    #[serde(rename = "tickprefix")]
+    tick_prefix: Option<String>,
+    #[serde(rename = "showtickprefix")]
+    show_tick_prefix: Option<ArrayShow>,
+    #[serde(rename = "ticksuffix")]
+    tick_suffix: Option<String>,
+    #[serde(rename = "showticksuffix")]
+    show_tick_suffix: Option<ArrayShow>,
+    #[serde(rename = "showticklabels")]
+    show_tick_labels: Option<bool>,
+    /// Replacement text for specific tick labels, keyed by the original
+    /// label (e.g. `{"0.5": "half"}`).
+    #[serde(rename = "labelalias")]
+    label_alias: Option<HashMap<String, String>>,
+    #[serde(rename = "hoverformat")]
+    hover_format: Option<String>,
+}
+
+impl ImaginaryAxis {
+    pub fn new() -> Self {
+        Default::default()
+    }
+}
+
+/// The layout of a Smith chart subplot, used for RF / impedance plots. See
+/// [`ScatterSmith`](crate::traces::ScatterSmith) for details on traces.
+#[serde_with::skip_serializing_none]
+#[derive(Serialize, Clone, Debug, FieldSetter)]
+pub struct LayoutSmith {
+    #[serde(rename = "realaxis")]
+    real_axis: Option<RealAxis>,
+    #[serde(rename = "imaginaryaxis")]
+    imaginary_axis: Option<ImaginaryAxis>,
+    #[serde(rename = "bgcolor")]
+    bg_color: Option<Box<dyn Color>>,
+    domain: Option<Domain>,
+}
+
+impl LayoutSmith {
+    pub fn new() -> Self {
+        Default::default()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use serde_json::{json, to_value};
+
+    use super::*;
+
+    #[test]
+    fn serialize_real_axis() {
+        let axis = RealAxis::new()
+            .visible(true)
+            .side(RealAxisSide::Bottom)
+            .color("#444")
+            .show_line(true)
+            .line_color("#111")
+            .line_width(1.0)
+            .show_grid(false)
+            .grid_color("#eee")
+            .grid_width(2.0)
+            .grid_dash(DashType::Dash)
+            .layer(AxisLayer::Above)
+            .tick_values(vec![0.2, 0.5, 1.0])
+            .ticks(RealAxisTicks::Top)
+            .tick_length(5.0)
+            .tick_width(2.0)
+            .tick_color("#222")
+            .tick_angle(90.0)
+            .tick_font(Font::new())
+            .tick_format(".1f")
+            .tick_prefix("p")
+            .show_tick_prefix(ArrayShow::First)
+            .tick_suffix("ohm")
+            .show_tick_suffix(ArrayShow::All)
+            .show_tick_labels(true)
+            .label_alias(HashMap::from([("1".to_string(), "one".to_string())]))
+            .hover_format(".2f");
+
+        let expected = json!({
+            "visible": true,
+            "side": "bottom",
+            "color": "#444",
+            "showline": true,
+            "linecolor": "#111",
+            "linewidth": 1.0,
+            "showgrid": false,
+            "gridcolor": "#eee",
+            "gridwidth": 2.0,
+            "griddash": "dash",
+            "layer": "above traces",
+            "tickvals": [0.2, 0.5, 1.0],
+            "ticks": "top",
+            "ticklen": 5.0,
+            "tickwidth": 2.0,
+            "tickcolor": "#222",
+            "tickangle": 90.0,
+            "tickfont": {},
+            "tickformat": ".1f",
+            "tickprefix": "p",
+            "showtickprefix": "first",
+            "ticksuffix": "ohm",
+            "showticksuffix": "all",
+            "showticklabels": true,
+            "labelalias": {"1": "one"},
+            "hoverformat": ".2f",
+        });
+
+        assert_eq!(to_value(axis).unwrap(), expected);
+        assert_eq!(to_value(RealAxisTicks::None).unwrap(), json!(""));
+    }
+
+    #[test]
+    fn serialize_layout_smith() {
+        let layout = LayoutSmith::new()
+            .real_axis(RealAxis::new())
+            .imaginary_axis(
+                ImaginaryAxis::new()
+                    .ticks(Ticks::Inside)
+                    .tick_values(vec![1.0]),
+            )
+            .bg_color("#fff")
+            .domain(Domain::new().row(0));
+
+        let expected = json!({
+            "realaxis": {},
+            "imaginaryaxis": {"ticks": "inside", "tickvals": [1.0]},
+            "bgcolor": "#fff",
+            "domain": {"row": 0},
+        });
+
+        assert_eq!(to_value(layout).unwrap(), expected);
+    }
+}
diff --git a/plotly/src/layout/ternary.rs b/plotly/src/layout/ternary.rs
new file mode 100644
index 00000000..db26e4d2
--- /dev/null
+++ b/plotly/src/layout/ternary.rs
@@ -0,0 +1,242 @@
+use std::collections::HashMap;
+
+use plotly_derive::FieldSetter;
+use serde::Serialize;
+
+use crate::{
+    color::Color,
+    common::{DashType, Domain, ExponentFormat, Font, TickFormatStop, TickMode, Ticks, Title},
+    layout::{ArrayShow, AxisLayer},
+    private::NumOrString,
+};
+
+/// One of the three axes (`a`, `b`, `c`) of a ternary subplot.
+#[serde_with::skip_serializing_none]
+#[derive(Serialize, Clone, Debug, FieldSetter)]
+pub struct TernaryAxis {
+    title: Option<Title>,
+    /// The minimum value visible on this axis. The maximum is determined by
+    /// the sum minus the minimum values of the other two axes.
+    min: Option<f64>,
+    color: Option<Box<dyn Color>>,
+    #[serde(rename = "showline")]
+    show_line: Option<bool>,
+    #[serde(rename = "linecolor")]
+    line_color: Option<Box<dyn Color>>,
+    #[serde(rename = "linewidth")]
+    line_width: Option<f64>,
+    #[serde(rename = "showgrid")]
+    show_grid: Option<bool>,
+    #[serde(rename = "gridcolor")]
+    grid_color: Option<Box<dyn Color>>,
+    #[serde(rename = "gridwidth")]
+    grid_width: Option<f64>,
+    #[serde(rename = "griddash")]
+    grid_dash: Option<DashType>,
+    layer: Option<AxisLayer>,
+    #[serde(rename = "tickmode")]
+    tick_mode: Option<TickMode>,
+    #[serde(rename = "nticks")]
+    n_ticks: Option<usize>,
+    #[serde(rename = "tick0")]
+    tick0: Option<NumOrString>,
+    #[serde(rename = "dtick")]
+    dtick: Option<NumOrString>,
+    #[serde(rename = "tickvals")]
+    tick_values: Option<Vec<f64>>,
+    #[serde(rename = "ticktext")]
+    tick_text: Option<Vec<String>>,
+    ticks: Option<Ticks>,
+    #[serde(rename = "ticklen")]
+    tick_length: Option<f64>,
+    #[serde(rename = "tickwidth")]
+    tick_width: Option<f64>,
+    #[serde(rename = "tickcolor")]
+    tick_color: Option<Box<dyn Color>>,
+    #[serde(rename = "tickangle")]
+    tick_angle: Option<f64>,
+    #[serde(rename = "tickfont")]
+    tick_font: Option<Font>,
+    #[serde(rename = "tickformat")]
+    tick_format: Option<String>,
+    #[serde(rename = "tickformatstops")]
+    tick_format_stops: Option<Vec<TickFormatStop>>,
+    #[serde(rename = "ticklabelstep")]
+    tick_label_step: Option<usize>,
+    #[serde(rename = "tickprefix")]
+    tick_prefix: Option<String>,
+    #[serde(rename = "showtickprefix")]
+    show_tick_prefix: Option<ArrayShow>,
+    #[serde(rename = "ticksuffix")]
+    tick_suffix: Option<String>,
+    #[serde(rename = "showticksuffix")]
+    show_tick_suffix: Option<ArrayShow>,
+    #[serde(rename = "showticklabels")]
+    show_tick_labels: Option<bool>,
+    /// Replacement text for specific tick labels, keyed by the original
+    /// label (e.g. `{"0.5": "half"}`).
+    #[serde(rename = "labelalias")]
+    label_alias: Option<HashMap<String, String>>,
+    #[serde(rename = "showexponent")]
+    show_exponent: Option<ArrayShow>,
+    #[serde(rename = "exponentformat")]
+    exponent_format: Option<ExponentFormat>,
+    #[serde(rename = "minexponent")]
+    min_exponent: Option<f64>,
+    #[serde(rename = "separatethousands")]
+    separate_thousands: Option<bool>,
+    #[serde(rename = "hoverformat")]
+    hover_format: Option<String>,
+    #[serde(rename = "uirevision")]
+    ui_revision: Option<NumOrString>,
+}
+
+impl TernaryAxis {
+    pub fn new() -> Self {
+        Default::default()
+    }
+}
+
+/// The layout of a ternary subplot: a triangle whose three axes `a`, `b` and
+/// `c` always add up to [`sum`](LayoutTernary::sum). See
+/// [`ScatterTernary`](crate::traces::ScatterTernary) for details on traces.
+#[serde_with::skip_serializing_none]
+#[derive(Serialize, Clone, Debug, FieldSetter)]
+pub struct LayoutTernary {
+    #[serde(rename = "aaxis")]
+    a_axis: Option<TernaryAxis>,
+    #[serde(rename = "baxis")]
+    b_axis: Option<TernaryAxis>,
+    #[serde(rename = "caxis")]
+    c_axis: Option<TernaryAxis>,
+    /// The number each triplet should add up to.
+    sum: Option<f64>,
+    #[serde(rename = "bgcolor")]
+    bg_color: Option<Box<dyn Color>>,
+    domain: Option<Domain>,
+    #[serde(rename = "uirevision")]
+    ui_revision: Option<NumOrString>,
+}
+
+impl LayoutTernary {
+    pub fn new() -> Self {
+        Default::default()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use serde_json::{json, to_value};
+
+    use super::*;
+
+    #[test]
+    fn serialize_ternary_axis() {
+        let axis = TernaryAxis::new()
+            .title("A")
+            .min(0.1)
+            .color("#444")
+            .show_line(true)
+            .line_color("#111")
+            .line_width(2.0)
+            .show_grid(true)
+            .grid_color("#eee")
+            .grid_width(1.0)
+            .grid_dash(DashType::Dot)
+            .layer(AxisLayer::Below)
+            .tick_mode(TickMode::Linear)
+            .n_ticks(5)
+            .tick0(0)
+            .dtick(0.2)
+            .tick_values(vec![0.5])
+            .tick_text(vec!["half"])
+            .ticks(Ticks::Outside)
+            .tick_length(4.0)
+            .tick_width(1.0)
+            .tick_color("#222")
+            .tick_angle(45.0)
+            .tick_font(Font::new())
+            .tick_format(".0%")
+            .tick_format_stops(vec![TickFormatStop::new()])
+            .tick_label_step(2)
+            .tick_prefix("p")
+            .show_tick_prefix(ArrayShow::All)
+            .tick_suffix("s")
+            .show_tick_suffix(ArrayShow::Last)
+            .show_tick_labels(true)
+            .label_alias(HashMap::from([("0.5".to_string(), "half".to_string())]))
+            .show_exponent(ArrayShow::None)
+            .exponent_format(ExponentFormat::Power)
+            .min_exponent(3.0)
+            .separate_thousands(true)
+            .hover_format(".2f")
+            .ui_revision(1);
+
+        let expected = json!({
+            "title": {"text": "A"},
+            "min": 0.1,
+            "color": "#444",
+            "showline": true,
+            "linecolor": "#111",
+            "linewidth": 2.0,
+            "showgrid": true,
+            "gridcolor": "#eee",
+            "gridwidth": 1.0,
+            "griddash": "dot",
+            "layer": "below traces",
+            "tickmode": "linear",
+            "nticks": 5,
+            "tick0": 0,
+            "dtick": 0.2,
+            "tickvals": [0.5],
+            "ticktext": ["half"],
+            "ticks": "outside",
+            "ticklen": 4.0,
+            "tickwidth": 1.0,
+            "tickcolor": "#222",
+            "tickangle": 45.0,
+            "tickfont": {},
+            "tickformat": ".0%",
+            "tickformatstops": [{"enabled": true}],
+            "ticklabelstep": 2,
+            "tickprefix": "p",
+            "showtickprefix": "all",
+            "ticksuffix": "s",
+            "showticksuffix": "last",
+            "showticklabels": true,
+            "labelalias": {"0.5": "half"},
+            "showexponent": "none",
+            "exponentformat": "power",
+            "minexponent": 3.0,
+            "separatethousands": true,
+            "hoverformat": ".2f",
+            "uirevision": 1,
+        });
+
+        assert_eq!(to_value(axis).unwrap(), expected);
+    }
+
+    #[test]
+    fn serialize_layout_ternary() {
+        let layout = LayoutTernary::new()
+            .a_axis(TernaryAxis::new().min(0.0))
+            .b_axis(TernaryAxis::new())
+            .c_axis(TernaryAxis::new())
+            .sum(100.0)
+            .bg_color("#fafafa")
+            .domain(Domain::new().x(&[0.0, 0.5]))
+            .ui_revision("r");
+
+        let expected = json!({
+            "aaxis": {"min": 0.0},
+            "baxis": {},
+            "caxis": {},
+            "sum": 100.0,
+            "bgcolor": "#fafafa",
+            "domain": {"x": [0.0, 0.5]},
+            "uirevision": "r",
+        });
+
+        assert_eq!(to_value(layout).unwrap(), expected);
+    }
+}
diff --git a/plotly/src/layout/themes.rs b/plotly/src/layout/themes.rs
index 494b7454..c0a83233 100644
--- a/plotly/src/layout/themes.rs
+++ b/plotly/src/layout/themes.rs
@@ -1,18 +1,20 @@
-use once_cell::sync::Lazy;
+use std::sync::LazyLock;
 
 use crate::{
-    common::{ColorBar, ColorScale, ColorScaleElement, Font, Label, Title},
+    common::{ColorBar, ColorScale, ColorScaleElement, Font, Label, Ticks, Title},
     layout::{
-        Axis, ColorAxis, HoverMode, LayoutColorScale, LayoutTemplate, Template, TicksDirection,
+        AngularAxis, Axis, ColorAxis, HoverMode, LayoutColorScale, LayoutPolar, LayoutTemplate,
+        LayoutTernary, PolarAxisAttributes, PolarAxisTicks, RadialAxis, Template, TernaryAxis,
+        TicksDirection,
     },
 };
 
-pub static DEFAULT: Lazy<Template> = Lazy::new(|| {
+pub static DEFAULT: LazyLock<Template> = LazyLock::new(|| {
     let layout_template = LayoutTemplate::new();
     Template::new().layout(layout_template)
 });
 
-pub static PLOTLY_WHITE: Lazy<Template> = Lazy::new(|| {
+pub static PLOTLY_WHITE: LazyLock<Template> = LazyLock::new(|| {
     let layout_template = LayoutTemplate::new()
         .color_axis(ColorAxis::new().color_bar(ColorBar::new().outline_width(0)))
         .color_scale(
@@ -86,9 +88,21 @@ pub static PLOTLY_WHITE: Lazy<Template> = Lazy::new(|| {
     Template::new().layout(layout_template)
 });
 
-pub static PLOTLY_DARK: Lazy<Template> = Lazy::new(|| {
-    // the following are unimplemented: layout.autotypenumbers, layout.polar,
-    // layout.ternary, layout.scene, layout.*defaults
+pub static PLOTLY_DARK: LazyLock<Template> = LazyLock::new(|| {
+    // the following are unimplemented: layout.autotypenumbers, layout.scene
+    // (its axes have no background attributes yet), layout.*defaults
+    let polar_axis = || {
+        PolarAxisAttributes::new()
+            .grid_color("#506784")
+            .line_color("#506784")
+            .ticks(PolarAxisTicks::new().ticks(Ticks::None))
+    };
+    let ternary_axis = || {
+        TernaryAxis::new()
+            .grid_color("#506784")
+            .line_color("#506784")
+            .ticks(Ticks::None)
+    };
     let layout_template = LayoutTemplate::new()
         .color_axis(ColorAxis::new().color_bar(ColorBar::new().outline_width(0)))
         .color_scale(
@@ -158,11 +172,24 @@ pub static PLOTLY_DARK: Lazy<Template> = Lazy::new(|| {
                 // missing title.standoff = 15
                 .zero_line_color("#283442")
                 .zero_line_width(2),
+        )
+        .polar(
+            LayoutPolar::new()
+                .bg_color("rgb(17,17,17)")
+                .angular_axis(AngularAxis::new().axis_attributes(polar_axis()))
+                .radial_axis(RadialAxis::new().axis_attributes(polar_axis())),
+        )
+        .ternary(
+            LayoutTernary::new()
+                .bg_color("rgb(17,17,17)")
+                .a_axis(ternary_axis())
+                .b_axis(ternary_axis())
+                .c_axis(ternary_axis()),
         );
     Template::new().layout(layout_template)
 });
 
-pub static SEABORN: Lazy<Template> = Lazy::new(|| {
+pub static SEABORN: LazyLock<Template> = LazyLock::new(|| {
     // Based on seaborn's "darkgrid" style and "deep" color palette
     let layout_template = LayoutTemplate::new()
         .font(Font::new().family("DejaVu Sans").size(12).color("#333333"))
@@ -192,7 +219,7 @@ pub static SEABORN: Lazy<Template> = Lazy::new(|| {
     Template::new().layout(layout_template)
 });
 
-pub static SEABORN_WHITEGRID: Lazy<Template> = Lazy::new(|| {
+pub static SEABORN_WHITEGRID: LazyLock<Template> = LazyLock::new(|| {
     // Seaborn "whitegrid" style
     let layout_template = LayoutTemplate::new()
         .font(Font::new().family("DejaVu Sans").size(12).color("#333333"))
@@ -222,7 +249,7 @@ pub static SEABORN_WHITEGRID: Lazy<Template> = Lazy::new(|| {
     Template::new().layout(layout_template)
 });
 
-pub static SEABORN_DARK: Lazy<Template> = Lazy::new(|| {
+pub static SEABORN_DARK: LazyLock<Template> = LazyLock::new(|| {
     // Seaborn "dark" style
     let layout_template = LayoutTemplate::new()
         .font(Font::new().family("DejaVu Sans").size(12).color("#eaeaf2"))
@@ -252,7 +279,7 @@ pub static SEABORN_DARK: Lazy<Template> = Lazy::new(|| {
     Template::new().layout(layout_template)
 });
 
-pub static MATPLOTLIB: Lazy<Template> = Lazy::new(|| {
+pub static MATPLOTLIB: LazyLock<Template> = LazyLock::new(|| {
     // Based on matplotlib's classic style with publication-ready formatting
     // Inspired by: https://medium.com/swlh/formatting-a-plotly-figure-with-matplotlib-style-fa56ddd97539
     let layout_template = LayoutTemplate::new()
@@ -296,7 +323,7 @@ pub static MATPLOTLIB: Lazy<Template> = Lazy::new(|| {
     Template::new().layout(layout_template)
 });
 
-pub static PLOTNINE: Lazy<Template> = Lazy::new(|| {
+pub static PLOTNINE: LazyLock<Template> = LazyLock::new(|| {
     // Based on plotnine's default theme (ggplot2-inspired)
     let layout_template = LayoutTemplate::new()
         .font(Font::new().family("DejaVu Sans").size(12).color("#525252"))
@@ -397,6 +424,23 @@ mod tests {
         assert!(plot.to_json().contains(expected));
     }
 
+    // polar and ternary subplots get the dark background and grid too (as in
+    // plotly.py's plotly_dark); without them plotly.js draws a white
+    // disc/triangle on the dark paper
+    #[test]
+    fn plotly_dark_styles_polar_and_ternary() {
+        let json = serde_json::to_value(&*PLOTLY_DARK).unwrap();
+        let layout = &json["layout"];
+        let axis = serde_json::json!({"linecolor": "#506784", "gridcolor": "#506784", "ticks": ""});
+        assert_eq!(layout["polar"]["bgcolor"], "rgb(17,17,17)");
+        assert_eq!(layout["polar"]["angularaxis"], axis);
+        assert_eq!(layout["polar"]["radialaxis"], axis);
+        assert_eq!(layout["ternary"]["bgcolor"], "rgb(17,17,17)");
+        for k in ["aaxis", "baxis", "caxis"] {
+            assert_eq!(layout["ternary"][k], axis, "{k}");
+        }
+    }
+
     #[test]
     fn seaborn() {
         let template = &*SEABORN;
diff --git a/plotly/src/layout/update_menu.rs b/plotly/src/layout/update_menu.rs
index 5b794e7a..9b63b870 100644
--- a/plotly/src/layout/update_menu.rs
+++ b/plotly/src/layout/update_menu.rs
@@ -163,6 +163,14 @@ impl ButtonBuilder {
         self
     }
 
+    /// Build the [`Button`].
+    ///
+    /// # Errors
+    ///
+    /// Returns the first error recorded by an earlier builder call (a restyle
+    /// or relayout that failed to serialize or was not a JSON object), or
+    /// [`ControlBuilderError::AnimationSerializationError`] if the animation
+    /// cannot be serialized.
     pub fn build(self) -> Result<Button, ControlBuilderError> {
         if let Some(error) = self.error {
             return Err(error);
diff --git a/plotly/src/lib.rs b/plotly/src/lib.rs
index d40a09d0..2c3f8c7f 100644
--- a/plotly/src/lib.rs
+++ b/plotly/src/lib.rs
@@ -1,41 +1,12 @@
 //! # Plotly.rs
 //!
 //! A plotting library for Rust powered by [Plotly.js](https://plot.ly/javascript/).
-//!
-//! ## Feature Deprecation Notice
-//!
-//! The `kaleido` and `kaleido_download` features are deprecated since version
-//! 0.13.0 and will be removed in version 0.15.0. Please migrate to the
-//! `plotly_static` and `static_export_*` features instead.
-#![recursion_limit = "256"] // lets us use a large serde_json::json! macro for testing crate::layout::Axis
+#![recursion_limit = "256"] // lets us use a large serde_json::json! macro for
+                            // testing crate::layout::Axis
 extern crate askama;
 extern crate rand;
 extern crate serde;
 
-#[cfg(feature = "kaleido")]
-#[deprecated(
-    since = "0.13.0",
-    note = "kaleido feature is deprecated and will be removed in version 0.15.0. Use plotly_static feature instead"
-)]
-const _KALEIDO_DEPRECATED: () = ();
-
-#[cfg(feature = "kaleido_download")]
-#[deprecated(
-    since = "0.13.0",
-    note = "kaleido_download feature is deprecated and will be removed in version 0.15.0. Use plotly_static_download feature instead"
-)]
-const _KALEIDO_DOWNLOAD_DEPRECATED: () = ();
-
-#[cfg(all(feature = "kaleido", target_family = "wasm"))]
-compile_error!(
-    r#"The "kaleido" feature is not available on "wasm" targets. Please compile without this feature for the wasm target family."#
-);
-
-#[cfg(all(feature = "kaleido", feature = "plotly_static"))]
-compile_error!(
-    r#"The "kaleido" feature and "plotly_static" are conflictings. Please select only one of them."#
-);
-
 #[cfg(feature = "plotly_ndarray")]
 pub mod ndarray;
 #[cfg(feature = "plotly_ndarray")]
@@ -60,23 +31,25 @@ 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, funnel, heat_map, histogram,
-    histogram2d, icicle, image, indicator, mesh3d, parcats, sankey, scatter, scatter3d,
-    scatter_map, scatter_mapbox, splom, sunburst, surface, treemap, violin, waterfall,
+    bar_polar, box_plot, carpet, choropleth, choropleth_map, cone, contour, contour_carpet,
+    density_map, funnel, funnel_area, heat_map, histogram, histogram2d, histogram2d_contour,
+    icicle, image, indicator, isosurface, mesh3d, parcats, parcoords, sankey, scatter, scatter3d,
+    scatter_carpet, scatter_map, scatter_mapbox, scatter_smith, scatter_ternary, splom,
+    stream_tube, sunburst, surface, treemap, violin, volume, waterfall,
 };
 // Bring the different trace types into the top-level scope
 pub use traces::{
-    Bar, BoxPlot, Candlestick, Choropleth, ChoroplethMap, Contour, DensityMap, DensityMapbox,
-    Funnel, HeatMap, Histogram, Histogram2d, Icicle, Image, Indicator, Mesh3D, Ohlc, Parcats, Pie,
-    Sankey, Scatter, Scatter3D, ScatterGeo, ScatterMap, ScatterMapbox, ScatterPolar, Splom,
-    Sunburst, Surface, Table, Treemap, Violin, Waterfall,
+    Bar, BarPolar, BoxPlot, Candlestick, Carpet, Choropleth, ChoroplethMap, Cone, Contour,
+    ContourCarpet, DensityMap, DensityMapbox, Funnel, FunnelArea, HeatMap, Histogram, Histogram2d,
+    Histogram2dContour, Icicle, Image, Indicator, IsoSurface, Mesh3D, Ohlc, Parcats, Parcoords,
+    Pie, Sankey, Scatter, Scatter3D, ScatterCarpet, ScatterGeo, ScatterMap, ScatterMapbox,
+    ScatterPolar, ScatterSmith, ScatterTernary, Splom, StreamTube, Sunburst, Surface, Table,
+    Treemap, Violin, Volume, Waterfall,
 };
 
 pub trait Restyle: serde::Serialize {}
 pub trait Relayout {}
 
-#[cfg(feature = "kaleido")]
-pub use plotly_kaleido::ImageFormat;
 #[cfg(feature = "plotly_static")]
 pub use plotly_static::{self, ImageFormat};
 
diff --git a/plotly/src/plot.rs b/plotly/src/plot.rs
index 32cd770b..1dc83767 100644
--- a/plotly/src/plot.rs
+++ b/plotly/src/plot.rs
@@ -5,8 +5,6 @@ use std::{fs::File, io::Write, path::Path};
 use askama::Template;
 use dyn_clone::DynClone;
 use erased_serde::Serialize as ErasedSerialize;
-#[cfg(feature = "kaleido")]
-use plotly_kaleido::ImageFormat;
 #[cfg(feature = "plotly_static")]
 use plotly_static::ImageFormat;
 use rand::{
@@ -27,7 +25,7 @@ struct PlotTemplate<'a> {
     js_scripts: &'a str,
 }
 
-#[cfg(any(feature = "kaleido", feature = "plotly_static"))]
+#[cfg(feature = "plotly_static")]
 #[derive(Template)]
 #[template(path = "static_plot.html", escape = "none")]
 #[cfg(all(not(target_family = "wasm"), not(target_os = "android")))]
@@ -55,14 +53,13 @@ struct JupyterNotebookPlotTemplate<'a> {
 
 #[cfg(all(not(target_family = "wasm"), not(target_os = "android")))]
 const DEFAULT_HTML_APP_NOT_FOUND: &str = r#"Could not find default application for HTML files.
-Consider using the `to_html` method obtain a string representation instead. If using the `kaleido` or `plotly_static` feature the
+Consider using the `to_html` method obtain a string representation instead. If using the `plotly_static` feature the
 `write_image` method can be used to produce a static image in one of the following formats:
 - ImageFormat::PNG
 - ImageFormat::JPEG
 - ImageFormat::WEBP
 - ImageFormat::SVG
 - ImageFormat::PDF
-- ImageFormat::EPS // will be removed in version 0.15.0
 
 Used as follows:
 let plot = Plot::new();
@@ -113,6 +110,11 @@ impl Traces {
         self.traces.iter()
     }
 
+    /// Serialize to a JSON string.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `serde_json` fails to serialize the value.
     pub fn to_json(&self) -> String {
         serde_json::to_string(self).unwrap()
     }
@@ -236,19 +238,15 @@ impl Plot {
 
     /// Add a single frame to the animation sequence.
     pub fn add_frame(&mut self, frame: Frame) -> &mut Self {
-        if self.frames.is_none() {
-            self.frames = Some(Vec::new());
-        }
-        self.frames.as_mut().unwrap().push(frame);
+        self.frames.get_or_insert_with(Vec::new).push(frame);
         self
     }
 
     /// Add multiple frames to the animation sequence.
     pub fn add_frames(&mut self, frames: &[Frame]) -> &mut Self {
-        if self.frames.is_none() {
-            self.frames = Some(frames.to_vec());
-        }
-        self.frames.as_mut().unwrap().extend(frames.iter().cloned());
+        self.frames
+            .get_or_insert_with(Vec::new)
+            .extend(frames.iter().cloned());
         self
     }
 
@@ -275,6 +273,11 @@ impl Plot {
     ///
     /// The HTML file is saved in a temp file, from which it is read and
     /// displayed by the browser.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the temporary HTML file cannot be created or written, or if
+    /// its path is not valid UTF-8.
     #[cfg(all(not(target_family = "wasm"), not(target_os = "android")))]
     pub fn show(&self) {
         use std::env;
@@ -298,7 +301,8 @@ impl Plot {
             file.flush().unwrap();
         }
 
-        // Hand off the job of opening the browser to an OS-specific implementation.
+        // Hand off the job of opening the browser to an OS-specific
+        // implementation.
         Plot::show_with_default_app(temp_path);
     }
 
@@ -307,18 +311,29 @@ impl Plot {
     /// The HTML file is generated and saved in the provided filename as long as
     /// the path already exists, after the file is saved, it is read and
     /// displayed by the browser.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `filename` is not valid UTF-8 or the HTML file cannot be
+    /// created or written.
     #[cfg(all(not(target_family = "wasm"), not(target_os = "android")))]
     pub fn show_html<P: AsRef<Path> + std::clone::Clone>(&self, filename: P) {
         let path = filename.as_ref().to_str().unwrap();
         self.write_html(filename.clone());
-        // Hand off the job of opening the browser to an OS-specific implementation.
+        // Hand off the job of opening the browser to an OS-specific
+        // implementation.
         Plot::show_with_default_app(path);
     }
 
     /// Display the fully rendered `Plot` as a static image of the given format
     /// in the default system browser.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the temporary HTML file cannot be created or written, or if
+    /// its path is not valid UTF-8.
     #[cfg(all(not(target_family = "wasm"), not(target_os = "android")))]
-    #[cfg(any(feature = "kaleido", feature = "plotly_static"))]
+    #[cfg(feature = "plotly_static")]
     pub fn show_image(&self, format: ImageFormat, width: usize, height: usize) {
         use std::env;
 
@@ -342,7 +357,8 @@ impl Plot {
             file.flush().unwrap();
         }
 
-        // Hand off the job of opening the browser to an OS-specific implementation.
+        // Hand off the job of opening the browser to an OS-specific
+        // implementation.
         Plot::show_with_default_app(temp_path);
     }
 
@@ -350,6 +366,10 @@ impl Plot {
     ///
     /// This method will render the plot to a full, standalone HTML document,
     /// before saving it to the given location.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the file cannot be created or written.
     pub fn write_html<P: AsRef<Path>>(&self, filename: P) {
         let rendered = self.to_html();
 
@@ -433,100 +453,6 @@ impl Plot {
         self.lab_display();
     }
 
-    /// Convert the `Plot` to a static image of the given image format and save
-    /// at the given location using kaleido.
-    ///
-    /// This function is deprecated since version 0.13.0. The kaleido-based
-    /// implementation will be removed in version 0.15.0. Use
-    /// `plotly_static` feature instead for static image export functionality.
-    #[deprecated(
-        since = "0.13.0",
-        note = "kaleido-based implementation is deprecated. Use plotly_static feature instead. The kaleido implementation will be removed in version 0.15.0"
-    )]
-    #[cfg(feature = "kaleido")]
-    pub fn write_image<P: AsRef<Path>>(
-        &self,
-        filename: P,
-        format: ImageFormat,
-        width: usize,
-        height: usize,
-        scale: f64,
-    ) {
-        let kaleido = plotly_kaleido::Kaleido::new();
-        kaleido
-            .save(
-                filename.as_ref(),
-                &serde_json::to_value(self).unwrap(),
-                format,
-                width,
-                height,
-                scale,
-            )
-            .unwrap_or_else(|_| panic!("failed to export plot to {:?}", filename.as_ref()));
-    }
-
-    /// Convert the `Plot` to a static image and return the image as a `base64`
-    /// String using kaleido. Supported formats are [ImageFormat::JPEG],
-    /// [ImageFormat::PNG] and [ImageFormat::WEBP]
-    ///
-    /// This function is deprecated since version 0.13.0. The kaleido-based
-    /// implementation will be removed in version 0.15.0. Use
-    /// `plotly_static` feature instead for static image export functionality.
-    #[deprecated(
-        since = "0.13.0",
-        note = "kaleido-based implementation is deprecated. Use plotly_static feature instead. The kaleido implementation will be removed in version 0.15.0"
-    )]
-    #[cfg(feature = "kaleido")]
-    pub fn to_base64(
-        &self,
-        format: ImageFormat,
-        width: usize,
-        height: usize,
-        scale: f64,
-    ) -> String {
-        match format {
-            ImageFormat::JPEG | ImageFormat::PNG | ImageFormat::WEBP => {
-                let kaleido = plotly_kaleido::Kaleido::new();
-                kaleido
-                    .image_to_string(
-                        &serde_json::to_value(self).unwrap(),
-                        format,
-                        width,
-                        height,
-                        scale,
-                    )
-                    .unwrap_or_else(|_| panic!("Kaleido failed to generate image"))
-            }
-            _ => {
-                eprintln!("Cannot generate base64 string for ImageFormat:{format}. Allowed formats are JPEG, PNG, WEBP");
-                String::default()
-            }
-        }
-    }
-
-    /// Convert the `Plot` to SVG and return it as a String using kaleido.
-    ///
-    /// This function is deprecated since version 0.13.0. The kaleido-based
-    /// implementation will be removed in version 0.15.0. Use
-    /// `plotly_static` feature instead for static image export functionality.
-    #[deprecated(
-        since = "0.13.0",
-        note = "kaleido-based implementation is deprecated. Use plotly_static feature instead. The kaleido implementation will be removed in version 0.15.0"
-    )]
-    #[cfg(feature = "kaleido")]
-    pub fn to_svg(&self, width: usize, height: usize, scale: f64) -> String {
-        let kaleido = plotly_kaleido::Kaleido::new();
-        kaleido
-            .image_to_string(
-                &serde_json::to_value(self).unwrap(),
-                ImageFormat::SVG,
-                width,
-                height,
-                scale,
-            )
-            .unwrap_or_else(|_| panic!("Kaleido failed to generate image"))
-    }
-
     /// Convert the `Plot` to a static image of the given image format and save
     /// at the given location.
     ///
@@ -539,6 +465,11 @@ impl Plot {
     /// consider using the [`ExporterSyncExt`] or [`ExporterAsyncExt`] extension
     /// methods to reuse a single `StaticExporter` instance across multiple
     /// operations.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the `StaticExporter` cannot be created (e.g. no
+    /// WebDriver is available) or if the export fails.
     #[cfg(feature = "plotly_static")]
     pub fn write_image<P: AsRef<Path>>(
         &self,
@@ -558,8 +489,8 @@ impl Plot {
     }
 
     /// Convert the `Plot` to a static image and return the image as a `base64`
-    /// String. Supported formats are [ImageFormat::JPEG],
-    /// [ImageFormat::PNG] and [ImageFormat::WEBP].
+    /// String. Supported formats are [`ImageFormat::JPEG`],
+    /// [`ImageFormat::PNG`] and [`ImageFormat::WEBP`].
     ///
     /// This method uses the [plotly_static](https://docs.rs/plotly_static/) crate and requires a WebDriver-compatible browser (Chrome or Firefox) to be available on the system.
     ///
@@ -572,6 +503,12 @@ impl Plot {
     /// using the [`ExporterSyncExt`] or [`ExporterAsyncExt`] extension methods
     /// to reuse a single `StaticExporter` instance across multiple
     /// operations.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if `format` is not JPEG, PNG or WEBP, if the
+    /// `StaticExporter` cannot be created (e.g. no WebDriver is available) or
+    /// if the export fails.
     #[cfg(feature = "plotly_static")]
     pub fn to_base64(
         &self,
@@ -589,7 +526,8 @@ impl Plot {
         result
     }
 
-    /// Convert the `Plot` to SVG and return it as a String using plotly_static.
+    /// Convert the `Plot` to SVG and return it as a String using
+    /// `plotly_static`.
     ///
     /// This method requires the usage of the `plotly_static` crate using one of
     /// the available feature flags. For advanced usage (parallelism, exporter reuse, custom config), see the [plotly_static documentation](https://docs.rs/plotly_static/).
@@ -600,6 +538,11 @@ impl Plot {
     /// consider using the [`ExporterSyncExt`] or [`ExporterAsyncExt`] extension
     /// methods to reuse a single `StaticExporter` instance across multiple
     /// operations.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the `StaticExporter` cannot be created (e.g. no
+    /// WebDriver is available) or if the export fails.
     #[cfg(feature = "plotly_static")]
     pub fn to_svg(
         &self,
@@ -616,10 +559,13 @@ impl Plot {
         result
     }
 
-    /// Deprecated: use [crate::export::sync::ExporterSyncExt::write_image].
+    /// Deprecated: use [`crate::export::sync::ExporterSyncExt::write_image`].
     #[deprecated(
         note = "Use exporter.write_image(&plot, ...) from plotly::export::sync::ExporterSyncExt"
     )]
+    /// # Errors
+    ///
+    /// Returns an error if the plot cannot be serialized or the export fails.
     #[cfg(feature = "plotly_static")]
     pub fn write_image_with_exporter<P: AsRef<Path>>(
         &self,
@@ -640,10 +586,14 @@ impl Plot {
         )
     }
 
-    /// Deprecated: use [crate::export::sync::ExporterSyncExt::to_base64].
+    /// Deprecated: use [`crate::export::sync::ExporterSyncExt::to_base64`].
     #[deprecated(
         note = "Use exporter.to_base64(&plot, ...) from plotly::export::sync::ExporterSyncExt"
     )]
+    /// # Errors
+    ///
+    /// Returns an error if `format` is not JPEG, PNG or WEBP, if the plot
+    /// cannot be serialized or if the export fails.
     #[cfg(feature = "plotly_static")]
     pub fn to_base64_with_exporter(
         &self,
@@ -669,10 +619,13 @@ impl Plot {
         }
     }
 
-    /// Deprecated: use [crate::export::sync::ExporterSyncExt::to_svg].
+    /// Deprecated: use [`crate::export::sync::ExporterSyncExt::to_svg`].
     #[deprecated(
         note = "Use exporter.to_svg(&plot, ...) from plotly::export::sync::ExporterSyncExt"
     )]
+    /// # Errors
+    ///
+    /// Returns an error if the plot cannot be serialized or the export fails.
     #[cfg(feature = "plotly_static")]
     pub fn to_svg_with_exporter(
         &self,
@@ -698,8 +651,14 @@ impl Plot {
         tmpl.render().unwrap()
     }
 
+    /// Render the `Plot` as a standalone HTML page that displays it as a static
+    /// image of the given format.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the HTML template fails to render.
     #[cfg(all(not(target_family = "wasm"), not(target_os = "android")))]
-    #[cfg(any(feature = "kaleido", feature = "plotly_static"))]
+    #[cfg(feature = "plotly_static")]
     pub fn render_static(&self, format: &ImageFormat, width: usize, height: usize) -> String {
         let tmpl = StaticPlotTemplate {
             plot: self,
@@ -739,8 +698,8 @@ impl Plot {
     /// This is used when the `plotly_embed_js` feature is enabled, providing
     /// self-contained HTML files that don't require external CDN resources.
     pub fn offline_js_sources() -> String {
-        // Note that since 'tex-mml-chtml' conflicts with 'tex-svg' when generating
-        // Latex Titles we no longer include it.
+        // Note that since 'tex-mml-chtml' conflicts with 'tex-svg' when
+        // generating Latex Titles we no longer include it.
         let local_tex_svg_js = include_str!("../resource/tex-svg-3.2.2.js");
         let local_plotly_js = include_str!("../resource/plotly.min.js");
 
@@ -764,20 +723,29 @@ impl Plot {
     /// disabled, providing smaller HTML files that rely on external
     /// resources.
     pub fn online_cdn_js() -> String {
-        // Note that since 'tex-mml-chtml' conflicts with 'tex-svg' when generating
-        // Latex Titles we no longer include it.
+        // Note that since 'tex-mml-chtml' conflicts with 'tex-svg' when
+        // generating Latex Titles we no longer include it.
         r##"<script src="https://cdn.jsdelivr.net/npm/mathjax@3.2.2/es5/tex-svg.js"></script>
         <script src="https://cdn.plot.ly/plotly-3.7.0.min.js"></script>
         "##
         .to_string()
     }
 
+    /// Serialize to a JSON string.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `serde_json` fails to serialize the value.
     pub fn to_json(&self) -> String {
         serde_json::to_string(self).unwrap()
     }
 
     #[cfg(target_family = "wasm")]
     /// Convert a `Plot` to a native JavaScript `js_sys::Object`.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the serialized plot is not a valid top-level JSON object.
     pub fn to_js_object(&self) -> wasm_bindgen_futures::js_sys::Object {
         use wasm_bindgen_futures::js_sys;
         use wasm_bindgen_futures::wasm_bindgen::JsCast;
@@ -817,7 +785,7 @@ impl Plot {
             .expect(DEFAULT_HTML_APP_NOT_FOUND);
     }
 
-    /// Generate unique seeds for SmallRng such that file names and div names
+    /// Generate unique seeds for `SmallRng` such that file names and div names
     /// are unique random for each call
     pub(crate) fn generate_seed() -> u64 {
         let time = SystemTime::now()
@@ -839,12 +807,10 @@ impl PartialEq for Plot {
 mod tests {
     use std::path::PathBuf;
 
-    #[cfg(feature = "kaleido")]
-    use plotly_kaleido::ImageFormat;
     #[cfg(feature = "plotly_static")]
     use plotly_static::ImageFormat;
     use serde_json::{json, to_value};
-    #[cfg(any(feature = "kaleido", feature = "plotly_static"))]
+    #[cfg(feature = "plotly_static")]
     use {base64::engine::general_purpose, base64::Engine};
 
     use super::*;
@@ -1028,6 +994,16 @@ mod tests {
         assert!(plot1 == plot2);
     }
 
+    #[test]
+    fn add_frames_does_not_duplicate() {
+        let mut plot = Plot::new();
+        plot.add_frames(&[Frame::new(), Frame::new()]);
+        assert_eq!(plot.frame_count(), 2);
+        plot.add_frames(&[Frame::new()]);
+        plot.add_frame(Frame::new());
+        assert_eq!(plot.frame_count(), 4);
+    }
+
     #[test]
     fn save_html() {
         let plot = create_test_plot();
diff --git a/plotly/src/traces/bar_polar.rs b/plotly/src/traces/bar_polar.rs
new file mode 100644
index 00000000..95e00f94
--- /dev/null
+++ b/plotly/src/traces/bar_polar.rs
@@ -0,0 +1,219 @@
+//! Polar bar trace
+
+use plotly_derive::FieldSetter;
+use serde::Serialize;
+
+use crate::{
+    common::{Dim, Label, LegendGroupTitle, Marker, PlotType, Selection, Visible},
+    layout::ThetaUnit,
+    private::{NumOrString, NumOrStringCollection},
+    Trace,
+};
+
+/// Construct a polar bar trace: bars drawn on a polar subplot, with the radial
+/// span set by `r` and the angular position by `theta`. Typically used for wind
+/// roses. Stacking and the gap between bars are controlled by
+/// [`LayoutPolar::bar_mode`](crate::layout::LayoutPolar::bar_mode) and
+/// [`LayoutPolar::bar_gap`](crate::layout::LayoutPolar::bar_gap).
+///
+/// # Examples
+///
+/// ```
+/// use plotly::BarPolar;
+///
+/// let trace = BarPolar::new(vec!["N", "E", "S", "W"], vec![1.5, 2.0, 0.5, 3.0]);
+///
+/// let expected = serde_json::json!({
+///     "type": "barpolar",
+///     "theta": ["N", "E", "S", "W"],
+///     "r": [1.5, 2.0, 0.5, 3.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 BarPolar<Theta, R>
+where
+    Theta: Serialize + Clone + 'static,
+    R: Serialize + Clone + 'static,
+{
+    #[field_setter(default = "PlotType::BarPolar")]
+    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>,
+    #[serde(rename = "legendrank")]
+    legend_rank: Option<usize>,
+    #[serde(rename = "legendwidth")]
+    legend_width: Option<f64>,
+    opacity: Option<f64>,
+    ids: Option<Vec<String>>,
+    /// Sets the radial coordinates.
+    r: Option<Vec<R>>,
+    /// Alternate to `r`: builds a linear space of r coordinates starting at
+    /// `r0` with step `dr`.
+    r0: Option<NumOrString>,
+    dr: Option<f64>,
+    /// Sets the angular coordinates.
+    theta: Option<Vec<Theta>>,
+    /// Alternate to `theta`: builds a linear space of theta coordinates
+    /// starting at `theta0` with step `dtheta`.
+    theta0: Option<NumOrString>,
+    dtheta: Option<f64>,
+    /// Sets the unit of input `theta` values. Has an effect only when on a
+    /// linear angular axis.
+    #[serde(rename = "thetaunit")]
+    theta_unit: Option<ThetaUnit>,
+    /// Sets where the bar base is drawn (in radial axis units).
+    base: Option<Dim<NumOrString>>,
+    /// Shifts the angular position where the bar is drawn (in `thetaunit`
+    /// units).
+    offset: Option<Dim<f64>>,
+    /// Sets the bar angular width (in `thetaunit` units).
+    width: Option<Dim<f64>>,
+    /// Sets a reference between this trace's data coordinates and a polar
+    /// subplot, e.g. `"polar"` (the default) or `"polar2"`.
+    subplot: Option<String>,
+    text: Option<Dim<String>>,
+    #[serde(rename = "hovertext")]
+    hover_text: Option<Dim<String>>,
+    /// Flaglist of `r`, `theta`, `text`, `name` joined with `+`, or one of
+    /// `all`, `none`, `skip`.
+    #[serde(rename = "hoverinfo")]
+    hover_info: Option<String>,
+    #[serde(rename = "hovertemplate")]
+    hover_template: Option<Dim<String>>,
+    #[serde(rename = "hovertemplatefallback")]
+    hover_template_fallback: Option<Dim<String>>,
+    #[serde(rename = "hoverlabel")]
+    hover_label: Option<Label>,
+    marker: Option<Marker>,
+    selected: Option<Selection>,
+    unselected: Option<Selection>,
+    #[serde(rename = "selectedpoints")]
+    selected_points: Option<Vec<u32>>,
+    meta: Option<NumOrString>,
+    #[serde(rename = "customdata")]
+    custom_data: Option<NumOrStringCollection>,
+    #[serde(rename = "uirevision")]
+    ui_revision: Option<NumOrString>,
+}
+
+impl<Theta, R> BarPolar<Theta, R>
+where
+    Theta: Serialize + Clone + 'static,
+    R: Serialize + Clone + 'static,
+{
+    pub fn new(theta: Vec<Theta>, r: Vec<R>) -> Box<Self> {
+        Box::new(Self {
+            theta: Some(theta),
+            r: Some(r),
+            ..Default::default()
+        })
+    }
+}
+
+impl<Theta, R> Trace for BarPolar<Theta, R>
+where
+    Theta: Serialize + Clone + 'static,
+    R: Serialize + Clone + 'static,
+{
+    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 default_bar_polar() {
+        let trace = BarPolar::<f64, f64>::default();
+        assert_eq!(to_value(trace).unwrap(), json!({"type": "barpolar"}));
+    }
+
+    #[test]
+    fn serialize_bar_polar() {
+        let trace = BarPolar::new(vec![0.0, 90.0], vec![1, 2])
+            .name("wind")
+            .visible(Visible::True)
+            .show_legend(true)
+            .legend_group("g")
+            .legend_group_title("G")
+            .legend_rank(5)
+            .legend_width(10.0)
+            .opacity(0.8)
+            .ids(vec!["a", "b"])
+            .r0(0)
+            .dr(1.0)
+            .theta0(0)
+            .dtheta(45.0)
+            .theta_unit(ThetaUnit::Gradians)
+            .base(NumOrString::F(0.5))
+            .offset_array(vec![1.0, 2.0])
+            .width(10.0)
+            .subplot("polar2")
+            .text("text")
+            .hover_text_array(vec!["h1", "h2"])
+            .hover_info("r+theta")
+            .hover_template("%{r}")
+            .hover_template_fallback("-")
+            .hover_label(Label::new())
+            .marker(Marker::new().opacity(0.5))
+            .selected(Selection::new())
+            .unselected(Selection::new())
+            .selected_points(vec![0])
+            .meta("meta")
+            .custom_data(vec!["cd"])
+            .ui_revision("rev");
+
+        let expected = json!({
+            "type": "barpolar",
+            "name": "wind",
+            "visible": true,
+            "showlegend": true,
+            "legendgroup": "g",
+            "legendgrouptitle": {"text": "G"},
+            "legendrank": 5,
+            "legendwidth": 10.0,
+            "opacity": 0.8,
+            "ids": ["a", "b"],
+            "r": [1, 2],
+            "r0": 0,
+            "dr": 1.0,
+            "theta": [0.0, 90.0],
+            "theta0": 0,
+            "dtheta": 45.0,
+            "thetaunit": "gradians",
+            "base": 0.5,
+            "offset": [1.0, 2.0],
+            "width": 10.0,
+            "subplot": "polar2",
+            "text": "text",
+            "hovertext": ["h1", "h2"],
+            "hoverinfo": "r+theta",
+            "hovertemplate": "%{r}",
+            "hovertemplatefallback": "-",
+            "hoverlabel": {},
+            "marker": {"opacity": 0.5},
+            "selected": {"marker": {}},
+            "unselected": {"marker": {}},
+            "selectedpoints": [0],
+            "meta": "meta",
+            "customdata": ["cd"],
+            "uirevision": "rev",
+        });
+
+        assert_eq!(to_value(trace).unwrap(), expected);
+    }
+}
diff --git a/plotly/src/traces/carpet.rs b/plotly/src/traces/carpet.rs
new file mode 100644
index 00000000..08b49930
--- /dev/null
+++ b/plotly/src/traces/carpet.rs
@@ -0,0 +1,554 @@
+//! Carpet trace (a 2D `a`/`b` coordinate system drawn on cartesian axes)
+
+use std::collections::HashMap;
+
+use plotly_derive::FieldSetter;
+use serde::Serialize;
+
+use crate::{
+    color::Color,
+    common::{
+        DashType, ExponentFormat, Font, LegendGroupTitle, PlotType, TickFormatStop, Visible,
+        XAxisId, YAxisId,
+    },
+    layout::{ArrayShow, AutoRange, AutoTypeNumbers, AxisType, CategoryOrder, RangeMode},
+    private::{NumOrString, NumOrStringCollection},
+    Trace,
+};
+
+/// One- or two-dimensional cartesian coordinates of the points of a
+/// [`Carpet`].
+#[derive(Serialize, Clone, Debug)]
+#[serde(untagged)]
+pub enum CarpetCoordinates {
+    OneDimensional(Vec<f64>),
+    TwoDimensional(Vec<Vec<f64>>),
+}
+
+impl From<Vec<f64>> for CarpetCoordinates {
+    fn from(values: Vec<f64>) -> Self {
+        Self::OneDimensional(values)
+    }
+}
+
+impl From<Vec<Vec<f64>>> for CarpetCoordinates {
+    fn from(values: Vec<Vec<f64>>) -> Self {
+        Self::TwoDimensional(values)
+    }
+}
+
+/// How the "cheater plot" x positions are computed when `x` is not provided.
+#[derive(Serialize, Clone, Debug)]
+#[serde(rename_all = "lowercase")]
+pub enum CheaterType {
+    Index,
+    Value,
+}
+
+#[derive(Serialize, Clone, Debug)]
+#[serde(rename_all = "lowercase")]
+pub enum CarpetTickMode {
+    Linear,
+    Array,
+}
+
+/// Which ends of the carpet the tick labels of an axis are drawn on.
+#[derive(Serialize, Clone, Debug)]
+#[serde(rename_all = "lowercase")]
+pub enum CarpetShowTickLabels {
+    Start,
+    End,
+    Both,
+    None,
+}
+
+#[serde_with::skip_serializing_none]
+#[derive(Serialize, Clone, Debug, FieldSetter)]
+pub struct CarpetAxisTitle {
+    text: Option<String>,
+    font: Option<Font>,
+    /// An additional amount by which to offset the title from the tick
+    /// labels, in pixels.
+    offset: Option<f64>,
+}
+
+impl CarpetAxisTitle {
+    pub fn new() -> Self {
+        Default::default()
+    }
+}
+
+impl From<&str> for CarpetAxisTitle {
+    fn from(text: &str) -> Self {
+        CarpetAxisTitle::new().text(text)
+    }
+}
+
+impl From<String> for CarpetAxisTitle {
+    fn from(text: String) -> Self {
+        CarpetAxisTitle::new().text(text)
+    }
+}
+
+/// The `a` or `b` axis of a [`Carpet`] trace.
+#[serde_with::skip_serializing_none]
+#[derive(Serialize, Clone, Debug, FieldSetter)]
+pub struct CarpetAxis {
+    title: Option<CarpetAxisTitle>,
+    #[serde(rename = "type")]
+    axis_type: Option<AxisType>,
+    #[serde(rename = "autotypenumbers")]
+    auto_type_numbers: Option<AutoTypeNumbers>,
+    /// `true`, `false` or [`AutoRange::Reversed`].
+    #[serde(rename = "autorange")]
+    auto_range: Option<AutoRange>,
+    #[serde(rename = "rangemode")]
+    range_mode: Option<RangeMode>,
+    range: Option<[NumOrString; 2]>,
+    #[serde(rename = "fixedrange")]
+    fixed_range: Option<bool>,
+    #[serde(rename = "cheatertype")]
+    cheater_type: Option<CheaterType>,
+    #[serde(rename = "categoryorder")]
+    category_order: Option<CategoryOrder>,
+    #[serde(rename = "categoryarray")]
+    category_array: Option<Vec<NumOrString>>,
+    /// Sets the stride between grid lines along the axis, in array index
+    /// units.
+    #[serde(rename = "arraydtick")]
+    array_dtick: Option<usize>,
+    /// Sets the starting index of grid lines along the axis.
+    #[serde(rename = "arraytick0")]
+    array_tick0: Option<usize>,
+    #[serde(rename = "tickmode")]
+    tick_mode: Option<CarpetTickMode>,
+    #[serde(rename = "nticks")]
+    n_ticks: Option<usize>,
+    #[serde(rename = "tick0")]
+    tick0: Option<f64>,
+    dtick: Option<f64>,
+    #[serde(rename = "tickvals")]
+    tick_values: Option<Vec<f64>>,
+    #[serde(rename = "ticktext")]
+    tick_text: Option<Vec<String>>,
+    #[serde(rename = "tickangle")]
+    tick_angle: Option<f64>,
+    #[serde(rename = "tickfont")]
+    tick_font: Option<Font>,
+    #[serde(rename = "tickformat")]
+    tick_format: Option<String>,
+    #[serde(rename = "tickformatstops")]
+    tick_format_stops: Option<Vec<TickFormatStop>>,
+    #[serde(rename = "tickprefix")]
+    tick_prefix: Option<String>,
+    #[serde(rename = "showtickprefix")]
+    show_tick_prefix: Option<ArrayShow>,
+    #[serde(rename = "ticksuffix")]
+    tick_suffix: Option<String>,
+    #[serde(rename = "showticksuffix")]
+    show_tick_suffix: Option<ArrayShow>,
+    #[serde(rename = "showticklabels")]
+    show_tick_labels: Option<CarpetShowTickLabels>,
+    /// Replacement text for specific tick labels, keyed by the original
+    /// label (e.g. `{"0.5": "half"}`).
+    #[serde(rename = "labelalias")]
+    label_alias: Option<HashMap<String, String>>,
+    #[serde(rename = "labelpadding")]
+    label_padding: Option<i32>,
+    #[serde(rename = "labelprefix")]
+    label_prefix: Option<String>,
+    #[serde(rename = "labelsuffix")]
+    label_suffix: Option<String>,
+    #[serde(rename = "showexponent")]
+    show_exponent: Option<ArrayShow>,
+    #[serde(rename = "exponentformat")]
+    exponent_format: Option<ExponentFormat>,
+    #[serde(rename = "minexponent")]
+    min_exponent: Option<f64>,
+    #[serde(rename = "separatethousands")]
+    separate_thousands: Option<bool>,
+    color: Option<Box<dyn Color>>,
+    #[serde(rename = "showline")]
+    show_line: Option<bool>,
+    #[serde(rename = "linecolor")]
+    line_color: Option<Box<dyn Color>>,
+    #[serde(rename = "linewidth")]
+    line_width: Option<f64>,
+    #[serde(rename = "showgrid")]
+    show_grid: Option<bool>,
+    #[serde(rename = "gridcolor")]
+    grid_color: Option<Box<dyn Color>>,
+    #[serde(rename = "gridwidth")]
+    grid_width: Option<f64>,
+    #[serde(rename = "griddash")]
+    grid_dash: Option<DashType>,
+    /// Sets the number of minor grid ticks per major grid tick.
+    #[serde(rename = "minorgridcount")]
+    minor_grid_count: Option<usize>,
+    #[serde(rename = "minorgridcolor")]
+    minor_grid_color: Option<Box<dyn Color>>,
+    #[serde(rename = "minorgridwidth")]
+    minor_grid_width: Option<f64>,
+    #[serde(rename = "minorgriddash")]
+    minor_grid_dash: Option<DashType>,
+    /// Whether a line is drawn at the start of the axis.
+    #[serde(rename = "startline")]
+    start_line: Option<bool>,
+    #[serde(rename = "startlinecolor")]
+    start_line_color: Option<Box<dyn Color>>,
+    #[serde(rename = "startlinewidth")]
+    start_line_width: Option<f64>,
+    /// Whether a line is drawn at the end of the axis.
+    #[serde(rename = "endline")]
+    end_line: Option<bool>,
+    #[serde(rename = "endlinecolor")]
+    end_line_color: Option<Box<dyn Color>>,
+    #[serde(rename = "endlinewidth")]
+    end_line_width: Option<f64>,
+    /// Smoothing of the grid lines (0 to 1.3).
+    smoothing: Option<f64>,
+}
+
+impl CarpetAxis {
+    pub fn new() -> Self {
+        Default::default()
+    }
+}
+
+/// Construct a carpet trace: a 2D coordinate system defined by the `a` and
+/// `b` parameters, mapped onto cartesian `x`/`y` positions. Carpets are used
+/// as the base for [`ScatterCarpet`](crate::ScatterCarpet) and
+/// [`ContourCarpet`](crate::ContourCarpet) traces, which reference a carpet
+/// through its [`carpet`](Carpet::carpet) id.
+///
+/// # Examples
+///
+/// ```
+/// use plotly::Carpet;
+///
+/// let trace = Carpet::new(vec![4.0, 4.0, 5.0, 5.0], vec![1.0, 2.0, 1.0, 2.0])
+///     .y(vec![2.0, 3.5, 4.0, 4.5])
+///     .carpet("c1");
+///
+/// let expected = serde_json::json!({
+///     "type": "carpet",
+///     "a": [4.0, 4.0, 5.0, 5.0],
+///     "b": [1.0, 2.0, 1.0, 2.0],
+///     "y": [2.0, 3.5, 4.0, 4.5],
+///     "carpet": "c1",
+/// });
+///
+/// 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 Carpet<A, B>
+where
+    A: Serialize + Clone,
+    B: Serialize + Clone,
+{
+    #[field_setter(default = "PlotType::Carpet")]
+    r#type: PlotType,
+    name: Option<String>,
+    visible: Option<Visible>,
+    #[serde(rename = "legendgrouptitle")]
+    legend_group_title: Option<LegendGroupTitle>,
+    #[serde(rename = "legendrank")]
+    legend_rank: Option<usize>,
+    #[serde(rename = "legendwidth")]
+    legend_width: Option<f64>,
+    opacity: Option<f64>,
+    ids: Option<Vec<String>>,
+    /// An identifier for this carpet, so that `scattercarpet` and
+    /// `contourcarpet` traces can specify a carpet plot on which they lie.
+    carpet: Option<String>,
+    /// An array containing values of the first parameter value.
+    a: Option<Vec<A>>,
+    /// Alternate to `a`: builds a linear space of `a` coordinates starting at
+    /// `a0` with step `da`.
+    a0: Option<f64>,
+    da: Option<f64>,
+    /// An array containing values of the second parameter value.
+    b: Option<Vec<B>>,
+    /// Alternate to `b`: builds a linear space of `b` coordinates starting at
+    /// `b0` with step `db`.
+    b0: Option<f64>,
+    db: Option<f64>,
+    /// A one- or two-dimensional array of x coordinates at each carpet point.
+    /// If omitted, the plot is a cheater plot and the x axis is hidden.
+    #[field_setter(skip)]
+    x: Option<CarpetCoordinates>,
+    /// A one- or two-dimensional array of y coordinates at each carpet point.
+    #[field_setter(skip)]
+    y: Option<CarpetCoordinates>,
+    #[serde(rename = "aaxis")]
+    a_axis: Option<CarpetAxis>,
+    #[serde(rename = "baxis")]
+    b_axis: Option<CarpetAxis>,
+    /// The shift applied to each successive row of data in creating a
+    /// cheater plot.
+    #[serde(rename = "cheaterslope")]
+    cheater_slope: Option<f64>,
+    /// Sets the default color of axis lines and labels.
+    color: Option<Box<dyn Color>>,
+    /// The default font used for axis and tick labels.
+    font: Option<Font>,
+    #[serde(rename = "xaxis")]
+    x_axis: Option<XAxisId>,
+    #[serde(rename = "yaxis")]
+    y_axis: Option<YAxisId>,
+    /// Sets the layer on which this trace is displayed, relative to other
+    /// SVG traces on the same subplot.
+    #[serde(rename = "zorder")]
+    z_order: Option<i32>,
+    meta: Option<NumOrString>,
+    #[serde(rename = "customdata")]
+    custom_data: Option<NumOrStringCollection>,
+    #[serde(rename = "uirevision")]
+    ui_revision: Option<NumOrString>,
+}
+
+impl<A, B> Carpet<A, B>
+where
+    A: Serialize + Clone,
+    B: Serialize + Clone,
+{
+    pub fn new(a: Vec<A>, b: Vec<B>) -> Box<Self> {
+        Box::new(Self {
+            a: Some(a),
+            b: Some(b),
+            ..Default::default()
+        })
+    }
+
+    /// Sets the x coordinates at each carpet point, as a 1D or 2D array.
+    pub fn x(mut self, x: impl Into<CarpetCoordinates>) -> Box<Self> {
+        self.x = Some(x.into());
+        Box::new(self)
+    }
+
+    /// Sets the y coordinates at each carpet point, as a 1D or 2D array.
+    pub fn y(mut self, y: impl Into<CarpetCoordinates>) -> Box<Self> {
+        self.y = Some(y.into());
+        Box::new(self)
+    }
+}
+
+impl<A, B> Trace for Carpet<A, B>
+where
+    A: Serialize + Clone,
+    B: 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_enums() {
+        assert_eq!(to_value(CheaterType::Index).unwrap(), json!("index"));
+        assert_eq!(to_value(CheaterType::Value).unwrap(), json!("value"));
+        assert_eq!(to_value(CarpetTickMode::Linear).unwrap(), json!("linear"));
+        assert_eq!(to_value(CarpetTickMode::Array).unwrap(), json!("array"));
+        assert_eq!(
+            to_value(CarpetShowTickLabels::Start).unwrap(),
+            json!("start")
+        );
+        assert_eq!(to_value(CarpetShowTickLabels::End).unwrap(), json!("end"));
+        assert_eq!(to_value(CarpetShowTickLabels::Both).unwrap(), json!("both"));
+        assert_eq!(to_value(CarpetShowTickLabels::None).unwrap(), json!("none"));
+    }
+
+    #[test]
+    fn serialize_carpet_axis() {
+        let axis = CarpetAxis::new()
+            .title(
+                CarpetAxisTitle::new()
+                    .text("A")
+                    .font(Font::new())
+                    .offset(5.0),
+            )
+            .axis_type(AxisType::Linear)
+            .auto_type_numbers(AutoTypeNumbers::Strict)
+            .auto_range(AutoRange::Reversed)
+            .range_mode(RangeMode::ToZero)
+            .range([NumOrString::F(0.0), NumOrString::F(10.0)])
+            .fixed_range(true)
+            .cheater_type(CheaterType::Index)
+            .category_order(CategoryOrder::Array)
+            .category_array(vec![NumOrString::S("x".to_string())])
+            .array_dtick(2)
+            .array_tick0(1)
+            .tick_mode(CarpetTickMode::Linear)
+            .n_ticks(4)
+            .tick0(0.0)
+            .dtick(1.0)
+            .tick_values(vec![1.0])
+            .tick_text(vec!["one"])
+            .tick_angle(30.0)
+            .tick_font(Font::new())
+            .tick_format(".1f")
+            .tick_format_stops(vec![TickFormatStop::new()])
+            .tick_prefix("p")
+            .show_tick_prefix(ArrayShow::First)
+            .tick_suffix("s")
+            .show_tick_suffix(ArrayShow::Last)
+            .show_tick_labels(CarpetShowTickLabels::Both)
+            .label_alias(HashMap::from([("4".to_string(), "four".to_string())]))
+            .label_padding(10)
+            .label_prefix("a = ")
+            .label_suffix("!")
+            .show_exponent(ArrayShow::All)
+            .exponent_format(ExponentFormat::SI)
+            .min_exponent(2.0)
+            .separate_thousands(false)
+            .color("#111")
+            .show_line(true)
+            .line_color("#222")
+            .line_width(1.5)
+            .show_grid(true)
+            .grid_color("#333")
+            .grid_width(0.5)
+            .grid_dash(DashType::Dot)
+            .minor_grid_count(4)
+            .minor_grid_color("#444")
+            .minor_grid_width(0.25)
+            .minor_grid_dash(DashType::Dash)
+            .start_line(true)
+            .start_line_color("#555")
+            .start_line_width(2.0)
+            .end_line(false)
+            .end_line_color("#666")
+            .end_line_width(3.0)
+            .smoothing(1.0);
+
+        let expected = json!({
+            "title": {"text": "A", "font": {}, "offset": 5.0},
+            "type": "linear",
+            "autotypenumbers": "strict",
+            "autorange": "reversed",
+            "rangemode": "tozero",
+            "range": [0.0, 10.0],
+            "fixedrange": true,
+            "cheatertype": "index",
+            "categoryorder": "array",
+            "categoryarray": ["x"],
+            "arraydtick": 2,
+            "arraytick0": 1,
+            "tickmode": "linear",
+            "nticks": 4,
+            "tick0": 0.0,
+            "dtick": 1.0,
+            "tickvals": [1.0],
+            "ticktext": ["one"],
+            "tickangle": 30.0,
+            "tickfont": {},
+            "tickformat": ".1f",
+            "tickformatstops": [{"enabled": true}],
+            "tickprefix": "p",
+            "showtickprefix": "first",
+            "ticksuffix": "s",
+            "showticksuffix": "last",
+            "showticklabels": "both",
+            "labelalias": {"4": "four"},
+            "labelpadding": 10,
+            "labelprefix": "a = ",
+            "labelsuffix": "!",
+            "showexponent": "all",
+            "exponentformat": "SI",
+            "minexponent": 2.0,
+            "separatethousands": false,
+            "color": "#111",
+            "showline": true,
+            "linecolor": "#222",
+            "linewidth": 1.5,
+            "showgrid": true,
+            "gridcolor": "#333",
+            "gridwidth": 0.5,
+            "griddash": "dot",
+            "minorgridcount": 4,
+            "minorgridcolor": "#444",
+            "minorgridwidth": 0.25,
+            "minorgriddash": "dash",
+            "startline": true,
+            "startlinecolor": "#555",
+            "startlinewidth": 2.0,
+            "endline": false,
+            "endlinecolor": "#666",
+            "endlinewidth": 3.0,
+            "smoothing": 1.0,
+        });
+
+        assert_eq!(to_value(axis).unwrap(), expected);
+    }
+
+    #[test]
+    fn serialize_carpet() {
+        let trace = Carpet::new(vec![1.0, 2.0], vec![3.0, 4.0])
+            .name("carpet")
+            .visible(Visible::True)
+            .legend_group_title("G")
+            .legend_rank(1)
+            .legend_width(2.0)
+            .opacity(0.9)
+            .ids(vec!["i"])
+            .carpet("c1")
+            .a0(0.0)
+            .da(1.0)
+            .b0(0.0)
+            .db(1.0)
+            .x(vec![vec![0.0, 1.0], vec![2.0, 3.0]])
+            .y(vec![vec![4.0, 5.0], vec![6.0, 7.0]])
+            .a_axis(CarpetAxis::new().title("a".into()))
+            .b_axis(CarpetAxis::new())
+            .cheater_slope(1.5)
+            .color("#444")
+            .font(Font::new())
+            .x_axis("x2")
+            .y_axis("y2")
+            .z_order(3)
+            .meta("m")
+            .custom_data(vec!["cd"])
+            .ui_revision(1);
+
+        let expected = json!({
+            "type": "carpet",
+            "name": "carpet",
+            "visible": true,
+            "legendgrouptitle": {"text": "G"},
+            "legendrank": 1,
+            "legendwidth": 2.0,
+            "opacity": 0.9,
+            "ids": ["i"],
+            "carpet": "c1",
+            "a": [1.0, 2.0],
+            "a0": 0.0,
+            "da": 1.0,
+            "b": [3.0, 4.0],
+            "b0": 0.0,
+            "db": 1.0,
+            "x": [[0.0, 1.0], [2.0, 3.0]],
+            "y": [[4.0, 5.0], [6.0, 7.0]],
+            "aaxis": {"title": {"text": "a"}},
+            "baxis": {},
+            "cheaterslope": 1.5,
+            "color": "#444",
+            "font": {},
+            "xaxis": "x2",
+            "yaxis": "y2",
+            "zorder": 3,
+            "meta": "m",
+            "customdata": ["cd"],
+            "uirevision": 1,
+        });
+
+        assert_eq!(to_value(trace).unwrap(), expected);
+    }
+}
diff --git a/plotly/src/traces/cone.rs b/plotly/src/traces/cone.rs
new file mode 100644
index 00000000..801e3375
--- /dev/null
+++ b/plotly/src/traces/cone.rs
@@ -0,0 +1,306 @@
+//! Cone (3D vector field) trace
+
+use plotly_derive::FieldSetter;
+use serde::Serialize;
+
+use crate::{
+    common::{ColorBar, ColorScale, Dim, Label, LegendGroupTitle, PlotType, Visible},
+    private::{NumOrString, NumOrStringCollection},
+    traces::mesh3d::{LightPosition, Lighting},
+    Trace,
+};
+
+/// Sets the cones' anchor with respect to their x/y/z positions.
+#[derive(Serialize, Clone, Debug)]
+#[serde(rename_all = "lowercase")]
+pub enum ConeAnchor {
+    Tip,
+    Tail,
+    /// Center of mass.
+    Cm,
+    Center,
+}
+
+/// Determines whether `sizeref` is set as a scaling factor relative to the
+/// vector field, as an absolute value, or whether the raw vector norms are
+/// used.
+#[derive(Serialize, Clone, Debug)]
+#[serde(rename_all = "lowercase")]
+pub enum ConeSizeMode {
+    Scaled,
+    Absolute,
+    Raw,
+}
+
+/// Construct a cone trace: a 3D vector field where each cone sits at an
+/// `(x, y, z)` position and points along the `(u, v, w)` vector.
+///
+/// # Examples
+///
+/// ```
+/// use plotly::Cone;
+///
+/// let trace = Cone::new(
+///     vec![1.0], vec![1.0], vec![1.0],
+///     vec![1.0], vec![1.0], vec![0.0],
+/// );
+///
+/// let expected = serde_json::json!({
+///     "type": "cone",
+///     "x": [1.0], "y": [1.0], "z": [1.0],
+///     "u": [1.0], "v": [1.0], "w": [0.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 Cone<X, Y, Z, U, V, W>
+where
+    X: Serialize + Clone,
+    Y: Serialize + Clone,
+    Z: Serialize + Clone,
+    U: Serialize + Clone,
+    V: Serialize + Clone,
+    W: Serialize + Clone,
+{
+    #[field_setter(default = "PlotType::Cone")]
+    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>,
+    #[serde(rename = "legendrank")]
+    legend_rank: Option<usize>,
+    #[serde(rename = "legendwidth")]
+    legend_width: Option<f64>,
+    opacity: Option<f64>,
+    ids: Option<Vec<String>>,
+    /// Sets the x coordinates of the vector field and of the displayed cones.
+    x: Option<Vec<X>>,
+    /// Sets the y coordinates of the vector field and of the displayed cones.
+    y: Option<Vec<Y>>,
+    /// Sets the z coordinates of the vector field and of the displayed cones.
+    z: Option<Vec<Z>>,
+    /// Sets the x components of the vector field.
+    u: Option<Vec<U>>,
+    /// Sets the y components of the vector field.
+    v: Option<Vec<V>>,
+    /// Sets the z components of the vector field.
+    w: Option<Vec<W>>,
+    anchor: Option<ConeAnchor>,
+    #[serde(rename = "sizemode")]
+    size_mode: Option<ConeSizeMode>,
+    /// Adjusts the cone size scaling. Its meaning depends on `sizemode`.
+    #[serde(rename = "sizeref")]
+    size_ref: Option<f64>,
+    /// Sets a reference between this trace's 3D coordinate system and a 3D
+    /// scene, e.g. `"scene"` (the default) or `"scene2"`.
+    scene: Option<String>,
+    text: Option<Dim<String>>,
+    #[serde(rename = "hovertext")]
+    hover_text: Option<Dim<String>>,
+    /// Flaglist of `x`, `y`, `z`, `u`, `v`, `w`, `norm`, `text`, `name`
+    /// joined with `+`, or one of `all`, `none`, `skip`.
+    #[serde(rename = "hoverinfo")]
+    hover_info: Option<String>,
+    #[serde(rename = "hovertemplate")]
+    hover_template: Option<Dim<String>>,
+    #[serde(rename = "hovertemplatefallback")]
+    hover_template_fallback: Option<Dim<String>>,
+    #[serde(rename = "hoverlabel")]
+    hover_label: Option<Label>,
+    #[serde(rename = "xhoverformat")]
+    x_hover_format: Option<String>,
+    #[serde(rename = "yhoverformat")]
+    y_hover_format: Option<String>,
+    #[serde(rename = "zhoverformat")]
+    z_hover_format: Option<String>,
+    #[serde(rename = "uhoverformat")]
+    u_hover_format: Option<String>,
+    #[serde(rename = "vhoverformat")]
+    v_hover_format: Option<String>,
+    #[serde(rename = "whoverformat")]
+    w_hover_format: Option<String>,
+    #[serde(rename = "coloraxis")]
+    color_axis: Option<String>,
+    #[serde(rename = "colorbar")]
+    color_bar: Option<ColorBar>,
+    #[serde(rename = "colorscale")]
+    color_scale: Option<ColorScale>,
+    #[serde(rename = "autocolorscale")]
+    auto_color_scale: Option<bool>,
+    #[serde(rename = "reversescale")]
+    reverse_scale: Option<bool>,
+    #[serde(rename = "showscale")]
+    show_scale: Option<bool>,
+    #[serde(rename = "cauto")]
+    c_auto: Option<bool>,
+    #[serde(rename = "cmin")]
+    c_min: Option<f64>,
+    #[serde(rename = "cmax")]
+    c_max: Option<f64>,
+    #[serde(rename = "cmid")]
+    c_mid: Option<f64>,
+    lighting: Option<Lighting>,
+    #[serde(rename = "lightposition")]
+    light_position: Option<LightPosition>,
+    meta: Option<NumOrString>,
+    #[serde(rename = "customdata")]
+    custom_data: Option<NumOrStringCollection>,
+    #[serde(rename = "uirevision")]
+    ui_revision: Option<NumOrString>,
+}
+
+impl<X, Y, Z, U, V, W> Cone<X, Y, Z, U, V, W>
+where
+    X: Serialize + Clone,
+    Y: Serialize + Clone,
+    Z: Serialize + Clone,
+    U: Serialize + Clone,
+    V: Serialize + Clone,
+    W: Serialize + Clone,
+{
+    pub fn new(x: Vec<X>, y: Vec<Y>, z: Vec<Z>, u: Vec<U>, v: Vec<V>, w: Vec<W>) -> Box<Self> {
+        Box::new(Self {
+            x: Some(x),
+            y: Some(y),
+            z: Some(z),
+            u: Some(u),
+            v: Some(v),
+            w: Some(w),
+            ..Default::default()
+        })
+    }
+}
+
+impl<X, Y, Z, U, V, W> Trace for Cone<X, Y, Z, U, V, W>
+where
+    X: Serialize + Clone,
+    Y: Serialize + Clone,
+    Z: Serialize + Clone,
+    U: Serialize + Clone,
+    V: Serialize + Clone,
+    W: 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_enums() {
+        assert_eq!(to_value(ConeAnchor::Tip).unwrap(), json!("tip"));
+        assert_eq!(to_value(ConeAnchor::Tail).unwrap(), json!("tail"));
+        assert_eq!(to_value(ConeAnchor::Cm).unwrap(), json!("cm"));
+        assert_eq!(to_value(ConeAnchor::Center).unwrap(), json!("center"));
+        assert_eq!(to_value(ConeSizeMode::Scaled).unwrap(), json!("scaled"));
+        assert_eq!(to_value(ConeSizeMode::Absolute).unwrap(), json!("absolute"));
+        assert_eq!(to_value(ConeSizeMode::Raw).unwrap(), json!("raw"));
+    }
+
+    #[test]
+    fn serialize_cone() {
+        let trace = Cone::new(vec![1], vec![2], vec![3], vec![0.1], vec![0.2], vec![0.3])
+            .name("cone")
+            .visible(Visible::True)
+            .show_legend(true)
+            .legend_group("g")
+            .legend_group_title("G")
+            .legend_rank(1)
+            .legend_width(2.0)
+            .opacity(0.9)
+            .ids(vec!["a"])
+            .anchor(ConeAnchor::Tip)
+            .size_mode(ConeSizeMode::Absolute)
+            .size_ref(0.5)
+            .scene("scene2")
+            .text("t")
+            .hover_text("h")
+            .hover_info("u+v+w+norm")
+            .hover_template("%{u}")
+            .hover_template_fallback("-")
+            .hover_label(Label::new())
+            .x_hover_format(".1f")
+            .y_hover_format(".2f")
+            .z_hover_format(".3f")
+            .u_hover_format(".4f")
+            .v_hover_format(".5f")
+            .w_hover_format(".6f")
+            .color_axis("coloraxis2")
+            .color_bar(ColorBar::new())
+            .color_scale(ColorScale::Palette(ColorScalePalette::Viridis))
+            .auto_color_scale(false)
+            .reverse_scale(true)
+            .show_scale(false)
+            .c_auto(false)
+            .c_min(0.0)
+            .c_max(1.0)
+            .c_mid(0.5)
+            .lighting(Lighting::new().ambient(0.5))
+            .light_position(LightPosition::new().x(1.0).y(2.0).z(3.0))
+            .meta("m")
+            .custom_data(vec!["cd"])
+            .ui_revision(3);
+
+        let expected = json!({
+            "type": "cone",
+            "name": "cone",
+            "visible": true,
+            "showlegend": true,
+            "legendgroup": "g",
+            "legendgrouptitle": {"text": "G"},
+            "legendrank": 1,
+            "legendwidth": 2.0,
+            "opacity": 0.9,
+            "ids": ["a"],
+            "x": [1], "y": [2], "z": [3],
+            "u": [0.1], "v": [0.2], "w": [0.3],
+            "anchor": "tip",
+            "sizemode": "absolute",
+            "sizeref": 0.5,
+            "scene": "scene2",
+            "text": "t",
+            "hovertext": "h",
+            "hoverinfo": "u+v+w+norm",
+            "hovertemplate": "%{u}",
+            "hovertemplatefallback": "-",
+            "hoverlabel": {},
+            "xhoverformat": ".1f",
+            "yhoverformat": ".2f",
+            "zhoverformat": ".3f",
+            "uhoverformat": ".4f",
+            "vhoverformat": ".5f",
+            "whoverformat": ".6f",
+            "coloraxis": "coloraxis2",
+            "colorbar": {},
+            "colorscale": "Viridis",
+            "autocolorscale": false,
+            "reversescale": true,
+            "showscale": false,
+            "cauto": false,
+            "cmin": 0.0,
+            "cmax": 1.0,
+            "cmid": 0.5,
+            "lighting": {"ambient": 0.5},
+            "lightposition": {"x": 1.0, "y": 2.0, "z": 3.0},
+            "meta": "m",
+            "customdata": ["cd"],
+            "uirevision": 3,
+        });
+
+        assert_eq!(to_value(trace).unwrap(), expected);
+    }
+}
diff --git a/plotly/src/traces/contour_carpet.rs b/plotly/src/traces/contour_carpet.rs
new file mode 100644
index 00000000..51c84738
--- /dev/null
+++ b/plotly/src/traces/contour_carpet.rs
@@ -0,0 +1,273 @@
+//! Carpet contour trace
+
+use plotly_derive::FieldSetter;
+use serde::Serialize;
+
+use crate::{
+    color::Color,
+    common::{ColorBar, ColorScale, LegendGroupTitle, Line, PlotType, Visible, XAxisId, YAxisId},
+    private::{NumOrString, NumOrStringCollection},
+    traces::contour::Contours,
+    Trace,
+};
+
+/// Whether the `a`/`b` coordinates of a [`ContourCarpet`] are given as an
+/// array or as a linear scaled space (from `a0`/`da` or `b0`/`db`).
+#[derive(Serialize, Clone, Debug)]
+#[serde(rename_all = "lowercase")]
+pub enum CoordinateType {
+    Array,
+    Scaled,
+}
+
+/// Construct a contour trace drawn on a [`Carpet`](crate::Carpet). The
+/// carpet is selected by its [`carpet`](ContourCarpet::carpet) id.
+///
+/// # Examples
+///
+/// ```
+/// use plotly::ContourCarpet;
+///
+/// let trace = ContourCarpet::new(vec![1.0, 2.0, 3.0, 4.0])
+///     .a(vec![0.0, 1.0, 0.0, 1.0])
+///     .b(vec![0.0, 0.0, 1.0, 1.0])
+///     .carpet("c1");
+///
+/// let expected = serde_json::json!({
+///     "type": "contourcarpet",
+///     "z": [1.0, 2.0, 3.0, 4.0],
+///     "a": [0.0, 1.0, 0.0, 1.0],
+///     "b": [0.0, 0.0, 1.0, 1.0],
+///     "carpet": "c1",
+/// });
+///
+/// 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 ContourCarpet<Z, A = f64, B = f64>
+where
+    Z: Serialize + Clone,
+    A: Serialize + Clone,
+    B: Serialize + Clone,
+{
+    #[field_setter(default = "PlotType::ContourCarpet")]
+    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>,
+    #[serde(rename = "legendrank")]
+    legend_rank: Option<usize>,
+    #[serde(rename = "legendwidth")]
+    legend_width: Option<f64>,
+    opacity: Option<f64>,
+    ids: Option<Vec<String>>,
+    /// The [`carpet`](crate::Carpet::carpet) id of the carpet this trace lies
+    /// on. If omitted, the first carpet is used.
+    carpet: Option<String>,
+    /// Sets the z data, a 1D or 2D array aligned with the carpet points.
+    z: Option<Vec<Z>>,
+    /// Sets the `a` coordinates.
+    a: Option<Vec<A>>,
+    /// Alternate to `a`: builds a linear space of `a` coordinates starting at
+    /// `a0` with step `da`.
+    a0: Option<NumOrString>,
+    da: Option<f64>,
+    #[serde(rename = "atype")]
+    a_type: Option<CoordinateType>,
+    /// Sets the `b` coordinates.
+    b: Option<Vec<B>>,
+    /// Alternate to `b`: builds a linear space of `b` coordinates starting at
+    /// `b0` with step `db`.
+    b0: Option<NumOrString>,
+    db: Option<f64>,
+    #[serde(rename = "btype")]
+    b_type: Option<CoordinateType>,
+    /// Transposes the z data.
+    transpose: Option<bool>,
+    #[serde(rename = "autocontour")]
+    auto_contour: Option<bool>,
+    /// Sets the maximum number of contour levels when `autocontour` is
+    /// `true`.
+    #[serde(rename = "ncontours")]
+    n_contours: Option<usize>,
+    contours: Option<Contours>,
+    line: Option<Line>,
+    #[serde(rename = "fillcolor")]
+    fill_color: Option<Box<dyn Color>>,
+    text: Option<Vec<String>>,
+    #[serde(rename = "hovertext")]
+    hover_text: Option<Vec<String>>,
+    #[serde(rename = "zauto")]
+    z_auto: Option<bool>,
+    #[serde(rename = "zmin")]
+    z_min: Option<f64>,
+    #[serde(rename = "zmax")]
+    z_max: Option<f64>,
+    #[serde(rename = "zmid")]
+    z_mid: Option<f64>,
+    #[serde(rename = "coloraxis")]
+    color_axis: Option<String>,
+    #[serde(rename = "colorbar")]
+    color_bar: Option<ColorBar>,
+    #[serde(rename = "colorscale")]
+    color_scale: Option<ColorScale>,
+    #[serde(rename = "autocolorscale")]
+    auto_color_scale: Option<bool>,
+    #[serde(rename = "reversescale")]
+    reverse_scale: Option<bool>,
+    #[serde(rename = "showscale")]
+    show_scale: Option<bool>,
+    #[serde(rename = "xaxis")]
+    x_axis: Option<XAxisId>,
+    #[serde(rename = "yaxis")]
+    y_axis: Option<YAxisId>,
+    /// Sets the layer on which this trace is displayed, relative to other
+    /// SVG traces on the same subplot.
+    #[serde(rename = "zorder")]
+    z_order: Option<i32>,
+    meta: Option<NumOrString>,
+    #[serde(rename = "customdata")]
+    custom_data: Option<NumOrStringCollection>,
+    #[serde(rename = "uirevision")]
+    ui_revision: Option<NumOrString>,
+}
+
+impl<Z> ContourCarpet<Z>
+where
+    Z: Serialize + Clone,
+{
+    pub fn new(z: Vec<Z>) -> Box<Self> {
+        Box::new(Self {
+            z: Some(z),
+            ..Default::default()
+        })
+    }
+}
+
+impl<Z, A, B> Trace for ContourCarpet<Z, A, B>
+where
+    Z: Serialize + Clone,
+    A: Serialize + Clone,
+    B: 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_coordinate_type() {
+        assert_eq!(to_value(CoordinateType::Array).unwrap(), json!("array"));
+        assert_eq!(to_value(CoordinateType::Scaled).unwrap(), json!("scaled"));
+    }
+
+    #[test]
+    fn serialize_contour_carpet() {
+        let trace = ContourCarpet::new(vec![vec![1.0, 2.0], vec![3.0, 4.0]])
+            .name("cc")
+            .visible(Visible::True)
+            .show_legend(true)
+            .legend_group("g")
+            .legend_group_title("G")
+            .legend_rank(1)
+            .legend_width(2.0)
+            .opacity(0.8)
+            .ids(vec!["i"])
+            .carpet("c1")
+            .a(vec![0.0, 1.0])
+            .a0(0)
+            .da(1.0)
+            .a_type(CoordinateType::Array)
+            .b(vec![0.0, 1.0])
+            .b0(0)
+            .db(1.0)
+            .b_type(CoordinateType::Scaled)
+            .transpose(true)
+            .auto_contour(false)
+            .n_contours(10)
+            .contours(Contours::new().show_lines(true))
+            .line(Line::new().width(1.0))
+            .fill_color("#abcdef")
+            .text(vec!["t"])
+            .hover_text(vec!["h"])
+            .z_auto(false)
+            .z_min(0.0)
+            .z_max(4.0)
+            .z_mid(2.0)
+            .color_axis("coloraxis")
+            .color_bar(ColorBar::new())
+            .color_scale(ColorScale::Palette(ColorScalePalette::Hot))
+            .auto_color_scale(false)
+            .reverse_scale(true)
+            .show_scale(false)
+            .x_axis("x2")
+            .y_axis("y2")
+            .z_order(2)
+            .meta("m")
+            .custom_data(vec!["cd"])
+            .ui_revision(1);
+
+        let expected = json!({
+            "type": "contourcarpet",
+            "name": "cc",
+            "visible": true,
+            "showlegend": true,
+            "legendgroup": "g",
+            "legendgrouptitle": {"text": "G"},
+            "legendrank": 1,
+            "legendwidth": 2.0,
+            "opacity": 0.8,
+            "ids": ["i"],
+            "carpet": "c1",
+            "z": [[1.0, 2.0], [3.0, 4.0]],
+            "a": [0.0, 1.0],
+            "a0": 0,
+            "da": 1.0,
+            "atype": "array",
+            "b": [0.0, 1.0],
+            "b0": 0,
+            "db": 1.0,
+            "btype": "scaled",
+            "transpose": true,
+            "autocontour": false,
+            "ncontours": 10,
+            "contours": {"showlines": true},
+            "line": {"width": 1.0},
+            "fillcolor": "#abcdef",
+            "text": ["t"],
+            "hovertext": ["h"],
+            "zauto": false,
+            "zmin": 0.0,
+            "zmax": 4.0,
+            "zmid": 2.0,
+            "coloraxis": "coloraxis",
+            "colorbar": {},
+            "colorscale": "Hot",
+            "autocolorscale": false,
+            "reversescale": true,
+            "showscale": false,
+            "xaxis": "x2",
+            "yaxis": "y2",
+            "zorder": 2,
+            "meta": "m",
+            "customdata": ["cd"],
+            "uirevision": 1,
+        });
+
+        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..56ad4482 100644
--- a/plotly/src/traces/density_mapbox.rs
+++ b/plotly/src/traces/density_mapbox.rs
@@ -31,7 +31,7 @@ where
     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"
+    /// 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
diff --git a/plotly/src/traces/funnel_area.rs b/plotly/src/traces/funnel_area.rs
new file mode 100644
index 00000000..9d9d444e
--- /dev/null
+++ b/plotly/src/traces/funnel_area.rs
@@ -0,0 +1,277 @@
+//! Funnel area trace
+
+use plotly_derive::FieldSetter;
+use serde::Serialize;
+
+use crate::private::{NumOrString, NumOrStringCollection};
+use crate::{
+    common::{Dim, Domain, Font, Label, LegendGroupTitle, Marker, PlotType, TextPosition, Visible},
+    Trace,
+};
+
+#[derive(Serialize, Clone, Debug)]
+pub enum FunnelAreaTitlePosition {
+    #[serde(rename = "top left")]
+    TopLeft,
+    #[serde(rename = "top center")]
+    TopCenter,
+    #[serde(rename = "top right")]
+    TopRight,
+}
+
+/// Title of a funnel area trace, drawn above the funnel.
+#[serde_with::skip_serializing_none]
+#[derive(Serialize, Clone, Debug, FieldSetter)]
+pub struct FunnelAreaTitle {
+    text: Option<String>,
+    font: Option<Font>,
+    position: Option<FunnelAreaTitlePosition>,
+}
+
+impl FunnelAreaTitle {
+    pub fn new() -> Self {
+        Default::default()
+    }
+}
+
+impl From<&str> for FunnelAreaTitle {
+    fn from(text: &str) -> Self {
+        FunnelAreaTitle::new().text(text)
+    }
+}
+
+impl From<String> for FunnelAreaTitle {
+    fn from(text: String) -> Self {
+        FunnelAreaTitle::new().text(text)
+    }
+}
+
+/// Construct a funnel area trace: a pie-like chart where each stage is drawn
+/// as a slice of a funnel whose area is proportional to its value.
+///
+/// # Examples
+///
+/// ```
+/// use plotly::FunnelArea;
+///
+/// let trace = FunnelArea::new(vec![5, 4, 3])
+///     .labels(vec!["The 1st", "The 2nd", "The 3rd"]);
+///
+/// let expected = serde_json::json!({
+///     "type": "funnelarea",
+///     "values": [5, 4, 3],
+///     "labels": ["The 1st", "The 2nd", "The 3rd"],
+/// });
+///
+/// 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 FunnelArea<V>
+where
+    V: Serialize + Clone,
+{
+    #[field_setter(default = "PlotType::FunnelArea")]
+    r#type: PlotType,
+    /// Sets the values of the sectors. If omitted, occurrences of each label
+    /// are counted.
+    values: Option<Vec<V>>,
+    /// Sets the sector labels. Duplicated labels have their values summed.
+    labels: Option<Vec<String>>,
+    /// Alternate to `labels`: builds a numeric set of labels starting at
+    /// `label0` with step `dlabel`.
+    label0: Option<f64>,
+    dlabel: Option<f64>,
+    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>,
+    #[serde(rename = "legendrank")]
+    legend_rank: Option<usize>,
+    #[serde(rename = "legendwidth")]
+    legend_width: Option<f64>,
+    opacity: Option<f64>,
+    ids: Option<Vec<String>>,
+    #[serde(rename = "customdata")]
+    custom_data: Option<NumOrStringCollection>,
+    meta: Option<NumOrString>,
+    domain: Option<Domain>,
+    /// Sets the ratio between height and width.
+    #[serde(rename = "aspectratio")]
+    aspect_ratio: Option<f64>,
+    /// Sets the ratio between the bottom length and the maximum top length.
+    #[serde(rename = "baseratio")]
+    base_ratio: Option<f64>,
+    /// Funnel area traces sharing a non-empty scale group are sized relative
+    /// to their totals.
+    #[serde(rename = "scalegroup")]
+    scale_group: Option<String>,
+    marker: Option<Marker>,
+    title: Option<FunnelAreaTitle>,
+    text: Option<Dim<String>>,
+    /// Flaglist of `label`, `text`, `value`, `percent` joined with `+`, or
+    /// `none`.
+    #[serde(rename = "textinfo")]
+    text_info: Option<String>,
+    #[serde(rename = "textposition")]
+    text_position: Option<Dim<TextPosition>>,
+    #[serde(rename = "texttemplate")]
+    text_template: Option<Dim<String>>,
+    #[serde(rename = "texttemplatefallback")]
+    text_template_fallback: Option<Dim<String>>,
+    #[serde(rename = "textfont")]
+    text_font: Option<Font>,
+    #[serde(rename = "insidetextfont")]
+    inside_text_font: Option<Font>,
+    #[serde(rename = "hovertext")]
+    hover_text: Option<Dim<String>>,
+    /// Flaglist of `label`, `text`, `value`, `percent`, `name` joined with
+    /// `+`, or one of `all`, `none`, `skip`.
+    #[serde(rename = "hoverinfo")]
+    hover_info: Option<String>,
+    #[serde(rename = "hovertemplate")]
+    hover_template: Option<Dim<String>>,
+    #[serde(rename = "hovertemplatefallback")]
+    hover_template_fallback: Option<Dim<String>>,
+    #[serde(rename = "hoverlabel")]
+    hover_label: Option<Label>,
+    #[serde(rename = "uirevision")]
+    ui_revision: Option<NumOrString>,
+}
+
+impl<V> FunnelArea<V>
+where
+    V: Serialize + Clone,
+{
+    pub fn new(values: Vec<V>) -> Box<Self> {
+        Box::new(Self {
+            values: Some(values),
+            ..Default::default()
+        })
+    }
+}
+
+impl<V> Trace for FunnelArea<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 default_funnel_area() {
+        let trace: FunnelArea<i32> = FunnelArea::default();
+        assert_eq!(trace.to_json(), json!({"type": "funnelarea"}).to_string());
+    }
+
+    #[test]
+    fn serialize_title_position() {
+        assert_eq!(
+            to_value(FunnelAreaTitlePosition::TopLeft).unwrap(),
+            json!("top left")
+        );
+        assert_eq!(
+            to_value(FunnelAreaTitlePosition::TopCenter).unwrap(),
+            json!("top center")
+        );
+        assert_eq!(
+            to_value(FunnelAreaTitlePosition::TopRight).unwrap(),
+            json!("top right")
+        );
+    }
+
+    #[test]
+    fn serialize_funnel_area() {
+        let trace = FunnelArea::new(vec![5, 4, 3])
+            .labels(vec!["a", "b", "c"])
+            .label0(1.0)
+            .dlabel(2.0)
+            .name("funnelarea")
+            .visible(Visible::LegendOnly)
+            .show_legend(false)
+            .legend_group("group")
+            .legend_group_title("Group")
+            .legend_rank(10)
+            .legend_width(20.0)
+            .opacity(0.5)
+            .ids(vec!["i1", "i2", "i3"])
+            .custom_data(vec!["c1"])
+            .meta("meta")
+            .domain(Domain::new().column(1))
+            .aspect_ratio(1.5)
+            .base_ratio(0.2)
+            .scale_group("sg")
+            .marker(Marker::new())
+            .title(
+                FunnelAreaTitle::new()
+                    .text("Title")
+                    .position(FunnelAreaTitlePosition::TopLeft),
+            )
+            .text_array(vec!["t1", "t2", "t3"])
+            .text_info("label+percent")
+            .text_position(TextPosition::Inside)
+            .text_template("%{label}")
+            .text_template_fallback("-")
+            .text_font(Font::new())
+            .inside_text_font(Font::new())
+            .hover_text("hover")
+            .hover_info("label+value")
+            .hover_template("%{value}")
+            .hover_template_fallback("-")
+            .hover_label(Label::new())
+            .ui_revision(1);
+
+        let expected = json!({
+            "type": "funnelarea",
+            "values": [5, 4, 3],
+            "labels": ["a", "b", "c"],
+            "label0": 1.0,
+            "dlabel": 2.0,
+            "name": "funnelarea",
+            "visible": "legendonly",
+            "showlegend": false,
+            "legendgroup": "group",
+            "legendgrouptitle": {"text": "Group"},
+            "legendrank": 10,
+            "legendwidth": 20.0,
+            "opacity": 0.5,
+            "ids": ["i1", "i2", "i3"],
+            "customdata": ["c1"],
+            "meta": "meta",
+            "domain": {"column": 1},
+            "aspectratio": 1.5,
+            "baseratio": 0.2,
+            "scalegroup": "sg",
+            "marker": {},
+            "title": {"text": "Title", "position": "top left"},
+            "text": ["t1", "t2", "t3"],
+            "textinfo": "label+percent",
+            "textposition": "inside",
+            "texttemplate": "%{label}",
+            "texttemplatefallback": "-",
+            "textfont": {},
+            "insidetextfont": {},
+            "hovertext": "hover",
+            "hoverinfo": "label+value",
+            "hovertemplate": "%{value}",
+            "hovertemplatefallback": "-",
+            "hoverlabel": {},
+            "uirevision": 1,
+        });
+
+        assert_eq!(to_value(trace).unwrap(), expected);
+    }
+}
diff --git a/plotly/src/traces/histogram2d_contour.rs b/plotly/src/traces/histogram2d_contour.rs
new file mode 100644
index 00000000..4b551fae
--- /dev/null
+++ b/plotly/src/traces/histogram2d_contour.rs
@@ -0,0 +1,293 @@
+//! 2D histogram contour trace
+
+use plotly_derive::FieldSetter;
+use serde::Serialize;
+
+use crate::{
+    common::{
+        Calendar, ColorBar, ColorScale, Dim, Font, HoverInfo, Label, LegendGroupTitle, Line,
+        PlotType, Visible, XAxisId, YAxisId,
+    },
+    private::{NumOrString, NumOrStringCollection},
+    traces::contour::Contours,
+    traces::histogram::{Bins, HistFunc, HistNorm},
+    Trace,
+};
+
+/// Construct a 2D histogram contour trace.
+///
+/// A `Histogram2dContour` bins raw `x`/`y` samples into a 2D grid, like
+/// [`Histogram2d`](crate::Histogram2d), and renders the binned counts as
+/// contours instead of a heatmap. Contour levels are set with
+/// `auto_contour`/`n_contours` or explicitly via [`Contours`]. Provide raw
+/// `x`/`y` data and let Plotly.js bin it via `hist_func`/`n_bins_x`/`n_bins_y`/
+/// `x_bins`/`y_bins`. Optionally supply per-sample aggregation values via `z`
+/// (a 1D array aligned with `x`/`y`) and a `hist_func` such as
+/// [`HistFunc::Sum`] or [`HistFunc::Average`] to aggregate those values within
+/// each bin instead of counting samples.
+///
+/// Note: unlike [`HeatMap`](crate::HeatMap), `z` here is per-sample aggregation
+/// data aligned with `x`/`y`, not a pre-binned 2D matrix. For a pre-computed
+/// matrix, use [`HeatMap`](crate::HeatMap).
+///
+/// # Examples
+///
+/// ```
+/// use plotly::Histogram2dContour;
+///
+/// let trace = Histogram2dContour::new(vec![1.0, 2.0, 2.0], vec![1.0, 1.0, 3.0]);
+///
+/// let expected = serde_json::json!({
+///     "type": "histogram2dcontour",
+///     "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 Histogram2dContour<X, Y, Z>
+where
+    X: Serialize + Clone,
+    Y: Serialize + Clone,
+    Z: Serialize + Clone,
+{
+    #[field_setter(default = "PlotType::Histogram2dContour")]
+    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>,
+    ids: Option<Vec<String>>,
+    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>,
+    /// Traces sharing a `bingroup` (with matching axis types) share the same
+    /// x and y bin settings.
+    #[serde(rename = "bingroup")]
+    bin_group: Option<String>,
+    #[serde(rename = "xbingroup")]
+    x_bin_group: Option<String>,
+    #[serde(rename = "ybingroup")]
+    y_bin_group: Option<String>,
+    #[serde(rename = "coloraxis")]
+    color_axis: Option<String>,
+    #[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>,
+    /// Determines whether the contour levels are chosen automatically
+    /// (`true`) or set by `contours.start`/`end`/`size`.
+    #[serde(rename = "autocontour")]
+    auto_contour: Option<bool>,
+    /// Sets the maximum number of contour levels when `auto_contour` is
+    /// `true`.
+    #[serde(rename = "ncontours")]
+    n_contours: Option<usize>,
+    contours: Option<Contours>,
+    /// Sets the contour line color, dash, width and smoothing.
+    line: Option<Line>,
+    #[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> Histogram2dContour<X, Y, f64>
+where
+    X: Serialize + Clone,
+    Y: Serialize + Clone,
+{
+    /// Build a new 2D histogram contour 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> Histogram2dContour<X, Y, Z>
+where
+    X: Serialize + Clone,
+    Y: Serialize + Clone,
+    Z: Serialize + Clone,
+{
+    /// Build a new 2D histogram contour from raw `x`/`y` samples plus
+    /// per-sample aggregation values `z`. All three vectors are aligned
+    /// (one entry per sample); combine with a `hist_func` such as
+    /// [`HistFunc::Sum`] to aggregate the `z` values within each `x`/`y`
+    /// bin.
+    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 Histogram2dContour<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 default_histogram2d_contour() {
+        let trace: Histogram2dContour<f64, f64, f64> = Histogram2dContour::default();
+        assert_eq!(
+            to_value(trace).unwrap(),
+            json!({"type": "histogram2dcontour"})
+        );
+    }
+
+    #[test]
+    fn serialize_histogram2d_contour() {
+        let trace = Histogram2dContour::new_xyz(vec![1.0, 2.0], vec![3.0, 4.0], vec![5.0, 6.0])
+            .name("h2c")
+            .ids(vec!["i1", "i2"])
+            .bin_group("bg")
+            .x_bin_group("xbg")
+            .y_bin_group("ybg")
+            .color_axis("coloraxis2")
+            .hist_func(HistFunc::Sum)
+            .n_bins_x(10)
+            .n_bins_y(20)
+            .auto_contour(false)
+            .n_contours(5)
+            .contours(Contours::new().show_labels(true))
+            .line(Line::new().width(0.5))
+            .color_scale(ColorScale::Palette(ColorScalePalette::Blues))
+            .x_axis("x2")
+            .y_axis("y2");
+
+        let expected = json!({
+            "type": "histogram2dcontour",
+            "name": "h2c",
+            "ids": ["i1", "i2"],
+            "bingroup": "bg",
+            "xbingroup": "xbg",
+            "ybingroup": "ybg",
+            "coloraxis": "coloraxis2",
+            "x": [1.0, 2.0],
+            "y": [3.0, 4.0],
+            "z": [5.0, 6.0],
+            "histfunc": "sum",
+            "nbinsx": 10,
+            "nbinsy": 20,
+            "autocontour": false,
+            "ncontours": 5,
+            "contours": {"showlabels": true},
+            "line": {"width": 0.5},
+            "colorscale": "Blues",
+            "xaxis": "x2",
+            "yaxis": "y2",
+        });
+
+        assert_eq!(to_value(trace).unwrap(), expected);
+    }
+}
diff --git a/plotly/src/traces/image.rs b/plotly/src/traces/image.rs
index 81c8f38f..b65f7970 100644
--- a/plotly/src/traces/image.rs
+++ b/plotly/src/traces/image.rs
@@ -188,7 +188,7 @@ pub struct Image {
     visible: Option<Visible>,
 
     /// Sets the legend rank for this trace. Items and groups with smaller ranks
-    /// are presented on top/left side while with `"reversed"
+    /// 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
diff --git a/plotly/src/traces/isosurface.rs b/plotly/src/traces/isosurface.rs
new file mode 100644
index 00000000..2d39be8c
--- /dev/null
+++ b/plotly/src/traces/isosurface.rs
@@ -0,0 +1,418 @@
+//! Isosurface (3D volume isosurface) trace
+
+use plotly_derive::FieldSetter;
+use serde::Serialize;
+
+use crate::{
+    common::{ColorBar, ColorScale, Dim, Label, LegendGroupTitle, PlotType, Visible},
+    private::{NumOrString, NumOrStringCollection},
+    traces::mesh3d::{Contour, LightPosition, Lighting},
+    Trace,
+};
+
+/// Settings for the caps along one axis of an [`IsoSurface`] or
+/// [`Volume`](crate::Volume) trace.
+#[serde_with::skip_serializing_none]
+#[derive(Serialize, Clone, Debug, FieldSetter)]
+pub struct Cap {
+    /// Sets the fill ratio of the caps (between 0.0 and 1.0). The default
+    /// fill value of 1 makes the caps solid.
+    fill: Option<f64>,
+    /// Sets whether the caps are drawn along this axis.
+    show: Option<bool>,
+}
+
+impl Cap {
+    pub fn new() -> Self {
+        Default::default()
+    }
+}
+
+/// The caps (surfaces closing off the volume at the domain edges) of an
+/// [`IsoSurface`] or [`Volume`](crate::Volume) trace.
+#[serde_with::skip_serializing_none]
+#[derive(Serialize, Clone, Debug, FieldSetter)]
+pub struct Caps {
+    x: Option<Cap>,
+    y: Option<Cap>,
+    z: Option<Cap>,
+}
+
+impl Caps {
+    pub fn new() -> Self {
+        Default::default()
+    }
+}
+
+/// Slices along one axis of an [`IsoSurface`] or [`Volume`](crate::Volume)
+/// trace.
+#[serde_with::skip_serializing_none]
+#[derive(Serialize, Clone, Debug, FieldSetter)]
+pub struct Slice {
+    /// Sets the fill ratio of the slices (between 0.0 and 1.0).
+    fill: Option<f64>,
+    /// Specifies the locations of the slices on this axis. When unset,
+    /// slices are made at every point of the axis.
+    locations: Option<Vec<f64>>,
+    show: Option<bool>,
+}
+
+impl Slice {
+    pub fn new() -> Self {
+        Default::default()
+    }
+}
+
+/// Slices through an [`IsoSurface`] or [`Volume`](crate::Volume) trace.
+#[serde_with::skip_serializing_none]
+#[derive(Serialize, Clone, Debug, FieldSetter)]
+pub struct Slices {
+    x: Option<Slice>,
+    y: Option<Slice>,
+    z: Option<Slice>,
+}
+
+impl Slices {
+    pub fn new() -> Self {
+        Default::default()
+    }
+}
+
+/// The space frame (the volume between `isomin` and `isomax`, drawn as
+/// tetrahedra) of an [`IsoSurface`] or [`Volume`](crate::Volume) trace.
+#[serde_with::skip_serializing_none]
+#[derive(Serialize, Clone, Debug, FieldSetter)]
+pub struct SpaceFrame {
+    /// Sets the fill ratio of the space frame elements (between 0.0 and 1.0).
+    fill: Option<f64>,
+    show: Option<bool>,
+}
+
+impl SpaceFrame {
+    pub fn new() -> Self {
+        Default::default()
+    }
+}
+
+/// The isosurfaces of an [`IsoSurface`] or [`Volume`](crate::Volume) trace.
+#[serde_with::skip_serializing_none]
+#[derive(Serialize, Clone, Debug, FieldSetter)]
+pub struct IsoSurfaceSurface {
+    /// Sets the number of isosurfaces between `isomin` and `isomax`.
+    count: Option<usize>,
+    /// Sets the fill ratio of the isosurface (between 0.0 and 1.0).
+    fill: Option<f64>,
+    /// Sets the surface pattern of the isosurface 3-D sections: a flaglist of
+    /// `A`, `B`, `C`, `D`, `E` joined with `+`, or one of `all`, `odd`,
+    /// `even`.
+    pattern: Option<String>,
+    show: Option<bool>,
+}
+
+impl IsoSurfaceSurface {
+    pub fn new() -> Self {
+        Default::default()
+    }
+}
+
+/// Construct an isosurface trace: surfaces of constant `value` through a 3D
+/// volume sampled on the `(x, y, z)` grid, between `isomin` and `isomax`.
+///
+/// # Examples
+///
+/// ```
+/// use plotly::IsoSurface;
+///
+/// let trace = IsoSurface::new(
+///     vec![0, 0, 1, 1], vec![0, 1, 0, 1], vec![1, 1, 1, 1], vec![1.0, 2.0, 3.0, 4.0],
+/// )
+/// .iso_min(1.5)
+/// .iso_max(3.5);
+///
+/// let expected = serde_json::json!({
+///     "type": "isosurface",
+///     "x": [0, 0, 1, 1],
+///     "y": [0, 1, 0, 1],
+///     "z": [1, 1, 1, 1],
+///     "value": [1.0, 2.0, 3.0, 4.0],
+///     "isomin": 1.5,
+///     "isomax": 3.5,
+/// });
+///
+/// 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 IsoSurface<X, Y, Z, V>
+where
+    X: Serialize + Clone,
+    Y: Serialize + Clone,
+    Z: Serialize + Clone,
+    V: Serialize + Clone,
+{
+    #[field_setter(default = "PlotType::IsoSurface")]
+    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>,
+    #[serde(rename = "legendrank")]
+    legend_rank: Option<usize>,
+    #[serde(rename = "legendwidth")]
+    legend_width: Option<f64>,
+    opacity: Option<f64>,
+    ids: Option<Vec<String>>,
+    /// Sets the x coordinates of the vertices on the x axis.
+    x: Option<Vec<X>>,
+    /// Sets the y coordinates of the vertices on the y axis.
+    y: Option<Vec<Y>>,
+    /// Sets the z coordinates of the vertices on the z axis.
+    z: Option<Vec<Z>>,
+    /// Sets the 4th dimension (value) of the vertices.
+    value: Option<Vec<V>>,
+    /// Sets the minimum boundary for the iso-surface plot.
+    #[serde(rename = "isomin")]
+    iso_min: Option<f64>,
+    /// Sets the maximum boundary for the iso-surface plot.
+    #[serde(rename = "isomax")]
+    iso_max: Option<f64>,
+    surface: Option<IsoSurfaceSurface>,
+    caps: Option<Caps>,
+    slices: Option<Slices>,
+    #[serde(rename = "spaceframe")]
+    space_frame: Option<SpaceFrame>,
+    contour: Option<Contour>,
+    #[serde(rename = "flatshading")]
+    flat_shading: Option<bool>,
+    /// Sets a reference between this trace's 3D coordinate system and a 3D
+    /// scene, e.g. `"scene"` (the default) or `"scene2"`.
+    scene: Option<String>,
+    text: Option<Dim<String>>,
+    #[serde(rename = "hovertext")]
+    hover_text: Option<Dim<String>>,
+    /// Flaglist of `x`, `y`, `z`, `text`, `name` joined with `+`, or one of
+    /// `all`, `none`, `skip`.
+    #[serde(rename = "hoverinfo")]
+    hover_info: Option<String>,
+    #[serde(rename = "hovertemplate")]
+    hover_template: Option<Dim<String>>,
+    #[serde(rename = "hovertemplatefallback")]
+    hover_template_fallback: Option<Dim<String>>,
+    #[serde(rename = "hoverlabel")]
+    hover_label: Option<Label>,
+    #[serde(rename = "xhoverformat")]
+    x_hover_format: Option<String>,
+    #[serde(rename = "yhoverformat")]
+    y_hover_format: Option<String>,
+    #[serde(rename = "zhoverformat")]
+    z_hover_format: Option<String>,
+    #[serde(rename = "valuehoverformat")]
+    value_hover_format: Option<String>,
+    #[serde(rename = "coloraxis")]
+    color_axis: Option<String>,
+    #[serde(rename = "colorbar")]
+    color_bar: Option<ColorBar>,
+    #[serde(rename = "colorscale")]
+    color_scale: Option<ColorScale>,
+    #[serde(rename = "autocolorscale")]
+    auto_color_scale: Option<bool>,
+    #[serde(rename = "reversescale")]
+    reverse_scale: Option<bool>,
+    #[serde(rename = "showscale")]
+    show_scale: Option<bool>,
+    #[serde(rename = "cauto")]
+    c_auto: Option<bool>,
+    #[serde(rename = "cmin")]
+    c_min: Option<f64>,
+    #[serde(rename = "cmax")]
+    c_max: Option<f64>,
+    #[serde(rename = "cmid")]
+    c_mid: Option<f64>,
+    lighting: Option<Lighting>,
+    #[serde(rename = "lightposition")]
+    light_position: Option<LightPosition>,
+    meta: Option<NumOrString>,
+    #[serde(rename = "customdata")]
+    custom_data: Option<NumOrStringCollection>,
+    #[serde(rename = "uirevision")]
+    ui_revision: Option<NumOrString>,
+}
+
+impl<X, Y, Z, V> IsoSurface<X, Y, Z, V>
+where
+    X: Serialize + Clone,
+    Y: Serialize + Clone,
+    Z: Serialize + Clone,
+    V: Serialize + Clone,
+{
+    pub fn new(x: Vec<X>, y: Vec<Y>, z: Vec<Z>, value: Vec<V>) -> Box<Self> {
+        Box::new(Self {
+            x: Some(x),
+            y: Some(y),
+            z: Some(z),
+            value: Some(value),
+            ..Default::default()
+        })
+    }
+}
+
+impl<X, Y, Z, V> Trace for IsoSurface<X, Y, Z, V>
+where
+    X: Serialize + Clone,
+    Y: Serialize + Clone,
+    Z: Serialize + Clone,
+    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::*;
+    use crate::common::ColorScalePalette;
+
+    #[test]
+    fn serialize_sub_structs() {
+        let caps = Caps::new()
+            .x(Cap::new().fill(0.5).show(true))
+            .y(Cap::new().show(false))
+            .z(Cap::new());
+        assert_eq!(
+            to_value(caps).unwrap(),
+            json!({"x": {"fill": 0.5, "show": true}, "y": {"show": false}, "z": {}})
+        );
+
+        let slices = Slices::new()
+            .x(Slice::new().fill(1.0).locations(vec![0.5]).show(true))
+            .y(Slice::new())
+            .z(Slice::new());
+        assert_eq!(
+            to_value(slices).unwrap(),
+            json!({"x": {"fill": 1.0, "locations": [0.5], "show": true}, "y": {}, "z": {}})
+        );
+
+        let space_frame = SpaceFrame::new().fill(0.15).show(true);
+        assert_eq!(
+            to_value(space_frame).unwrap(),
+            json!({"fill": 0.15, "show": true})
+        );
+
+        let surface = IsoSurfaceSurface::new()
+            .count(3)
+            .fill(0.8)
+            .pattern("A+B")
+            .show(true);
+        assert_eq!(
+            to_value(surface).unwrap(),
+            json!({"count": 3, "fill": 0.8, "pattern": "A+B", "show": true})
+        );
+    }
+
+    #[test]
+    fn serialize_iso_surface() {
+        let trace = IsoSurface::new(vec![0], vec![1], vec![2], vec![3.0])
+            .name("iso")
+            .visible(Visible::True)
+            .show_legend(true)
+            .legend_group("g")
+            .legend_group_title("G")
+            .legend_rank(1)
+            .legend_width(2.0)
+            .opacity(0.6)
+            .ids(vec!["a"])
+            .iso_min(0.0)
+            .iso_max(5.0)
+            .surface(IsoSurfaceSurface::new().count(2))
+            .caps(Caps::new())
+            .slices(Slices::new())
+            .space_frame(SpaceFrame::new())
+            .contour(Contour::new().show(true))
+            .flat_shading(false)
+            .scene("scene3")
+            .text("t")
+            .hover_text("h")
+            .hover_info("x+y+z")
+            .hover_template("%{value}")
+            .hover_template_fallback("-")
+            .hover_label(Label::new())
+            .x_hover_format("a")
+            .y_hover_format("b")
+            .z_hover_format("c")
+            .value_hover_format("d")
+            .color_axis("coloraxis")
+            .color_bar(ColorBar::new())
+            .color_scale(ColorScale::Palette(ColorScalePalette::Blues))
+            .auto_color_scale(false)
+            .reverse_scale(true)
+            .show_scale(false)
+            .c_auto(false)
+            .c_min(0.0)
+            .c_max(5.0)
+            .c_mid(2.5)
+            .lighting(Lighting::new())
+            .light_position(LightPosition::new())
+            .meta("m")
+            .custom_data(vec!["cd"])
+            .ui_revision(1);
+
+        let expected = json!({
+            "type": "isosurface",
+            "name": "iso",
+            "visible": true,
+            "showlegend": true,
+            "legendgroup": "g",
+            "legendgrouptitle": {"text": "G"},
+            "legendrank": 1,
+            "legendwidth": 2.0,
+            "opacity": 0.6,
+            "ids": ["a"],
+            "x": [0], "y": [1], "z": [2],
+            "value": [3.0],
+            "isomin": 0.0,
+            "isomax": 5.0,
+            "surface": {"count": 2},
+            "caps": {},
+            "slices": {},
+            "spaceframe": {},
+            "contour": {"show": true},
+            "flatshading": false,
+            "scene": "scene3",
+            "text": "t",
+            "hovertext": "h",
+            "hoverinfo": "x+y+z",
+            "hovertemplate": "%{value}",
+            "hovertemplatefallback": "-",
+            "hoverlabel": {},
+            "xhoverformat": "a",
+            "yhoverformat": "b",
+            "zhoverformat": "c",
+            "valuehoverformat": "d",
+            "coloraxis": "coloraxis",
+            "colorbar": {},
+            "colorscale": "Blues",
+            "autocolorscale": false,
+            "reversescale": true,
+            "showscale": false,
+            "cauto": false,
+            "cmin": 0.0,
+            "cmax": 5.0,
+            "cmid": 2.5,
+            "lighting": {},
+            "lightposition": {},
+            "meta": "m",
+            "customdata": ["cd"],
+            "uirevision": 1,
+        });
+
+        assert_eq!(to_value(trace).unwrap(), expected);
+    }
+}
diff --git a/plotly/src/traces/mesh3d.rs b/plotly/src/traces/mesh3d.rs
index ed8541d2..08fff200 100644
--- a/plotly/src/traces/mesh3d.rs
+++ b/plotly/src/traces/mesh3d.rs
@@ -80,12 +80,12 @@ impl Lighting {
 #[serde_with::skip_serializing_none]
 #[derive(Serialize, Clone, Debug, FieldSetter)]
 pub struct LightPosition {
-    /// Numeric vector, representing the X coordinate for each vertex.
-    x: Option<Vec<f64>>,
-    /// Numeric vector, representing the Y coordinate for each vertex.
-    y: Option<Vec<f64>>,
-    /// Numeric vector, representing the Z coordinate for each vertex.
-    z: Option<Vec<f64>>,
+    /// X coordinate of the light source, between -1e5 and 1e5.
+    x: Option<f64>,
+    /// Y coordinate of the light source, between -1e5 and 1e5.
+    y: Option<f64>,
+    /// Z coordinate of the light source, between -1e5 and 1e5.
+    z: Option<f64>,
 }
 
 impl LightPosition {
@@ -118,7 +118,7 @@ where
     #[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"
+    /// 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
@@ -471,11 +471,8 @@ mod tests {
 
     #[test]
     fn serialize_light_position() {
-        let light_position = LightPosition::new()
-            .x(vec![10.0])
-            .y(vec![20.0])
-            .z(vec![30.0]);
-        let expected = json!({"x": [10.0], "y": [20.0], "z": [30.0]});
+        let light_position = LightPosition::new().x(10.0).y(20.0).z(30.0);
+        let expected = json!({"x": 10.0, "y": 20.0, "z": 30.0});
 
         assert_eq!(to_value(light_position).unwrap(), expected);
     }
diff --git a/plotly/src/traces/mod.rs b/plotly/src/traces/mod.rs
index b146b93a..2a4f2a04 100644
--- a/plotly/src/traces/mod.rs
+++ b/plotly/src/traces/mod.rs
@@ -1,70 +1,96 @@
 //! The various supported traces
 
 pub mod bar;
+pub mod bar_polar;
 pub mod box_plot;
 mod candlestick;
+pub mod carpet;
 pub mod choropleth;
 pub mod choropleth_map;
+pub mod cone;
 pub mod contour;
+pub mod contour_carpet;
 pub mod density_map;
 mod density_mapbox;
 pub mod funnel;
+pub mod funnel_area;
 pub mod heat_map;
 pub mod histogram;
 pub mod histogram2d;
+pub mod histogram2d_contour;
 pub mod icicle;
 pub mod image;
 pub mod indicator;
+pub mod isosurface;
 pub mod mesh3d;
 mod ohlc;
 pub mod parcats;
+pub mod parcoords;
 pub mod pie;
 pub mod sankey;
 pub mod scatter;
 pub mod scatter3d;
+pub mod scatter_carpet;
 pub mod scatter_geo;
 pub mod scatter_map;
 pub mod scatter_mapbox;
 mod scatter_polar;
+pub mod scatter_smith;
+pub mod scatter_ternary;
 pub mod splom;
+pub mod stream_tube;
 pub mod sunburst;
 pub mod surface;
 pub mod table;
 pub mod treemap;
 pub mod violin;
+pub mod volume;
 pub mod waterfall;
 
 pub use bar::Bar;
+pub use bar_polar::BarPolar;
 pub use box_plot::BoxPlot;
 pub use candlestick::Candlestick;
+pub use carpet::Carpet;
 pub use choropleth::Choropleth;
 pub use choropleth_map::ChoroplethMap;
+pub use cone::Cone;
 pub use contour::Contour;
+pub use contour_carpet::ContourCarpet;
 pub use density_map::DensityMap;
 pub use density_mapbox::DensityMapbox;
 pub use funnel::Funnel;
+pub use funnel_area::FunnelArea;
 pub use heat_map::HeatMap;
 pub use histogram::Histogram;
 pub use histogram2d::Histogram2d;
+pub use histogram2d_contour::Histogram2dContour;
 pub use icicle::Icicle;
 pub use indicator::Indicator;
+pub use isosurface::IsoSurface;
 pub use mesh3d::Mesh3D;
 pub use ohlc::Ohlc;
 pub use parcats::Parcats;
+pub use parcoords::Parcoords;
 pub use pie::Pie;
 pub use sankey::Sankey;
 pub use scatter::Scatter;
 pub use scatter3d::Scatter3D;
+pub use scatter_carpet::ScatterCarpet;
 pub use scatter_geo::ScatterGeo;
 pub use scatter_map::ScatterMap;
 pub use scatter_mapbox::ScatterMapbox;
 pub use scatter_polar::ScatterPolar;
+pub use scatter_smith::ScatterSmith;
+pub use scatter_ternary::ScatterTernary;
 pub use splom::Splom;
+pub use stream_tube::StreamTube;
 pub use sunburst::Sunburst;
 pub use surface::Surface;
 pub use table::Table;
 pub use treemap::Treemap;
 pub use violin::Violin;
+pub use volume::Volume;
 pub use waterfall::Waterfall;
 
 pub use self::image::Image;
diff --git a/plotly/src/traces/parcoords.rs b/plotly/src/traces/parcoords.rs
new file mode 100644
index 00000000..9f1422aa
--- /dev/null
+++ b/plotly/src/traces/parcoords.rs
@@ -0,0 +1,322 @@
+//! Parallel coordinates trace
+
+use plotly_derive::FieldSetter;
+use serde::Serialize;
+
+use crate::{
+    color::Color,
+    common::{ColorBar, ColorScale, Dim, Domain, Font, LegendGroupTitle, PlotType, Visible},
+    private::{NumOrString, NumOrStringCollection},
+    Trace,
+};
+
+/// Brushed selection on a [`Dimension`], in data units.
+#[derive(Serialize, Clone, Debug)]
+#[serde(untagged)]
+pub enum ConstraintRange {
+    /// A single `[min, max]` interval.
+    Single([f64; 2]),
+    /// Several `[min, max]` intervals (requires `multiselect`).
+    Multiple(Vec<[f64; 2]>),
+}
+
+#[derive(Serialize, Clone, Debug)]
+#[serde(rename_all = "lowercase")]
+pub enum LabelSide {
+    Top,
+    Bottom,
+}
+
+/// One vertical axis of a [`Parcoords`] trace.
+#[serde_with::skip_serializing_none]
+#[derive(Serialize, Clone, Debug, FieldSetter)]
+pub struct Dimension {
+    /// The values of this dimension, one per line.
+    values: Option<Vec<f64>>,
+    /// The axis label shown above (or below) the dimension.
+    label: Option<String>,
+    /// The domain range shown on the axis; defaults to the data extent.
+    range: Option<[f64; 2]>,
+    #[serde(rename = "constraintrange")]
+    constraint_range: Option<ConstraintRange>,
+    /// Whether several constraint ranges may be brushed on this dimension.
+    #[serde(rename = "multiselect")]
+    multi_select: Option<bool>,
+    #[serde(rename = "tickformat")]
+    tick_format: Option<String>,
+    #[serde(rename = "tickvals")]
+    tick_values: Option<Vec<f64>>,
+    #[serde(rename = "ticktext")]
+    tick_text: Option<Vec<String>>,
+    /// Shows the dimension when `true`, hides it when `false`.
+    visible: Option<bool>,
+    /// The item name used to refer to this dimension in a template.
+    name: Option<String>,
+    #[serde(rename = "templateitemname")]
+    template_item_name: Option<String>,
+}
+
+impl Dimension {
+    pub fn new() -> Self {
+        Default::default()
+    }
+}
+
+/// Lines of a [`Parcoords`] trace and their color scale.
+#[serde_with::skip_serializing_none]
+#[derive(Serialize, Clone, Debug, FieldSetter)]
+pub struct ParcoordsLine {
+    /// A single color, or one numeric value per line mapped through
+    /// `colorscale`.
+    color: Option<Dim<Box<dyn Color>>>,
+    #[serde(rename = "colorscale")]
+    color_scale: Option<ColorScale>,
+    #[serde(rename = "autocolorscale")]
+    auto_color_scale: Option<bool>,
+    #[serde(rename = "reversescale")]
+    reverse_scale: Option<bool>,
+    #[serde(rename = "showscale")]
+    show_scale: Option<bool>,
+    #[serde(rename = "colorbar")]
+    color_bar: Option<ColorBar>,
+    #[serde(rename = "coloraxis")]
+    color_axis: Option<String>,
+    #[serde(rename = "cauto")]
+    c_auto: Option<bool>,
+    #[serde(rename = "cmin")]
+    c_min: Option<f64>,
+    #[serde(rename = "cmax")]
+    c_max: Option<f64>,
+    #[serde(rename = "cmid")]
+    c_mid: Option<f64>,
+}
+
+impl ParcoordsLine {
+    pub fn new() -> Self {
+        Default::default()
+    }
+}
+
+/// Style of the lines outside the brushed constraint ranges.
+#[serde_with::skip_serializing_none]
+#[derive(Serialize, Clone, Debug, FieldSetter)]
+pub struct UnselectedLine {
+    color: Option<Box<dyn Color>>,
+    opacity: Option<f64>,
+}
+
+impl UnselectedLine {
+    pub fn new() -> Self {
+        Default::default()
+    }
+}
+
+#[serde_with::skip_serializing_none]
+#[derive(Serialize, Clone, Debug, FieldSetter)]
+pub struct Unselected {
+    line: Option<UnselectedLine>,
+}
+
+impl Unselected {
+    pub fn new() -> Self {
+        Default::default()
+    }
+}
+
+/// Construct a parallel coordinates trace: each row of data is drawn as a
+/// polyline across a set of vertical [`Dimension`] axes.
+///
+/// # Examples
+///
+/// ```
+/// use plotly::{parcoords::Dimension, Parcoords};
+///
+/// let trace = Parcoords::new(vec![
+///     Dimension::new().label("A").values(vec![1.0, 2.0]),
+///     Dimension::new().label("B").values(vec![3.0, 1.0]),
+/// ]);
+///
+/// let expected = serde_json::json!({
+///     "type": "parcoords",
+///     "dimensions": [
+///         {"label": "A", "values": [1.0, 2.0]},
+///         {"label": "B", "values": [3.0, 1.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 Parcoords {
+    #[field_setter(default = "PlotType::Parcoords")]
+    r#type: PlotType,
+    name: Option<String>,
+    visible: Option<Visible>,
+    #[serde(rename = "legendgrouptitle")]
+    legend_group_title: Option<LegendGroupTitle>,
+    #[serde(rename = "legendrank")]
+    legend_rank: Option<usize>,
+    #[serde(rename = "legendwidth")]
+    legend_width: Option<f64>,
+    ids: Option<Vec<String>>,
+    dimensions: Option<Vec<Dimension>>,
+    line: Option<ParcoordsLine>,
+    unselected: Option<Unselected>,
+    domain: Option<Domain>,
+    /// Sets the angle of the dimension labels, in degrees.
+    #[serde(rename = "labelangle")]
+    label_angle: Option<f64>,
+    #[serde(rename = "labelside")]
+    label_side: Option<LabelSide>,
+    #[serde(rename = "labelfont")]
+    label_font: Option<Font>,
+    #[serde(rename = "rangefont")]
+    range_font: Option<Font>,
+    #[serde(rename = "tickfont")]
+    tick_font: Option<Font>,
+    meta: Option<NumOrString>,
+    #[serde(rename = "customdata")]
+    custom_data: Option<NumOrStringCollection>,
+    #[serde(rename = "uirevision")]
+    ui_revision: Option<NumOrString>,
+}
+
+impl Parcoords {
+    pub fn new(dimensions: Vec<Dimension>) -> Box<Self> {
+        Box::new(Self {
+            dimensions: Some(dimensions),
+            ..Default::default()
+        })
+    }
+}
+
+impl Trace for Parcoords {
+    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_constraint_range() {
+        assert_eq!(
+            to_value(ConstraintRange::Single([1.0, 2.0])).unwrap(),
+            json!([1.0, 2.0])
+        );
+        assert_eq!(
+            to_value(ConstraintRange::Multiple(vec![[1.0, 2.0], [4.0, 5.0]])).unwrap(),
+            json!([[1.0, 2.0], [4.0, 5.0]])
+        );
+    }
+
+    #[test]
+    fn serialize_dimension() {
+        let dimension = Dimension::new()
+            .values(vec![1.0, 2.0])
+            .label("A")
+            .range([0.0, 10.0])
+            .constraint_range(ConstraintRange::Single([1.0, 2.0]))
+            .multi_select(false)
+            .tick_format(".1f")
+            .tick_values(vec![0.0, 5.0])
+            .tick_text(vec!["zero", "five"])
+            .visible(true)
+            .name("a")
+            .template_item_name("tmpl");
+
+        let expected = json!({
+            "values": [1.0, 2.0],
+            "label": "A",
+            "range": [0.0, 10.0],
+            "constraintrange": [1.0, 2.0],
+            "multiselect": false,
+            "tickformat": ".1f",
+            "tickvals": [0.0, 5.0],
+            "ticktext": ["zero", "five"],
+            "visible": true,
+            "name": "a",
+            "templateitemname": "tmpl",
+        });
+
+        assert_eq!(to_value(dimension).unwrap(), expected);
+    }
+
+    #[test]
+    fn serialize_parcoords() {
+        let trace = Parcoords::new(vec![Dimension::new()])
+            .name("pc")
+            .visible(Visible::True)
+            .legend_group_title("G")
+            .legend_rank(1)
+            .legend_width(2.0)
+            .ids(vec!["a"])
+            .line(
+                ParcoordsLine::new()
+                    .color_array(vec![1.0, 2.0])
+                    .color_scale(ColorScale::Palette(ColorScalePalette::Viridis))
+                    .auto_color_scale(false)
+                    .reverse_scale(true)
+                    .show_scale(true)
+                    .color_bar(ColorBar::new())
+                    .color_axis("coloraxis")
+                    .c_auto(false)
+                    .c_min(1.0)
+                    .c_max(2.0)
+                    .c_mid(1.5),
+            )
+            .unselected(Unselected::new().line(UnselectedLine::new().color("#aaa").opacity(0.2)))
+            .domain(Domain::new().row(1))
+            .label_angle(30.0)
+            .label_side(LabelSide::Bottom)
+            .label_font(Font::new())
+            .range_font(Font::new())
+            .tick_font(Font::new())
+            .meta("m")
+            .custom_data(vec!["cd"])
+            .ui_revision(1);
+
+        let expected = json!({
+            "type": "parcoords",
+            "name": "pc",
+            "visible": true,
+            "legendgrouptitle": {"text": "G"},
+            "legendrank": 1,
+            "legendwidth": 2.0,
+            "ids": ["a"],
+            "dimensions": [{}],
+            "line": {
+                "color": [1.0, 2.0],
+                "colorscale": "Viridis",
+                "autocolorscale": false,
+                "reversescale": true,
+                "showscale": true,
+                "colorbar": {},
+                "coloraxis": "coloraxis",
+                "cauto": false,
+                "cmin": 1.0,
+                "cmax": 2.0,
+                "cmid": 1.5,
+            },
+            "unselected": {"line": {"color": "#aaa", "opacity": 0.2}},
+            "domain": {"row": 1},
+            "labelangle": 30.0,
+            "labelside": "bottom",
+            "labelfont": {},
+            "rangefont": {},
+            "tickfont": {},
+            "meta": "m",
+            "customdata": ["cd"],
+            "uirevision": 1,
+        });
+
+        assert_eq!(to_value(trace).unwrap(), expected);
+    }
+}
diff --git a/plotly/src/traces/pie.rs b/plotly/src/traces/pie.rs
index ea7b6c11..c863ba79 100644
--- a/plotly/src/traces/pie.rs
+++ b/plotly/src/traces/pie.rs
@@ -38,9 +38,9 @@ pub enum PieDirection {
 /// # Using only labels
 ///
 /// Build a new Pie Chart by only assigning the labels field. The Pie chart
-/// will be generated by counting the number of unique labels, see [Pie::labels]
-/// field description. Note that to create a Pie chart by using this
-/// function, the type parameter `P` needs to be specialized, this can be
+/// will be generated by counting the number of unique labels, see
+/// [`Pie::labels`] field description. Note that to create a Pie chart by using
+/// this function, the type parameter `P` needs to be specialized, this can be
 /// done by doing
 ///
 /// ```
@@ -316,7 +316,7 @@ where
         })
     }
 
-    /// Same as [Pie::new()]
+    /// Same as [`Pie::new()`]
     pub fn from_values(values: Vec<P>) -> Box<Self> {
         Box::new(Self {
             values: Some(values),
@@ -326,7 +326,7 @@ where
 
     /// Build a new Pie Chart by only assigning the labels field. The Pie chart
     /// will be generated by counting the number of unique labels, see
-    /// [Pie::labels] field description. Note that to create a Pie chart by
+    /// [`Pie::labels`] field description. Note that to create a Pie chart by
     /// using this function, the type parameter `P` needs to be specialized,
     /// this can be done by doing
     /// ```
diff --git a/plotly/src/traces/sankey.rs b/plotly/src/traces/sankey.rs
index 9b2633c3..4b6816ea 100644
--- a/plotly/src/traces/sankey.rs
+++ b/plotly/src/traces/sankey.rs
@@ -183,7 +183,7 @@ where
     #[serde(rename = "legendgrouptitle")]
     legend_group_title: Option<LegendGroupTitle>,
     /// Sets the legend rank for this trace. Items and groups with smaller ranks
-    /// are presented on top/left side while with `"reversed"
+    /// 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
diff --git a/plotly/src/traces/scatter3d.rs b/plotly/src/traces/scatter3d.rs
index e5aaae44..69cc9bb9 100644
--- a/plotly/src/traces/scatter3d.rs
+++ b/plotly/src/traces/scatter3d.rs
@@ -1,4 +1,4 @@
-//! Scatter3D plot
+//! `Scatter3D` plot
 
 #[cfg(feature = "plotly_ndarray")]
 use ndarray::{Array, Ix1};
@@ -105,7 +105,7 @@ where
     #[serde(rename = "legendgroup")]
     legend_group: Option<String>,
     /// Sets the legend rank for this trace. Items and groups with smaller ranks
-    /// are presented on top/left side while with `"reversed"
+    /// are presented on top/left side while with `"reversed"`
     /// `legend.traceorder` 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
diff --git a/plotly/src/traces/scatter_carpet.rs b/plotly/src/traces/scatter_carpet.rs
new file mode 100644
index 00000000..b59e4d21
--- /dev/null
+++ b/plotly/src/traces/scatter_carpet.rs
@@ -0,0 +1,233 @@
+//! Carpet scatter trace
+
+use plotly_derive::FieldSetter;
+use serde::Serialize;
+
+use crate::{
+    color::Color,
+    common::{
+        Dim, Fill, Font, HoverOn, Label, LegendGroupTitle, Line, Marker, Mode, PlotType, Position,
+        Selection, Visible, XAxisId, YAxisId,
+    },
+    private::{NumOrString, NumOrStringCollection},
+    Trace,
+};
+
+/// Construct a scatter trace on a [`Carpet`](crate::Carpet): each point is
+/// placed by its `a` and `b` carpet coordinates. The carpet is selected by its
+/// [`carpet`](ScatterCarpet::carpet) id.
+///
+/// # Examples
+///
+/// ```
+/// use plotly::{common::Mode, ScatterCarpet};
+///
+/// let trace = ScatterCarpet::new(vec![4.0, 4.5], vec![1.5, 2.5])
+///     .carpet("c1")
+///     .mode(Mode::Markers);
+///
+/// let expected = serde_json::json!({
+///     "type": "scattercarpet",
+///     "a": [4.0, 4.5],
+///     "b": [1.5, 2.5],
+///     "carpet": "c1",
+///     "mode": "markers",
+/// });
+///
+/// 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 ScatterCarpet<A, B>
+where
+    A: Serialize + Clone,
+    B: Serialize + Clone,
+{
+    #[field_setter(default = "PlotType::ScatterCarpet")]
+    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>,
+    #[serde(rename = "legendrank")]
+    legend_rank: Option<usize>,
+    #[serde(rename = "legendwidth")]
+    legend_width: Option<f64>,
+    opacity: Option<f64>,
+    mode: Option<Mode>,
+    ids: Option<Vec<String>>,
+    /// Sets the `a`-axis coordinates.
+    a: Option<Vec<A>>,
+    /// Sets the `b`-axis coordinates.
+    b: Option<Vec<B>>,
+    /// The [`carpet`](crate::Carpet::carpet) id of the carpet this trace lies
+    /// on. If omitted, the first carpet is used.
+    carpet: Option<String>,
+    #[serde(rename = "xaxis")]
+    x_axis: Option<XAxisId>,
+    #[serde(rename = "yaxis")]
+    y_axis: Option<YAxisId>,
+    /// Sets the layer on which this trace is displayed, relative to other
+    /// SVG traces on the same subplot.
+    #[serde(rename = "zorder")]
+    z_order: Option<i32>,
+    text: Option<Dim<String>>,
+    #[serde(rename = "textposition")]
+    text_position: Option<Dim<Position>>,
+    #[serde(rename = "texttemplate")]
+    text_template: Option<Dim<String>>,
+    #[serde(rename = "texttemplatefallback")]
+    text_template_fallback: Option<Dim<String>>,
+    #[serde(rename = "textfont")]
+    text_font: Option<Font>,
+    #[serde(rename = "hovertext")]
+    hover_text: Option<Dim<String>>,
+    /// Flaglist of `a`, `b`, `text`, `name` joined with `+`, or one of
+    /// `all`, `none`, `skip`.
+    #[serde(rename = "hoverinfo")]
+    hover_info: Option<String>,
+    #[serde(rename = "hovertemplate")]
+    hover_template: Option<Dim<String>>,
+    #[serde(rename = "hovertemplatefallback")]
+    hover_template_fallback: Option<Dim<String>>,
+    #[serde(rename = "hoverlabel")]
+    hover_label: Option<Label>,
+    #[serde(rename = "hoveron")]
+    hover_on: Option<HoverOn>,
+    marker: Option<Marker>,
+    line: Option<Line>,
+    #[serde(rename = "connectgaps")]
+    connect_gaps: Option<bool>,
+    fill: Option<Fill>,
+    #[serde(rename = "fillcolor")]
+    fill_color: Option<Box<dyn Color>>,
+    selected: Option<Selection>,
+    unselected: Option<Selection>,
+    #[serde(rename = "selectedpoints")]
+    selected_points: Option<Vec<u32>>,
+    meta: Option<NumOrString>,
+    #[serde(rename = "customdata")]
+    custom_data: Option<NumOrStringCollection>,
+    #[serde(rename = "uirevision")]
+    ui_revision: Option<NumOrString>,
+}
+
+impl<A, B> ScatterCarpet<A, B>
+where
+    A: Serialize + Clone,
+    B: Serialize + Clone,
+{
+    pub fn new(a: Vec<A>, b: Vec<B>) -> Box<Self> {
+        Box::new(Self {
+            a: Some(a),
+            b: Some(b),
+            ..Default::default()
+        })
+    }
+}
+
+impl<A, B> Trace for ScatterCarpet<A, B>
+where
+    A: Serialize + Clone,
+    B: 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_scatter_carpet() {
+        let trace = ScatterCarpet::new(vec![1], vec![2])
+            .name("t")
+            .visible(Visible::True)
+            .show_legend(true)
+            .legend_group("g")
+            .legend_group_title("G")
+            .legend_rank(1)
+            .legend_width(2.0)
+            .opacity(0.5)
+            .mode(Mode::LinesMarkersText)
+            .ids(vec!["i"])
+            .carpet("c1")
+            .x_axis("x2")
+            .y_axis("y2")
+            .z_order(1)
+            .text("text")
+            .text_position(Position::TopCenter)
+            .text_template("%{a}")
+            .text_template_fallback("-")
+            .text_font(Font::new())
+            .hover_text("h")
+            .hover_info("a+b")
+            .hover_template("%{b}")
+            .hover_template_fallback("-")
+            .hover_label(Label::new())
+            .hover_on(HoverOn::Points)
+            .marker(Marker::new())
+            .line(Line::new())
+            .connect_gaps(true)
+            .fill(Fill::ToSelf)
+            .fill_color("#123456")
+            .selected(Selection::new())
+            .unselected(Selection::new())
+            .selected_points(vec![0])
+            .meta("m")
+            .custom_data(vec!["cd"])
+            .ui_revision(1);
+
+        let expected = json!({
+            "type": "scattercarpet",
+            "name": "t",
+            "visible": true,
+            "showlegend": true,
+            "legendgroup": "g",
+            "legendgrouptitle": {"text": "G"},
+            "legendrank": 1,
+            "legendwidth": 2.0,
+            "opacity": 0.5,
+            "mode": "lines+markers+text",
+            "ids": ["i"],
+            "a": [1], "b": [2],
+            "carpet": "c1",
+            "xaxis": "x2",
+            "yaxis": "y2",
+            "zorder": 1,
+            "text": "text",
+            "textposition": "top center",
+            "texttemplate": "%{a}",
+            "texttemplatefallback": "-",
+            "textfont": {},
+            "hovertext": "h",
+            "hoverinfo": "a+b",
+            "hovertemplate": "%{b}",
+            "hovertemplatefallback": "-",
+            "hoverlabel": {},
+            "hoveron": "points",
+            "marker": {},
+            "line": {},
+            "connectgaps": true,
+            "fill": "toself",
+            "fillcolor": "#123456",
+            "selected": {"marker": {}},
+            "unselected": {"marker": {}},
+            "selectedpoints": [0],
+            "meta": "m",
+            "customdata": ["cd"],
+            "uirevision": 1,
+        });
+
+        assert_eq!(to_value(trace).unwrap(), expected);
+    }
+}
diff --git a/plotly/src/traces/scatter_geo.rs b/plotly/src/traces/scatter_geo.rs
index 0a0dc1ec..dd8f766c 100644
--- a/plotly/src/traces/scatter_geo.rs
+++ b/plotly/src/traces/scatter_geo.rs
@@ -45,7 +45,7 @@ where
     #[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"
+    /// 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
diff --git a/plotly/src/traces/scatter_map.rs b/plotly/src/traces/scatter_map.rs
index b63c1386..0ff864f5 100644
--- a/plotly/src/traces/scatter_map.rs
+++ b/plotly/src/traces/scatter_map.rs
@@ -109,7 +109,7 @@ where
     #[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"
+    /// 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
diff --git a/plotly/src/traces/scatter_mapbox.rs b/plotly/src/traces/scatter_mapbox.rs
index 8a7f5d4c..1d59dfab 100644
--- a/plotly/src/traces/scatter_mapbox.rs
+++ b/plotly/src/traces/scatter_mapbox.rs
@@ -45,7 +45,7 @@ where
     #[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"
+    /// 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
diff --git a/plotly/src/traces/scatter_smith.rs b/plotly/src/traces/scatter_smith.rs
new file mode 100644
index 00000000..4eede380
--- /dev/null
+++ b/plotly/src/traces/scatter_smith.rs
@@ -0,0 +1,222 @@
+//! Smith chart scatter trace
+
+use plotly_derive::FieldSetter;
+use serde::Serialize;
+
+use crate::{
+    color::Color,
+    common::{
+        Dim, Fill, Font, HoverOn, Label, LegendGroupTitle, Line, Marker, Mode, PlotType, Position,
+        Selection, Visible,
+    },
+    private::{NumOrString, NumOrStringCollection},
+    Trace,
+};
+
+/// Construct a scatter trace on a Smith chart subplot, typically used to plot
+/// normalized impedances given by their `real` and `imag` parts.
+///
+/// # Examples
+///
+/// ```
+/// use plotly::{common::Mode, ScatterSmith};
+///
+/// let trace = ScatterSmith::new(vec![0.5, 1.0, 2.0], vec![0.5, -1.0, 0.0])
+///     .mode(Mode::LinesMarkers);
+///
+/// let expected = serde_json::json!({
+///     "type": "scattersmith",
+///     "real": [0.5, 1.0, 2.0],
+///     "imag": [0.5, -1.0, 0.0],
+///     "mode": "lines+markers",
+/// });
+///
+/// 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 ScatterSmith<Re, Im>
+where
+    Re: Serialize + Clone,
+    Im: Serialize + Clone,
+{
+    #[field_setter(default = "PlotType::ScatterSmith")]
+    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>,
+    #[serde(rename = "legendrank")]
+    legend_rank: Option<usize>,
+    #[serde(rename = "legendwidth")]
+    legend_width: Option<f64>,
+    opacity: Option<f64>,
+    mode: Option<Mode>,
+    ids: Option<Vec<String>>,
+    /// Sets the real component of the data, in units of normalized impedance
+    /// such that real=1, imag=0 is the center of the chart.
+    real: Option<Vec<Re>>,
+    /// Sets the imaginary component of the data, in units of normalized
+    /// impedance such that real=1, imag=0 is the center of the chart.
+    imag: Option<Vec<Im>>,
+    /// Sets a reference between this trace's data coordinates and a Smith
+    /// subplot, e.g. `"smith"` (the default) or `"smith2"`.
+    subplot: Option<String>,
+    text: Option<Dim<String>>,
+    #[serde(rename = "textposition")]
+    text_position: Option<Dim<Position>>,
+    #[serde(rename = "texttemplate")]
+    text_template: Option<Dim<String>>,
+    #[serde(rename = "texttemplatefallback")]
+    text_template_fallback: Option<Dim<String>>,
+    #[serde(rename = "textfont")]
+    text_font: Option<Font>,
+    #[serde(rename = "hovertext")]
+    hover_text: Option<Dim<String>>,
+    /// Flaglist of `real`, `imag`, `text`, `name` joined with `+`, or one of
+    /// `all`, `none`, `skip`.
+    #[serde(rename = "hoverinfo")]
+    hover_info: Option<String>,
+    #[serde(rename = "hovertemplate")]
+    hover_template: Option<Dim<String>>,
+    #[serde(rename = "hovertemplatefallback")]
+    hover_template_fallback: Option<Dim<String>>,
+    #[serde(rename = "hoverlabel")]
+    hover_label: Option<Label>,
+    #[serde(rename = "hoveron")]
+    hover_on: Option<HoverOn>,
+    marker: Option<Marker>,
+    line: Option<Line>,
+    #[serde(rename = "connectgaps")]
+    connect_gaps: Option<bool>,
+    #[serde(rename = "cliponaxis")]
+    clip_on_axis: Option<bool>,
+    fill: Option<Fill>,
+    #[serde(rename = "fillcolor")]
+    fill_color: Option<Box<dyn Color>>,
+    selected: Option<Selection>,
+    unselected: Option<Selection>,
+    #[serde(rename = "selectedpoints")]
+    selected_points: Option<Vec<u32>>,
+    meta: Option<NumOrString>,
+    #[serde(rename = "customdata")]
+    custom_data: Option<NumOrStringCollection>,
+    #[serde(rename = "uirevision")]
+    ui_revision: Option<NumOrString>,
+}
+
+impl<Re, Im> ScatterSmith<Re, Im>
+where
+    Re: Serialize + Clone,
+    Im: Serialize + Clone,
+{
+    pub fn new(real: Vec<Re>, imag: Vec<Im>) -> Box<Self> {
+        Box::new(Self {
+            real: Some(real),
+            imag: Some(imag),
+            ..Default::default()
+        })
+    }
+}
+
+impl<Re, Im> Trace for ScatterSmith<Re, Im>
+where
+    Re: Serialize + Clone,
+    Im: 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_scatter_smith() {
+        let trace = ScatterSmith::new(vec![1], vec![2])
+            .name("t")
+            .visible(Visible::True)
+            .show_legend(true)
+            .legend_group("g")
+            .legend_group_title("G")
+            .legend_rank(1)
+            .legend_width(2.0)
+            .opacity(0.5)
+            .mode(Mode::LinesMarkersText)
+            .ids(vec!["i"])
+            .subplot("smith2")
+            .text("text")
+            .text_position(Position::TopCenter)
+            .text_template("%{a}")
+            .text_template_fallback("-")
+            .text_font(Font::new())
+            .hover_text("h")
+            .hover_info("real+imag")
+            .hover_template("%{b}")
+            .hover_template_fallback("-")
+            .hover_label(Label::new())
+            .hover_on(HoverOn::Points)
+            .marker(Marker::new())
+            .line(Line::new())
+            .connect_gaps(true)
+            .clip_on_axis(false)
+            .fill(Fill::ToSelf)
+            .fill_color("#123456")
+            .selected(Selection::new())
+            .unselected(Selection::new())
+            .selected_points(vec![0])
+            .meta("m")
+            .custom_data(vec!["cd"])
+            .ui_revision(1);
+
+        let expected = json!({
+            "type": "scattersmith",
+            "name": "t",
+            "visible": true,
+            "showlegend": true,
+            "legendgroup": "g",
+            "legendgrouptitle": {"text": "G"},
+            "legendrank": 1,
+            "legendwidth": 2.0,
+            "opacity": 0.5,
+            "mode": "lines+markers+text",
+            "ids": ["i"],
+            "real": [1], "imag": [2],
+            "subplot": "smith2",
+            "text": "text",
+            "textposition": "top center",
+            "texttemplate": "%{a}",
+            "texttemplatefallback": "-",
+            "textfont": {},
+            "hovertext": "h",
+            "hoverinfo": "real+imag",
+            "hovertemplate": "%{b}",
+            "hovertemplatefallback": "-",
+            "hoverlabel": {},
+            "hoveron": "points",
+            "marker": {},
+            "line": {},
+            "connectgaps": true,
+            "cliponaxis": false,
+            "fill": "toself",
+            "fillcolor": "#123456",
+            "selected": {"marker": {}},
+            "unselected": {"marker": {}},
+            "selectedpoints": [0],
+            "meta": "m",
+            "customdata": ["cd"],
+            "uirevision": 1,
+        });
+
+        assert_eq!(to_value(trace).unwrap(), expected);
+    }
+}
diff --git a/plotly/src/traces/scatter_ternary.rs b/plotly/src/traces/scatter_ternary.rs
new file mode 100644
index 00000000..4c58936a
--- /dev/null
+++ b/plotly/src/traces/scatter_ternary.rs
@@ -0,0 +1,233 @@
+//! Ternary scatter trace
+
+use plotly_derive::FieldSetter;
+use serde::Serialize;
+
+use crate::{
+    color::Color,
+    common::{
+        Dim, Fill, Font, HoverOn, Label, LegendGroupTitle, Line, Marker, Mode, PlotType, Position,
+        Selection, Visible,
+    },
+    private::{NumOrString, NumOrStringCollection},
+    Trace,
+};
+
+/// Construct a scatter trace on a ternary subplot. Each point is given by
+/// its `a`, `b` and `c` components, which are normalized to add up to `sum`
+/// (or to [`LayoutTernary::sum`](crate::layout::LayoutTernary::sum)).
+///
+/// # Examples
+///
+/// ```
+/// use plotly::{common::Mode, ScatterTernary};
+///
+/// let trace = ScatterTernary::new(vec![0.2, 0.5], vec![0.3, 0.25], vec![0.5, 0.25])
+///     .mode(Mode::Markers);
+///
+/// let expected = serde_json::json!({
+///     "type": "scatterternary",
+///     "a": [0.2, 0.5],
+///     "b": [0.3, 0.25],
+///     "c": [0.5, 0.25],
+///     "mode": "markers",
+/// });
+///
+/// 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 ScatterTernary<A, B, C>
+where
+    A: Serialize + Clone,
+    B: Serialize + Clone,
+    C: Serialize + Clone,
+{
+    #[field_setter(default = "PlotType::ScatterTernary")]
+    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>,
+    #[serde(rename = "legendrank")]
+    legend_rank: Option<usize>,
+    #[serde(rename = "legendwidth")]
+    legend_width: Option<f64>,
+    opacity: Option<f64>,
+    mode: Option<Mode>,
+    ids: Option<Vec<String>>,
+    /// Sets the quantity of component `a` in each data point.
+    a: Option<Vec<A>>,
+    /// Sets the quantity of component `b` in each data point.
+    b: Option<Vec<B>>,
+    /// Sets the quantity of component `c` in each data point.
+    c: Option<Vec<C>>,
+    /// The number each triplet should add up to. If unset (or 0), the
+    /// subplot's `sum` is used.
+    sum: Option<f64>,
+    /// Sets a reference between this trace's data coordinates and a ternary
+    /// subplot, e.g. `"ternary"` (the default) or `"ternary2"`.
+    subplot: Option<String>,
+    text: Option<Dim<String>>,
+    #[serde(rename = "textposition")]
+    text_position: Option<Dim<Position>>,
+    #[serde(rename = "texttemplate")]
+    text_template: Option<Dim<String>>,
+    #[serde(rename = "texttemplatefallback")]
+    text_template_fallback: Option<Dim<String>>,
+    #[serde(rename = "textfont")]
+    text_font: Option<Font>,
+    #[serde(rename = "hovertext")]
+    hover_text: Option<Dim<String>>,
+    /// Flaglist of `a`, `b`, `c`, `text`, `name` joined with `+`, or one of
+    /// `all`, `none`, `skip`.
+    #[serde(rename = "hoverinfo")]
+    hover_info: Option<String>,
+    #[serde(rename = "hovertemplate")]
+    hover_template: Option<Dim<String>>,
+    #[serde(rename = "hovertemplatefallback")]
+    hover_template_fallback: Option<Dim<String>>,
+    #[serde(rename = "hoverlabel")]
+    hover_label: Option<Label>,
+    #[serde(rename = "hoveron")]
+    hover_on: Option<HoverOn>,
+    marker: Option<Marker>,
+    line: Option<Line>,
+    #[serde(rename = "connectgaps")]
+    connect_gaps: Option<bool>,
+    #[serde(rename = "cliponaxis")]
+    clip_on_axis: Option<bool>,
+    fill: Option<Fill>,
+    #[serde(rename = "fillcolor")]
+    fill_color: Option<Box<dyn Color>>,
+    selected: Option<Selection>,
+    unselected: Option<Selection>,
+    #[serde(rename = "selectedpoints")]
+    selected_points: Option<Vec<u32>>,
+    meta: Option<NumOrString>,
+    #[serde(rename = "customdata")]
+    custom_data: Option<NumOrStringCollection>,
+    #[serde(rename = "uirevision")]
+    ui_revision: Option<NumOrString>,
+}
+
+impl<A, B, C> ScatterTernary<A, B, C>
+where
+    A: Serialize + Clone,
+    B: Serialize + Clone,
+    C: Serialize + Clone,
+{
+    pub fn new(a: Vec<A>, b: Vec<B>, c: Vec<C>) -> Box<Self> {
+        Box::new(Self {
+            a: Some(a),
+            b: Some(b),
+            c: Some(c),
+            ..Default::default()
+        })
+    }
+}
+
+impl<A, B, C> Trace for ScatterTernary<A, B, C>
+where
+    A: Serialize + Clone,
+    B: Serialize + Clone,
+    C: 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_scatter_ternary() {
+        let trace = ScatterTernary::new(vec![1], vec![2], vec![3])
+            .name("t")
+            .visible(Visible::True)
+            .show_legend(true)
+            .legend_group("g")
+            .legend_group_title("G")
+            .legend_rank(1)
+            .legend_width(2.0)
+            .opacity(0.5)
+            .mode(Mode::LinesMarkersText)
+            .ids(vec!["i"])
+            .sum(100.0)
+            .subplot("ternary2")
+            .text("text")
+            .text_position(Position::TopCenter)
+            .text_template("%{a}")
+            .text_template_fallback("-")
+            .text_font(Font::new())
+            .hover_text("h")
+            .hover_info("a+b+c")
+            .hover_template("%{b}")
+            .hover_template_fallback("-")
+            .hover_label(Label::new())
+            .hover_on(HoverOn::Points)
+            .marker(Marker::new())
+            .line(Line::new())
+            .connect_gaps(true)
+            .clip_on_axis(false)
+            .fill(Fill::ToSelf)
+            .fill_color("#123456")
+            .selected(Selection::new())
+            .unselected(Selection::new())
+            .selected_points(vec![0])
+            .meta("m")
+            .custom_data(vec!["cd"])
+            .ui_revision(1);
+
+        let expected = json!({
+            "type": "scatterternary",
+            "name": "t",
+            "visible": true,
+            "showlegend": true,
+            "legendgroup": "g",
+            "legendgrouptitle": {"text": "G"},
+            "legendrank": 1,
+            "legendwidth": 2.0,
+            "opacity": 0.5,
+            "mode": "lines+markers+text",
+            "ids": ["i"],
+            "a": [1], "b": [2], "c": [3],
+            "sum": 100.0,
+            "subplot": "ternary2",
+            "text": "text",
+            "textposition": "top center",
+            "texttemplate": "%{a}",
+            "texttemplatefallback": "-",
+            "textfont": {},
+            "hovertext": "h",
+            "hoverinfo": "a+b+c",
+            "hovertemplate": "%{b}",
+            "hovertemplatefallback": "-",
+            "hoverlabel": {},
+            "hoveron": "points",
+            "marker": {},
+            "line": {},
+            "connectgaps": true,
+            "cliponaxis": false,
+            "fill": "toself",
+            "fillcolor": "#123456",
+            "selected": {"marker": {}},
+            "unselected": {"marker": {}},
+            "selectedpoints": [0],
+            "meta": "m",
+            "customdata": ["cd"],
+            "uirevision": 1,
+        });
+
+        assert_eq!(to_value(trace).unwrap(), expected);
+    }
+}
diff --git a/plotly/src/traces/stream_tube.rs b/plotly/src/traces/stream_tube.rs
new file mode 100644
index 00000000..a460bcc3
--- /dev/null
+++ b/plotly/src/traces/stream_tube.rs
@@ -0,0 +1,303 @@
+//! Streamtube (3D flow) trace
+
+use plotly_derive::FieldSetter;
+use serde::Serialize;
+
+use crate::{
+    common::{ColorBar, ColorScale, Dim, Label, LegendGroupTitle, PlotType, Visible},
+    private::{NumOrString, NumOrStringCollection},
+    traces::mesh3d::{LightPosition, Lighting},
+    Trace,
+};
+
+/// Starting positions of the streamtubes. When unset, tubes start from the
+/// x-z plane at the lowest `y`, at every interior grid point of that plane.
+#[serde_with::skip_serializing_none]
+#[derive(Serialize, Clone, Debug, FieldSetter)]
+pub struct Starts {
+    x: Option<Vec<f64>>,
+    y: Option<Vec<f64>>,
+    z: Option<Vec<f64>>,
+}
+
+impl Starts {
+    pub fn new() -> Self {
+        Default::default()
+    }
+}
+
+/// Construct a streamtube trace: tubes following the flow of a 3D vector
+/// field `(u, v, w)` sampled on the `(x, y, z)` grid. The tube diameter
+/// reflects the local divergence of the field.
+///
+/// # Examples
+///
+/// ```
+/// use plotly::StreamTube;
+///
+/// let trace = StreamTube::new(
+///     vec![0.0, 1.0], vec![0.0, 1.0], vec![0.0, 1.0],
+///     vec![1.0, 1.0], vec![0.0, 0.0], vec![0.0, 0.0],
+/// );
+///
+/// let expected = serde_json::json!({
+///     "type": "streamtube",
+///     "x": [0.0, 1.0], "y": [0.0, 1.0], "z": [0.0, 1.0],
+///     "u": [1.0, 1.0], "v": [0.0, 0.0], "w": [0.0, 0.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 StreamTube<X, Y, Z, U, V, W>
+where
+    X: Serialize + Clone,
+    Y: Serialize + Clone,
+    Z: Serialize + Clone,
+    U: Serialize + Clone,
+    V: Serialize + Clone,
+    W: Serialize + Clone,
+{
+    #[field_setter(default = "PlotType::StreamTube")]
+    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>,
+    #[serde(rename = "legendrank")]
+    legend_rank: Option<usize>,
+    #[serde(rename = "legendwidth")]
+    legend_width: Option<f64>,
+    opacity: Option<f64>,
+    ids: Option<Vec<String>>,
+    /// Sets the x coordinates of the vector field.
+    x: Option<Vec<X>>,
+    /// Sets the y coordinates of the vector field.
+    y: Option<Vec<Y>>,
+    /// Sets the z coordinates of the vector field.
+    z: Option<Vec<Z>>,
+    /// Sets the x components of the vector field.
+    u: Option<Vec<U>>,
+    /// Sets the y components of the vector field.
+    v: Option<Vec<V>>,
+    /// Sets the z components of the vector field.
+    w: Option<Vec<W>>,
+    starts: Option<Starts>,
+    /// The maximum number of displayed segments in a streamtube.
+    #[serde(rename = "maxdisplayed")]
+    max_displayed: Option<usize>,
+    /// The scaling factor for the streamtubes. The default is 1, which avoids
+    /// two max divergence tubes from touching at adjacent starting positions.
+    #[serde(rename = "sizeref")]
+    size_ref: Option<f64>,
+    /// Sets a reference between this trace's 3D coordinate system and a 3D
+    /// scene, e.g. `"scene"` (the default) or `"scene2"`.
+    scene: Option<String>,
+    /// Sets a text element associated with this trace, shown in hover labels
+    /// when `hoverinfo` contains `text`.
+    text: Option<String>,
+    #[serde(rename = "hovertext")]
+    hover_text: Option<String>,
+    /// Flaglist of `x`, `y`, `z`, `u`, `v`, `w`, `norm`, `divergence`,
+    /// `text`, `name` joined with `+`, or one of `all`, `none`, `skip`.
+    #[serde(rename = "hoverinfo")]
+    hover_info: Option<String>,
+    #[serde(rename = "hovertemplate")]
+    hover_template: Option<Dim<String>>,
+    #[serde(rename = "hovertemplatefallback")]
+    hover_template_fallback: Option<Dim<String>>,
+    #[serde(rename = "hoverlabel")]
+    hover_label: Option<Label>,
+    #[serde(rename = "xhoverformat")]
+    x_hover_format: Option<String>,
+    #[serde(rename = "yhoverformat")]
+    y_hover_format: Option<String>,
+    #[serde(rename = "zhoverformat")]
+    z_hover_format: Option<String>,
+    #[serde(rename = "uhoverformat")]
+    u_hover_format: Option<String>,
+    #[serde(rename = "vhoverformat")]
+    v_hover_format: Option<String>,
+    #[serde(rename = "whoverformat")]
+    w_hover_format: Option<String>,
+    #[serde(rename = "coloraxis")]
+    color_axis: Option<String>,
+    #[serde(rename = "colorbar")]
+    color_bar: Option<ColorBar>,
+    #[serde(rename = "colorscale")]
+    color_scale: Option<ColorScale>,
+    #[serde(rename = "autocolorscale")]
+    auto_color_scale: Option<bool>,
+    #[serde(rename = "reversescale")]
+    reverse_scale: Option<bool>,
+    #[serde(rename = "showscale")]
+    show_scale: Option<bool>,
+    #[serde(rename = "cauto")]
+    c_auto: Option<bool>,
+    #[serde(rename = "cmin")]
+    c_min: Option<f64>,
+    #[serde(rename = "cmax")]
+    c_max: Option<f64>,
+    #[serde(rename = "cmid")]
+    c_mid: Option<f64>,
+    lighting: Option<Lighting>,
+    #[serde(rename = "lightposition")]
+    light_position: Option<LightPosition>,
+    meta: Option<NumOrString>,
+    #[serde(rename = "customdata")]
+    custom_data: Option<NumOrStringCollection>,
+    #[serde(rename = "uirevision")]
+    ui_revision: Option<NumOrString>,
+}
+
+impl<X, Y, Z, U, V, W> StreamTube<X, Y, Z, U, V, W>
+where
+    X: Serialize + Clone,
+    Y: Serialize + Clone,
+    Z: Serialize + Clone,
+    U: Serialize + Clone,
+    V: Serialize + Clone,
+    W: Serialize + Clone,
+{
+    pub fn new(x: Vec<X>, y: Vec<Y>, z: Vec<Z>, u: Vec<U>, v: Vec<V>, w: Vec<W>) -> Box<Self> {
+        Box::new(Self {
+            x: Some(x),
+            y: Some(y),
+            z: Some(z),
+            u: Some(u),
+            v: Some(v),
+            w: Some(w),
+            ..Default::default()
+        })
+    }
+}
+
+impl<X, Y, Z, U, V, W> Trace for StreamTube<X, Y, Z, U, V, W>
+where
+    X: Serialize + Clone,
+    Y: Serialize + Clone,
+    Z: Serialize + Clone,
+    U: Serialize + Clone,
+    V: Serialize + Clone,
+    W: 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_starts() {
+        let starts = Starts::new().x(vec![0.0]).y(vec![1.0]).z(vec![2.0]);
+        assert_eq!(
+            to_value(starts).unwrap(),
+            json!({"x": [0.0], "y": [1.0], "z": [2.0]})
+        );
+    }
+
+    #[test]
+    fn serialize_stream_tube() {
+        let trace = StreamTube::new(vec![0], vec![1], vec![2], vec![1], vec![0], vec![0])
+            .name("tube")
+            .visible(Visible::LegendOnly)
+            .show_legend(true)
+            .legend_group("g")
+            .legend_group_title("G")
+            .legend_rank(1)
+            .legend_width(2.0)
+            .opacity(0.7)
+            .ids(vec!["a"])
+            .starts(Starts::new().x(vec![0.0]))
+            .max_displayed(500)
+            .size_ref(0.3)
+            .scene("scene")
+            .text("t")
+            .hover_text("h")
+            .hover_info("divergence+norm")
+            .hover_template("%{divergence}")
+            .hover_template_fallback("-")
+            .hover_label(Label::new())
+            .x_hover_format("a")
+            .y_hover_format("b")
+            .z_hover_format("c")
+            .u_hover_format("d")
+            .v_hover_format("e")
+            .w_hover_format("f")
+            .color_axis("coloraxis")
+            .color_bar(ColorBar::new())
+            .color_scale(ColorScale::Palette(ColorScalePalette::Portland))
+            .auto_color_scale(true)
+            .reverse_scale(false)
+            .show_scale(true)
+            .c_auto(true)
+            .c_min(-1.0)
+            .c_max(1.0)
+            .c_mid(0.0)
+            .lighting(Lighting::new())
+            .light_position(LightPosition::new())
+            .meta("m")
+            .custom_data(vec!["cd"])
+            .ui_revision("rev");
+
+        let expected = json!({
+            "type": "streamtube",
+            "name": "tube",
+            "visible": "legendonly",
+            "showlegend": true,
+            "legendgroup": "g",
+            "legendgrouptitle": {"text": "G"},
+            "legendrank": 1,
+            "legendwidth": 2.0,
+            "opacity": 0.7,
+            "ids": ["a"],
+            "x": [0], "y": [1], "z": [2],
+            "u": [1], "v": [0], "w": [0],
+            "starts": {"x": [0.0]},
+            "maxdisplayed": 500,
+            "sizeref": 0.3,
+            "scene": "scene",
+            "text": "t",
+            "hovertext": "h",
+            "hoverinfo": "divergence+norm",
+            "hovertemplate": "%{divergence}",
+            "hovertemplatefallback": "-",
+            "hoverlabel": {},
+            "xhoverformat": "a",
+            "yhoverformat": "b",
+            "zhoverformat": "c",
+            "uhoverformat": "d",
+            "vhoverformat": "e",
+            "whoverformat": "f",
+            "coloraxis": "coloraxis",
+            "colorbar": {},
+            "colorscale": "Portland",
+            "autocolorscale": true,
+            "reversescale": false,
+            "showscale": true,
+            "cauto": true,
+            "cmin": -1.0,
+            "cmax": 1.0,
+            "cmid": 0.0,
+            "lighting": {},
+            "lightposition": {},
+            "meta": "m",
+            "customdata": ["cd"],
+            "uirevision": "rev",
+        });
+
+        assert_eq!(to_value(trace).unwrap(), expected);
+    }
+}
diff --git a/plotly/src/traces/violin.rs b/plotly/src/traces/violin.rs
index 3d49357b..daf2146a 100644
--- a/plotly/src/traces/violin.rs
+++ b/plotly/src/traces/violin.rs
@@ -324,7 +324,8 @@ mod tests {
         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`).
+        // 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"]);
diff --git a/plotly/src/traces/volume.rs b/plotly/src/traces/volume.rs
new file mode 100644
index 00000000..46e0cefc
--- /dev/null
+++ b/plotly/src/traces/volume.rs
@@ -0,0 +1,339 @@
+//! Volume (3D volume rendering) trace
+
+use plotly_derive::FieldSetter;
+use serde::{Serialize, Serializer};
+
+use crate::{
+    common::{ColorBar, ColorScale, Dim, Label, LegendGroupTitle, PlotType, Visible},
+    private::{NumOrString, NumOrStringCollection},
+    traces::{
+        isosurface::{Caps, IsoSurfaceSurface, Slices, SpaceFrame},
+        mesh3d::{Contour, LightPosition, Lighting},
+    },
+    Trace,
+};
+
+/// Maps normalized values of a [`Volume`] trace to opacities.
+#[derive(Clone, Debug)]
+pub enum OpacityScale {
+    /// Same opacity for every value (the default).
+    Uniform,
+    /// Lower values are more opaque.
+    Min,
+    /// Higher values are more opaque.
+    Max,
+    /// The lowest and highest values are more opaque.
+    Extremes,
+    /// Custom `(normalized value, opacity)` pairs. Mappings for at least the
+    /// lowest (0.0) and highest (1.0) values are required, e.g.
+    /// `vec![(0.0, 1.0), (0.5, 0.2), (1.0, 1.0)]`.
+    Custom(Vec<(f64, f64)>),
+}
+
+impl Serialize for OpacityScale {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            Self::Uniform => serializer.serialize_str("uniform"),
+            Self::Min => serializer.serialize_str("min"),
+            Self::Max => serializer.serialize_str("max"),
+            Self::Extremes => serializer.serialize_str("extremes"),
+            Self::Custom(pairs) => pairs
+                .iter()
+                .map(|(value, opacity)| [*value, *opacity])
+                .collect::<Vec<_>>()
+                .serialize(serializer),
+        }
+    }
+}
+
+/// Construct a volume trace: a 3D volume rendering of `value` sampled on the
+/// `(x, y, z)` grid, drawn as many semi-transparent isosurfaces between
+/// `isomin` and `isomax`.
+///
+/// # Examples
+///
+/// ```
+/// use plotly::{volume::OpacityScale, Volume};
+///
+/// let trace = Volume::new(
+///     vec![0, 0, 1, 1], vec![0, 1, 0, 1], vec![1, 1, 1, 1], vec![1.0, 2.0, 3.0, 4.0],
+/// )
+/// .opacity(0.1)
+/// .opacity_scale(OpacityScale::Extremes);
+///
+/// let expected = serde_json::json!({
+///     "type": "volume",
+///     "x": [0, 0, 1, 1],
+///     "y": [0, 1, 0, 1],
+///     "z": [1, 1, 1, 1],
+///     "value": [1.0, 2.0, 3.0, 4.0],
+///     "opacity": 0.1,
+///     "opacityscale": "extremes",
+/// });
+///
+/// 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 Volume<X, Y, Z, V>
+where
+    X: Serialize + Clone,
+    Y: Serialize + Clone,
+    Z: Serialize + Clone,
+    V: Serialize + Clone,
+{
+    #[field_setter(default = "PlotType::Volume")]
+    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>,
+    #[serde(rename = "legendrank")]
+    legend_rank: Option<usize>,
+    #[serde(rename = "legendwidth")]
+    legend_width: Option<f64>,
+    /// Sets the opacity of the surface. Volume renderings typically need a
+    /// low opacity (e.g. 0.1) to see inside the volume.
+    opacity: Option<f64>,
+    #[serde(rename = "opacityscale")]
+    opacity_scale: Option<OpacityScale>,
+    ids: Option<Vec<String>>,
+    /// Sets the x coordinates of the vertices on the x axis.
+    x: Option<Vec<X>>,
+    /// Sets the y coordinates of the vertices on the y axis.
+    y: Option<Vec<Y>>,
+    /// Sets the z coordinates of the vertices on the z axis.
+    z: Option<Vec<Z>>,
+    /// Sets the 4th dimension (value) of the vertices.
+    value: Option<Vec<V>>,
+    /// Sets the minimum boundary of the rendered values.
+    #[serde(rename = "isomin")]
+    iso_min: Option<f64>,
+    /// Sets the maximum boundary of the rendered values.
+    #[serde(rename = "isomax")]
+    iso_max: Option<f64>,
+    surface: Option<IsoSurfaceSurface>,
+    caps: Option<Caps>,
+    slices: Option<Slices>,
+    #[serde(rename = "spaceframe")]
+    space_frame: Option<SpaceFrame>,
+    contour: Option<Contour>,
+    #[serde(rename = "flatshading")]
+    flat_shading: Option<bool>,
+    /// Sets a reference between this trace's 3D coordinate system and a 3D
+    /// scene, e.g. `"scene"` (the default) or `"scene2"`.
+    scene: Option<String>,
+    text: Option<Dim<String>>,
+    #[serde(rename = "hovertext")]
+    hover_text: Option<Dim<String>>,
+    /// Flaglist of `x`, `y`, `z`, `text`, `name` joined with `+`, or one of
+    /// `all`, `none`, `skip`.
+    #[serde(rename = "hoverinfo")]
+    hover_info: Option<String>,
+    #[serde(rename = "hovertemplate")]
+    hover_template: Option<Dim<String>>,
+    #[serde(rename = "hovertemplatefallback")]
+    hover_template_fallback: Option<Dim<String>>,
+    #[serde(rename = "hoverlabel")]
+    hover_label: Option<Label>,
+    #[serde(rename = "xhoverformat")]
+    x_hover_format: Option<String>,
+    #[serde(rename = "yhoverformat")]
+    y_hover_format: Option<String>,
+    #[serde(rename = "zhoverformat")]
+    z_hover_format: Option<String>,
+    #[serde(rename = "valuehoverformat")]
+    value_hover_format: Option<String>,
+    #[serde(rename = "coloraxis")]
+    color_axis: Option<String>,
+    #[serde(rename = "colorbar")]
+    color_bar: Option<ColorBar>,
+    #[serde(rename = "colorscale")]
+    color_scale: Option<ColorScale>,
+    #[serde(rename = "autocolorscale")]
+    auto_color_scale: Option<bool>,
+    #[serde(rename = "reversescale")]
+    reverse_scale: Option<bool>,
+    #[serde(rename = "showscale")]
+    show_scale: Option<bool>,
+    #[serde(rename = "cauto")]
+    c_auto: Option<bool>,
+    #[serde(rename = "cmin")]
+    c_min: Option<f64>,
+    #[serde(rename = "cmax")]
+    c_max: Option<f64>,
+    #[serde(rename = "cmid")]
+    c_mid: Option<f64>,
+    lighting: Option<Lighting>,
+    #[serde(rename = "lightposition")]
+    light_position: Option<LightPosition>,
+    meta: Option<NumOrString>,
+    #[serde(rename = "customdata")]
+    custom_data: Option<NumOrStringCollection>,
+    #[serde(rename = "uirevision")]
+    ui_revision: Option<NumOrString>,
+}
+
+impl<X, Y, Z, V> Volume<X, Y, Z, V>
+where
+    X: Serialize + Clone,
+    Y: Serialize + Clone,
+    Z: Serialize + Clone,
+    V: Serialize + Clone,
+{
+    pub fn new(x: Vec<X>, y: Vec<Y>, z: Vec<Z>, value: Vec<V>) -> Box<Self> {
+        Box::new(Self {
+            x: Some(x),
+            y: Some(y),
+            z: Some(z),
+            value: Some(value),
+            ..Default::default()
+        })
+    }
+}
+
+impl<X, Y, Z, V> Trace for Volume<X, Y, Z, V>
+where
+    X: Serialize + Clone,
+    Y: Serialize + Clone,
+    Z: Serialize + Clone,
+    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::*;
+    use crate::common::ColorScalePalette;
+
+    #[test]
+    fn serialize_opacity_scale() {
+        assert_eq!(to_value(OpacityScale::Uniform).unwrap(), json!("uniform"));
+        assert_eq!(to_value(OpacityScale::Min).unwrap(), json!("min"));
+        assert_eq!(to_value(OpacityScale::Max).unwrap(), json!("max"));
+        assert_eq!(to_value(OpacityScale::Extremes).unwrap(), json!("extremes"));
+        assert_eq!(
+            to_value(OpacityScale::Custom(vec![
+                (0.0, 1.0),
+                (0.5, 0.2),
+                (1.0, 1.0)
+            ]))
+            .unwrap(),
+            json!([[0.0, 1.0], [0.5, 0.2], [1.0, 1.0]])
+        );
+    }
+
+    #[test]
+    fn serialize_volume() {
+        let trace = Volume::new(vec![0], vec![1], vec![2], vec![3.0])
+            .name("vol")
+            .visible(Visible::True)
+            .show_legend(true)
+            .legend_group("g")
+            .legend_group_title("G")
+            .legend_rank(1)
+            .legend_width(2.0)
+            .opacity(0.1)
+            .opacity_scale(OpacityScale::Max)
+            .ids(vec!["a"])
+            .iso_min(0.0)
+            .iso_max(5.0)
+            .surface(IsoSurfaceSurface::new().count(17))
+            .caps(Caps::new())
+            .slices(Slices::new())
+            .space_frame(SpaceFrame::new())
+            .contour(Contour::new())
+            .flat_shading(true)
+            .scene("scene")
+            .text("t")
+            .hover_text("h")
+            .hover_info("all")
+            .hover_template("%{value}")
+            .hover_template_fallback("-")
+            .hover_label(Label::new())
+            .x_hover_format("a")
+            .y_hover_format("b")
+            .z_hover_format("c")
+            .value_hover_format("d")
+            .color_axis("coloraxis")
+            .color_bar(ColorBar::new())
+            .color_scale(ColorScale::Palette(ColorScalePalette::Jet))
+            .auto_color_scale(false)
+            .reverse_scale(false)
+            .show_scale(true)
+            .c_auto(true)
+            .c_min(0.0)
+            .c_max(5.0)
+            .c_mid(2.5)
+            .lighting(Lighting::new())
+            .light_position(LightPosition::new())
+            .meta("m")
+            .custom_data(vec!["cd"])
+            .ui_revision(1);
+
+        let expected = json!({
+            "type": "volume",
+            "name": "vol",
+            "visible": true,
+            "showlegend": true,
+            "legendgroup": "g",
+            "legendgrouptitle": {"text": "G"},
+            "legendrank": 1,
+            "legendwidth": 2.0,
+            "opacity": 0.1,
+            "opacityscale": "max",
+            "ids": ["a"],
+            "x": [0], "y": [1], "z": [2],
+            "value": [3.0],
+            "isomin": 0.0,
+            "isomax": 5.0,
+            "surface": {"count": 17},
+            "caps": {},
+            "slices": {},
+            "spaceframe": {},
+            "contour": {},
+            "flatshading": true,
+            "scene": "scene",
+            "text": "t",
+            "hovertext": "h",
+            "hoverinfo": "all",
+            "hovertemplate": "%{value}",
+            "hovertemplatefallback": "-",
+            "hoverlabel": {},
+            "xhoverformat": "a",
+            "yhoverformat": "b",
+            "zhoverformat": "c",
+            "valuehoverformat": "d",
+            "coloraxis": "coloraxis",
+            "colorbar": {},
+            "colorscale": "Jet",
+            "autocolorscale": false,
+            "reversescale": false,
+            "showscale": true,
+            "cauto": true,
+            "cmin": 0.0,
+            "cmax": 5.0,
+            "cmid": 2.5,
+            "lighting": {},
+            "lightposition": {},
+            "meta": "m",
+            "customdata": ["cd"],
+            "uirevision": 1,
+        });
+
+        assert_eq!(to_value(trace).unwrap(), expected);
+    }
+}
diff --git a/plotly_derive/Cargo.toml b/plotly_derive/Cargo.toml
index cba1e240..d14c823d 100644
--- a/plotly_derive/Cargo.toml
+++ b/plotly_derive/Cargo.toml
@@ -1,10 +1,9 @@
 [package]
 name = "plotly_derive"
-version = "0.14.1"
+version = "0.15.0"
 description = "Internal proc macro crate for Plotly-rs."
 authors = ["Ioannis Giagkiozis <i.giagkiozis@gmail.com>"]
 license = "MIT"
-homepage = "https://github.com/plotly/plotly.rs"
 documentation = "https://docs.rs/plotly"
 repository = "https://github.com/plotly/plotly.rs"
 edition = "2021"
@@ -12,9 +11,9 @@ keywords = ["plot", "chart", "plotly"]
 
 [dependencies]
 quote = "1"
-syn = "2"
+syn = "3"
 proc-macro2 = "1"
-darling = "0.23"
+darling = "0.24"
 
 [lib]
 proc-macro = true
diff --git a/plotly_derive/src/field_setter.rs b/plotly_derive/src/field_setter.rs
index bcc87554..429b0113 100644
--- a/plotly_derive/src/field_setter.rs
+++ b/plotly_derive/src/field_setter.rs
@@ -509,8 +509,8 @@ impl FieldReceiver {
             _ => quote![],
         };
 
-        // Optional matrix setter for Dim<_> when #[field_setter(with_matrix)] is
-        // present
+        // Optional matrix setter for Dim<_> when #[field_setter(with_matrix)]
+        // is present
         let matrix_setter = if self.with_matrix {
             let matrix_ident = Ident::new(
                 &format!("{field_ident}_matrix"),
diff --git a/plotly_derive/src/lib.rs b/plotly_derive/src/lib.rs
index e5111a73..f135112e 100644
--- a/plotly_derive/src/lib.rs
+++ b/plotly_derive/src/lib.rs
@@ -7,12 +7,27 @@ use syn::DeriveInput;
 use syn::{parse_macro_input, ItemStruct};
 mod field_setter;
 
+/// Derive chainable setters, `new()` and `Default` for a struct of `Option`
+/// fields.
+///
+/// # Panics
+///
+/// Panics, failing compilation, if the input cannot be parsed, if the struct
+/// has unnamed (tuple) fields, or if a `#[field_setter(default = "...")]`
+/// value is not valid Rust tokens. Unsupported attributes are reported as
+/// regular compile errors rather than panics.
 #[proc_macro_derive(FieldSetter, attributes(field_setter))]
 pub fn field_setter(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
     let input = syn::parse::<DeriveInput>(input).unwrap();
     field_setter::field_setter_impl(input)
 }
 
+/// Generate both `LayoutTemplate` and `Layout` from a single field list.
+///
+/// # Panics
+///
+/// Panics, failing compilation, if the generated `template` field fails to
+/// parse; this indicates a bug in this macro.
 #[proc_macro_attribute]
 pub fn layout_structs(_attr: TokenStream, item: TokenStream) -> TokenStream {
     let input = parse_macro_input!(item as ItemStruct);
@@ -30,7 +45,8 @@ pub fn layout_structs(_attr: TokenStream, item: TokenStream) -> TokenStream {
         #vis struct #template_struct_name #fields
     };
 
-    // Generate Layout (with template field and #[field_setter(kind = "layout")])
+    // Generate Layout (with template field and #[field_setter(kind =
+    // "layout")])
     let layout_struct_name = format_ident!("Layout");
     let mut layout_fields = fields.clone();
     // Add the template field
diff --git a/plotly_kaleido/.gitignore b/plotly_kaleido/.gitignore
deleted file mode 100644
index f3c022cf..00000000
--- a/plotly_kaleido/.gitignore
+++ /dev/null
@@ -1,2 +0,0 @@
-examples/downloader.rs
-kaleido/*
\ No newline at end of file
diff --git a/plotly_kaleido/Cargo.toml b/plotly_kaleido/Cargo.toml
deleted file mode 100644
index a935e3d7..00000000
--- a/plotly_kaleido/Cargo.toml
+++ /dev/null
@@ -1,34 +0,0 @@
-[package]
-name = "plotly_kaleido"
-version = "0.13.6"
-description = "Additional output format support for plotly using Kaleido"
-authors = [
-    "Ioannis Giagkiozis <i.giagkiozis@gmail.com>",
-    "Andrei Gherghescu andrei-ng@protonmail.com",
-]
-license = "MIT"
-readme = "README.md"
-workspace = ".."
-homepage = "https://github.com/plotly/plotly.rs"
-documentation = "https://docs.rs/plotly_kaleido"
-repository = "https://github.com/plotly/plotly.rs"
-edition = "2021"
-keywords = ["plot", "chart", "plotly", "ndarray"]
-
-exclude = ["target/*", "kaleido/*", "examples/*"]
-
-[features]
-download = []
-
-[dependencies]
-serde = { version = "1.0", features = ["derive"] }
-serde_json = "1.0"
-dunce = "1.0"
-base64 = "0.23"
-
-[dev-dependencies]
-plotly_kaleido = { path = ".", features = ["download"] }
-
-[build-dependencies]
-zip = "8.0"
-directories = ">=4, <7"
diff --git a/plotly_kaleido/README.md b/plotly_kaleido/README.md
deleted file mode 100644
index 0d0eae99..00000000
--- a/plotly_kaleido/README.md
+++ /dev/null
@@ -1,7 +0,0 @@
-# plotly_kaleido
-
-This is an internal crate which implements the `kaleido` feature for [Plotly.rs](https://github.com/plotly/plotly.rs).
-
-The `kaleido` feature enables `Plot` conversion to the following output formats: `png`, `jpeg`, `webp`, `svg`, `pdf` and `eps`.
-
-See [examples/](https://github.com/plotly/plotly.rs/tree/main/examples/kaleido) for usage demonstrations.
\ No newline at end of file
diff --git a/plotly_kaleido/build.rs b/plotly_kaleido/build.rs
deleted file mode 100644
index b0df880f..00000000
--- a/plotly_kaleido/build.rs
+++ /dev/null
@@ -1,148 +0,0 @@
-extern crate directories;
-extern crate zip;
-
-use std::env;
-use std::fs;
-use std::io;
-use std::io::Result;
-use std::path::{Path, PathBuf};
-use std::process::Command;
-
-use directories::ProjectDirs;
-
-#[cfg(all(target_arch = "x86_64", target_os = "linux"))]
-const KALEIDO_URL: &str =
-    "https://github.com/plotly/Kaleido/releases/download/v0.2.1/kaleido_linux_x64.zip";
-
-#[cfg(all(target_arch = "aarch64", target_os = "linux"))]
-const KALEIDO_URL: &str =
-    "https://github.com/plotly/Kaleido/releases/download/v0.2.1/kaleido_linux_arm64.zip";
-
-#[cfg(target_os = "windows")]
-const KALEIDO_URL: &str =
-    "https://github.com/plotly/Kaleido/releases/download/v0.2.1/kaleido_win_x64.zip";
-
-#[cfg(all(target_arch = "x86_64", target_os = "macos"))]
-const KALEIDO_URL: &str =
-    "https://github.com/plotly/Kaleido/releases/download/v0.2.1/kaleido_mac_x64.zip";
-
-#[cfg(all(target_arch = "aarch64", target_os = "macos"))]
-const KALEIDO_URL: &str =
-    "https://github.com/plotly/Kaleido/releases/download/v0.2.1/kaleido_mac_arm64.zip";
-
-#[cfg(any(target_os = "linux", target_os = "macos"))]
-const KALEIDO_BIN: &str = "kaleido";
-
-#[cfg(target_os = "windows")]
-const KALEIDO_BIN: &str = "kaleido.exe";
-
-fn extract_zip(p: &Path, zip_file: &Path) -> Result<()> {
-    let file = fs::File::open(zip_file).unwrap();
-    let mut archive = zip::ZipArchive::new(file).unwrap();
-
-    for i in 0..archive.len() {
-        let mut file = archive.by_index(i).unwrap();
-        let outpath = file.mangled_name();
-        let outpath = p.join(outpath);
-        println!("outpath: {outpath:?}");
-
-        {
-            let comment = file.comment();
-            if !comment.is_empty() {
-                println!("File {i} comment: {comment}");
-            }
-        }
-
-        if (file.name()).ends_with('/') {
-            println!(
-                "File {} extracted to \"{}\"",
-                i,
-                outpath.as_path().display()
-            );
-            fs::create_dir_all(&outpath).unwrap();
-        } else {
-            println!(
-                "File {} extracted to \"{}\" ({} bytes)",
-                i,
-                outpath.as_path().display(),
-                file.size()
-            );
-            if let Some(p) = outpath.parent() {
-                if !p.exists() {
-                    fs::create_dir_all(p).unwrap();
-                }
-            }
-            let mut outfile = fs::File::create(&outpath).unwrap();
-            io::copy(&mut file, &mut outfile).unwrap();
-        }
-
-        // Get and Set permissions
-        #[cfg(unix)]
-        {
-            use std::os::unix::fs::PermissionsExt;
-
-            if let Some(mode) = file.unix_mode() {
-                fs::set_permissions(&outpath, fs::Permissions::from_mode(mode)).unwrap();
-            }
-        }
-    }
-
-    fs::remove_file(zip_file)?;
-    Ok(())
-}
-
-fn main() -> Result<()> {
-    if cfg!(feature = "download") {
-        let project_dirs = ProjectDirs::from("org", "plotly", "kaleido")
-            .expect("Could not create Kaleido config directory path.");
-        let dst: PathBuf = project_dirs.config_dir().into();
-
-        let kaleido_binary = dst.join("bin").join(KALEIDO_BIN);
-
-        println!("cargo:rerun-if-changed=src/lib.rs");
-        println!(
-            "cargo::rerun-if-changed={}",
-            kaleido_binary.to_string_lossy()
-        );
-
-        println!(
-            "cargo:rustc-env=KALEIDO_COMPILE_TIME_DLD_PATH={}",
-            dst.to_string_lossy()
-        );
-
-        if kaleido_binary.exists() {
-            return Ok(());
-        }
-
-        let msg = format!(
-            "Downloaded Plotly Kaleido from {KALEIDO_URL} to '{}'",
-            dst.to_string_lossy()
-        );
-        println!("cargo::warning={msg}");
-
-        let p = PathBuf::from(env::var("OUT_DIR").unwrap());
-        let kaleido_zip_file = p.join("kaleido.zip");
-
-        let mut cmd = Command::new("cargo")
-            .args(["install", "ruget"])
-            .spawn()
-            .unwrap();
-        cmd.wait()?;
-
-        let mut cmd = Command::new("ruget")
-            .args([
-                KALEIDO_URL,
-                "-o",
-                kaleido_zip_file.as_path().to_str().unwrap(),
-            ])
-            .spawn()
-            .unwrap();
-        cmd.wait()?;
-
-        extract_zip(&dst, &kaleido_zip_file)?;
-    } else {
-        let msg = "'download' feature disabled. Please install Kaleido manually and make the environment variable 'KALEIDO_PATH' point to it.".to_string();
-        println!("cargo::warning={msg}");
-    }
-    Ok(())
-}
diff --git a/plotly_kaleido/kaleido/placeholder.md b/plotly_kaleido/kaleido/placeholder.md
deleted file mode 100644
index a141c566..00000000
--- a/plotly_kaleido/kaleido/placeholder.md
+++ /dev/null
@@ -1 +0,0 @@
-placeholder for plotly/Kaleido
diff --git a/plotly_kaleido/src/lib.rs b/plotly_kaleido/src/lib.rs
deleted file mode 100644
index 6f18b114..00000000
--- a/plotly_kaleido/src/lib.rs
+++ /dev/null
@@ -1,479 +0,0 @@
-//! # Plotly Kaleido
-//! Plotly Kaleido implements the `kaleido` feature for [Plotly.rs](https://github.com/plotly/plotly.rs)
-//!
-//! The `kaleido` feature enables `Plot` conversion to the following output
-//! formats: png, jpeg, webp, svg, pdf and eps. It has the added benefit over
-//! the `orca` feature in that there is no need for an additional installation
-//! for the feature to function properly. The Kaleido precompiled binaries are
-//! packaged redistributed from the original repository [plotly/Kaleido](https://github.com/plotly/Kaleido).
-//!
-//! Note that [plotly/Kaleido](https://github.com/plotly/Kaleido) is still in pre-release and as such the `kaleido`
-//! feature should be considered in pre-release mode as well.
-
-#![cfg(not(target_family = "wasm"))]
-use std::fs::File;
-use std::io::prelude::*;
-use std::io::BufReader;
-use std::path::{Path, PathBuf};
-use std::process::{Command, Stdio};
-
-use base64::{engine::general_purpose, Engine as _};
-use serde::{Deserialize, Serialize};
-use serde_json::Value;
-
-/// Image format for static image export using Kaleido.
-///
-/// This enum defines all the image formats that can be exported from Plotly
-/// plots using the Kaleido engine. Kaleido supports all these formats natively.
-#[derive(Debug, Clone)]
-#[allow(deprecated)]
-pub enum ImageFormat {
-    /// Portable Network Graphics format
-    PNG,
-    /// Joint Photographic Experts Group format
-    JPEG,
-    /// WebP format (Google's image format)
-    WEBP,
-    /// Scalable Vector Graphics format
-    SVG,
-    /// Portable Document Format
-    PDF,
-    /// Encapsulated PostScript format (deprecated)
-    ///
-    /// This format is deprecated since version 0.13.0 and will be removed in
-    /// version 0.15.0. Use SVG or PDF instead for vector graphics. EPS is
-    /// not supported in the open source version.
-    #[deprecated(
-        since = "0.13.0",
-        note = "Use SVG or PDF instead. EPS variant will be removed in version 0.15.0"
-    )]
-    EPS,
-}
-
-impl std::fmt::Display for ImageFormat {
-    /// Converts the ImageFormat to its lowercase string representation.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// use plotly_kaleido::ImageFormat;
-    ///
-    /// assert_eq!(ImageFormat::PNG.to_string(), "png");
-    /// assert_eq!(ImageFormat::SVG.to_string(), "svg");
-    /// assert_eq!(ImageFormat::PDF.to_string(), "pdf");
-    /// assert_eq!(ImageFormat::EPS.to_string(), "eps");
-    /// ```
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(
-            f,
-            "{}",
-            match self {
-                Self::PNG => "png",
-                Self::JPEG => "jpeg",
-                Self::WEBP => "webp",
-                Self::SVG => "svg",
-                Self::PDF => "pdf",
-                #[allow(deprecated)]
-                Self::EPS => "eps",
-            }
-        )
-    }
-}
-
-impl serde::Serialize for ImageFormat {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        serializer.serialize_str(&self.to_string())
-    }
-}
-
-#[allow(dead_code)]
-#[derive(Deserialize, Debug)]
-struct KaleidoResult {
-    code: i32,
-    message: Option<String>,
-    #[serde(rename = "pdfBgColor")]
-    pdf_background_color: Option<String>,
-    format: Option<String>,
-    result: Option<String>,
-    width: Option<usize>,
-    height: Option<usize>,
-    scale: Option<f64>,
-    version: Option<String>,
-}
-
-impl KaleidoResult {
-    fn from(result: &str) -> KaleidoResult {
-        serde_json::from_str(result).unwrap()
-    }
-}
-
-#[derive(Serialize)]
-struct PlotData<'a> {
-    format: ImageFormat,
-    width: usize,
-    height: usize,
-    scale: f64,
-    // TODO: it would be great if this could be a plotly::Plot, but with the current workspace set
-    // up, that would be a cyclic dependency.
-    data: &'a Value,
-}
-
-impl<'a> PlotData<'a> {
-    fn new(
-        data: &'a Value,
-        format: ImageFormat,
-        width: usize,
-        height: usize,
-        scale: f64,
-    ) -> PlotData<'a> {
-        PlotData {
-            format,
-            width,
-            height,
-            scale,
-            data,
-        }
-    }
-
-    fn to_json(&self) -> String {
-        serde_json::to_string(self).unwrap()
-    }
-}
-
-#[derive(Default)]
-pub struct Kaleido {
-    cmd_path: PathBuf,
-}
-
-impl Kaleido {
-    const KALEIDO_PATH_ENV: &str = "KALEIDO_PATH";
-
-    pub fn new() -> Kaleido {
-        use std::env;
-
-        let path = match env::var(Self::KALEIDO_PATH_ENV) {
-            Ok(runtime_env) => runtime_env,
-            Err(runtime_env_err) => match option_env!("KALEIDO_COMPILE_TIME_DLD_PATH") {
-                Some(compile_time_path) => compile_time_path.to_string(),
-                None => {
-                    println!("{}: {}", Self::KALEIDO_PATH_ENV, runtime_env_err);
-                    println!("Use `kaleido_download` feature to automatically download, install and use Kaleido when targeting applications that run on the host machine.");
-                    println!("Use `{}` environment variable when targeting applications intended to run on different machines. Manually install Kaleido on the target machine and point {} to the installation location.", Self::KALEIDO_PATH_ENV, Self::KALEIDO_PATH_ENV
-                    );
-                    std::process::exit(1);
-                }
-            },
-        };
-
-        let path = match Kaleido::binary_path(&path) {
-            Ok(kaleido_path) => kaleido_path,
-            Err(msg) => panic!("Failed tu use Kaleido binary at {path} due to {msg}"),
-        };
-
-        Kaleido { cmd_path: path }
-    }
-
-    fn binary_path(dld_path: &str) -> Result<PathBuf, &'static str> {
-        let mut p = PathBuf::from(dld_path);
-        p = Self::os_binary_path(p);
-        if !p.exists() {
-            return Err("could not find kaleido executable in path");
-        }
-        Ok(p)
-    }
-
-    #[cfg(any(target_os = "linux", target_os = "macos"))]
-    fn os_binary_path(path: PathBuf) -> PathBuf {
-        match path.join("kaleido").canonicalize() {
-            Ok(v) => v,
-            Err(e) => {
-                println!(
-                    "Failed to find Kaleido binary at '{}': {e}",
-                    path.to_string_lossy()
-                );
-                panic!("{e}");
-            }
-        }
-    }
-
-    #[cfg(target_os = "windows")]
-    fn os_binary_path(path: PathBuf) -> PathBuf {
-        path.join("kaleido.cmd")
-    }
-
-    /// Generate a static image from a Plotly graph and save it to a file
-    pub fn save(
-        &self,
-        dst: &Path,
-        plotly_data: &Value,
-        format: ImageFormat,
-        width: usize,
-        height: usize,
-        scale: f64,
-    ) -> Result<(), Box<dyn std::error::Error>> {
-        let mut dst = PathBuf::from(dst);
-        dst.set_extension(format.to_string());
-
-        let image_data = self.convert(plotly_data, format.clone(), width, height, scale)?;
-        #[allow(deprecated)]
-        let data = match format {
-            ImageFormat::SVG | ImageFormat::EPS => image_data.as_bytes(),
-            _ => &general_purpose::STANDARD.decode(image_data).unwrap(),
-        };
-        let mut file = File::create(dst.as_path())?;
-        file.write_all(data)?;
-        file.flush()?;
-
-        Ok(())
-    }
-
-    /// Generate a static image from a Plotly graph and return it as a String
-    /// The output may be base64 encoded or a plain text depending on the image
-    /// format provided as argument. SVG and EPS are returned in plain text
-    /// while JPEG, PNG, WEBP will be returned as a base64 encoded string.
-    pub fn image_to_string(
-        &self,
-        plotly_data: &Value,
-        format: ImageFormat,
-        width: usize,
-        height: usize,
-        scale: f64,
-    ) -> Result<String, Box<dyn std::error::Error>> {
-        let image_data = self.convert(plotly_data, format.clone(), width, height, scale)?;
-        Ok(image_data)
-    }
-
-    /// Convert the Plotly graph to a static image using Kaleido and return the
-    /// result as a String
-    pub fn convert(
-        &self,
-        plotly_data: &Value,
-        format: ImageFormat,
-        width: usize,
-        height: usize,
-        scale: f64,
-    ) -> Result<String, Box<dyn std::error::Error>> {
-        let p = self.cmd_path.to_str().unwrap();
-        let format_str = format.to_string();
-
-        // Removed flag 'disable-gpu' as it causes issues on MacOS and other platforms
-        // see Kaleido issue #323
-        let cmd_args = vec![
-            "plotly",
-            "--allow-file-access-from-files",
-            "--disable-breakpad",
-            "--disable-dev-shm-usage",
-            "--disable-software-rasterizer",
-            "--single-process",
-            "--no-sandbox",
-        ];
-
-        #[allow(clippy::zombie_processes)]
-        let mut process = Command::new(p)
-            .current_dir(self.cmd_path.parent().unwrap())
-            .args(cmd_args)
-            .stdin(Stdio::piped())
-            .stdout(Stdio::piped())
-            .stderr(Stdio::piped())
-            .spawn()
-            .unwrap_or_else(|_| {
-                panic!(
-                    "{}",
-                    format!(
-                        "failed to spawn Kaleido binary at {}",
-                        self.cmd_path.to_string_lossy()
-                    )
-                    .to_string()
-                )
-            });
-        {
-            let plot_data = PlotData::new(plotly_data, format, width, height, scale).to_json();
-            let mut process_stdin = process.stdin.take().unwrap();
-            process_stdin
-                .write_all(plot_data.as_bytes())
-                .expect("couldn't write to Kaleido stdin");
-            process_stdin.flush()?;
-        }
-
-        let output_lines = BufReader::new(process.stdout.take().unwrap()).lines();
-        for line in output_lines.map_while(Result::ok) {
-            let res = KaleidoResult::from(line.as_str());
-            if let Some(image_data) = res.result {
-                // TODO: this should be refactored
-                // The assumption is that  KaleidoResult contains a single image.
-                // We should end the loop on the first valid one.
-                // If that is not the case, prior implementation would have returned the last
-                // valid image
-                return Ok(image_data);
-            }
-        }
-
-        // Don't eat up Kaleido/Chromium errors but show them in the terminal
-        println!("Kaleido failed to generate static image for format: {format_str}.");
-        println!("Kaleido stderr output:");
-        let stderr = process.stderr.take().unwrap();
-        let stderr_lines = BufReader::new(stderr).lines();
-        for line in stderr_lines {
-            let line = line.unwrap();
-            eprintln!("{line}");
-        }
-
-        Ok(String::default())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use std::path::PathBuf;
-
-    use serde_json::{json, to_value};
-
-    use super::*;
-
-    fn create_test_plot() -> Value {
-        to_value(json!({
-            "data": [
-              {
-                "name": "Surface",
-                "type": "surface",
-                "x": [
-                  1.0,
-                  2.0,
-                  3.0
-                ],
-                "y": [
-                  4.0,
-                  5.0,
-                  6.0
-                ],
-                "z": [
-                  [
-                    1.0,
-                    2.0,
-                    3.0
-                  ],
-                  [
-                    4.0,
-                    5.0,
-                    6.0
-                  ],
-                  [
-                    7.0,
-                    8.0,
-                    9.0
-                  ]
-                ]
-              }
-            ],
-            "layout": {}
-        }))
-        .unwrap()
-    }
-
-    #[test]
-    fn can_find_kaleido_executable() {
-        let _k = Kaleido::new();
-    }
-
-    #[test]
-    fn plot_data_to_json() {
-        let test_plot = create_test_plot();
-        let kaleido_data = PlotData::new(&test_plot, ImageFormat::PNG, 400, 500, 1.);
-        let expected = json!({
-            "data": test_plot,
-            "format": "png",
-            "width": 400,
-            "height": 500,
-            "scale": 1.0
-        });
-
-        assert_eq!(to_value(kaleido_data).unwrap(), expected);
-    }
-
-    // For MacOS failures, see issue #241 and upstream https://github.com/plotly/Kaleido/issues/323 is resolved
-    #[test]
-    fn save_png() {
-        let test_plot = create_test_plot();
-        let k = Kaleido::new();
-        let dst = PathBuf::from("example.png");
-        let r = k.save(dst.as_path(), &test_plot, ImageFormat::PNG, 1200, 900, 4.5);
-        assert!(r.is_ok());
-        assert!(dst.exists());
-        let metadata = std::fs::metadata(&dst).expect("Could not retrieve file metadata");
-        let file_size = metadata.len();
-        assert!(file_size > 0,);
-        assert!(std::fs::remove_file(dst.as_path()).is_ok());
-    }
-
-    #[test]
-    fn save_jpeg() {
-        let test_plot = create_test_plot();
-        let k = Kaleido::new();
-        let dst = PathBuf::from("example.jpeg");
-        let r = k.save(dst.as_path(), &test_plot, ImageFormat::JPEG, 1200, 900, 4.5);
-        assert!(r.is_ok());
-        assert!(dst.exists());
-        let metadata = std::fs::metadata(&dst).expect("Could not retrieve file metadata");
-        let file_size = metadata.len();
-        assert!(file_size > 0,);
-        assert!(std::fs::remove_file(dst.as_path()).is_ok());
-    }
-
-    #[test]
-    fn save_webp() {
-        let test_plot = create_test_plot();
-        let k = Kaleido::new();
-        let dst = PathBuf::from("example.webp");
-        let r = k.save(dst.as_path(), &test_plot, ImageFormat::WEBP, 1200, 900, 4.5);
-        assert!(r.is_ok());
-        assert!(dst.exists());
-        let metadata = std::fs::metadata(&dst).expect("Could not retrieve file metadata");
-        let file_size = metadata.len();
-        assert!(file_size > 0,);
-        assert!(std::fs::remove_file(dst.as_path()).is_ok());
-    }
-
-    #[test]
-    fn save_svg() {
-        let test_plot = create_test_plot();
-        let k = Kaleido::new();
-        let dst = PathBuf::from("example.svg");
-        let r = k.save(dst.as_path(), &test_plot, ImageFormat::SVG, 1200, 900, 4.5);
-        assert!(r.is_ok());
-        assert!(dst.exists());
-        let metadata = std::fs::metadata(&dst).expect("Could not retrieve file metadata");
-        let file_size = metadata.len();
-        assert!(file_size > 0,);
-        assert!(std::fs::remove_file(dst.as_path()).is_ok());
-    }
-
-    #[test]
-    fn save_pdf() {
-        let test_plot = create_test_plot();
-        let k = Kaleido::new();
-        let dst = PathBuf::from("example.pdf");
-        let r = k.save(dst.as_path(), &test_plot, ImageFormat::PDF, 1200, 900, 4.5);
-        assert!(r.is_ok());
-        assert!(dst.exists());
-        let metadata = std::fs::metadata(&dst).expect("Could not retrieve file metadata");
-        let file_size = metadata.len();
-        assert!(file_size > 0,);
-        assert!(std::fs::remove_file(dst.as_path()).is_ok());
-    }
-
-    // Kaleido generates empty eps files
-    #[test]
-    #[ignore]
-    fn save_eps() {
-        let test_plot = create_test_plot();
-        let k = Kaleido::new();
-        let dst = PathBuf::from("example.eps");
-        #[allow(deprecated)]
-        let r = k.save(dst.as_path(), &test_plot, ImageFormat::EPS, 1200, 900, 4.5);
-        assert!(r.is_ok());
-        assert!(std::fs::remove_file(dst.as_path()).is_ok());
-    }
-}
diff --git a/plotly_static/Cargo.toml b/plotly_static/Cargo.toml
index 953e21fd..84a53a23 100644
--- a/plotly_static/Cargo.toml
+++ b/plotly_static/Cargo.toml
@@ -1,11 +1,10 @@
 [package]
 name = "plotly_static"
-version = "0.1.0"
+version = "0.2.0"
 description = "Export Plotly graphs to static images using WebDriver"
 authors = ["Andrei Gherghescu andrei-ng@protonmail.com"]
 license = "MIT"
 workspace = ".."
-homepage = "https://github.com/plotly/plotly.rs"
 repository = "https://github.com/plotly/plotly.rs"
 edition = "2021"
 keywords = ["plotly", "static", "image", "export", "webdriver"]
@@ -40,8 +39,7 @@ clap = { version = "4.0", features = ["derive"] }
 [build-dependencies]
 tokio = { version = "1", features = ["full"] }
 anyhow = "1.0"
-dirs = "6.0"
-zip = "8.0"
+dirs = "7.0"
 webdriver-downloader = "0.17"
 
 # Needed for docs.rs to build the documentation
diff --git a/plotly_static/README.md b/plotly_static/README.md
index eb10e334..89624bf0 100644
--- a/plotly_static/README.md
+++ b/plotly_static/README.md
@@ -57,7 +57,7 @@ Add to your `Cargo.toml`:
 
 ```toml
 [dependencies]
-plotly_static = { version = "0.1", features = ["chromedriver", "webdriver_download"] }
+plotly_static = { version = "0.2", features = ["chromedriver", "webdriver_download"] }
 serde_json = "1.0"
 ```
 
diff --git a/plotly_static/src/lib.rs b/plotly_static/src/lib.rs
index 347cdc1c..2f372880 100644
--- a/plotly_static/src/lib.rs
+++ b/plotly_static/src/lib.rs
@@ -76,7 +76,7 @@
 //!
 //! ```toml
 //! [dependencies]
-//! plotly_static = { version = "0.1", features = ["chromedriver", "webdriver_download"] }
+//! plotly_static = { version = "0.2", features = ["chromedriver", "webdriver_download"] }
 //! ```
 //!
 //! ## Async Support
@@ -262,26 +262,27 @@
 //!
 //! ## Comparison with Kaleido
 //!
+//! `plotly_static` replaces the Kaleido-based `plotly_kaleido` backend, which
+//! was removed in plotly.rs 0.15.0.
+//!
 //! - **No custom Chromium/Chrome external dependency**: Uses standard WebDriver
 //!   instead of proprietary Kaleido
 //! - **Better Browser Support**: Works with any WebDriver-compatible browser:
 //!   Chrome/Chromium,Firefox,Brave
 //! - **Extensible**: Easy to control browser capabilities and customize the
-//!   StaticExporter instance
+//!   `StaticExporter` instance
 //!
 //! ## Limitations
 //!
 //! - Requires a WebDriver-compatible browser
 //! - PDF export uses browser JavaScript `html2pdf` (not native Plotly PDF)
-//! - EPS is no longer supported and will be removed
+//! - EPS is not supported (removed in 0.2.0); use SVG or PDF instead
 //! - Slightly slower than Kaleido
 //!
 //! ## License
 //!
 //! MIT License - see LICENSE file for details.
 
-// TODO: remove this once version 0.15.0 is out
-#![allow(deprecated)]
 use std::fs::File;
 use std::io::prelude::*;
 use std::path::{Path, PathBuf};
@@ -322,14 +323,6 @@ const DRIVER_FEATURE_REQUIRED: &str = "Static image export at runtime requires e
 /// - **SVG**: Scalable Vector Graphics format (vector-based, scalable)
 /// - **PDF**: Portable Document Format (implemented via browser JS)
 ///
-/// # Deprecated Formats
-///
-/// - **EPS**: Encapsulated PostScript format (deprecated since 0.13.0, will be
-///   removed in 0.15.0)
-///   - Use SVG or PDF instead for vector graphics
-///   - EPS is not supported in the open source version and in versions prior to
-///     0.13.0 has been generating empty images.
-///
 /// # Examples
 ///
 /// ```rust
@@ -339,7 +332,6 @@ const DRIVER_FEATURE_REQUIRED: &str = "Static image export at runtime requires e
 /// assert_eq!(format.to_string(), "png");
 /// ```
 #[derive(Debug, Clone, Serialize)]
-#[allow(deprecated)]
 pub enum ImageFormat {
     /// Portable Network Graphics format
     PNG,
@@ -351,20 +343,10 @@ pub enum ImageFormat {
     SVG,
     /// Portable Document Format (implemented via browser JS)
     PDF,
-    /// Encapsulated PostScript format (deprecated)
-    ///
-    /// This format is deprecated since version 0.13.0 and will be removed in
-    /// version 0.15.0. Use SVG or PDF instead for vector graphics. EPS is
-    /// not supported in the open source Plotly ecosystem version.
-    #[deprecated(
-        since = "0.13.0",
-        note = "Use SVG or PDF instead. EPS variant will be removed in version 0.15.0"
-    )]
-    EPS,
 }
 
 impl std::fmt::Display for ImageFormat {
-    /// Formats the ImageFormat as a string.
+    /// Formats the `ImageFormat` as a string.
     ///
     /// # Examples
     ///
@@ -383,8 +365,6 @@ impl std::fmt::Display for ImageFormat {
                 Self::WEBP => "webp",
                 Self::SVG => "svg",
                 Self::PDF => "pdf",
-                #[allow(deprecated)]
-                Self::EPS => "eps",
             }
         )
     }
@@ -427,7 +407,7 @@ struct PlotData<'a> {
 /// # Default Configuration
 ///
 /// - WebDriver port: 4444
-/// - WebDriver URL: "http://localhost"
+/// - WebDriver URL: `"http://localhost"`
 /// - Spawn webdriver: true (automatically manages WebDriver lifecycle)
 /// - Offline mode: false
 /// - PDF export timeout: 250ms
@@ -436,7 +416,7 @@ struct PlotData<'a> {
 pub struct StaticExporterBuilder {
     /// WebDriver server port (default: 4444)
     webdriver_port: u32,
-    /// WebDriver server base URL (default: "http://localhost")
+    /// WebDriver server base URL (default: `"http://localhost"`)
     webdriver_url: String,
     /// Auto-spawn WebDriver if not running (default: true)
     spawn_webdriver: bool,
@@ -453,7 +433,7 @@ impl Default for StaticExporterBuilder {
     ///
     /// The default configuration includes:
     /// - WebDriver port: 4444
-    /// - WebDriver URL: "http://localhost"
+    /// - WebDriver URL: `"http://localhost"`
     /// - Spawn webdriver: true
     /// - Offline mode: false
     /// - PDF export timeout: 250ms
@@ -625,7 +605,7 @@ impl StaticExporterBuilder {
     ///   existing WebDriver without spawning
     ///
     /// Returns a `Result<StaticExporter>` where:
-    /// - `Ok(exporter)` - Successfully created the StaticExporter instance
+    /// - `Ok(exporter)` - Successfully created the `StaticExporter` instance
     /// - `Err(e)` - Failed to create the instance (e.g., WebDriver not
     ///   available, port conflicts, etc.)
     ///
@@ -639,6 +619,15 @@ impl StaticExporterBuilder {
     ///     .build()
     ///     .expect("Failed to build StaticExporter");
     /// ```
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if no driver feature (`chromedriver` or `geckodriver`)
+    /// is enabled, or if the WebDriver cannot be spawned or connected to.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the Tokio runtime cannot be created.
     pub fn build(&self) -> Result<StaticExporter> {
         let runtime = std::sync::Arc::new(
             tokio::runtime::Builder::new_multi_thread()
@@ -652,7 +641,7 @@ impl StaticExporterBuilder {
         Ok(StaticExporter { runtime, inner })
     }
 
-    /// Create a new WebDriver instance based on the spawn_webdriver flag
+    /// 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;
@@ -693,6 +682,13 @@ impl StaticExporterBuilder {
     ///     .build_async()
     ///     .expect("Failed to build AsyncStaticExporter");
     /// ```
+    ///
+    /// Build an [`AsyncStaticExporter`] for use in async contexts.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if no driver feature (`chromedriver` or `geckodriver`)
+    /// is enabled, or if the WebDriver cannot be spawned or connected to.
     pub fn build_async(&self) -> Result<AsyncStaticExporter> {
         #[cfg(not(any(feature = "chromedriver", feature = "geckodriver")))]
         return Err(anyhow!(DRIVER_FEATURE_REQUIRED));
@@ -818,6 +814,12 @@ impl StaticExporter {
     /// // Close the exporter
     /// exporter.close();
     /// ```
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if called from within an async (Tokio) context, if the
+    /// browser export fails, if the image data cannot be decoded, or if the
+    /// file cannot be written.
     pub fn write_fig(
         &mut self,
         dst: &Path,
@@ -847,7 +849,7 @@ impl StaticExporter {
     /// string. or an error if the export fails.
     ///
     /// The format of the string depends on the image format. For
-    /// ImageFormat::SVG the function will generate plain SVG text, for
+    /// `ImageFormat::SVG` the function will generate plain SVG text, for
     /// other formats it will return base64-encoded data.
     ///
     /// # Examples
@@ -880,6 +882,11 @@ impl StaticExporter {
     /// // svg_data contains the SVG markup as a string
     /// assert!(svg_data.starts_with("<svg"));
     /// ```
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if called from within an async (Tokio) context, or if
+    /// the browser export fails.
     pub fn write_to_string(
         &mut self,
         plot: &serde_json::Value,
@@ -920,13 +927,13 @@ impl StaticExporter {
     }
 }
 
-/// Async StaticExporter for async contexts. Keeps the same API as the sync
-/// StaticExporter for compatibility.
+/// Async `StaticExporter` for async contexts. Keeps the same API as the sync
+/// `StaticExporter` for compatibility.
 pub struct AsyncStaticExporter {
     /// WebDriver server port (default: 4444)
     webdriver_port: u32,
 
-    /// WebDriver server base URL (default: "http://localhost")
+    /// WebDriver server base URL (default: `"http://localhost"`)
     webdriver_url: String,
 
     /// WebDriver process manager for spawning and cleanup
@@ -953,6 +960,11 @@ impl AsyncStaticExporter {
     /// Exports a Plotly plot to a static image file
     ///
     /// Same as [`StaticExporter::write_fig`] but async.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the browser export fails, if the image data cannot
+    /// be decoded, or if the file cannot be written.
     pub async fn write_fig(
         &mut self,
         dst: &Path,
@@ -988,6 +1000,10 @@ impl AsyncStaticExporter {
     /// Exports a Plotly plot to a string representation.
     ///
     /// Same as [`StaticExporter::write_to_string`] but async.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the browser export fails.
     pub async fn write_to_string(
         &mut self,
         plot: &serde_json::Value,
@@ -1060,14 +1076,15 @@ impl AsyncStaticExporter {
             new_client
         };
 
-        // For offline mode, write HTML to file to avoid data URI size limits since JS
-        // libraries are embedded in the file
+        // For offline mode, write HTML to file to avoid data URI size limits
+        // since JS libraries are embedded in the file
         let url = if self.offline_mode {
             let temp_file = template::to_file(html_content)
                 .with_context(|| "Failed to create temporary HTML file")?;
             format!("file://{}", temp_file.to_string_lossy())
         } else {
-            // For online mode, use data URI (smaller size since JS is loaded from CDN)
+            // For online mode, use data URI (smaller size since JS is loaded
+            // from CDN)
             format!("data:text/html,{}", encode(html_content))
         };
 
@@ -1128,11 +1145,6 @@ impl AsyncStaticExporter {
             ImageFormat::PNG | ImageFormat::JPEG | ImageFormat::WEBP | ImageFormat::PDF => {
                 common::extract_encoded(result, &plot.format)
             }
-            #[allow(deprecated)]
-            ImageFormat::EPS => {
-                error!("EPS format is deprecated. Use SVG or PDF instead.");
-                common::extract_encoded(result, &plot.format)
-            }
         }
     }
 
@@ -1143,7 +1155,8 @@ impl AsyncStaticExporter {
         }
         #[cfg(any(feature = "chromedriver", feature = "geckodriver"))]
         {
-            // Define browser capabilities (copied to avoid reordering existing code)
+            // 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();
@@ -1373,8 +1386,8 @@ mod tests {
         PORT_COUNTER.fetch_add(1, Ordering::SeqCst)
     }
 
-    // In CI which may run on slow machines, we run a different strategy to generate
-    // the unique port.
+    // In CI which may run on slow machines, we run a different strategy to
+    // generate the unique port.
     #[cfg(feature = "debug")]
     fn get_unique_port() -> u32 {
         static PORT_COUNTER: AtomicU32 = AtomicU32::new(4844);
@@ -1669,8 +1682,8 @@ mod tests {
         assert!(std::fs::remove_file(dst1.as_path()).is_ok());
         exporter1.close();
 
-        // Create second exporter on the same port - this should connect to existing
-        // WebDriver process (but create a new session)
+        // Create second exporter on the same port - this should connect to
+        // existing WebDriver process (but create a new session)
         let mut exporter2 = StaticExporterBuilder::default()
             .spawn_webdriver(true)
             .webdriver_port(test_port)
@@ -1687,15 +1700,16 @@ mod tests {
         assert!(std::fs::remove_file(dst2.as_path()).is_ok());
         exporter2.close();
 
-        // Create third exporter on the same port - should also connect to existing
-        // WebDriver process
+        // Create third exporter on the same port - should also connect to
+        // existing WebDriver process
         let mut exporter3 = StaticExporterBuilder::default()
             .spawn_webdriver(true)
             .webdriver_port(test_port)
             .build()
             .unwrap();
 
-        // Export third image using another new session on the same WebDriver process
+        // Export third image using another new session on the same WebDriver
+        // process
         let dst3 = PathBuf::from("process_reuse_3.png");
         exporter3
             .write_fig(dst3.as_path(), &test_plot, ImageFormat::PNG, 800, 600, 1.0)
diff --git a/plotly_static/src/template.rs b/plotly_static/src/template.rs
index 32e0b1cc..a3d9c1c0 100644
--- a/plotly_static/src/template.rs
+++ b/plotly_static/src/template.rs
@@ -256,7 +256,8 @@ pub(crate) fn to_file(data: &str) -> Result<PathBuf> {
 
 fn offline_js_sources() -> String {
     // tex-mml-chtml conflicts with tex-svg when generating Latex Titles
-    // let local_tex_mml_js = include_str!("../resource/tex-mml-chtml-3.2.0.js");
+    // let local_tex_mml_js =
+    // include_str!("../resource/tex-mml-chtml-3.2.0.js");
     let local_plotly_js = include_str!("../resource/plotly.min.js");
     let local_tex_svg_js = include_str!("../resource/tex-svg-3.2.2.js");
     let local_html2pdf_js = include_str!("../resource/html2pdf.bundle.min.js");
diff --git a/plotly_static/src/webdriver.rs b/plotly_static/src/webdriver.rs
index 830a3998..c0249e42 100644
--- a/plotly_static/src/webdriver.rs
+++ b/plotly_static/src/webdriver.rs
@@ -1,4 +1,4 @@
-//! WebDriver management module for plotly_static.
+//! WebDriver management module for `plotly_static`.
 //!
 //! This module provides WebDriver process management, including:
 //! - Automatic detection of existing WebDriver sessions
diff --git a/plotly_static/src/webdriver/launch.rs b/plotly_static/src/webdriver/launch.rs
index 600ce1c9..070b2299 100644
--- a/plotly_static/src/webdriver/launch.rs
+++ b/plotly_static/src/webdriver/launch.rs
@@ -172,7 +172,8 @@ impl WebDriver {
     }
 
     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 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);