diff --git a/app/databrowser/pom.xml b/app/databrowser/pom.xml
index 39513f75e2..fbf2b2e32d 100644
--- a/app/databrowser/pom.xml
+++ b/app/databrowser/pom.xml
@@ -8,6 +8,21 @@
   <artifactId>app-databrowser</artifactId>
   <name>${project.groupId}:${project.artifactId}</name>
   <dependencies>
+    <dependency>
+      <groupId>io.fair-acc</groupId>
+      <artifactId>chartfx</artifactId>
+      <version>11.3.1</version>
+      <exclusions>
+        <exclusion>
+          <groupId>org.openjfx</groupId>
+          <artifactId>javafx-base</artifactId>
+        </exclusion>
+        <exclusion>
+          <groupId>org.openjfx</groupId>
+          <artifactId>javafx-controls</artifactId>
+        </exclusion>
+      </exclusions>
+    </dependency>
     <dependency>
       <groupId>org.junit.jupiter</groupId>
       <artifactId>junit-jupiter</artifactId>
diff --git a/app/databrowser/src/main/java/org/csstudio/trends/databrowser3/Messages.java b/app/databrowser/src/main/java/org/csstudio/trends/databrowser3/Messages.java
index 69a2b45b61..51cd8f70c6 100644
--- a/app/databrowser/src/main/java/org/csstudio/trends/databrowser3/Messages.java
+++ b/app/databrowser/src/main/java/org/csstudio/trends/databrowser3/Messages.java
@@ -14,6 +14,14 @@
  */
 public class Messages
 {
+    public static String WaveformHistoryStaggerTT;
+    public static String WaveformHistoryCursorTT;
+    public static String WaveformHistorySample;
+    public static String WaveformHistoryLimitSummary;
+    public static String WaveformHistoryLimitTT;
+    public static String WaveformHistoryNonWaveformSummary;
+    public static String WaveformHistoryNonWaveformTT;
+
     // ---
     // --- Keep alphabetically sorted and 'in sync' with messages.properties!
     // ---
@@ -324,6 +332,8 @@ public class Messages
                          ValueAxes,
                          ValueAxisName,
                          ValueColumn,
+                         WaveformHistoryPrevious,
+                         WaveformHistoryPreviousTT,
                          WaveformIndex,
                          WaveformIndexCol,
                          WaveformIndexColTT,
diff --git a/app/databrowser/src/main/java/org/csstudio/trends/databrowser3/ui/waveformview/WaveformHistoryChart.java b/app/databrowser/src/main/java/org/csstudio/trends/databrowser3/ui/waveformview/WaveformHistoryChart.java
new file mode 100644
index 0000000000..9cd4cc3e87
--- /dev/null
+++ b/app/databrowser/src/main/java/org/csstudio/trends/databrowser3/ui/waveformview/WaveformHistoryChart.java
@@ -0,0 +1,622 @@
+package org.csstudio.trends.databrowser3.ui.waveformview;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Locale;
+
+import org.csstudio.javafx.rtplot.Activator;
+import org.csstudio.trends.databrowser3.Messages;
+
+import io.fair_acc.chartfx.XYChart;
+import io.fair_acc.chartfx.axes.spi.DefaultNumericAxis;
+import io.fair_acc.chartfx.plugins.ChartPlugin;
+import io.fair_acc.chartfx.plugins.DataPointTooltip;
+import io.fair_acc.chartfx.plugins.EditAxis;
+import io.fair_acc.chartfx.plugins.Zoomer;
+import io.fair_acc.chartfx.renderer.spi.HistoryDataSetRenderer;
+import io.fair_acc.chartfx.ui.geometry.Side;
+import io.fair_acc.dataset.DataSet;
+import io.fair_acc.dataset.spi.DoubleDataSet;
+
+import javafx.application.Platform;
+import javafx.beans.property.SimpleObjectProperty;
+import javafx.geometry.Insets;
+import javafx.geometry.Bounds;
+import javafx.geometry.Point2D;
+import javafx.scene.Group;
+import javafx.scene.Node;
+import javafx.scene.Parent;
+import javafx.scene.control.Button;
+import javafx.scene.control.ButtonBase;
+import javafx.scene.control.Label;
+import javafx.scene.control.Separator;
+import javafx.scene.control.ToggleButton;
+import javafx.scene.control.ToolBar;
+import javafx.scene.control.Tooltip;
+import javafx.scene.effect.ColorAdjust;
+import javafx.scene.image.ImageView;
+import javafx.scene.layout.BorderPane;
+import javafx.scene.layout.HBox;
+import javafx.scene.layout.Region;
+import javafx.scene.layout.VBox;
+import javafx.scene.paint.Color;
+import javafx.scene.paint.Paint;
+import javafx.scene.input.MouseEvent;
+import javafx.scene.shape.Circle;
+import javafx.scene.shape.Line;
+import javafx.scene.text.Font;
+import javafx.scene.text.FontWeight;
+
+/**
+ * Displays the current waveform and fading history for one or more PVs.
+ * Each PV has an independent Y-axis; the toolbar can stagger their ranges.
+ */
+public class WaveformHistoryChart extends BorderPane {
+
+    /**
+     * A named PV and its waveforms ordered oldest to newest.
+     */
+    public record WaveformSeries(String name, List<double[]> waveforms) {
+    }
+
+    private static final double HISTORY_FADING = 0.9;
+    private static final double ICON_SCALE = 0.8;
+    private static final double STAGGER_GAP = 0.1;
+    private static final Font AXIS_TITLE_FONT = Font.font("System", FontWeight.BOLD, 12);
+
+    private final DefaultNumericAxis xAxis;
+    private final DefaultNumericAxis mainYAxis;
+    private final XYChart chart;
+    private final ToolBar toolbar;
+
+    private final List<DoubleDataSet> waveforms = new ArrayList<>();
+    private final List<HistoryDataSetRenderer> renderers = new ArrayList<>();
+    private final List<DefaultNumericAxis> extraYAxes = new ArrayList<>();
+    private final List<double[]> valueRanges = new ArrayList<>();
+    private final WaveformCursor waveformCursor = new WaveformCursor();
+
+    private int historyLength;
+    private boolean axisColorUpdatePending;
+
+    public WaveformHistoryChart(int historyLength) {
+        xAxis = new DefaultNumericAxis("Sample");
+        mainYAxis = new DefaultNumericAxis("Value");
+        xAxis.setAutoRanging(true);
+        mainYAxis.setAutoRanging(true);
+        xAxis.setUnit(null);
+        mainYAxis.setUnit(null);
+
+        chart = new XYChart(xAxis, mainYAxis);
+        chart.setAnimated(false);
+        chart.setLegendVisible(false);
+
+        chart.getPlugins().add(new Zoomer());
+        chart.getPlugins().add(new EditAxis());
+        chart.getPlugins().add(new DataPointTooltip());
+        chart.getPlugins().add(waveformCursor);
+
+        // ChartFX dataset line colors are resolved by JavaFX CSS after the
+        // chart is attached to a Scene.
+        chart.sceneProperty().addListener((obs, oldScene, newScene) -> {
+            if (newScene != null) {
+                scheduleAxisColorUpdate();
+            }
+        });
+
+        setHistoryLength(historyLength);
+        toolbar = createToolbar();
+        setTop(toolbar);
+        setCenter(chart);
+    }
+
+    private ToolBar createToolbar() {
+        chart.toolBarSideProperty().bind(new SimpleObjectProperty<>(Side.TOP));
+        chart.getMenuPane().setTop(null);
+
+        var sourceToolbar = chart.getToolBar();
+        List<Node> controls = new ArrayList<>(sourceToolbar.getChildren());
+        sourceToolbar.getChildren().clear();
+
+        HBox buttonBox = new HBox(4);
+        for (Node control : controls) {
+            if (control instanceof HBox innerBox) {
+                buttonBox.getChildren().addAll(new ArrayList<>(innerBox.getChildren()));
+                innerBox.getChildren().clear();
+            } else {
+                buttonBox.getChildren().add(control);
+            }
+        }
+
+        while (!buttonBox.getChildren().isEmpty()
+                && buttonBox.getChildren().get(0) instanceof Separator) {
+            buttonBox.getChildren().remove(0);
+        }
+
+        // Same icon as the original RTPlot Stagger button.
+        Button stagger = new Button();
+        stagger.setTooltip(new Tooltip(Messages.WaveformHistoryStaggerTT));
+        stagger.setGraphic(new ImageView(Activator.getIcon("stagger")));
+        stagger.setOnAction(event -> staggerWaveforms());
+        // Insert ahead of ChartFX's existing zoom/pan controls.
+        buttonBox.getChildren().add(0, stagger);
+
+        // Kay-style crosshair: a toggle that reads the current sample of
+        // every selected waveform at the same X position.
+        ToggleButton crosshair = new ToggleButton();
+        crosshair.setTooltip(new Tooltip(Messages.WaveformHistoryCursorTT));
+        crosshair.setGraphic(new ImageView(Activator.getIcon("crosshair")));
+        crosshair.setOnAction(event -> waveformCursor.setActive(crosshair.isSelected()));
+        buttonBox.getChildren().add(1, crosshair);
+
+        for (Node control : buttonBox.getChildren()) {
+            // Preserve the original Stagger and Crosshair icon contrast.
+            compactControl(control, (control == crosshair || control == stagger) ? 0.0 : 0.45);
+            sizeButton(control, 34, 26);
+        }
+
+        ToolBar result = new ToolBar(buttonBox);
+        result.setPadding(new Insets(2, 4, 2, 4));
+        result.setMinHeight(Region.USE_PREF_SIZE);
+        result.setMaxHeight(Region.USE_PREF_SIZE);
+        result.setStyle("-fx-font-size: 10px;"
+                + "-fx-background-color: transparent;"
+                + "-fx-border-width: 0;");
+        return result;
+    }
+
+    /**
+     * Place Inspect Waveforms controls on the same toolbar as the chart tools.
+     * Call on the JavaFX application thread.
+     */
+    public void addToolbarControls(Node... controls) {
+        toolbar.getItems().addAll(controls);
+    }
+
+    private static void compactControl(Node node, double brightness) {
+        if (node instanceof ButtonBase button) {
+            Node graphic = button.getGraphic();
+            if (graphic != null) {
+                button.setGraphic(null);
+                graphic.setScaleX(graphic.getScaleX() * ICON_SCALE);
+                graphic.setScaleY(graphic.getScaleY() * ICON_SCALE);
+                ColorAdjust adjust = new ColorAdjust();
+                adjust.setBrightness(brightness);
+                graphic.setEffect(adjust);
+                button.setGraphic(new Group(graphic));
+            }
+        } else if (node instanceof Parent parent) {
+            for (Node child : parent.getChildrenUnmodifiable()) {
+                compactControl(child, brightness);
+            }
+        }
+    }
+
+    /**
+     * Change the number of previous waveforms retained (on FX thread).
+     */
+    public void setHistoryLength(int historyLength) {
+        final int length = Math.max(0, historyLength);
+        if (this.historyLength == length) {
+            return;
+        }
+        this.historyLength = length;
+        resetHistoryRenderers();
+        chart.invalidate();
+    }
+
+    /**
+     * Recreate renderers without changing the current Y-axis arrangement.
+     */
+    private void resetHistoryRenderers() {
+        // Old cursor markers/readouts refer to the previous datasets.
+        waveformCursor.hideCursor();
+        renderers.clear();
+        for (int pv = 0; pv < waveforms.size(); pv++) {
+            HistoryDataSetRenderer renderer = new HistoryDataSetRenderer(historyLength);
+            renderer.setIntensityFading(HISTORY_FADING);
+            renderer.setGlobalIndexOffset(pv);
+            renderer.getDatasets().add(waveforms.get(pv));
+            renderer.getAxes().addAll(xAxis, axisForPv(pv));
+            renderers.add(renderer);
+        }
+        chart.getRenderers().setAll(renderers);
+        scheduleAxisColorUpdate();
+    }
+
+    /**
+     * Schedule one CSS color refresh per JavaFX pulse, even if renderers
+     * have been recreated repeatedly before that pulse executes.
+     */
+    private void scheduleAxisColorUpdate() {
+        if (axisColorUpdatePending) {
+            return;
+        }
+        axisColorUpdatePending = true;
+        Platform.runLater(() -> {
+            axisColorUpdatePending = false;
+            updateAxisColorsFromRenderers();
+        });
+    }
+
+    /**
+     * Match each Y-axis title to the CSS-resolved line color of its PV.
+     * Using DataSetNode avoids maintaining a separate color palette.
+     */
+    private void updateAxisColorsFromRenderers() {
+        if (chart.getScene() == null) {
+            return;
+        }
+
+        chart.applyCss();
+        for (int pv = 0; pv < renderers.size(); pv++) {
+            HistoryDataSetRenderer renderer = renderers.get(pv);
+            if (renderer.getDatasetNodes().isEmpty()) {
+                continue;
+            }
+            var lineColor = renderer.getDatasetNodes().get(0).getLineColor();
+            if (lineColor != null) {
+                axisForPv(pv).getAxisLabel().setFill(lineColor);
+            }
+        }
+    }
+
+    private DefaultNumericAxis axisForPv(int pv) {
+        // Every PV has its own Y-axis, even before Stagger is pressed.
+        return pv == 0 ? mainYAxis : extraYAxes.get(pv - 1);
+    }
+
+    /**
+     * Replace all displayed PVs and their histories (on FX thread).
+     */
+    public void setWaveformSeries(List<WaveformSeries> series) {
+        if (!Platform.isFxApplicationThread()) {
+            throw new IllegalStateException(
+                    "setWaveformSeries must run on the JavaFX application thread");
+        }
+
+        // Changing the PV selection resets any manually staggered ranges.
+        // Navigating samples within the same selection preserves them.
+        if (!hasSamePvSelection(series)) {
+            clearStaggering();
+        }
+
+        // Detach old renderers before dropping any axes no longer needed.
+        chart.getRenderers().clear();
+        waveforms.clear();
+        ensureYAxes(series.size());
+        valueRanges.clear();
+        for (WaveformSeries item : series) {
+            waveforms.add(new DoubleDataSet(item.name(), 100));
+            valueRanges.add(rangeOf(item.waveforms()));
+        }
+        // Label each Y-axis with the corresponding PV name.
+        for (int pv = 0; pv < series.size(); pv++) {
+            DefaultNumericAxis axis = axisForPv(pv);
+            axis.setName(series.get(pv).name());
+            axis.setUnit(null);
+            axis.getAxisLabel().setFont(AXIS_TITLE_FONT);
+        }
+        resetHistoryRenderers();
+
+        // Each renderer owns one independent history buffer, so each PV can
+        // be loaded separately without inserting blank history frames.
+        for (int pv = 0; pv < series.size(); pv++) {
+            List<double[]> values = series.get(pv).waveforms();
+            DoubleDataSet dataset = waveforms.get(pv);
+            HistoryDataSetRenderer renderer = renderers.get(pv);
+            int from = Math.max(0, values.size() - historyLength - 1);
+            for (int idx = from; idx < values.size(); idx++) {
+                if (idx > from) {
+                    renderer.shiftHistory();
+                }
+                replaceWaveform(dataset, values.get(idx));
+            }
+        }
+        chart.invalidate();
+    }
+
+    private boolean hasSamePvSelection(List<WaveformSeries> series) {
+        if (series.size() != waveforms.size()) {
+            return false;
+        }
+        for (int pv = 0; pv < series.size(); pv++) {
+            if (!waveforms.get(pv).getName().equals(series.get(pv).name())) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /**
+     * One-shot Stagger action based on RTPlot/PlotProcessor.stagger().
+     * Each PV's values occupy one of N nonoverlapping vertical bands with
+     * 10% internal padding. Raw sample values are never changed.
+     */
+    public void staggerWaveforms() {
+        if (!Platform.isFxApplicationThread()) {
+            throw new IllegalStateException("staggerWaveforms must run on the FX thread");
+        }
+        int count = waveforms.size();
+        if (count < 2) {
+            return;
+        }
+
+        for (int pv = 0; pv < count; pv++) {
+            DefaultNumericAxis axis = axisForPv(pv);
+            double low = valueRanges.get(pv)[0];
+            double high = valueRanges.get(pv)[1];
+            if (!Double.isFinite(low) || !Double.isFinite(high) || low > high) {
+                continue;
+            }
+            if (low == high) {
+                double half = Math.abs(low / 2.0);
+                if (half == 0) half = 1.0;
+                low -= half;
+                high += half;
+            }
+            double span = high - low;
+            low -= STAGGER_GAP * span;
+            high += STAGGER_GAP * span;
+            span = high - low;
+
+            // Match Kay's rule: first PV on top, last PV on bottom.
+            low -= (count - pv - 1) * span;
+            high += pv * span;
+
+            axis.setAutoRanging(false);
+            axis.setMin(low);
+            axis.setMax(high);
+
+            HistoryDataSetRenderer renderer = renderers.get(pv);
+            renderer.getAxes().setAll(xAxis, axis);
+
+            // Refresh the renderer's cached xAxis and yAxis references.
+            renderer.updateAxes();
+        }
+        chart.invalidate();
+    }
+
+    private void ensureYAxes(int count) {
+        int required = Math.max(0, count - 1);
+
+        // Create the axes at PV-selection time, not on the first Stagger click.
+        while (extraYAxes.size() < required) {
+            DefaultNumericAxis axis = new DefaultNumericAxis("Value");
+            axis.setSide(Side.LEFT);
+            axis.setUnit(null);
+            axis.setAutoRanging(true);
+            extraYAxes.add(axis);
+            chart.getAxes().add(axis);
+        }
+
+        // Retire axes when fewer PVs are selected.
+        while (extraYAxes.size() > required) {
+            DefaultNumericAxis axis = extraYAxes.remove(extraYAxes.size() - 1);
+            chart.getAxes().remove(axis);
+        }
+    }
+
+    /**
+     * Clear the manual stagger ranges, but keep one Y-axis per PV.
+     * Unused axes are removed by ensureYAxes() when the PV count changes.
+     */
+    private void clearStaggering() {
+        mainYAxis.setAutoRanging(true);
+        for (DefaultNumericAxis axis : extraYAxes) {
+            axis.setAutoRanging(true);
+        }
+    }
+
+    static double[] rangeOf(List<double[]> history) {
+        double low = Double.POSITIVE_INFINITY;
+        double high = Double.NEGATIVE_INFINITY;
+        for (double[] values : history) {
+            if (values == null) {
+                continue;
+            }
+            for (double value : values) {
+                if (!Double.isFinite(value)) {
+                    continue;
+                }
+                low = Math.min(low, value);
+                high = Math.max(high, value);
+            }
+        }
+        return new double[]{low, high};
+    }
+
+    private static void replaceWaveform(DoubleDataSet dataset, double[] values) {
+        dataset.clearData();
+        for (int sample = 0; sample < values.length; sample++) {
+            dataset.add(sample, values[sample]);
+        }
+    }
+
+    /**
+     * A ChartFX plugin that displays a common sample cursor across the
+     * independently scaled Y-axes. Only the latest waveform for each PV
+     * contributes to the readout; history traces remain visually unchanged.
+     */
+    private final class WaveformCursor extends ChartPlugin {
+        private final Line vertical = new Line();
+        private final Line horizontal = new Line();
+        private final Group markers = new Group();
+        private final VBox readout = new VBox(2);
+        private final Label sampleLabel = new Label();
+        private final List<Label> valueLabels = new ArrayList<>();
+        private final List<Circle> markerNodes = new ArrayList<>();
+        private boolean active;
+
+        WaveformCursor() {
+            setAddButtonsToToolBar(false);
+            vertical.setStroke(Color.rgb(70, 70, 70, 0.7));
+            horizontal.setStroke(Color.rgb(70, 70, 70, 0.45));
+            vertical.getStrokeDashArray().addAll(4.0, 3.0);
+            horizontal.getStrokeDashArray().addAll(4.0, 3.0);
+
+            readout.setManaged(false);
+            readout.setMouseTransparent(true);
+            readout.setStyle("-fx-background-color: rgba(255,255,255,0.94);"
+                    + "-fx-border-color: #aaaaaa;"
+                    + "-fx-border-radius: 3; -fx-background-radius: 3;"
+                    + "-fx-padding: 5;");
+            sampleLabel.setStyle("-fx-font-weight: bold; -fx-font-size: 11px;");
+            readout.getChildren().add(sampleLabel);
+
+            vertical.setMouseTransparent(true);
+            horizontal.setMouseTransparent(true);
+            markers.setMouseTransparent(true);
+
+            registerInputEventHandler(MouseEvent.MOUSE_MOVED, this::mouseMoved);
+            registerInputEventHandler(MouseEvent.MOUSE_EXITED, event -> hideCursor());
+        }
+
+        void setActive(boolean enabled) {
+            active = enabled;
+            if (!enabled) {
+                hideCursor();
+            }
+        }
+
+        void hideCursor() {
+            if (!getChartChildren().isEmpty()) {
+                getChartChildren().clear();
+            }
+        }
+
+        /** Allocate cursor nodes only when the number of displayed PVs grows. */
+        private void ensureCursorEntries(int count) {
+            while (valueLabels.size() < count) {
+                Label valueLabel = new Label();
+                valueLabel.setStyle("-fx-font-size: 11px; -fx-font-weight: bold;");
+                valueLabel.setVisible(false);
+                valueLabel.setManaged(false);
+                valueLabels.add(valueLabel);
+                readout.getChildren().add(valueLabel);
+
+                Circle marker = new Circle(4);
+                marker.setStroke(Color.WHITE);
+                marker.setStrokeWidth(1.5);
+                marker.setMouseTransparent(true);
+                marker.setVisible(false);
+                markerNodes.add(marker);
+                markers.getChildren().add(marker);
+            }
+            while (valueLabels.size() > count) {
+                int last = valueLabels.size() - 1;
+                readout.getChildren().remove(valueLabels.remove(last));
+                markers.getChildren().remove(markerNodes.remove(last));
+            }
+        }
+
+        private void mouseMoved(MouseEvent event) {
+            if (!active || !isMouseEventWithinCanvas(event)
+                    || waveforms.isEmpty() || chart.getCanvas().getScene() == null) {
+                hideCursor();
+                return;
+            }
+
+            // Both the chart axes and the plugin overlay use canvas-local
+            // coordinates. This avoids offsets from the additional Y-axes.
+            Point2D mouse = chart.getCanvas().sceneToLocal(
+                    event.getSceneX(), event.getSceneY());
+            Bounds bounds = chart.getCanvas().getBoundsInLocal();
+            if (!bounds.contains(mouse)) {
+                hideCursor();
+                return;
+            }
+
+            // The waveform X coordinates are consecutive integer sample indices.
+            int sample = (int) Math.round(xAxis.getValueForDisplay(mouse.getX()));
+            double cursorX = xAxis.getDisplayPosition(sample);
+            if (!Double.isFinite(cursorX) || cursorX < bounds.getMinX()
+                    || cursorX > bounds.getMaxX()) {
+                hideCursor();
+                return;
+            }
+
+            vertical.setStartX(cursorX);
+            vertical.setEndX(cursorX);
+            vertical.setStartY(bounds.getMinY());
+            vertical.setEndY(bounds.getMaxY());
+            horizontal.setStartX(bounds.getMinX());
+            horizontal.setEndX(bounds.getMaxX());
+            horizontal.setStartY(mouse.getY());
+            horizontal.setEndY(mouse.getY());
+
+            sampleLabel.setText(Messages.WaveformHistorySample + " " + sample);
+            ensureCursorEntries(waveforms.size());
+
+            for (int pv = 0; pv < waveforms.size(); pv++) {
+                Label valueLabel = valueLabels.get(pv);
+                Circle marker = markerNodes.get(pv);
+                valueLabel.setVisible(false);
+                valueLabel.setManaged(false);
+                marker.setVisible(false);
+
+                DoubleDataSet dataset = waveforms.get(pv);
+                if (sample < 0 || sample >= dataset.getDataCount()) {
+                    continue; // no waveform values for this PV at this sample
+                }
+
+                double value = dataset.get(DataSet.DIM_Y, sample);
+                if (!Double.isFinite(value)) {
+                    continue;
+                }
+                double y = axisForPv(pv).getDisplayPosition(value);
+                Paint color = Color.BLACK;
+                if (pv < renderers.size() && !renderers.get(pv).getDatasetNodes().isEmpty()) {
+                    Paint actualColor = renderers.get(pv).getDatasetNodes().get(0).getLineColor();
+                    if (actualColor != null) {
+                        color = actualColor;
+                    }
+                }
+
+                valueLabel.setText(String.format(Locale.US,
+                        "%s: %.6g", dataset.getName(), value));
+                valueLabel.setTextFill(color);
+                valueLabel.setManaged(true);
+                valueLabel.setVisible(true);
+
+                if (Double.isFinite(y) && y >= bounds.getMinY() && y <= bounds.getMaxY()) {
+                    marker.setCenterX(cursorX);
+                    marker.setCenterY(y);
+                    marker.setFill(color);
+                    marker.setVisible(true);
+                }
+            }
+
+            // Attach the overlay before measuring it so JavaFX can resolve
+            // the labels' actual CSS font metrics on the first mouse move.
+            if (getChartChildren().isEmpty()) {
+                getChartChildren().addAll(vertical, horizontal, markers, readout);
+            }
+
+            // Keep the readout within the visible plot, next to the cursor.
+            readout.applyCss();
+            double width = readout.prefWidth(-1);
+            double height = readout.prefHeight(width);
+            double left = cursorX + 12;
+            if (left + width > bounds.getMaxX()) {
+                left = cursorX - width - 12;
+            }
+            left = Math.max(bounds.getMinX(), Math.min(left, bounds.getMaxX() - width));
+            double top = Math.max(bounds.getMinY(),
+                    Math.min(mouse.getY() + 12, bounds.getMaxY() - height));
+            readout.resizeRelocate(left, top, width, height);
+        }
+    }
+
+    private static void sizeButton(Node node, double width, double height) {
+        if (node instanceof ButtonBase button) {
+            button.setMinSize(width, height);
+            button.setPrefSize(width, height);
+            button.setMaxSize(width, height);
+            button.setPadding(Insets.EMPTY);
+        } else if (node instanceof Parent parent) {
+            for (Node child : parent.getChildrenUnmodifiable()) {
+                sizeButton(child, width, height);
+            }
+        }
+    }
+}
diff --git a/app/databrowser/src/main/java/org/csstudio/trends/databrowser3/ui/waveformview/WaveformView.java b/app/databrowser/src/main/java/org/csstudio/trends/databrowser3/ui/waveformview/WaveformView.java
index 246952007a..9261e7538f 100644
--- a/app/databrowser/src/main/java/org/csstudio/trends/databrowser3/ui/waveformview/WaveformView.java
+++ b/app/databrowser/src/main/java/org/csstudio/trends/databrowser3/ui/waveformview/WaveformView.java
@@ -11,151 +11,108 @@
 import java.time.Instant;
 import java.util.ArrayList;
 import java.util.List;
-import java.util.concurrent.ScheduledFuture;
-import java.util.concurrent.TimeUnit;
-
-import org.csstudio.javafx.rtplot.LineStyle;
-import org.csstudio.javafx.rtplot.PointType;
-import org.csstudio.javafx.rtplot.RTValuePlot;
-import org.csstudio.javafx.rtplot.Trace;
-import org.csstudio.javafx.rtplot.TraceType;
-import org.csstudio.javafx.rtplot.YAxis;
+
 import org.csstudio.javafx.rtplot.data.TimeDataSearch;
-import org.csstudio.trends.databrowser3.Activator;
 import org.csstudio.trends.databrowser3.Messages;
-import org.csstudio.trends.databrowser3.model.AnnotationInfo;
 import org.csstudio.trends.databrowser3.model.Model;
 import org.csstudio.trends.databrowser3.model.ModelItem;
 import org.csstudio.trends.databrowser3.model.ModelListener;
 import org.csstudio.trends.databrowser3.model.PlotSample;
 import org.csstudio.trends.databrowser3.model.PlotSamples;
-import org.csstudio.trends.databrowser3.ui.ToggleToolbarMenuItem;
 import org.epics.vtype.VNumberArray;
 import org.epics.vtype.VType;
 import org.phoebus.archive.vtype.VTypeHelper;
-import org.phoebus.ui.application.SaveSnapshotAction;
 import org.phoebus.ui.javafx.MultiCheckboxCombo;
-import org.phoebus.ui.javafx.PrintAction;
 import org.phoebus.util.time.TimestampFormats;
 
-import javafx.application.Platform;
 import javafx.beans.Observable;
 import javafx.beans.binding.Bindings;
 import javafx.geometry.Insets;
-import javafx.geometry.Point2D;
+import javafx.geometry.Orientation;
 import javafx.geometry.Pos;
 import javafx.scene.control.Button;
-import javafx.scene.control.ContextMenu;
 import javafx.scene.control.Label;
-import javafx.scene.control.SeparatorMenuItem;
+import javafx.scene.control.Separator;
 import javafx.scene.control.Slider;
+import javafx.scene.control.Spinner;
 import javafx.scene.control.TextField;
 import javafx.scene.control.Tooltip;
 import javafx.scene.layout.HBox;
 import javafx.scene.layout.Priority;
 import javafx.scene.layout.VBox;
 
-/** Panel for inspecting Waveform (Array) Samples of the current Model
- *  @author Kay Kasemir
- *  @author Will Rogers Original work to show current waveform sample in plot
- *  @author Takashi Nakamoto Allowed original WaveformView to handle multiple items with
- *                           the same name.
+/**
+ * Inspect waveform samples using the ChartFX waveform history chart.
+ * Multiple selected PVs share the sample-time reference but maintain
+ * independent waveform histories.
  */
 @SuppressWarnings("nls")
-public class WaveformView extends VBox
-{
-    /** Text used for the annotation that indicates waveform sample */
-    private static final String ANNOTATION_TEXT = Messages.WaveformView;
+public class WaveformView extends VBox {
+    private static final int DEFAULT_HISTORY_LENGTH = 5;
 
-    private final Model model;
+    // Temporary runtime configuration. Can later be moved into Data Browser preferences.
+    // Example VM option: -Dphoebus.waveform.max_pvs=8
+    private static final int MAX_PVS =
+            Math.max(1, Integer.getInteger("phoebus.waveform.max_pvs", 4));
 
-    /** Selected model item in model, or <code>null</code> */
+    private final Model model;
     private final List<ModelItem> model_items = new ArrayList<>();
-
-    /** Waveform for the currently selected sample */
-    private final List<WaveformValueDataProvider> waveforms = new ArrayList<>();
-
-    private final MultiCheckboxCombo<ModelItem> items = new MultiCheckboxCombo<>(Messages.WaveformViewSelect);
-
-    /** Is this code updating 'items', so ignore? */
+    private final MultiCheckboxCombo<ModelItem> items =
+            new MultiCheckboxCombo<>(Messages.WaveformViewSelect);
     private boolean updating_selected_items = false;
 
-    private RTValuePlot plot;
-
-    /** Model item that selected the sample */
+    private final Spinner<Integer> history_length =
+            new Spinner<>(0, 100, DEFAULT_HISTORY_LENGTH);
+    private final Label limit_warning = new Label();
+    private final Label waveform_warning = new Label();
+    private final Separator limit_separator = new Separator(Orientation.VERTICAL);
+    private final Separator waveform_separator = new Separator(Orientation.VERTICAL);
+    private boolean over_limit_selected = false;
+    private final WaveformHistoryChart history_plot =
+            new WaveformHistoryChart(DEFAULT_HISTORY_LENGTH);
+    private int applied_history_length = DEFAULT_HISTORY_LENGTH;
     private ModelItem selection_item = null;
-
-    /** Index of sample in model_item */
     private final Slider sample_index = new Slider();
+    private boolean positioning_sample_index = false;
+    private final TextField timestamp = new TextField();
+    private final TextField status = new TextField();
 
-    private final TextField timestamp = new TextField(),
-                            status = new TextField();
-
-    /** Annotation in plot that indicates waveform sample */
-    private final List<AnnotationInfo> waveform_annotations = new ArrayList<>();
-
-    private boolean changing_annotations = false;
-
-    private ScheduledFuture<?> pending_move = null;
-
-    private final ModelListener model_listener = new  ModelListener()
-    {
+    private final ModelListener model_listener = new ModelListener() {
         @Override
-        public void itemAdded(final ModelItem item)
-        {
+        public void itemAdded(final ModelItem item) {
             updatePVs();
         }
 
         @Override
-        public void itemRemoved(final ModelItem item)
-        {
+        public void itemRemoved(final ModelItem item) {
             model_items.remove(item);
-            // Will update the combo to reflect missing item
             updatePVs();
         }
 
         @Override
-        public void changedItemLook(final ModelItem item)
-        {
+        public void changedItemLook(final ModelItem item) {
             updatePVs();
         }
 
         @Override
-        public void changedAnnotations()
-        {
-            if (changing_annotations)
-                return;
-
-            // Reacting as the user moves the annotation
-            // would be too expensive.
-            // Delay, canceling previous request, for "post-selection"
-            // type update once the user stops moving the annotation for a little time
-            if (pending_move != null)
-                pending_move.cancel(false);
-
-            pending_move = Activator.timer.schedule(WaveformView.this::userMovedAnnotation, 500, TimeUnit.MILLISECONDS);
+        public void changedAnnotations() {
+            // Draggable annotations are not yet supported by the ChartFX view.
         }
 
         @Override
-        public void changedTimerange()
-        {
-            // Update selected sample to assert that it's one of the visible ones.
-            if (! model_items.isEmpty())
+        public void changedTimerange() {
+            if (!model_items.isEmpty())
                 showSelectedSample();
         }
     };
 
-    /** @param model Model */
-    public WaveformView(final Model model)
-    {
+    public WaveformView(final Model model) {
         this.model = model;
-
         model.addListener(model_listener);
 
-        items.selectedOptions().addListener((Observable o) ->
-        {
-            if (! updating_selected_items)
-                selectPV(items.getSelectedOptions());
+        items.selectedOptions().addListener((Observable o) -> {
+            if (!updating_selected_items)
+                selectPV(new ArrayList<>(items.getSelectedOptions()));
         });
 
         final Button refresh = new Button(Messages.SampleView_Refresh);
@@ -165,301 +122,295 @@ public WaveformView(final Model model)
         final Label label = new Label(Messages.SampleView_Item);
         final HBox top_row = new HBox(5, label, items, refresh);
         top_row.setAlignment(Pos.CENTER_LEFT);
-
-        // Combo should fill the available space.
-        // Tried HBox.setHgrow(items, Priority.ALWAYS) etc.,
-        // but always resulted in shrinking the label and button.
-        // -> Explicitly compute combo width from available space
-        //    minus padding and size of label, button
-        items.prefWidthProperty().bind(top_row.widthProperty().subtract(20).subtract(label.widthProperty()).subtract(refresh.widthProperty()));
+        items.prefWidthProperty().bind(top_row.widthProperty()
+                .subtract(20).subtract(label.widthProperty())
+                .subtract(refresh.widthProperty()));
         items.prefHeightProperty().bind(refresh.heightProperty());
 
-        createPlot();
+        history_length.setPrefWidth(70);
+        history_length.setTooltip(new Tooltip(Messages.WaveformHistoryPreviousTT));
+        history_length.valueProperty().addListener((obs, oldValue, value) -> updateHistory());
+
+        configureWarning(limit_warning, limit_separator);
+        configureWarning(waveform_warning, waveform_separator);
+
+        history_plot.addToolbarControls(
+                new Separator(Orientation.VERTICAL),
+                new Label(Messages.WaveformHistoryPrevious), history_length,
+                limit_separator, limit_warning,
+                waveform_separator, waveform_warning);
+
+        history_plot.setPadding(new Insets(0, 5, 5, 5));
+        VBox.setVgrow(history_plot, Priority.ALWAYS);
 
         sample_index.setBlockIncrement(1);
         sample_index.disableProperty().bind(Bindings.isEmpty(items.selectedOptions()));
         sample_index.setTooltip(new Tooltip(Messages.WaveformTimeSelector));
-        sample_index.valueProperty().addListener(p -> showSelectedSample());
+        sample_index.valueProperty().addListener(observable -> {
+            if (!positioning_sample_index)
+                showSelectedSample();
+        });
 
         timestamp.setEditable(false);
         status.setEditable(false);
         HBox.setHgrow(timestamp, Priority.ALWAYS);
         HBox.setHgrow(status, Priority.ALWAYS);
-        final HBox bottom_row = new HBox(5, new Label(Messages.WaveformTimestamp), timestamp, new Label(Messages.WaveformStatus), status);
+        final HBox bottom_row = new HBox(5,
+                new Label(Messages.WaveformTimestamp), timestamp,
+                new Label(Messages.WaveformStatus), status);
         bottom_row.setAlignment(Pos.CENTER_LEFT);
 
         top_row.setPadding(new Insets(5));
-        plot.setPadding(new Insets(0, 5, 5, 5));
         bottom_row.setPadding(new Insets(0, 5, 5, 5));
-        VBox.setVgrow(plot, Priority.ALWAYS);
-        getChildren().setAll(top_row, plot, sample_index, bottom_row);
+        getChildren().setAll(top_row, history_plot,
+                sample_index, bottom_row);
 
         updatePVs();
     }
 
-    private void createPlot()
-    {
-        plot = new RTValuePlot(true);
-        plot.getXAxis().setName(Messages.WaveformIndex);
-        plot.getYAxes().get(0).setAutoscale(true);
-        plot.getYAxes().get(0).useAxisName(false);
-        plot.showLegend(false);
-        createContextMenu();
-    }
-
-    private void createContextMenu()
-    {
-        final ContextMenu menu = new ContextMenu();
-        plot.setOnContextMenuRequested(event ->
-        {
-            menu.getItems().setAll(new ToggleToolbarMenuItem(plot));
-
-            final List<Trace<Double>> traces = new ArrayList<>();
-            plot.getTraces().forEach(traces::add);
-            if (! traces.isEmpty())
-                menu.getItems().add(new ToggleLinesMenuItem(plot, traces));
-
-
-            menu.getItems().addAll(new SeparatorMenuItem(),
-                                   new PrintAction(plot),
-                                   new SaveSnapshotAction(plot));
-
-            menu.show(getScene().getWindow(), event.getScreenX(), event.getScreenY());
-        });
-    }
-
-    private void updatePVs()
-    {
-        // Which PVs were selected?
-        final List<ModelItem> select = new ArrayList<>(items.getSelectedOptions());
+    private void updatePVs() {
+        final List<ModelItem> selected = new ArrayList<>(items.getSelectedOptions());
 
         updating_selected_items = true;
-
-        // Show PV names of model
-        final List<ModelItem> new_items = model.getItems();
-        items.setOptions(new_items);
-
-        // Re-select those that were selected and are still valid
-        select.retainAll(new_items);
-        items.selectOptions(select);
-
-        updating_selected_items = false;
-
-        selectPV(select);
+        try {
+            final List<ModelItem> available = model.getItems();
+            items.setOptions(available);
+            selected.retainAll(available);
+            if (selected.size() > MAX_PVS)
+                selected.subList(MAX_PVS, selected.size()).clear();
+            items.selectOptions(selected);
+        } finally {
+            updating_selected_items = false;
+        }
+        selectPV(selected);
     }
 
-    private void selectPV(final List<ModelItem> selected_items)
-    {
-        // Delete all existing traces
-        for (Trace<Double> trace : plot.getTraces())
-            plot.removeTrace(trace);
-        waveforms.clear();
-        removeAnnotations();
+    private void selectPV(final List<ModelItem> requested) {
+        final List<ModelItem> selected = new ArrayList<>(requested);
+        over_limit_selected = selected.size() > MAX_PVS;
+        if (over_limit_selected) {
+            selected.subList(MAX_PVS, selected.size()).clear();
+            updating_selected_items = true;
+            try {
+                items.selectOptions(selected);
+            } finally {
+                updating_selected_items = false;
+            }
+        }
 
         model_items.clear();
-        model_items.addAll(selected_items);
-
-        // No PV?
-        if (model_items.isEmpty())
+        model_items.addAll(selected);
+        if (model_items.isEmpty()) {
+            selection_item = null;
+            clearInfo();
+            updateToolbarWarning(List.of());
+            history_plot.setWaveformSeries(List.of());
             return;
+        }
+        if (selection_item == null || !model_items.contains(selection_item))
+            selection_item = model_items.get(0);
 
-        // Create trace for each waveform
-        for (ModelItem model_item : model_items)
-        {
-            final WaveformValueDataProvider waveform = new WaveformValueDataProvider();
-            waveforms.add(waveform);
-            plot.addTrace(model_item.getResolvedDisplayName(), model_item.getUnits(), waveform, model_item.getPaintColor(), TraceType.NONE, 1, LineStyle.SOLID, PointType.CIRCLES, 5, 0);
+        // Start at the newest sample whenever the PV selection changes.
+        // This makes history available for PVs that started recording later.
+        final PlotSamples reference = selection_item.getSamples();
+        final int last;
+        reference.getLock().lock();
+        try {
+            last = Math.max(0, reference.size() - 1);
+        } finally {
+            reference.getLock().unlock();
         }
 
-        // Enable waveform selection and update slider's range
+        // Suppress the slider listener while updating its range and value.
+        // Show the selected sample once after both properties are consistent.
+        positioning_sample_index = true;
+        try {
+            sample_index.setMax(last);
+            sample_index.setValue(last);
+        } finally {
+            positioning_sample_index = false;
+        }
         showSelectedSample();
-        // Autoscale Y axes by default.
-        for (YAxis<Double> yaxis : plot.getYAxes())
-            yaxis.setAutoscale(true);
     }
 
-    private void showSelectedSample()
-    {
-        // No items?
-        if (model_items.isEmpty())
-        {
-            selection_item = null;
+    private void showSelectedSample() {
+        if (model_items.isEmpty()) {
+            clearInfo();
             return;
         }
-
-        // If no item selected for the idx, use the first one
-        if (selection_item == null  ||  !model_items.contains(selection_item))
+        if (selection_item == null || !model_items.contains(selection_item))
             selection_item = model_items.get(0);
 
-        // Determine time stamp of selected item's sample
-        final int idx = (int) Math.round(sample_index.getValue());
+        final PlotSamples reference = selection_item.getSamples();
         final Instant selected_time;
-        PlotSamples samples = selection_item.getSamples();
-        samples.getLock().lock();
-        try
-        {
-            selected_time = samples.get(idx).getPosition();
-        }
-        finally
-        {
-            samples.getLock().unlock();
+        reference.getLock().lock();
+        try {
+            final int count = reference.size();
+            if (count == 0) {
+                clearInfo();
+                updateToolbarWarning(List.of());
+                history_plot.setWaveformSeries(List.of());
+                return;
+            }
+            final int last = count - 1;
+            if (sample_index.getMax() != last) {
+                // Changing the slider range may itself fire a value change.
+                positioning_sample_index = true;
+                try {
+                    sample_index.setMax(last);
+                } finally {
+                    positioning_sample_index = false;
+                }
+            }
+            final int index = Math.max(0, Math.min(last,
+                    (int) Math.round(sample_index.getValue())));
+            selected_time = reference.get(index).getPosition();
+        } finally {
+            reference.getLock().unlock();
         }
 
-        String timestampText = "", statusText = "";
-        int n = 0, max_size = 1;
-        for (ModelItem model_item : model_items)
-        {
-            // Get selected sample (= one waveform)
-            samples = model_item.getSamples();
-            PlotSample sample;
+        final StringBuilder times = new StringBuilder();
+        final StringBuilder statuses = new StringBuilder();
+        for (ModelItem item : model_items) {
+            final PlotSamples samples = item.getSamples();
+            final VType value;
             samples.getLock().lock();
-            try
-            {
-                if (model_item == selection_item)
-                {   // idx refers to exact sample of this item
-                    sample_index.setMax(samples.size());
-                    sample = samples.get(idx);
-                }
-                else
-                {   // Find closest sample based on time stamp
-                    final TimeDataSearch search = new TimeDataSearch();
-                    final int s = search.findClosestSample(samples, selected_time);
-                    sample = samples.get(s);
-                }
-            }
-            finally
-            {
+            try {
+                if (samples.size() == 0)
+                    continue;
+                final int index = selectedSampleIndex(item, samples, selected_time);
+                value = samples.get(index).getVType();
+            } finally {
                 samples.getLock().unlock();
             }
-
-            // Setting the value can be delayed while the plot is being updated
-            final VType value = sample.getVType();
-            final WaveformValueDataProvider waveform = waveforms.get(n);
-            Activator.thread_pool.execute(() -> waveform.setValue(value));
             if (value == null)
-                clearInfo();
-            else
-            {
-                updateAnnotation(n, sample.getPosition(), sample.getValue());
-
-                if (n == 0)
-                {
-                    final int size = value instanceof VNumberArray ? ((VNumberArray)value).getData().size() : 1;
-                    if (size > max_size)
-                        max_size = size;
-                    timestampText = TimestampFormats.MILLI_FORMAT.format(org.phoebus.core.vtypes.VTypeHelper.getTimestamp(value));
-                    statusText = MessageFormat.format(Messages.SeverityStatusFmt, org.phoebus.core.vtypes.VTypeHelper.getSeverity(value).toString(), VTypeHelper.getMessage(value));
-                }
-                else
-                {
-                    timestampText += "; " + TimestampFormats.MILLI_FORMAT.format(org.phoebus.core.vtypes.VTypeHelper.getTimestamp(value));
-                    statusText += "; " + MessageFormat.format(Messages.SeverityStatusFmt, org.phoebus.core.vtypes.VTypeHelper.getSeverity(value).toString(), VTypeHelper.getMessage(value));
-                }
+                continue;
+            if (times.length() != 0) {
+                times.append("; ");
+                statuses.append("; ");
             }
-
-            ++n;
+            times.append(TimestampFormats.MILLI_FORMAT.format(
+                    org.phoebus.core.vtypes.VTypeHelper.getTimestamp(value)));
+            statuses.append(MessageFormat.format(Messages.SeverityStatusFmt,
+                    org.phoebus.core.vtypes.VTypeHelper.getSeverity(value).toString(),
+                    VTypeHelper.getMessage(value)));
         }
-        plot.getXAxis().setValueRange(0.0, (double)max_size);
-
-        timestamp.setText(timestampText);
-        status.setText(statusText);
-        plot.requestUpdate();
+        timestamp.setText(times.toString());
+        status.setText(statuses.toString());
+        updateHistory(selected_time);
     }
 
-    /** Clear all the info fields. */
-    private void clearInfo()
-    {
-        timestamp.setText("");
-        status.setText("");
-        removeAnnotations();
-        selection_item = null;
+    private void updateHistory() {
+        if (model_items.isEmpty()) {
+            history_plot.setWaveformSeries(List.of());
+            return;
+        }
+        showSelectedSample();
     }
 
-    private void userMovedAnnotation()
-    {
-        if (waveform_annotations.isEmpty())
-            return;
+    private void updateHistory(final Instant selected_time) {
+        final int previous = history_length.getValue();
+        final List<WaveformHistoryChart.WaveformSeries> series = new ArrayList<>();
+        final List<String> nonWaveformPvs = new ArrayList<>();
 
-        // Compare position of waveform_annotations to those in model
-        // to determine which annotation the user moved.
-        final List<AnnotationInfo> model_annotations = model.getAnnotations();
-        for (AnnotationInfo waveform_annotation : waveform_annotations)
-            for (AnnotationInfo annotation : model_annotations)
-                if (annotation.isInternal()                                          &&
-                    annotation.getItemIndex() == waveform_annotation.getItemIndex()  &&
-                    ! annotation.getTime().equals(waveform_annotation.getTime()))
-            {
-                // System.out.println("User moved " + annotation.getText() + "\nfrom " + waveform_annotation.getTime() + "\n  to " + annotation.getTime());
-
-                selection_item = model.getItems().get(annotation.getItemIndex());
-                final PlotSamples samples = selection_item.getSamples();
-                final TimeDataSearch search = new TimeDataSearch();
-                final int idx;
-                samples.getLock().lock();
-                try
-                {
-                    idx = search.findClosestSample(samples, annotation.getTime());
-                }
-                finally
-                {
-                    samples.getLock().unlock();
+        for (ModelItem item : model_items) {
+            final List<double[]> history = new ArrayList<>();
+            boolean sawScalarSample = false;
+            final PlotSamples samples = item.getSamples();
+            samples.getLock().lock();
+            try {
+                if (samples.size() > 0) {
+                    final int closest = selectedSampleIndex(item, samples, selected_time);
+                    final int first = Math.max(0, closest - previous);
+                    for (int index = first; index <= closest; index++) {
+                        final PlotSample sample = samples.get(index);
+                        if (!(sample.getVType() instanceof VNumberArray array)) {
+                            if (sample.getVType() != null)
+                                sawScalarSample = true;
+                            continue;
+                        }
+                        history.add(copyWaveform(array));
+                    }
                 }
-                // Update waveform view for that sample on UI thread
-                Platform.runLater(() ->
-                {
-                    if (sample_index.getMax() < idx)
-                        sample_index.setMax(idx);
-                    sample_index.setValue(idx);
-                    showSelectedSample();
-                });
-                return;
+            } finally {
+                samples.getLock().unlock();
             }
+            if (history.isEmpty() && sawScalarSample)
+                nonWaveformPvs.add(item.getResolvedDisplayName());
+            series.add(new WaveformHistoryChart.WaveformSeries(
+                    item.getResolvedDisplayName(), history));
+        }
+
+        // Preserve history depth when it hasn't changed to avoid needless resets.
+        if (applied_history_length != previous) {
+            history_plot.setHistoryLength(previous);
+            applied_history_length = previous;
+        }
+        history_plot.setWaveformSeries(series);
+        updateToolbarWarning(nonWaveformPvs);
     }
 
-    private void updateAnnotation(final int annotation_index, final Instant time, final double value)
-    {
-        final List<AnnotationInfo> annotations = new ArrayList<>(model.getAnnotations());
-        // Initial annotation offset
-        Point2D offset = new Point2D(20, -20);
-
-        final String label = ANNOTATION_TEXT + " " + model_items.get(annotation_index).getDisplayName();
-
-        // If already in model, note its offset and remove
-        for (AnnotationInfo annotation : annotations)
-        {
-            if (annotation.getText().equals(label))
-            {   // Update offset to where user last placed it
-                offset = annotation.getOffset();
-                annotations.remove(annotation);
-                break;
-            }
+    /**
+     * Find the index corresponding to the selected time. Call with the
+     * PlotSamples lock held and only when the collection is nonempty.
+     */
+    private int selectedSampleIndex(final ModelItem item,
+                                    final PlotSamples samples,
+                                    final Instant selectedTime) {
+        final int last = samples.size() - 1;
+        final int index = item == selection_item
+                ? (int) Math.round(sample_index.getValue())
+                : new TimeDataSearch().findClosestSample(samples, selectedTime);
+        return Math.max(0, Math.min(index, last));
+    }
+
+    private static double[] copyWaveform(final VNumberArray array) {
+        final double[] values = new double[array.getData().size()];
+        for (int index = 0; index < values.length; index++) {
+            values[index] = array.getData().getDouble(index);
         }
+        return values;
+    }
 
-        final int item_index = model.getItems().indexOf(model_items.get(annotation_index));
-        final AnnotationInfo waveform_annotation = new AnnotationInfo(true, item_index, time, value, offset, label);
-        waveform_annotations.add(annotation_index, waveform_annotation);
-        annotations.add(waveform_annotation);
+    private static void configureWarning(final Label warning,
+                                         final Separator separator) {
+        warning.setStyle("-fx-text-fill: #a35b00;");
+        warning.setVisible(false);
+        warning.managedProperty().bind(warning.visibleProperty());
+        warning.setTooltip(new Tooltip());
+        separator.visibleProperty().bind(warning.visibleProperty());
+        separator.managedProperty().bind(separator.visibleProperty());
+    }
 
-        changing_annotations = true;
-        model.setAnnotations(annotations);
-        changing_annotations = false;
+    private static void setWarning(final Label warning,
+                                   final String summary,
+                                   final String details) {
+        warning.setText(summary);
+        warning.getTooltip().setText(details);
+        warning.setVisible(!summary.isEmpty());
     }
 
-    private void removeAnnotations()
-    {
-        boolean changes = false;
-        // Remove all waveform_annotations from model
-        final List<AnnotationInfo> modelAnnotations = new ArrayList<>(model.getAnnotations());
-        for (AnnotationInfo waveform_annotation : waveform_annotations)
-            if (modelAnnotations.remove(waveform_annotation))
-                changes = true;
-        waveform_annotations.clear();
-
-        if (changes)
-        {
-            changing_annotations = true;
-            model.setAnnotations(modelAnnotations);
-            changing_annotations = false;
+    private void updateToolbarWarning(final List<String> nonWaveformPvs) {
+        if (over_limit_selected) {
+            setWarning(limit_warning,
+                    MessageFormat.format(Messages.WaveformHistoryLimitSummary, MAX_PVS),
+                    MessageFormat.format(Messages.WaveformHistoryLimitTT, MAX_PVS));
+        } else {
+            setWarning(limit_warning, "", "");
+        }
+
+        if (!nonWaveformPvs.isEmpty()) {
+            final String names = String.join(", ", nonWaveformPvs);
+            setWarning(waveform_warning,
+                    MessageFormat.format(Messages.WaveformHistoryNonWaveformSummary, names),
+                    MessageFormat.format(Messages.WaveformHistoryNonWaveformTT, names));
+        } else {
+            setWarning(waveform_warning, "", "");
         }
     }
+
+    private void clearInfo() {
+        timestamp.clear();
+        status.clear();
+    }
 }
diff --git a/app/databrowser/src/main/resources/org/csstudio/trends/databrowser3/messages.properties b/app/databrowser/src/main/resources/org/csstudio/trends/databrowser3/messages.properties
index c6cf31e00b..55aca4bae3 100644
--- a/app/databrowser/src/main/resources/org/csstudio/trends/databrowser3/messages.properties
+++ b/app/databrowser/src/main/resources/org/csstudio/trends/databrowser3/messages.properties
@@ -304,6 +304,8 @@ UseUnixTimeStamp=Use UNIX time stamp (in ms)
 ValueAxes=Value Axes
 ValueAxisName=Axis Name
 ValueColumn=Value
+WaveformHistoryPrevious=Previous waveforms:
+WaveformHistoryPreviousTT=Number of previous waveforms to display
 WaveformIndex=Waveform Index
 WaveformIndexCol=Index
 WaveformIndexColTT=Waveform Index
@@ -313,4 +315,11 @@ WaveformTimeSelector=Select waveform by time
 WaveformTimestamp=Timestamp:
 WaveformView=Waveform View
 WaveformViewSelect=Select Items...
-YesAllPVsAreAddedToTheAxis=Yes, all PVs are added to the axis:
\ No newline at end of file
+YesAllPVsAreAddedToTheAxis=Yes, all PVs are added to the axis:
+WaveformHistoryStaggerTT=Stagger waveforms
+WaveformHistoryCursorTT=Show waveform cursor values
+WaveformHistorySample=Sample
+WaveformHistoryLimitSummary=Showing first {0} PVs (max {0})
+WaveformHistoryLimitTT=Inspect Waveforms currently supports up to {0} PVs. Additional selections are ignored.
+WaveformHistoryNonWaveformSummary=No waveform data: {0}
+WaveformHistoryNonWaveformTT=Selected PV(s) contain scalar rather than waveform array samples: {0}
diff --git a/app/databrowser/src/main/resources/org/csstudio/trends/databrowser3/messages_fr.properties b/app/databrowser/src/main/resources/org/csstudio/trends/databrowser3/messages_fr.properties
index e957d45ad5..18a4779f26 100644
--- a/app/databrowser/src/main/resources/org/csstudio/trends/databrowser3/messages_fr.properties
+++ b/app/databrowser/src/main/resources/org/csstudio/trends/databrowser3/messages_fr.properties
@@ -304,6 +304,8 @@ UseUnixTimeStamp=Utiliser l'horodatage UNIX (en ms)
 ValueAxes=Axes des valeurs
 ValueAxisName=Nom de l'axe
 ValueColumn=Valeur
+WaveformHistoryPrevious=Formes d'onde précédentes :
+WaveformHistoryPreviousTT=Nombre de formes d'onde précédentes à afficher
 WaveformIndex=Indice de la forme d'onde
 WaveformIndexCol=Indice
 WaveformIndexColTT=Indice de la forme d'onde
@@ -314,3 +316,11 @@ WaveformTimestamp=Horodatage :
 WaveformView=Vue de la forme d'onde
 WaveformViewSelect=Sélectionner un élément...
 YesAllPVsAreAddedToTheAxis=Oui, tous les PV sont ajoutés à l'axe :
+
+WaveformHistoryStaggerTT=Décaler les formes d’onde
+WaveformHistoryCursorTT=Afficher les valeurs du curseur des formes d’onde
+WaveformHistorySample=Échantillon
+WaveformHistoryLimitSummary=Affichage des {0} premières PV (maximum {0})
+WaveformHistoryLimitTT=L’inspection des formes d’onde prend en charge au maximum {0} PV. Les sélections supplémentaires sont ignorées.
+WaveformHistoryNonWaveformSummary=Aucune donnée de forme d’onde : {0}
+WaveformHistoryNonWaveformTT=Les PV sélectionnées contiennent des valeurs scalaires au lieu d’échantillons de tableaux : {0}
diff --git a/app/databrowser/src/test/java/org/csstudio/trends/databrowser3/ui/waveformview/WaveformHistoryChartTest.java b/app/databrowser/src/test/java/org/csstudio/trends/databrowser3/ui/waveformview/WaveformHistoryChartTest.java
new file mode 100644
index 0000000000..170fe3c0b7
--- /dev/null
+++ b/app/databrowser/src/test/java/org/csstudio/trends/databrowser3/ui/waveformview/WaveformHistoryChartTest.java
@@ -0,0 +1,32 @@
+package org.csstudio.trends.databrowser3.ui.waveformview;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.util.List;
+import org.junit.jupiter.api.Test;
+
+class WaveformHistoryChartTest {
+    @Test
+    void rangeIgnoresNonFiniteValues() {
+        double[] range = WaveformHistoryChart.rangeOf(List.of(
+                new double[]{Double.NaN, -5.0, Double.POSITIVE_INFINITY},
+                new double[]{7.0, Double.NEGATIVE_INFINITY, 2.0}));
+        assertEquals(-5.0, range[0]);
+        assertEquals(7.0, range[1]);
+    }
+
+    @Test
+    void emptyHistoryHasNoFiniteBounds() {
+        double[] range = WaveformHistoryChart.rangeOf(List.of());
+        assertTrue(Double.isInfinite(range[0]) && range[0] > 0);
+        assertTrue(Double.isInfinite(range[1]) && range[1] < 0);
+    }
+
+    @Test
+    void constantWaveformHasEqualBounds() {
+        double[] range = WaveformHistoryChart.rangeOf(List.of(new double[]{3, 3, 3}));
+        assertEquals(3, range[0]);
+        assertEquals(3, range[1]);
+    }
+}