---
title: "StackedListPlot"
language: "en"
type: "Symbol"
summary: "StackedListPlot[{data1, data2, ...}] plots lines for each of the datai, with the i\\[Null]^th curve being the accumulation of values in data1 through datai. StackedListPlot[{..., w[datai], ...}] plots datai with features defined by the symbolic wrapper w."
keywords: 
- stacked list plot
- accumulated list plot
- stacked line plot
- stacked line graph
- component curves
- components plot
canonical_url: "https://reference.wolfram.com/language/ref/StackedListPlot.html"
source: "Wolfram Language Documentation"
related_guides: 
  - 
    title: "Data Visualization"
    link: "https://reference.wolfram.com/language/guide/DataVisualization.en.md"
related_functions: 
  - 
    title: "StackedDateListPlot"
    link: "https://reference.wolfram.com/language/ref/StackedDateListPlot.en.md"
  - 
    title: "ListLinePlot"
    link: "https://reference.wolfram.com/language/ref/ListLinePlot.en.md"
  - 
    title: "ListStepPlot"
    link: "https://reference.wolfram.com/language/ref/ListStepPlot.en.md"
  - 
    title: "DateListPlot"
    link: "https://reference.wolfram.com/language/ref/DateListPlot.en.md"
  - 
    title: "BarChart"
    link: "https://reference.wolfram.com/language/ref/BarChart.en.md"
  - 
    title: "PieChart"
    link: "https://reference.wolfram.com/language/ref/PieChart.en.md"
  - 
    title: "Accumulate"
    link: "https://reference.wolfram.com/language/ref/Accumulate.en.md"
  - 
    title: "PlotLayout"
    link: "https://reference.wolfram.com/language/ref/PlotLayout.en.md"
---
# StackedListPlot

StackedListPlot[{data1, data2, …}] plots lines for each of the datai, with the i$$^{\text{th}}$$ curve being the accumulation of values in data1 through datai.

StackedListPlot[{…, w[datai], …}] plots datai with features defined by the symbolic wrapper w.

## Details and Options

* The ``datai`` have the following forms and interpretations:

{Subscript[y, 1],Subscript[y, 2],\[Ellipsis]}	heights {Subscript[y, 1],Subscript[y, 2],\[Ellipsis]} with automatic x values
      	{{Subscript[x, 1],Subscript[y, 1]},{Subscript[x, 2],Subscript[y, 2]},\[Ellipsis]}	values {{Subscript[x, 1],Subscript[y, 1]},{Subscript[x, 2],Subscript[y, 2]},\[Ellipsis]}
      	<\|"Subscript[k, 1]"->Subscript[y, 1],"Subscript[k, 2]"->Subscript[y, 2],\[Ellipsis]\|>	values {Subscript[y, 1],Subscript[y, 2],\[Ellipsis]}
      	<\|Subscript[x, 1]->Subscript[y, 1],Subscript[x, 2]->Subscript[y, 2],\[Ellipsis]\|>	key-value pairs {{Subscript[x, 1],Subscript[y, 1]},{Subscript[x, 2],Subscript[y, 2]},\[Ellipsis]}
      	{Subscript[y, 1]->"Subscript[lbl, 1]",Subscript[y, 2]->"Subscript[lbl, 2]",\[Ellipsis]}, {Subscript[y, 1],Subscript[y, 2],\[Ellipsis]}->{"Subscript[lbl, 1]","Subscript[lbl, 2]",\[Ellipsis]}	values {Subscript[y, 1],Subscript[y, 2],\[Ellipsis]} with labels {Subscript[lbl, 1],Subscript[lbl, 2],\[Ellipsis]}
      	SparseArray	values as a normal array
      	TimeSeries, EventSeries	time-value pairs
      	QuantityArray	magnitudes
      	WeightedData	unweighted values

* Data values ``xi`` and ``yi`` can be given in the following forms:

|                        |                               |
| ---------------------- | ----------------------------- |
| xi                     | a real-valued number          |
| Quantity[xi, unit]     | a quantity with a unit        |
| Around[xi, ei]         | value xi with uncertainty ei  |
| Interval[{xmin, xmax}] | values between xmin and xmax  |

* If necessary, the data will be sorted according to the ``xi``.

* The positive part of each ``datai`` is plotted on the positive axis and the negative part on the negative axis.

* Negative values of ``yi`` stack in the opposite direction from positive values.

* Values ``xi`` and ``yi`` that are not of the preceding form are taken to be missing and are not shown. Missing data is taken to be zero for accumulation purposes.

* ``StackedListPlot[Tabular[…] -> cspec]`` extracts and plots values from the tabular object using the column specification ``cspec``.

* The following forms of column specifications ``cspec`` are allowed for plotting tabular data:

|                                     |                                                   |
| ----------------------------------- | ------------------------------------------------- |
| {colx, coly}                        | plot column y against column x                    |
| {{colx1, coly1}, {colx2, coly2}, …} | plot column y1 agains column x1, y2 against x2, … |
| coly, {coly}                        | plot column y as a sequence of values             |
| {{coly1}, …, {colyi}, …}            | plot columns y1, y2, … as sequences of values     |

* The ``colx`` can also be ``Automatic``, in which case sequential values are generated using ``DataRange``.

* The following wrappers ``w`` can be used for the ``datai``:

|                                         |                                                        |
| --------------------------------------- | ------------------------------------------------------ |
| Annotation[datai, label]                | provide an annotation for the data                     |
| Button[datai, action]                   | define an action to execute when the data is clicked   |
| Callout[datai, label]                   | label the data with a callout                          |
| Callout[datai, label, pos]              | place the callout at relative position pos             |
| EventHandler[datai, events]             | define a general event handler for the data            |
| Highlighted[datai, effect]              | dynamically highlight fi with an effect                |
| Highlighted[datai, Placed[effect, pos]] | statically highlight fi with an effect at position pos |
| Hyperlink[datai, uri]                   | make the data a hyperlink                              |
| Labeled[datai, label]                   | label the data                                         |
| Labeled[datai, label, pos]              | place the label at relative position pos               |
| Legended[datai, label]                  | identify the data in a legend                          |
| PopupWindow[datai, cont]                | attach a popup window to the data                      |
| StatusArea[datai, label]                | display in the status area on mouseover                |
| Style[datai, styles]                    | show the data using the specified styles               |
| Tooltip[datai, label]                   | attach a tooltip to the curve                          |

* Wrappers ``w`` can be applied at multiple levels:

|                     |                            |
| ------------------- | -------------------------- |
| {…, w[yi], …}       | wrap the value yi in data  |
| {…, w[{xi, yi}], …} | wrap the point {xi, yi}    |
| w[datai]            | wrap the data              |
| w[{data1, …}]       | wrap a collection of datai |
| w1[w2[…]]           | use nested wrappers        |

* ``Callout``, ``Labeled`` and ``Placed`` can use the following positions ``pos``:

|                             |                                                            |
| --------------------------- | ---------------------------------------------------------- |
| Automatic                   | automatically placed labels                                |
| Above, Below, Before, After | positions around the curve                                 |
| x                           | near the curve at a position x                             |
| Scaled[s]                   | scaled position s along the curve                          |
| {s, Above}, {s, Below}, …   | relative position at position s along the curve            |
| {pos, epos}                 | epos in label placed at relative position pos of the curve |

* ``StackedListPlot`` has the same options as ``Graphics``, with the following additions and changes:  []

|                       |                     |                                                             |
| :-------------------- | :------------------ | :---------------------------------------------------------- |
| AspectRatio           | 1 / GoldenRatio     | ratio of height to width                                    |
| Axes                  | True                | whether to draw axes                                        |
| ClippingStyle         | None                | what to draw when lines are clipped                         |
| ColorFunction         | Automatic           | how to determine the coloring of lines                      |
| ColorFunctionScaling  | True                | whether to scale arguments to ColorFunction                 |
| DataRange             | Automatic           | the range of x values to assume for data                    |
| Filling               | Automatic           | filling under each line                                     |
| FillingStyle          | Automatic           | style to use for filling                                    |
| InterpolationOrder    | None                | the polynomial degree of curves used in joining data points |
| IntervalMarkers       | Automatic           | how to render uncertainty                                   |
| IntervalMarkersStyle  | Automatic           | style for uncertainty elements                              |
| LabelingFunction      | Automatic           | how to label points                                         |
| LabelingSize          | Automatic           | maximum size of callouts and labels                         |
| LabelingTarget        | Automatic           | how to determine automatic label positions                  |
| MaxPlotPoints         | Infinity            | the maximum number of points to include                     |
| Mesh                  | None                | how many mesh points to draw on each line                   |
| MeshFunctions         | {#1&}               | how to determine the placement of mesh points               |
| MeshShading           | None                | how to shade regions between mesh points                    |
| MeshStyle             | Automatic           | the style for mesh points                                   |
| Method                | Automatic           | methods to use                                              |
| PerformanceGoal       | \$PerformanceGoal   | aspects of performance to try to optimize                   |
| PlotFit               | None                | how to fit a curve to the points                            |
| PlotFitElements       | Automatic           | fitted elements to show in the plot                         |
| PlotHighlighting      | Automatic           | highlighting effect for curves                              |
| PlotInteractivity     | \$PlotInteractivity | whether to allow interactive elements                       |
| PlotLabel             | None                | overall label for the plot                                  |
| PlotLabels            | None                | labels for data                                             |
| PlotLayout            | "Stacked"           | how to position data                                        |
| PlotLegends           | None                | legends for data                                            |
| PlotMarkers           | None                | markers to use to indicate each point                       |
| PlotRange             | Automatic           | range of values to include                                  |
| PlotRangeClipping     | True                | whether to clip at the plot range                           |
| PlotStyle             | Automatic           | graphics directives to determine the style of each line     |
| PlotTheme             | \$PlotTheme         | overall theme for the plot                                  |
| ScalingFunctions      | None                | how to scale individual coordinates                         |
| TargetUnits           | Automatic           | units to display in the plot                                |

* ``DataRange`` determines how values ``{y1, …, yn}`` are interpreted into ``{{x1, y1}, …, {xn, yn}}``. Possible settings include:

|                |                           |
| -------------- | ------------------------- |
| Automatic, All | uniform from 1 to n       |
| {xmin, xmax}   | uniform from xmin to xmax |

* In general, a list of pairs ``{{x1, y1}, {x2, y2}, …}`` is interpreted as a list of points, but the setting ``DataRange -> All`` forces it to be interpreted as multiple data sources ``{{y11, y12}, {y21, y23}, …}``.

* ``LabelingFunction -> f`` specifies that each point should have a label given by ``f[value, index, lbls]``, where ``value`` is the value associated with the point, ``index`` is its position in the ``data``, and ``lbls`` is the list of relevant labels.

* The following settings for ``PlotLayout`` can be used to display multiple sets of data:

|         |              |                                            |
| ------- | ------------ | ------------------------------------------ |
| [image] | "Stacked"    | accumulate the data per axis               |
| [image] | "Percentile" | accumulate and normalize the data per axis |

* Typical settings for ``PlotLegends`` include:

|                  |                                    |
| ---------------- | ---------------------------------- |
| None             | no legend                          |
| Automatic        | automatically determine legend     |
| {lbl1, lbl2, …}  | use lbl1, lbl2, … as legend labels |
| Placed[lspec, …] | specify placement for legend       |

* ``ColorData["DefaultPlotColors"]`` gives the default sequence of colors used by ``PlotStyle``.

* ``ScalingFunctions -> "scale"`` scales the $y$ coordinate; ``ScalingFunctions -> {"scalex", "scaley"}`` scales both the $x$ and $y$ coordinates.

* Possible highlighting effects for ``Highlighted`` and ``PlotHighlighting`` include:

|         |                     |                                                                               |
| ------- | ------------------- | ----------------------------------------------------------------------------- |
| [image] | style               | highlight the indicated curve                                                 |
| [image] | "Ball"              | highlight and label the indicated point in a curve                            |
| [image] | "Dropline"          | highlight and label the indicated point in a curve with droplines to the axes |
| [image] | "XSlice"            | highlight and label all points along a vertical slice                         |
| [image] | "YSlice"            | highlight and label all points along a horizontal slice                       |
| [image] | Placed[effect, pos] | statically highlight the given position pos                                   |

* Highlight position specifications ``pos`` include:

|                 |                                              |
| --------------- | -------------------------------------------- |
| x, {x}          | effect at {x, y} with y chosen automatically |
| {x, y}          | effect at {x, y}                             |
| {pos1, pos2, …} | multiple positions posi                      |

### List of all options

|                        |                     |                                                                                    |
| ---------------------- | ------------------- | ---------------------------------------------------------------------------------- |
| AlignmentPoint         | Center              | the default point in the graphic to align with                                     |
| AspectRatio            | 1 / GoldenRatio     | ratio of height to width                                                           |
| Axes                   | True                | whether to draw axes                                                               |
| AxesLabel              | None                | axes labels                                                                        |
| AxesOrigin             | Automatic           | where axes should cross                                                            |
| AxesStyle              | {}                  | style specifications for the axes                                                  |
| Background             | None                | background color for the plot                                                      |
| BaselinePosition       | Automatic           | how to align with a surrounding text baseline                                      |
| BaseStyle              | {}                  | base style specifications for the graphic                                          |
| ClippingStyle          | None                | what to draw when lines are clipped                                                |
| ColorFunction          | Automatic           | how to determine the coloring of lines                                             |
| ColorFunctionScaling   | True                | whether to scale arguments to ColorFunction                                        |
| ContentSelectable      | Automatic           | whether to allow contents to be selected                                           |
| CoordinatesToolOptions | Automatic           | detailed behavior of the coordinates tool                                          |
| DataRange              | Automatic           | the range of x values to assume for data                                           |
| Epilog                 | {}                  | primitives rendered after the main plot                                            |
| Filling                | Automatic           | filling under each line                                                            |
| FillingStyle           | Automatic           | style to use for filling                                                           |
| FormatType             | TraditionalForm     | the default format type for text                                                   |
| Frame                  | False               | whether to put a frame around the plot                                             |
| FrameLabel             | None                | frame labels                                                                       |
| FrameStyle             | {}                  | style specifications for the frame                                                 |
| FrameTicks             | Automatic           | frame ticks                                                                        |
| FrameTicksStyle        | {}                  | style specifications for frame ticks                                               |
| GridLines              | None                | grid lines to draw                                                                 |
| GridLinesStyle         | {}                  | style specifications for grid lines                                                |
| ImageMargins           | 0.                  | the margins to leave around the graphic                                            |
| ImagePadding           | All                 | what extra padding to allow for labels etc.                                        |
| ImageSize              | Automatic           | the absolute size at which to render the graphic                                   |
| InterpolationOrder     | None                | the polynomial degree of curves used in joining data points                        |
| IntervalMarkers        | Automatic           | how to render uncertainty                                                          |
| IntervalMarkersStyle   | Automatic           | style for uncertainty elements                                                     |
| LabelingFunction       | Automatic           | how to label points                                                                |
| LabelingSize           | Automatic           | maximum size of callouts and labels                                                |
| LabelingTarget         | Automatic           | how to determine automatic label positions                                         |
| LabelStyle             | {}                  | style specifications for labels                                                    |
| MaxPlotPoints          | Infinity            | the maximum number of points to include                                            |
| Mesh                   | None                | how many mesh points to draw on each line                                          |
| MeshFunctions          | {#1&}               | how to determine the placement of mesh points                                      |
| MeshShading            | None                | how to shade regions between mesh points                                           |
| MeshStyle              | Automatic           | the style for mesh points                                                          |
| Method                 | Automatic           | methods to use                                                                     |
| PerformanceGoal        | \$PerformanceGoal   | aspects of performance to try to optimize                                          |
| PlotFit                | None                | how to fit a curve to the points                                                   |
| PlotFitElements        | Automatic           | fitted elements to show in the plot                                                |
| PlotHighlighting       | Automatic           | highlighting effect for curves                                                     |
| PlotInteractivity      | \$PlotInteractivity | whether to allow interactive elements                                              |
| PlotLabel              | None                | overall label for the plot                                                         |
| PlotLabels             | None                | labels for data                                                                    |
| PlotLayout             | "Stacked"           | how to position data                                                               |
| PlotLegends            | None                | legends for data                                                                   |
| PlotMarkers            | None                | markers to use to indicate each point                                              |
| PlotRange              | Automatic           | range of values to include                                                         |
| PlotRangeClipping      | True                | whether to clip at the plot range                                                  |
| PlotRangePadding       | Automatic           | how much to pad the range of values                                                |
| PlotRegion             | Automatic           | the final display region to be filled                                              |
| PlotStyle              | Automatic           | graphics directives to determine the style of each line                            |
| PlotTheme              | \$PlotTheme         | overall theme for the plot                                                         |
| PreserveImageOptions   | Automatic           | whether to preserve image options when displaying new versions of the same graphic |
| Prolog                 | {}                  | primitives rendered before the main plot                                           |
| RotateLabel            | True                | whether to rotate y labels on the frame                                            |
| ScalingFunctions       | None                | how to scale individual coordinates                                                |
| TargetUnits            | Automatic           | units to display in the plot                                                       |
| Ticks                  | Automatic           | axes ticks                                                                         |
| TicksStyle             | {}                  | style specifications for axes ticks                                                |

## Examples (132)

### Basic Examples (4)

Plot a stacked list of $y$ values:

```wl
In[1]:= StackedListPlot[{{3, 2, 1, 6, 4, 7, 7, 2, 3, 1}, {7, 8, 8, 3, 5, 9, 10, 3, 10, 10}, {10, 2, 4, 8, 4, 10, 8, 4, 5, 3}}]

Out[1]= [image]
```

---

Plot a stacked list of $x$, $y$ pairs:

```wl
In[1]:= d = {{{16, 78}, {25, 51}, {44, 87}, {64, 62}, {87, 16}, {93, 19}}, {{14, 34}, {41, 75}, {59, 80}, {61, 90}, {67, 19}, {79, 22}}, {{24, 93}, {36, 80}, {53, 53}, {93, 98}, {99, 55}, {100, 54}}};

In[2]:= StackedListPlot[d]

Out[2]= [image]
```

---

Identify the data with callouts:

```wl
In[1]:= StackedListPlot[MapIndexed[Callout[#, IntegerName[First[#2], "Ordinal"]]&, RandomInteger[{1, 10}, {3, 10}]], ImageSize -> 300]

Out[1]= [image]
```

---

Plot values including units:

```wl
In[1]:= StackedListPlot[Quantity[RandomInteger[{1, 10}, {3, 10}], "Centimeters"], AxesLabel -> Automatic]

Out[1]= [image]
```

### Scope (30)

#### General Data (5)

Lines are constructed taking into account points in all datasets:

```wl
In[1]:= d = {{{6.7, 5.4}, {7.8, 8.1}, {8.1, 7.0}, {8.9, 7.3}, {10., 9.}}, {{5.4, 5.9}, {7.8, 5.6}, {8., 7.8}, {8.5, 5.2}, {8.6, 7.}}, {{6.2, 8.4}, {6.3, 5.8}, {6.4, 9.9}, {6.5, 5.2}, {8.1, 8.0}}};

In[2]:= StackedListPlot[d, PlotMarkers -> Automatic]

Out[2]= [image]
```

---

Missing values are taken to be zero:

```wl
In[1]:= StackedListPlot[{{1, 2, 4, 2, 5, 1}, {1, 1, 1, Missing[], 1, 1}, {1, 2, 3, 4, 5, 6}}]

Out[1]= [image]
```

---

Negative points are stacked in the opposite direction:

```wl
In[1]:= data = {{1, -2, 3, 4, 5}, {1, 2, -3, 4, 5}, {1, 2, 3, -4, 5}};

In[2]:= StackedListPlot[data]

Out[2]= [image]
```

---

Change the layout to show data as percentiles:

```wl
In[1]:= d = RandomInteger[{1, 10}, {3, 10}];

In[2]:= StackedListPlot[d, PlotLayout -> "Percentile"]

Out[2]= [image]
```

---

Use ``ScalingFunctions`` to scale the axes:

```wl
In[1]:= d = RandomInteger[{1, 1000}, {3, 10}];

In[2]:= StackedListPlot[d, ScalingFunctions -> "Log"]

Out[2]= [image]
```

#### Tabular Data (1)

Get tabular data for historical populations of several countries:

```wl
In[1]:= tab = Tabular[IconizedObject[«Country populations»]]

Out[1]=
Tabular[Association["RawSchema" -> Association["ColumnProperties" -> 
     Association["Date" -> Association["ElementType" -> TypeSpecifier["Date"]["Integer64", "Year", 
          "Gregorian", None]], "UK" -> Association["ElementType" -> TypeSpecif ... ntity[1.2393916*^7, "People"], 
            Quantity[1.4604481*^7, "People"], Quantity[1.6928886*^7, "People"], 
            Quantity[1.8903313*^7, "People"], Quantity[2.1856965*^7, "People"], 
            Quantity[2.5544179*^7, "People"]}]]}}]]]]
```

Plot the total populations of France, UK and Japan from 1940 to 2020:

```wl
In[2]:= StackedListPlot[tab -> {{"Date", "France"}, {"Date", "UK"}, {"Date", "Japan"}}]

Out[2]= [image]
```

Show the populations as percentages of the total:

```wl
In[3]:= StackedListPlot[tab -> {{"Date", "France"}, {"Date", "UK"}, {"Date", "Japan"}}, PlotLayout -> "Percentile"]

Out[3]= [image]
```

Include legends for the plot, using the column names:

```wl
In[4]:= StackedListPlot[tab -> {{"Date", "France"}, {"Date", "Germany"}, {"Date", "Australia"}}, PlotLegends -> {"France", "UK", "Japan"}]

Out[4]= [image]
```

#### Special Data (5)

Use ``Quantity`` to include units with the data:

```wl
In[1]:= d = RandomInteger[{1, 10}, {3, 10}];

In[2]:= StackedListPlot[Quantity[d, "Meters"], AxesLabel -> Automatic]

Out[2]= [image]
```

---

Specify strings to use as labels:

```wl
In[1]:= d = {1, 4, 2, 3, 10, 8, 2};

In[2]:= StackedListPlot[{d -> {"a", "b", "c", "d", "e", "f", "g"}, d}]

Out[2]= [image]

In[3]:= StackedListPlot[{d, {2, 3, 5, 7, 11, 13, 17} -> {"a", "b", "c", "d", "e", "f", "g"}}]

Out[3]= [image]
```

---

Specify a location for labels:

```wl
In[1]:= d = {1, 4, 2, 3, 10, 8, 2};

In[2]:= StackedListPlot[{d, {2, 3, 5, 7, 11, 13, 17} -> {"a", "b", "c", "d", "e", "f", "g"}}, LabelingFunction -> Above]

Out[2]= [image]
```

---

Plot ``TimeSeries`` directly:

```wl
In[1]:= data = {CountryData["UnitedStates", {{"Population"}, {1988, 2013}}], CountryData["China", {{"Population"}, {1988, 2013}}]};

In[2]:= StackedListPlot[data, AxesLabel -> Automatic, PlotLabels -> {"USA", "China"}]

Out[2]= [image]
```

---

Plot data with uncertainty:

```wl
In[1]:= StackedListPlot[Table[Around[RandomInteger[{1, 25}], RandomReal[5]], 3, 10]]

Out[1]= [image]
```

Use intervals:

```wl
In[2]:= StackedListPlot[Table[Interval[RandomInteger[25, 2]], 3, 10]]

Out[2]= [image]

In[3]:= StackedListPlot[Table[Around[RandomInteger[{1, 25}], RandomReal[5]], 3, 10], IntervalMarkers -> "Bands"]

Out[3]= [image]
```

#### Data Wrappers (3)

Use wrappers on data sources or collections of data sources:

```wl
In[1]:= {StackedListPlot[{Style[{1, 2, 3}, Green], {4, 5, 6}}], StackedListPlot[Style[{{1, 2, 3}, {4, 5, 6}}, Blue]]}

Out[1]= {[image], [image]}
```

---

Use the value of each point as a tooltip:

```wl
In[1]:= d = {1, 4, 2, 3, 10, 8, 2};

In[2]:= StackedListPlot[{d, Tooltip@d}, Mesh -> Full]

Out[2]= [image]
```

Use a specific tooltip for the curve:

```wl
In[3]:= StackedListPlot[{d, Tooltip[d, "Second"]}]

Out[3]= [image]
```

---

Use ``PopupWindow`` to provide additional drilldown information:

```wl
In[1]:= d = {1, 4, 2, 3, 10, 8, 2};

In[2]:= StackedListPlot[{d, PopupWindow[{1, 2, 3}, Graphics[Circle[]]]}]

Out[2]= [image]
```

``Button`` can be used to trigger any action:

```wl
In[3]:= StackedListPlot[{d, Button[{1, 2, 3}, Speak["Hello"]]}]

Out[3]= [image]
```

#### Labeling and Legending (10)

Label data sources with ``Labeled`` :

```wl
In[1]:= data = RandomInteger[{1, 25}, {3, 10}];

In[2]:= StackedListPlot[MapThread[Labeled[#1, #2]&, {data, {"First", "Second", "Third"}}]]

Out[2]= [image]
```

---

Specify the labels with ``PlotLabels`` :

```wl
In[1]:= data = RandomInteger[{1, 25}, {3, 10}];

In[2]:= StackedListPlot[data, PlotLabels -> {"First", "Second", "Third"}]

Out[2]= [image]
```

---

Label data automatically with ``Callout`` :

```wl
In[1]:= data = RandomInteger[{1, 25}, {3, 10}];

In[2]:= StackedListPlot[{Callout[data[[1]], "First"], Callout[data[[2]], "Second"], Callout[data[[3]], "Third"]}]

Out[2]= [image]
```

Include legends for each curve:

```wl
In[3]:= StackedListPlot[data, PlotLegends -> {"First", "Second", "Third"}]

Out[3]= [image]
```

---

Specify the maximum size of labels:

```wl
In[1]:= data = Table[Labeled[Prime[i], RandomWord[]], {i, 10}];

In[2]:= StackedListPlot[{data, data}, LabelingSize -> 30]

Out[2]= [image]
```

Use the full label:

```wl
In[3]:= StackedListPlot[{data, data}, LabelingSize -> Full]

Out[3]= [image]
```

---

For dense sets of points, some labels may be turned into tooltips by default:

```wl
In[1]:= data = Sort[Table[Callout[RandomReal[1, 2], i], {i, 150}]];

In[2]:= StackedListPlot[{data, data}]

Out[2]= [image]
```

Increasing the size of the plot will show more labels:

```wl
In[3]:= StackedListPlot[{data, data}, ImageSize -> 400]

Out[3]= [image]
```

---

Use ``Legended`` to provide a legend for a specific dataset:

```wl
In[1]:=
upper = RandomReal[{1.5, 2}, 50];
lower = RandomReal[0.5, 50];

In[2]:= StackedListPlot[{lower, Legended[Mean[{lower, upper}], "average"], upper}]

Out[2]= [image]
```

Use ``Placed`` to change the legend location:

```wl
In[3]:= StackedListPlot[{lower, Legended[Mean[{lower, upper}], Placed["average", Below]], upper}]

Out[3]= [image]
```

---

Use association keys as labels:

```wl
In[1]:= StackedListPlot[<|"fibonacci" -> Fibonacci[Range[10]], "stacked primes" -> Prime[Range[10]]|>, PlotLabels -> Automatic, PlotLegends -> None]

Out[1]= [image]
```

---

Plots usually have interactive callouts showing the coordinates when you mouse over them:

```wl
In[1]:= StackedListPlot[{{...}, {...}}]

Out[1]= [image]
```

Including specific wrappers or interactions, such as tooltips, turns off the interactive features:

```wl
In[2]:= StackedListPlot[Callout[{...}, "hello", 13]]

Out[2]= [image]
```

---

Choose from multiple interactive highlighting effects:

```wl
In[1]:= {StackedListPlot[{{...}, {...}}, PlotHighlighting -> "Dropline"], StackedListPlot[{{...}, {...}}, PlotHighlighting -> "XSlice"]}

Out[1]= {[image], [image]}
```

---

Use ``Highlighted`` to emphasize specific points in a plot:

```wl
In[1]:= StackedListPlot[Highlighted[{{...}, {...}}, Placed["Ball", 7]]]

Out[1]= [image]
```

Highlight multiple points:

```wl
In[2]:= StackedListPlot[Highlighted[{{...}, {...}}, Placed["Ball", {{6}, {15}}]]]

Out[2]= [image]
```

#### Presentation (6)

Multiple curves are automatically colored to be distinct:

```wl
In[1]:= data = RandomInteger[{1, 25}, {3, 5, 2}];

In[2]:= StackedListPlot[data]

Out[2]= [image]
```

Provide explicit styling to different curves:

```wl
In[3]:= StackedListPlot[data, PlotStyle -> {Dashed, Red, Green}, PlotMarkers -> True]

Out[3]= [image]
```

Use a theme with simple ticks in a bold color scheme:

```wl
In[4]:= StackedListPlot[data, PlotTheme -> "Marketing"]

Out[4]= [image]
```

---

Add labels to the plot:

```wl
In[1]:= data = {{23, 17, 22, 8, 4, 14, 6, 18, 18, 3}, {9, 16, 2, 24, 2, 12, 5, 25, 11, 4}};

In[2]:= StackedListPlot[data, AxesLabel -> {k, None}, PlotLabel -> "Stacked data"]

Out[2]= [image]
```

---

Add tooltips to the data:

```wl
In[1]:=
data1 = {23, 17, 22, 8, 4, 14, 6, 18, 18, 3};
data2 = {9, 16, 2, 24, 2, 12, 5, 25, 11, 4};

In[2]:= StackedListPlot[{Tooltip[data1, "first"], Tooltip[data2, "second"]}]

Out[2]= [image]
```

---

Fill between specific curves:

```wl
In[1]:= StackedListPlot[RandomInteger[{1, 25}, {2, 10}], Filling -> {1 -> {2}}]

Out[1]= [image]
```

---

Create an overlay mesh:

```wl
In[1]:= StackedListPlot[RandomInteger[{1, 25}, {3, 5, 2}], Mesh -> 10]

Out[1]= [image]
```

---

Style the curve segments between mesh points:

```wl
In[1]:= StackedListPlot[RandomInteger[{1, 25}, {3, 5, 2}], Mesh -> 10, MeshShading -> {Red, None, Blue}]

Out[1]= [image]
```

### Options (95)

#### AspectRatio (4)

By default, ``StackedListPlot`` uses a fixed height-to-width ratio for the plot:

```wl
In[1]:= StackedListPlot[RandomInteger[{1, 10}, {3, 10}]]

Out[1]= [image]
```

---

Make the height the same as the width with ``AspectRatio -> 1`` :

```wl
In[1]:= StackedListPlot[RandomInteger[{1, 10}, {3, 10}], AspectRatio -> 1]

Out[1]= [image]
```

---

``AspectRatio -> Automatic`` determines the ratio from the plot ranges:

```wl
In[1]:= StackedListPlot[RandomInteger[{1, 10}, {3, 10}], AspectRatio -> Automatic]

Out[1]= [image]
```

---

``AspectRatio -> Full`` adjusts the height and width to tightly fit inside other constructs:

```wl
In[1]:=
plot = StackedListPlot[RandomInteger[{1, 10}, {3, 10}], AspectRatio -> Full];
{Framed[Pane[plot, {50, 100}]], Framed[Pane[plot, {100, 100}]], Framed[Pane[plot, {100, 50}]]}

Out[1]= {[image], [image], [image]}
```

#### Axes (3)

By default, axes are drawn:

```wl
In[1]:= StackedListPlot[RandomInteger[{1, 10}, {3, 10}]]

Out[1]= [image]
```

---

Use ``Axes -> False`` to turn off axes:

```wl
In[1]:= StackedListPlot[RandomInteger[{1, 10}, {3, 10}], Axes -> False]

Out[1]= [image]
```

---

Turn on each axis individually:

```wl
In[1]:= {StackedListPlot[RandomInteger[{1, 10}, {3, 10}], Axes -> {True, False}], StackedListPlot[RandomInteger[{1, 10}, {3, 10}], Axes -> {False, True}]}

Out[1]= {[image], [image]}
```

#### AxesLabel (4)

No axes labels are drawn by default:

```wl
In[1]:= StackedListPlot[RandomInteger[{1, 10}, {3, 10}], Frame -> False, Axes -> True]

Out[1]= [image]
```

---

Place a label on the $y$ axis:

```wl
In[1]:= StackedListPlot[RandomInteger[{1, 10}, {3, 10}], Frame -> False, Axes -> True, AxesLabel -> value]

Out[1]= [image]
```

---

Specify axes labels:

```wl
In[1]:= StackedListPlot[RandomInteger[{1, 10}, {3, 10}], Frame -> False, Axes -> True, AxesLabel -> {position, value}]

Out[1]= [image]
```

---

Use units as labels:

```wl
In[1]:= StackedListPlot[QuantityArray[RandomInteger[{1, 10}, {3, 10}], "Meters"], Frame -> False, Axes -> True, AxesLabel -> Automatic]

Out[1]= [image]
```

#### AxesOrigin (2)

The position of the axes is determined automatically:

```wl
In[1]:= StackedListPlot[RandomInteger[{1, 10}, {3, 10}], Frame -> False, Axes -> True]

Out[1]= [image]
```

---

Specify an explicit origin for the axes:

```wl
In[1]:= StackedListPlot[RandomInteger[{1, 10}, {3, 10}], Frame -> False, Axes -> True, AxesOrigin -> {6, 0}]

Out[1]= [image]
```

#### AxesStyle (4)

Change the style for the axes:

```wl
In[1]:= StackedListPlot[RandomInteger[{1, 10}, {3, 10}], AxesStyle -> Red]

Out[1]= [image]
```

---

Specify the style of each axis:

```wl
In[1]:= StackedListPlot[RandomInteger[{1, 10}, {3, 10}], AxesStyle -> {{Thick, Red}, {Thick, Blue}}]

Out[1]= [image]
```

---

Use different styles for the ticks and the axes:

```wl
In[1]:= StackedListPlot[RandomInteger[{1, 10}, {3, 10}], AxesStyle -> Green, TicksStyle -> Black]

Out[1]= [image]
```

---

Use different styles for the labels and the axes:

```wl
In[1]:= StackedListPlot[RandomInteger[{1, 10}, {3, 10}], AxesStyle -> Green, LabelStyle -> Black]

Out[1]= [image]
```

#### ClippingStyle (1)

Omit clipped regions of the plot:

```wl
In[1]:= d = Table[Sin[x], {x, -3, 3}];

In[2]:= StackedListPlot[{d, d}, PlotRange -> {-.7, .7}, ClippingStyle -> {Red, Green}]

Out[2]= [image]
```

Show the clipped regions like the rest of the curve:

```wl
In[3]:= StackedListPlot[{d, d}, ClippingStyle -> Automatic, PlotRange -> {-.7, .7}, PlotStyle -> Thick]

Out[3]= [image]
```

Show clipped regions with red lines:

```wl
In[4]:= StackedListPlot[{d, d}, PlotRange -> {-.7, .7}, ClippingStyle -> Red]

Out[4]= [image]
```

Show clipped regions as red at the bottom and thick at the top:

```wl
In[5]:= StackedListPlot[{d, d}, PlotRange -> {-.7, .7}, ClippingStyle -> {Red, Thick}]

Out[5]= [image]
```

Show clipped regions as red and thick:

```wl
In[6]:= StackedListPlot[{d, d}, PlotRange -> {-.7, .7}, ClippingStyle -> Directive[Red, Thick]]

Out[6]= [image]
```

#### DataRange (4)

Lists of height values are displayed against the number of elements:

```wl
In[1]:= StackedListPlot[RandomInteger[{1, 10}, {3, 10}]]

Out[1]= [image]
```

Rescale to the sampling space:

```wl
In[2]:= StackedListPlot[RandomInteger[{1, 10}, {3, 10}], DataRange -> {0, 2}]

Out[2]= [image]
```

---

Each dataset is scaled to the same domain:

```wl
In[1]:= StackedListPlot[RandomInteger[{1, 10}, {3, 10}], DataRange -> {0, 1}]

Out[1]= [image]
```

---

Pairs are interpreted as $x$, $y$ coordinates:

```wl
In[1]:= d = Transpose[{Range[10], #}]& /@ RandomInteger[{1, 10}, {3, 10}];

In[2]:= StackedListPlot[d]

Out[2]= [image]
```

Specifying ``DataRange`` in this case has no effect, since $x$ values are part of the data:

```wl
In[3]:= StackedListPlot[d, DataRange -> {0, 1}]

Out[3]= [image]
```

---

Force interpretation as multiple datasets:

```wl
In[1]:= StackedListPlot[{{1, 1}, {2, 2}, {3, 2}}, DataRange -> All, AxesOrigin -> {1, 0}]

Out[1]= [image]
```

#### Filling (3)

Use symbolic or explicit values:

```wl
In[1]:= d = RandomInteger[{1, 10}, {3, 10}];

In[2]:= Table[StackedListPlot[d, Filling -> c], {c, {Top, Bottom, Axis, Prime[15]}}]

Out[2]= {[image], [image], [image], [image]}
```

---

Fills that overlap by default combine using opacity:

```wl
In[1]:= StackedListPlot[RandomInteger[{1, 10}, {3, 10}], Filling -> Axis]

Out[1]= [image]
```

Fill between the first curve and the axis:

```wl
In[2]:= StackedListPlot[RandomInteger[{1, 10}, {3, 10}], Filling -> {1 -> Axis}]

Out[2]= [image]
```

---

Fill between two lines:

```wl
In[1]:= StackedListPlot[RandomInteger[{1, 10}, {3, 10}], Filling -> {1 -> {2}}]

Out[1]= [image]
```

Fill between curves 1 and 2 with a specific style:

```wl
In[2]:= StackedListPlot[RandomInteger[{1, 10}, {3, 10}], Filling -> {1 -> {{2}, Hue[.6]}}]

Out[2]= [image]
```

Fill between curves 1 and $y=\frac{1}{2}$ with light orange:

```wl
In[3]:= StackedListPlot[RandomInteger[{1, 10}, {3, 10}], Filling -> {1 -> {1 / 2, LightOrange}}]

Out[3]= [image]
```

#### FillingStyle (2)

Use different fill colors:

```wl
In[1]:= d = RandomInteger[{1, 10}, {2, 10}];

In[2]:= Table[StackedListPlot[d, Filling -> Axis, FillingStyle -> c], {c, {Red, Green, Blue, Yellow}}]

Out[2]= {[image], [image], [image], [image]}
```

---

Fill with opacity 0.5 orange:

```wl
In[1]:= StackedListPlot[RandomInteger[{1, 10}, {3, 10}], Filling -> Axis, FillingStyle -> Directive[Opacity[0.5], Orange]]

Out[1]= [image]
```

Fill with red below the axis and with blue above:

```wl
In[2]:= StackedListPlot[RandomInteger[{-10, 10}, {3, 10}], Filling -> Axis, FillingStyle -> {Red, Blue}]

Out[2]= [image]
```

Use a variable filling style obtained from ``ColorFunction`` :

```wl
In[3]:= StackedListPlot[RandomInteger[{1, 10}, {3, 10}], ColorFunction -> Function[{x, y}, Hue[y]], Filling -> Axis, FillingStyle -> Automatic]

Out[3]= [image]
```

#### ImageSize (7)

Use named sizes such as ``Tiny``, ``Small``, ``Medium`` and ``Large`` :

```wl
In[1]:= {StackedListPlot[RandomInteger[{1, 10}, {3, 10}], ImageSize -> Tiny], StackedListPlot[RandomInteger[{1, 10}, {3, 10}], ImageSize -> Small]}

Out[1]= {[image], [image]}
```

---

Specify the width of the plot:

```wl
In[1]:= {StackedListPlot[RandomInteger[{1, 10}, {3, 10}], ImageSize -> 150], StackedListPlot[RandomInteger[{1, 10}, {3, 10}], AspectRatio -> 1.5, ImageSize -> 150]}

Out[1]= {[image], [image]}
```

Specify the height of the plot:

```wl
In[2]:= {StackedListPlot[RandomInteger[{1, 10}, {3, 10}], ImageSize -> {Automatic, 150}], StackedListPlot[RandomInteger[{1, 10}, {3, 10}], AspectRatio -> 2, ImageSize -> {Automatic, 150}]}

Out[2]= {[image], [image]}
```

---

Allow the width and height to be up to a certain size:

```wl
In[1]:= {StackedListPlot[RandomInteger[{1, 10}, {3, 10}], ImageSize -> UpTo[200]], StackedListPlot[RandomInteger[{1, 10}, {3, 10}], AspectRatio -> 2, ImageSize -> UpTo[200]]}

Out[1]= {[image], [image]}
```

---

Specify the width and height for a graphic, padding with space if necessary:

```wl
In[1]:= StackedListPlot[RandomInteger[{1, 10}, {3, 10}], ImageSize -> {200, 300}, Background -> LightBlue]

Out[1]= [image]
```

Setting ``AspectRatio -> Full`` will fill the available space:

```wl
In[2]:= StackedListPlot[RandomInteger[{1, 10}, {3, 10}], AspectRatio -> Full, ImageSize -> {200, 300}, Background -> LightBlue]

Out[2]= [image]
```

---

Use maximum sizes for the width and height:

```wl
In[1]:= {StackedListPlot[RandomInteger[{1, 10}, {3, 10}], ImageSize -> {UpTo[150], UpTo[100]}], StackedListPlot[RandomInteger[{1, 10}, {3, 10}], AspectRatio -> 2, ImageSize -> {UpTo[150], UpTo[100]}]}

Out[1]= {[image], [image]}
```

---

Use ``ImageSize -> Full`` to fill the available space in an object:

```wl
In[1]:= Framed[Pane[StackedListPlot[RandomInteger[{1, 10}, {3, 10}], ImageSize -> Full, Background -> LightBlue], {200, 100}]]

Out[1]= [image]
```

---

Specify the image size as a fraction of the available space:

```wl
In[1]:= Framed[Pane[StackedListPlot[RandomInteger[{1, 10}, {3, 10}], AspectRatio -> Full, ImageSize -> {Scaled[0.5], Scaled[0.5]}, Background -> LightBlue], {200, 200}]]

Out[1]= [image]
```

#### InterpolationOrder (1)

Points are normally joined with straight lines:

```wl
In[1]:= StackedListPlot[RandomInteger[{1, 10}, {3, 10}], Mesh -> Full]

Out[1]= [image]
```

Use quadratic spline interpolation to fit the data:

```wl
In[2]:= StackedListPlot[RandomInteger[{1, 10}, {3, 10}], InterpolationOrder -> 2, Mesh -> Full]

Out[2]= [image]
```

Use flat regions with steps at each data point:

```wl
In[3]:= StackedListPlot[RandomInteger[{1, 10}, {3, 10}], InterpolationOrder -> 0, Mesh -> Full]

Out[3]= [image]
```

#### IntervalMarkers (3)

By default, uncertainties are capped:

```wl
In[1]:= StackedListPlot[Table[Around[RandomInteger[{1, 25}], RandomReal[3]], 3, 10]]

Out[1]= [image]
```

---

Use bars to denote uncertainties without caps:

```wl
In[1]:= StackedListPlot[Table[Around[RandomInteger[{1, 25}], RandomReal[3]], 3, 10], IntervalMarkers -> "Bars"]

Out[1]= [image]
```

---

Use bands to represent uncertainties:

```wl
In[1]:= StackedListPlot[Table[Around[RandomInteger[{1, 25}], RandomReal[3]], 3, 10], IntervalMarkers -> "Bands"]

Out[1]= [image]
```

#### IntervalMarkersStyle (2)

Uncertainties automatically inherit the plot style:

```wl
In[1]:= StackedListPlot[Table[Around[RandomInteger[{1, 25}], RandomReal[3]], 2, 10], PlotStyle -> {Red, Blue}]

Out[1]= [image]
```

---

Specify the style for uncertainties:

```wl
In[1]:= StackedListPlot[Table[Around[RandomInteger[{1, 25}], RandomReal[3]], 2, 10], IntervalMarkersStyle -> Gray]

Out[1]= [image]
```

#### LabelingFunction (1)

By default, points are automatically labeled with strings:

```wl
In[1]:= d = {1, 4, 2, 3, 10, 8, 2};

In[2]:= StackedListPlot[{d -> {"a", "b", "c", "d", "e", "f", "g"}, d}]

Out[2]= [image]
```

Use ``LabelingFunction -> None`` to suppress the labels:

```wl
In[3]:= StackedListPlot[{d -> {"a", "b", "c", "d", "e", "f", "g"}, d}, LabelingFunction -> None]

Out[3]= [image]
```

Put the labels above the points:

```wl
In[4]:= StackedListPlot[{d -> {"a", "b", "c", "d", "e", "f", "g"}, d}, LabelingFunction -> Above]

Out[4]= [image]
```

Use callouts to label the points:

```wl
In[5]:= StackedListPlot[{d -> {"a", "b", "c", "d", "e", "f"}, d}, LabelingFunction -> Callout[Automatic, Automatic]]

Out[5]= [image]
```

Label the points with their values:

```wl
In[6]:= StackedListPlot[{d -> {"a", "b", "c", "d", "e", "f", "g"}, d}, LabelingFunction -> (#1&)]

Out[6]= [image]
```

Label the points with their indices:

```wl
In[7]:= StackedListPlot[{d -> {"a", "b", "c", "d", "e", "f", "g"}, d}, LabelingFunction -> (#2&)]

Out[7]= [image]
```

#### LabelingSize (4)

Textual labels are shown at their actual sizes:

```wl
In[1]:= data = {1, 1, 2, 3, 5, 8} -> {"healthfulness", "obstreperous", "spectrogram", "vestige", "coinage", "limey"};

In[2]:= StackedListPlot[{data, data}, ImageSize -> Medium]

Out[2]= [image]
```

---

Image labels are automatically resized:

```wl
In[1]:= data = {1, 1, 2, 3, 5, 8} -> {[image], [image], [image], [image], [image], [image]};

In[2]:= StackedListPlot[{data, data}, ImageSize -> Medium]

Out[2]= [image]
```

---

Specify a maximum size for textual labels:

```wl
In[1]:= data = {1, 1, 2, 3, 5, 8} -> {"healthfulness", "obstreperous", "spectrogram", "vestige", "coinage", "limey"};

In[2]:= StackedListPlot[{data, data}, ImageSize -> Medium, LabelingSize -> 30]

Out[2]= [image]
```

Specify a maximum size for image labels:

```wl
In[3]:= data = {1, 1, 2, 3, 5, 8} -> {[image], [image], [image], [image], [image], [image]};

In[4]:= StackedListPlot[{data, data}, ImageSize -> Medium, LabelingSize -> 20]

Out[4]= [image]
```

---

Show image labels at their natural sizes:

```wl
In[1]:= data = {1, 1, 2, 3, 5, 8} -> {[image], [image], [image], [image], [image], [image]};

In[2]:= StackedListPlot[{data, data}, ImageSize -> Medium, LabelingSize -> Full]

Out[2]= [image]
```

#### LabelingTarget (6)

Labels are automatically placed to maximize readability:

```wl
In[1]:= StackedListPlot[{IconizedObject[«Subscript[data, 1]»], IconizedObject[«Subscript[data, 2]»]}]

Out[1]= [image]
```

---

Show all labels:

```wl
In[1]:= StackedListPlot[{IconizedObject[«Subscript[data, 1]»], IconizedObject[«Subscript[data, 2]»]}, LabelingTarget -> All]

Out[1]= [image]
```

---

Use a denser layout for the labels:

```wl
In[1]:= StackedListPlot[{IconizedObject[«Subscript[data, 1]»], IconizedObject[«Subscript[data, 2]»]}, LabelingTarget -> "Dense"]

Out[1]= [image]
```

---

Show the half of the labels that are easiest to read:

```wl
In[1]:= StackedListPlot[{IconizedObject[«Subscript[data, 1]»], IconizedObject[«Subscript[data, 2]»]}, LabelingTarget -> 0.5]

Out[1]= [image]
```

---

Only allow labels that are orthogonal to the points:

```wl
In[1]:= StackedListPlot[{IconizedObject[«Subscript[data, 1]»], IconizedObject[«Subscript[data, 2]»]}, LabelingTarget -> <|"AllowedLabelingPositions" -> "Sides"|>]

Out[1]= [image]
```

Only allow labels that are diagonal to the points:

```wl
In[2]:= StackedListPlot[{IconizedObject[«Subscript[data, 1]»], IconizedObject[«Subscript[data, 2]»]}, LabelingTarget -> <|"AllowedLabelingPositions" -> "Corners"|>]

Out[2]= [image]
```

---

Allow labels to be clipped by the edges of the plot:

```wl
In[1]:= StackedListPlot[{IconizedObject[«Subscript[data, 1]»], IconizedObject[«Subscript[data, 2]»]}, LabelingTarget -> <|"AllowLabelClipping" -> True|>]

Out[1]= [image]
```

#### MaxPlotPoints (1)

All points are included by default:

```wl
In[1]:= d = RandomInteger[{1, 10}, {3, 10}];

In[2]:= StackedListPlot[d]

Out[2]= [image]
```

Uniformly spaced data is downsampled:

```wl
In[3]:= Table[StackedListPlot[d, MaxPlotPoints -> mp], {mp, {Infinity, 5, 2}}]

Out[3]= {[image], [image], [image]}
```

#### Mesh (1)

The initial and final sampling meshes are typically the same:

```wl
In[1]:= d = RandomInteger[{1, 10}, {3, 10}];

In[2]:= {StackedListPlot[d, Mesh -> Full], StackedListPlot[d, Mesh -> All]}

Out[2]= {[image], [image]}
```

Interpolated data may introduce points:

```wl
In[3]:= {StackedListPlot[d, Mesh -> Full, InterpolationOrder -> 2], StackedListPlot[d, Mesh -> All, InterpolationOrder -> 2]}

Out[3]= [image]
```

Use 20 mesh levels evenly spaced in the $x$ direction:

```wl
In[4]:= StackedListPlot[d, Mesh -> 20]

Out[4]= [image]
```

Use an explicit list of values for the mesh in the $x$ direction:

```wl
In[5]:= StackedListPlot[d, Mesh -> {Range[0, 2Pi, Pi / 4]}, MeshStyle -> PointSize[Medium]]

Out[5]= [image]
```

Specify style and mesh levels in the $x$ direction:

```wl
In[6]:= StackedListPlot[d, Mesh -> {Table[{x, Hue[x / (2Pi)]}, {x, 0., 2Pi, 2Pi / 8}]}]

Out[6]= [image]
```

#### MeshFunctions (1)

Use a mesh evenly spaced in the $x$ and $y$ directions:

```wl
In[1]:= d = RandomInteger[{1, 10}, {3, 10}];

In[2]:= Table[StackedListPlot[d, MeshFunctions -> {Function[{x, y}, Evaluate[f]]}, Mesh -> 9, PlotLabel -> f], {f, {x, y}}]

Out[2]= {[image], [image]}
```

Show 5 mesh levels in the $x$ direction (red) and 10 in the $y$ direction (blue):

```wl
In[3]:= StackedListPlot[d, Mesh -> {3, 10}, MeshFunctions -> {#1&, #2&}, MeshStyle -> {Directive[PointSize[Medium], Red], Blue}]

Out[3]= [image]
```

#### MeshShading (1)

Alternate red and blue segments of equal width in the $x$ direction:

```wl
In[1]:= d = RandomInteger[{1, 10}, {3, 10}];

In[2]:= StackedListPlot[d, Mesh -> 10, MeshFunctions -> {#1&}, MeshShading -> {Red, Blue}]

Out[2]= [image]
```

Use ``None`` to remove segments:

```wl
In[3]:= StackedListPlot[d, Mesh -> 10, MeshFunctions -> {#1&}, MeshShading -> {Red, None}]

Out[3]= [image]
```

``MeshShading`` can be used with ``PlotStyle`` :

```wl
In[4]:= StackedListPlot[d, Mesh -> 10, PlotStyle -> Thick, MeshFunctions -> {#1&}, MeshShading -> {Red, Blue}]

Out[4]= [image]
```

``MeshShading`` has higher priority than ``PlotStyle`` for styling the curve:

```wl
In[5]:= StackedListPlot[d, Mesh -> 10, PlotStyle -> Black, MeshFunctions -> {#1&}, MeshShading -> {Red, Blue}]

Out[5]= [image]
```

Use ``PlotStyle`` for some segments by setting ``MeshShading`` to ``Automatic`` :

```wl
In[6]:= StackedListPlot[d, Mesh -> 10, PlotStyle -> Directive[Thick, Yellow], MeshFunctions -> {#1&}, MeshShading -> {Red, Automatic}]

Out[6]= [image]
```

``MeshShading`` can be used with ``ColorFunction`` :

```wl
In[7]:=
StackedListPlot[d, Mesh -> 10, PlotStyle -> Thick, MeshFunctions -> {#1&}, MeshShading -> {Black, Automatic}, 
	ColorFunction -> Function[{x, y}, Hue[x]]]

Out[7]= [image]
```

#### MeshStyle (1)

Color the mesh the same color as the plot:

```wl
In[1]:= d = RandomInteger[{1, 10}, {3, 10}];

In[2]:= StackedListPlot[d, Mesh -> 10, MeshStyle -> Automatic]

Out[2]= [image]
```

Use a red mesh in the $x$ direction:

```wl
In[3]:= StackedListPlot[d, Mesh -> 10, MeshStyle -> Red]

Out[3]= [image]
```

Use a red mesh in the $x$ direction and a blue mesh in the $y$ direction:

```wl
In[4]:= StackedListPlot[d, Mesh -> 10, MeshStyle -> {Red, Blue}, MeshFunctions -> {#1&, #2&}]

Out[4]= [image]
```

Use big red mesh points in the $x$ direction:

```wl
In[5]:= StackedListPlot[d, Mesh -> 10, MeshStyle -> Directive[PointSize[Large], Red]]

Out[5]= [image]
```

#### PlotHighlighting (7)

Plots have interactive coordinate callouts with the default setting ``PlotHighlighting -> Automatic`` :

```wl
In[1]:= StackedListPlot[{IconizedObject[«primes»], IconizedObject[«squares»]}]

Out[1]= [image]
```

Use ``PlotHighlighting -> None`` to disable the highlighting for the entire plot:

```wl
In[2]:= StackedListPlot[{IconizedObject[«primes»], IconizedObject[«squares»]}, PlotHighlighting -> None]

Out[2]= [image]
```

Use ``Highlighted[…, None]`` to disable highlighting for a single set:

```wl
In[3]:= StackedListPlot[{IconizedObject[«primes»], Highlighted[IconizedObject[«squares»], None]}]

Out[3]= [image]
```

---

Move the mouse over the curve to highlight it with a label and droplines to the axes:

```wl
In[1]:= StackedListPlot[{IconizedObject[«primes»], IconizedObject[«squares»]}, PlotHighlighting -> "Dropline"]

Out[1]= [image]
```

Use a ball and label to highlight a specific point in the plot:

```wl
In[2]:= StackedListPlot[Highlighted[{IconizedObject[«primes»], IconizedObject[«squares»]}, Placed["Dropline", 15]]]

Out[2]= [image]
```

---

Move the mouse over the plot to highlight it with a slice showing $y$ values corresponding to the $x$ position:

```wl
In[1]:= StackedListPlot[{IconizedObject[«primes»], IconizedObject[«squares»]}, PlotHighlighting -> "XSlice"]

Out[1]= [image]
```

Highlight a particular set of points at a fixed $x$ value:

```wl
In[2]:= StackedListPlot[{Highlighted[IconizedObject[«primes»], Placed["XSlice", 17]], IconizedObject[«squares»]}]

Out[2]= [image]
```

---

Move the mouse over the plot to highlight it with a slice showing $x$ values corresponding to the $y$ position:

```wl
In[1]:= StackedListPlot[{IconizedObject[«data»], IconizedObject[«squares»]}, PlotHighlighting -> "YSlice"]

Out[1]= [image]
```

---

Use a component that shows the points on the plot closest to the $x$ position of the mouse cursor:

```wl
In[1]:= StackedListPlot[{IconizedObject[«primes»], IconizedObject[«squares»]}, PlotHighlighting -> "XNearestPoint"]

Out[1]= [image]
```

Specify the style for the points:

```wl
In[2]:= StackedListPlot[{IconizedObject[«primes»], IconizedObject[«squares»]}, PlotHighlighting -> {"XNearestPoint", <|"Style" -> Black|>}]

Out[2]= [image]
```

---

Use a component that shows the coordinates on the points closest to the mouse cursor:

```wl
In[1]:= StackedListPlot[{IconizedObject[«primes»], IconizedObject[«squares»]}, PlotHighlighting -> "XYLabel"]

Out[1]= [image]
```

Use ``Callout`` options to change the appearance of the label:

```wl
In[2]:= StackedListPlot[{IconizedObject[«primes»], IconizedObject[«squares»]}, PlotHighlighting -> {"XYLabel", <|"Appearance" -> "Corners", "CalloutMarker" -> "Circle"|>}]

Out[2]= [image]
```

---

Combine components to create a custom effect:

```wl
In[1]:= StackedListPlot[{IconizedObject[«primes»], IconizedObject[«squares»]}, PlotHighlighting -> {{"XNearestPoint", <|"Style" -> Black|>}, {"XYLabel", <|"Appearance" -> "Corners", "CalloutMarker" -> "Circle"|>}}]

Out[1]= [image]
```

#### PlotInteractivity (4)

Plots have interactive highlighting by default:

```wl
In[1]:= StackedListPlot[{{2, 3, 5, 7, 11}, {13, 17, 19, 23, 29}}]

Out[1]= [image]
```

---

Turn off all the interactive elements:

```wl
In[1]:= StackedListPlot[{{2, 3, 5, 7, 11}, {13, 17, 19, 23, 29}}, PlotInteractivity -> False]

Out[1]= [image]
```

---

Interactive elements provided as part of the input are disabled:

```wl
In[1]:= StackedListPlot[{{2, 3, 5, 7, 11}, Tooltip[{13, 17, 19, 23, 29}, "hello"]}, PlotInteractivity -> False]

Out[1]= [image]
```

---

Allow provided interactive elements and disable automatic ones:

```wl
In[1]:= StackedListPlot[{{2, 3, 5, 7, 11}, Tooltip[{13, 17, 19, 23, 29}, "hello"]}, PlotInteractivity -> <|"User" -> True, "System" -> False|>]

Out[1]= [image]
```

#### PlotLabel (1)

Add an overall label to the plot:

```wl
In[1]:= d = Prime[Range[100]];

In[2]:= StackedListPlot[{d, d}, PlotLabel -> "Accumulated prime numbers"]

Out[2]= [image]
```

#### PlotLabels (5)

Specify text to label sets of points:

```wl
In[1]:= StackedListPlot[RandomInteger[{1, 10}, {3, 10}], PlotLabels -> Range[10], Filling -> None, ImageSize -> 300]

Out[1]= [image]
```

---

Place the labels above the points:

```wl
In[1]:= StackedListPlot[RandomInteger[{1, 10}, {3, 10}], Filling -> None, ImageSize -> 300, PlotLabels -> Placed[Range[10], Above]]

Out[1]= [image]
```

---

Use callouts to identify the datasets:

```wl
In[1]:= StackedListPlot[RandomInteger[{1, 10}, {3, 10}], Filling -> None, ImageSize -> 300, PlotLabels -> (Callout[#, {Scaled[0.25]}]& /@ Range[5])]

Out[1]= [image]
```

---

Label curves with the keys from an association:

```wl
In[1]:= StackedListPlot[<|"Set 1" -> RandomInteger[{1, 10}, 10], "Set 2" -> RandomInteger[{1, 10}, 10]|>, PlotLabels -> Automatic, PlotLegends -> None]

Out[1]= [image]
```

---

Use ``None`` to not label a data source:

```wl
In[1]:= StackedListPlot[RandomInteger[{1, 10}, {2, 10}], PlotLabels -> {"Set 1", None}]

Out[1]= [image]
```

#### PlotLayout (1)

```wl
In[1]:= data = Accumulate /@ RandomReal[{0, 5}, {3, 20}];

In[2]:= StackedListPlot[data]

Out[2]= [image]

In[3]:= StackedListPlot[data, PlotLayout -> "Percentile"]

Out[3]= [image]
```

#### PlotLegends (1)

Generate a legend using labels:

```wl
In[1]:= d = RandomInteger[{1, 10}, {2, 10}];

In[2]:= StackedListPlot[d, PlotLegends -> {"Foo", "Bar"}]

Out[2]= [image]
```

Generate a legend using placeholders:

```wl
In[3]:= StackedListPlot[d, PlotLegends -> Automatic]

Out[3]= [image]
```

Legends use the same styles as the plot:

```wl
In[4]:= StackedListPlot[d, PlotStyle -> {Red, Blue}, PlotLegends -> {"Foo", "Bar"}]

Out[4]= [image]
```

Use ``Placed`` to specify legend placement:

```wl
In[5]:= Table[StackedListPlot[d, PlotLabel -> pos, PlotLegends -> Placed[{"Foo", "Bar"}, pos]], {pos, {Above, Below, Before, After}}]

Out[5]= {[image], [image], [image], [image]}
```

Place the legend inside the plot:

```wl
In[6]:= StackedListPlot[d, PlotStyle -> {Red, Blue}, PlotLegends -> Placed[{"Foo", "Bar"}, {0.85, 0.3}]]

Out[6]= [image]
```

Use ``LineLegend`` to change the legend appearance:

```wl
In[7]:= StackedListPlot[d, PlotStyle -> {Red, Blue}, PlotLegends -> LineLegend[{"Foo", "Bar"}, LegendMarkerSize -> 10, LegendFunction -> Frame]]

Out[7]= [image]
```

#### PlotMarkers (8)

``ListLinePlot`` normally uses distinct colors to distinguish different sets of data:

```wl
In[1]:= StackedListPlot[RandomInteger[{1, 10}, {3, 10}], PlotMarkers -> None]

Out[1]= [image]
```

---

Automatically use colors and shapes to distinguish sets of data:

```wl
In[1]:= StackedListPlot[RandomInteger[{1, 10}, {3, 10}], PlotMarkers -> Automatic]

Out[1]= [image]
```

---

Use shapes only:

```wl
In[1]:= StackedListPlot[RandomInteger[{1, 10}, {3, 10}], PlotMarkers -> Automatic, PlotStyle -> Black]

Out[1]= [image]
```

---

Change the size of the default plot markers:

```wl
In[1]:= Table[StackedListPlot[RandomInteger[{1, 10}, {3, 10}], PlotMarkers -> {Automatic, s}], {s, {Small, Medium}}]

Out[1]= {[image], [image]}
```

---

Use arbitrary text for plot markers:

```wl
In[1]:= StackedListPlot[RandomInteger[{1, 10}, {3, 10}], PlotMarkers -> {"1", "2", "3", "4"}]

Out[1]= [image]
```

---

Use explicit graphics for plot markers:

```wl
In[1]:= {m1, m2, m3, m4} = Graphics /@ {Circle[{0, 0}, 1], Disk[{0, 0}, 1], Line[{{-0.5, -0.5}, {0.5, -0.5}, {0.5, 0.5}, {-0.5, 0.5}, {-0.5, -0.5}}], Polygon[{{-0.5, -0.5}, {0.5, -0.5}, {0.5, 0.5}, {-0.5, 0.5}}]}

Out[1]= {[image], [image], [image], [image]}

In[2]:= StackedListPlot[RandomInteger[{1, 10}, {3, 10}], PlotMarkers -> Table[{s, 0.05}, {s, {m1, m2, m3, m4}}]]

Out[2]= [image]
```

---

Use the same symbol for all the sets of data:

```wl
In[1]:= StackedListPlot[RandomInteger[{1, 10}, {3, 10}], PlotMarkers -> "●"]

Out[1]= [image]
```

---

Explicitly use a symbol and size:

```wl
In[1]:= Table[StackedListPlot[RandomInteger[{1, 10}, {3, 10}], PlotMarkers -> {"●", s}], {s, {4, 8, 12}}]

Out[1]= {[image], [image], [image]}
```

#### PlotRange (1)

``PlotRange`` shows all data by default:

```wl
In[1]:= d = RandomInteger[{1, 10}, {3, 10}];

In[2]:= StackedListPlot[d]

Out[2]= [image]
```

Calculate automatic range:

```wl
In[3]:= StackedListPlot[d, PlotRange -> Automatic]

Out[3]= [image]
```

#### PlotStyle (4)

Use different style directives:

```wl
In[1]:= d = RandomInteger[{1, 10}, {3, 10}];

In[2]:= Table[StackedListPlot[d, PlotStyle -> ps], {ps, {Red, Thick, Dashed, Directive[Red, Thick]}}]

Out[2]= {[image], [image], [image], [image]}
```

---

By default, different styles are chosen for multiple curves:

```wl
In[1]:= StackedListPlot[RandomInteger[{1, 10}, {3, 10}]]

Out[1]= [image]
```

---

Explicitly specify the style for different curves:

```wl
In[1]:= StackedListPlot[RandomInteger[{1, 10}, {3, 10}], PlotStyle -> {Red, Green, Blue}]

Out[1]= [image]
```

---

``PlotStyle`` can be combined with ``ColorFunction`` :

```wl
In[1]:= d = RandomInteger[{1, 10}, {3, 10}];

In[2]:= StackedListPlot[d, PlotStyle -> Thick, ColorFunction -> Function[{x, y}, Hue[y]]]

Out[2]= [image]
```

``PlotStyle`` can be combined with ``MeshShading`` :

```wl
In[3]:= StackedListPlot[d, PlotStyle -> Directive[Opacity[0.5], Thick], Mesh -> 10, MeshFunctions -> {#1&}, MeshShading -> {Red, Blue}]

Out[3]= [image]
```

``MeshStyle`` by default uses the same style as ``PlotStyle`` :

```wl
In[4]:= StackedListPlot[d, PlotStyle -> Red, Mesh -> All]

Out[4]= [image]
```

#### PlotTheme (3)

Use a theme with simple styling and plot markers in a bright color scheme:

```wl
In[1]:= StackedListPlot[RandomInteger[{1, 10}, {3, 10}], PlotTheme -> "Business"]

Out[1]= [image]
```

---

Change the color scheme:

```wl
In[1]:= StackedListPlot[RandomInteger[{1, 10}, {3, 10}], PlotTheme -> "Business", PlotStyle -> 96]

Out[1]= [image]
```

---

Use a theme with minimal styling:

```wl
In[1]:= StackedListPlot[RandomInteger[{1, 10}, {3, 10}], PlotTheme -> "Minimal"]

Out[1]= [image]
```

#### ScalingFunctions (3)

By default, plots have linear scales in each direction:

```wl
In[1]:= StackedListPlot[RandomInteger[{1, 10}, {3, 10}]]

Out[1]= [image]
```

---

Use a log scale in the $y$ direction:

```wl
In[1]:= StackedListPlot[RandomInteger[{1, 10}, {3, 10}], ScalingFunctions -> "Log"]

Out[1]= [image]
```

---

Use a linear scale in the $y$ direction that shows smaller numbers at the top:

```wl
In[1]:= d = RandomInteger[{1, 10}, {3, 10}];

In[2]:= StackedListPlot[d, ScalingFunctions -> "Reverse"]

Out[2]= [image]
```

Use a reciprocal scale in the $y$ direction:

```wl
In[3]:= StackedListPlot[d, ScalingFunctions -> "Reciprocal"]

Out[3]= [image]
```

Use different scales in the $x$ and $y$ directions:

```wl
In[4]:= StackedListPlot[d, ScalingFunctions -> {"Reverse", "Log"}]

Out[4]= [image]
```

Reverse the $x$ axis without changing the $y$ axis:

```wl
In[5]:= StackedListPlot[d, ScalingFunctions -> {"Reverse", None}]

Out[5]= [image]
```

Use a scale defined by a function and its inverse:

```wl
In[6]:= StackedListPlot[d, ScalingFunctions -> {None, {-Log[#]&, Exp[-#]&}}]

Out[6]= [image]
```

Positions in ``Ticks`` and ``GridLines`` are automatically scaled:

```wl
In[7]:= StackedListPlot[d, ScalingFunctions -> "Log", Ticks -> {Automatic, 2 ^ Range[10]}, GridLines -> {None, 2 ^ Range[10]}]

Out[7]= [image]
```

``PlotRange`` and ``AxesOrigin`` are automatically scaled:

```wl
In[8]:= StackedListPlot[d, ScalingFunctions -> "Log", PlotRange -> {1, 100}, AxesOrigin -> {Automatic, 10}]

Out[8]= [image]

In[9]:= StackedListPlot[d, AxesOrigin -> {Automatic, 10}]

Out[9]= [image]
```

#### TargetUnits (1)

Automatically detect units:

```wl
In[1]:= d = Quantity[RandomInteger[{1, 10}, {3, 10}], "Hours"];

In[2]:= StackedListPlot[d, AxesLabel -> Automatic]

Out[2]= [image]
```

Specify alternate units:

```wl
In[3]:= StackedListPlot[d, TargetUnits -> "Minutes", AxesLabel -> Automatic]

Out[3]= [image]
```

### Applications (3)

Apple revenues by product:

```wl
In[1]:=
aapldata = TemporalData[Automatic, {{CompressedData["«267»"], {1619000000, 1689000000, 1570000000, 1660000000, 3997000000, 1818000000, 1678000000, 
    1563000000, 3371000000, 1665000000, 1492000000, 1477000000, 3391000000, 1861000000, 1545000000, 
    110300 ... 8000000, 26064000000, 19751000000, 32209000000, 51182000000, 40282000000, 31368000000, 
    28160000000, 51635000000, 32857000000, 24048000000, 54378000000}}, 
  CompressedData["«158»"], 6, {"Discrete", 6}, 
  {"Discrete", 1}, 1, {}}, False, 11.2];

In[2]:= StackedListPlot[aapldata, PlotLegends -> {"Mac", "iPod", "iPad", "Services", "Other Products", "iPhone"}, ImageSize -> 300]

Out[2]= [image]
```

Apple unit sales by product:

```wl
In[3]:=
aapludata = TemporalData[Automatic, {{{2164000, 1517000, 1764000, 2611000, 2319000, 2289000, 2496000, 3053000, 
    2524000, 2216000, 2603000, 3885000, 3362000, 2943000, 3472000, 4894000, 4134000, 3760000, 
    3947000, 4923000, 5198000, 4017000, 4020000, 4574 ... 0, 37430000, 31241000, 
    39272000, 51025000, 43719000, 35203000, 48046000, 74468000, 61170000, 47534000, 45513000, 
    74779000, 51193000, 40399000, 78290000}}, CompressedData["«160»"], 4, {"Discrete", 4}, {"Discrete", 1}, 1, {}}, False, 11.2];

In[4]:= StackedListPlot[aapludata, PlotLegends -> {"Mac", "iPod", "iPad", "iPhone"}, ImageSize -> 300, ScalingFunctions -> "Log"]

Out[4]= [image]
```

---

Percentage of world GDP share by region over time:

```wl
In[1]:=
PercentWorldGDP = TemporalData[Automatic, {CompressedData["«408»"], 
  {{{1, 1000, 1500, 1600, 1700, 1820, 1870, 1913, 1950, 1973, 2001}}}, 8, {"Discrete", 8}, 
  {"Discrete", 1}, 1, {}}, False, 11.2];

In[2]:= StackedListPlot[PercentWorldGDP, PlotTheme -> "Marketing", PlotLegends -> {"Western Europe", "Eastern Europe", "Former USSR", "Western Offshoots", "Latin America", "Japan", "Asia", "Africa"}, ImageSize -> 300, FrameLabel -> {"Year", "% of World GDP"}, PlotMarkers -> None]

Out[2]= [image]
```

---

Percentage of world GDP share by country over time:

```wl
In[1]:=
TopGDPCountries = TemporalData[Automatic, {{{Missing[], Missing[], 0.3, 0.2, 0.1, 1.8, 8.8, 18.9, 27.3, 22.1, 21.4}, 
   {Missing[], Missing[], 3.3, 3.8, 3.7, 3.9, 6.5, 8.7, 5., 5.9, 4.1}, 
   {1.2, 2.7, 3.1, 2.9, 4.1, 3., 2.3, 2.6, 3., 7.8, 7.1}, {Missing[], Missin ... , 22.4, 24.4, 16., 12.1, 7.5, 4.2, 3.1, 5.4}, 
   {26.1, 22.7, 24.9, 29., 22.3, 32.9, 17.1, 8.8, 4.5, 4.6, 12.3}}, 
  {{{1, 1000, 1500, 1600, 1700, 1820, 1870, 1913, 1950, 1973, 2001}}}, 6, {"Discrete", 6}, 
  {"Discrete", 1}, 1, {}}, False, 11.2];

In[2]:= StackedListPlot[TopGDPCountries, PlotTheme -> "Business", PlotLabels -> {"USA", "Germany", "Japan", "UK", "India", "China"}, ImageSize -> Medium, FrameLabel -> {"Year", "% of World GDP"}, PlotMarkers -> None]

Out[2]= [image]
```

## See Also

* [`StackedDateListPlot`](https://reference.wolfram.com/language/ref/StackedDateListPlot.en.md)
* [`ListLinePlot`](https://reference.wolfram.com/language/ref/ListLinePlot.en.md)
* [`ListStepPlot`](https://reference.wolfram.com/language/ref/ListStepPlot.en.md)
* [`DateListPlot`](https://reference.wolfram.com/language/ref/DateListPlot.en.md)
* [`BarChart`](https://reference.wolfram.com/language/ref/BarChart.en.md)
* [`PieChart`](https://reference.wolfram.com/language/ref/PieChart.en.md)
* [`Accumulate`](https://reference.wolfram.com/language/ref/Accumulate.en.md)
* [`PlotLayout`](https://reference.wolfram.com/language/ref/PlotLayout.en.md)

## Related Guides

* [Data Visualization](https://reference.wolfram.com/language/guide/DataVisualization.en.md)

## History

* [Introduced in 2017 (11.2)](https://reference.wolfram.com/language/guide/SummaryOfNewFeaturesIn112.en.md) \| [Updated in 2018 (11.3)](https://reference.wolfram.com/language/guide/SummaryOfNewFeaturesIn113.en.md) ▪ [2019 (12.0)](https://reference.wolfram.com/language/guide/SummaryOfNewFeaturesIn120.en.md) ▪ [2021 (13.0)](https://reference.wolfram.com/language/guide/SummaryOfNewFeaturesIn130.en.md) ▪ [2023 (13.3)](https://reference.wolfram.com/language/guide/SummaryOfNewFeaturesIn133.en.md) ▪ [2025 (14.2)](https://reference.wolfram.com/language/guide/SummaryOfNewFeaturesIn142.en.md) ▪ [2025 (14.3)](https://reference.wolfram.com/language/guide/SummaryOfNewFeaturesIn143.en.md)