diff --git a/.gitignore b/.gitignore
index 37e77b667..7fe64d424 100644
--- a/.gitignore
+++ b/.gitignore
@@ -14,6 +14,7 @@
 /.idea/other.xml
 /.idea/codeStyles/Project.xml
 /.idea/inspectionProfiles/Project_Default.xml
+/.idea/studiobot.xml
 
 *.iml
 .gradle
diff --git a/.idea/codeStyles/Project.xml b/.idea/codeStyles/Project.xml
index 962b221c2..7d9505635 100644
--- a/.idea/codeStyles/Project.xml
+++ b/.idea/codeStyles/Project.xml
@@ -127,8 +127,10 @@
       <option name="CODE_STYLE_DEFAULTS" value="KOTLIN_OFFICIAL" />
       <option name="RIGHT_MARGIN" value="120" />
       <indentOptions>
+        <option name="INDENT_SIZE" value="2" />
         <option name="CONTINUATION_INDENT_SIZE" value="4" />
+        <option name="TAB_SIZE" value="2" />
       </indentOptions>
     </codeStyleSettings>
   </code_scheme>
-</component>
\ No newline at end of file
+</component>
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index b690c663e..3fbe5fd05 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -1,24 +1,25 @@
 [versions]
 accompanist = "0.34.0"
 activity = "1.9.0"
-agp = "8.4.1"
+agp = "8.5.1"
 androidXAnnotation = "1.8.0"
 androidXCore = "1.13.1"
 appcompat = "1.7.0"
-composeBom = "2024.05.00"
+composeBom = "2024.06.00"
 composeNavigation = "2.7.7"
+composeStableMarker = "1.0.5"
 coroutines = "1.8.1"
 desugar_jdk_libs = "2.0.4"
 dokka = "1.9.20"
 jUnit = "4.13.2"
 jUnitExt = "1.1.5"
-jupiter = "5.10.2"
+jupiter = "5.10.3"
 kotlin = "2.0.0"
-lifecycle = "2.8.1"
+lifecycle = "2.8.3"
 material = "1.12.0"
-mockK = "1.13.11"
+mockK = "1.13.12"
 paparazziGradlePlugin = "1.3.4"
-testCore = "1.5.0"
+testCore = "1.6.1"
 
 [libraries]
 activityCompose = { group = "androidx.activity", name = "activity-compose", version.ref = "activity" }
@@ -32,6 +33,7 @@ composeMaterial = { group = "androidx.compose.material", name = "material" }
 composeMaterial3 = { group = "androidx.compose.material3", name = "material3" }
 composeNavigation = { group = "androidx.navigation", name = "navigation-compose", version.ref = "composeNavigation" }
 composePreview = { group = "androidx.compose.ui", name = "ui-tooling-preview" }
+composeStableMarker = { group = "com.github.skydoves", name = "compose-stable-marker", version.ref = "composeStableMarker" }
 composeUI = { group = "androidx.compose.ui", name = "ui" }
 composeUITooling = { group = "androidx.compose.ui", name = "ui-tooling" }
 composeViewBinding = { group = "androidx.compose.ui", name = "ui-viewbinding" }
diff --git a/gradle/wrapper/gradle-wrapper.jar b/gradle/wrapper/gradle-wrapper.jar
index e6441136f..2c3521197 100644
Binary files a/gradle/wrapper/gradle-wrapper.jar and b/gradle/wrapper/gradle-wrapper.jar differ
diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index a4413138c..09523c0e5 100644
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.8-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.9-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME
diff --git a/gradlew b/gradlew
index b740cf133..f5feea6d6 100755
--- a/gradlew
+++ b/gradlew
@@ -15,6 +15,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
+# SPDX-License-Identifier: Apache-2.0
+#
 
 ##############################################################################
 #
@@ -84,7 +86,8 @@ done
 # shellcheck disable=SC2034
 APP_BASE_NAME=${0##*/}
 # Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
-APP_HOME=$( cd "${APP_HOME:-./}" > /dev/null && pwd -P ) || exit
+APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s
+' "$PWD" ) || exit
 
 # Use the maximum available, or set MAX_FD != -1 to use that value.
 MAX_FD=maximum
diff --git a/gradlew.bat b/gradlew.bat
index 25da30dbd..9d21a2183 100644
--- a/gradlew.bat
+++ b/gradlew.bat
@@ -13,6 +13,8 @@
 @rem See the License for the specific language governing permissions and
 @rem limitations under the License.
 @rem
+@rem SPDX-License-Identifier: Apache-2.0
+@rem
 
 @if "%DEBUG%"=="" @echo off
 @rem ##########################################################################
diff --git a/sample/src/main/java/com/patrykandpatrick/vico/sample/previews/AxisLinePreviews.kt b/sample/src/main/java/com/patrykandpatrick/vico/sample/previews/AxisLinePreviews.kt
deleted file mode 100644
index 1956327cc..000000000
--- a/sample/src/main/java/com/patrykandpatrick/vico/sample/previews/AxisLinePreviews.kt
+++ /dev/null
@@ -1,148 +0,0 @@
-/*
- * Copyright 2024 by Patryk Goworowski and Patrick Michalik.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.patrykandpatrick.vico.sample.previews
-
-import androidx.compose.foundation.layout.PaddingValues
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.tooling.preview.Preview
-import androidx.compose.ui.unit.dp
-import com.patrykandpatrick.vico.compose.cartesian.CartesianChartHost
-import com.patrykandpatrick.vico.compose.cartesian.axis.rememberAxisLabelComponent
-import com.patrykandpatrick.vico.compose.cartesian.axis.rememberBottomAxis
-import com.patrykandpatrick.vico.compose.cartesian.axis.rememberEndAxis
-import com.patrykandpatrick.vico.compose.cartesian.axis.rememberStartAxis
-import com.patrykandpatrick.vico.compose.cartesian.layer.rememberColumnCartesianLayer
-import com.patrykandpatrick.vico.compose.cartesian.rememberCartesianChart
-import com.patrykandpatrick.vico.compose.common.component.rememberShapeComponent
-import com.patrykandpatrick.vico.compose.common.of
-import com.patrykandpatrick.vico.core.cartesian.axis.VerticalAxis
-import com.patrykandpatrick.vico.core.cartesian.data.CartesianChartModel
-import com.patrykandpatrick.vico.core.cartesian.data.ColumnCartesianLayerModel
-import com.patrykandpatrick.vico.core.common.Dimensions
-import com.patrykandpatrick.vico.core.common.shape.Corner
-import com.patrykandpatrick.vico.core.common.shape.CorneredShape
-import com.patrykandpatrick.vico.core.common.shape.CutCornerTreatment
-import com.patrykandpatrick.vico.core.common.shape.RoundedCornerTreatment
-import com.patrykandpatrick.vico.core.common.shape.Shape
-
-private val model = CartesianChartModel(ColumnCartesianLayerModel.build { series(1, 2, 3, 4) })
-
-@Composable
-@Preview(showBackground = true, widthDp = 250)
-fun HorizontalAxisTextInside() {
-  val label =
-    rememberAxisLabelComponent(
-      background =
-        rememberShapeComponent(
-          shape =
-            CorneredShape(
-              topLeft = Corner.Relative(percentage = 50, cornerTreatment = CutCornerTreatment),
-              bottomRight =
-                Corner.Relative(percentage = 50, cornerTreatment = RoundedCornerTreatment),
-            ),
-          color = Color.LightGray,
-          strokeColor = Color.Gray,
-          strokeWidth = 1.dp,
-        ),
-      padding = Dimensions.of(horizontal = 2.dp, vertical = 8.dp),
-      margins = Dimensions.of(horizontal = 4.dp, vertical = 4.dp),
-    )
-  PaddingValues()
-  CartesianChartHost(
-    chart =
-      rememberCartesianChart(
-        rememberColumnCartesianLayer(),
-        startAxis =
-          rememberStartAxis(
-            horizontalLabelPosition = VerticalAxis.HorizontalLabelPosition.Inside,
-            label = label,
-          ),
-        endAxis =
-          rememberEndAxis(
-            horizontalLabelPosition = VerticalAxis.HorizontalLabelPosition.Inside,
-            guideline = null,
-            label = label,
-          ),
-      ),
-    model = model,
-  )
-}
-
-@Composable
-@Preview(showBackground = true, widthDp = 250)
-fun HorizontalAxisTextInsideAndBottomAxis() {
-  val label =
-    rememberAxisLabelComponent(
-      background = rememberShapeComponent(shape = Shape.Pill, color = Color.LightGray),
-      padding = Dimensions.of(horizontal = 2.dp, vertical = 8.dp),
-      margins = Dimensions.of(horizontal = 4.dp, vertical = 4.dp),
-    )
-  CartesianChartHost(
-    chart =
-      rememberCartesianChart(
-        rememberColumnCartesianLayer(),
-        startAxis =
-          rememberStartAxis(
-            horizontalLabelPosition = VerticalAxis.HorizontalLabelPosition.Inside,
-            label = label,
-          ),
-        endAxis =
-          rememberEndAxis(
-            horizontalLabelPosition = VerticalAxis.HorizontalLabelPosition.Inside,
-            guideline = null,
-            label = label,
-          ),
-        bottomAxis = rememberBottomAxis(),
-      ),
-    model = model,
-  )
-}
-
-@Composable
-@Preview(showBackground = true, widthDp = 250)
-fun HorizontalAxisTextOutside() {
-  CartesianChartHost(
-    chart =
-      rememberCartesianChart(
-        rememberColumnCartesianLayer(),
-        startAxis =
-          rememberStartAxis(horizontalLabelPosition = VerticalAxis.HorizontalLabelPosition.Outside),
-        endAxis =
-          rememberEndAxis(
-            horizontalLabelPosition = VerticalAxis.HorizontalLabelPosition.Outside,
-            guideline = null,
-          ),
-      ),
-    model = model,
-  )
-}
-
-@Composable
-@Preview(showBackground = true, widthDp = 250)
-fun HorizontalAxisGuidelineDoesNotOverlayBottomAxisLine() {
-  CartesianChartHost(
-    chart =
-      rememberCartesianChart(
-        rememberColumnCartesianLayer(),
-        startAxis =
-          rememberStartAxis(horizontalLabelPosition = VerticalAxis.HorizontalLabelPosition.Outside),
-        bottomAxis = rememberBottomAxis(),
-      ),
-    model = model,
-  )
-}
diff --git a/sample/src/main/java/com/patrykandpatrick/vico/sample/previews/CandlestickLinePreview.kt b/sample/src/main/java/com/patrykandpatrick/vico/sample/previews/CandlestickLinePreview.kt
deleted file mode 100644
index 2fe954a98..000000000
--- a/sample/src/main/java/com/patrykandpatrick/vico/sample/previews/CandlestickLinePreview.kt
+++ /dev/null
@@ -1,59 +0,0 @@
-/*
- * Copyright 2024 by Patryk Goworowski and Patrick Michalik.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.patrykandpatrick.vico.sample.previews
-
-import androidx.compose.material3.Surface
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.remember
-import androidx.compose.ui.tooling.preview.Preview
-import com.patrykandpatrick.vico.compose.cartesian.CartesianChartHost
-import com.patrykandpatrick.vico.compose.cartesian.axis.rememberBottomAxis
-import com.patrykandpatrick.vico.compose.cartesian.axis.rememberStartAxis
-import com.patrykandpatrick.vico.compose.cartesian.layer.absoluteRelative
-import com.patrykandpatrick.vico.compose.cartesian.layer.rememberCandlestickCartesianLayer
-import com.patrykandpatrick.vico.compose.cartesian.rememberCartesianChart
-import com.patrykandpatrick.vico.core.cartesian.data.CandlestickCartesianLayerModel
-import com.patrykandpatrick.vico.core.cartesian.data.CartesianChartModel
-import com.patrykandpatrick.vico.core.cartesian.layer.CandlestickCartesianLayer
-
-@Preview(widthDp = 350)
-@Composable
-fun CandlestickLinePreview() {
-  Surface {
-    CartesianChartHost(
-      chart =
-        rememberCartesianChart(
-          rememberCandlestickCartesianLayer(
-            CandlestickCartesianLayer.CandleProvider.absoluteRelative()
-          ),
-          startAxis = rememberStartAxis(),
-          bottomAxis = rememberBottomAxis(),
-        ),
-      model =
-        remember {
-          CartesianChartModel(
-            CandlestickCartesianLayerModel.build(
-              opening = listOf(4, 8, 12, 14, 10, 18),
-              closing = listOf(8, 12, 14, 10, 18, 14),
-              low = listOf(2, 6, 10, 4, 6, 10),
-              high = listOf(12, 14, 16, 16, 20, 18),
-            )
-          )
-        },
-    )
-  }
-}
diff --git a/sample/src/main/java/com/patrykandpatrick/vico/sample/previews/ColumnChartsWithNegativeValuesPreviews.kt b/sample/src/main/java/com/patrykandpatrick/vico/sample/previews/ColumnChartsWithNegativeValuesPreviews.kt
deleted file mode 100644
index da4781b89..000000000
--- a/sample/src/main/java/com/patrykandpatrick/vico/sample/previews/ColumnChartsWithNegativeValuesPreviews.kt
+++ /dev/null
@@ -1,119 +0,0 @@
-/*
- * Copyright 2024 by Patryk Goworowski and Patrick Michalik.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.patrykandpatrick.vico.sample.previews
-
-import androidx.compose.foundation.layout.height
-import androidx.compose.material.Surface
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.remember
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.tooling.preview.Preview
-import androidx.compose.ui.unit.dp
-import com.patrykandpatrick.vico.compose.cartesian.CartesianChartHost
-import com.patrykandpatrick.vico.compose.cartesian.axis.rememberBottomAxis
-import com.patrykandpatrick.vico.compose.cartesian.axis.rememberStartAxis
-import com.patrykandpatrick.vico.compose.cartesian.layer.rememberColumnCartesianLayer
-import com.patrykandpatrick.vico.compose.cartesian.rememberCartesianChart
-import com.patrykandpatrick.vico.compose.common.component.rememberTextComponent
-import com.patrykandpatrick.vico.core.cartesian.axis.AxisItemPlacer
-import com.patrykandpatrick.vico.core.cartesian.data.AxisValueOverrider
-import com.patrykandpatrick.vico.core.cartesian.data.CartesianChartModel
-import com.patrykandpatrick.vico.core.cartesian.data.LineCartesianLayerModel
-import com.patrykandpatrick.vico.sample.showcase.rememberMarker
-
-private val model =
-  CartesianChartModel(LineCartesianLayerModel.build { series(2, -1, 4, -2, 1, 5, -3) })
-
-@Preview
-@Composable
-public fun SingleColumnChartWithNegativeValues() {
-  val marker = rememberMarker()
-  Surface {
-    CartesianChartHost(
-      modifier = Modifier.height(250.dp),
-      chart =
-        rememberCartesianChart(
-          rememberColumnCartesianLayer(),
-          startAxis =
-            rememberStartAxis(
-              itemPlacer = remember { AxisItemPlacer.Vertical.count(count = { 9 }) }
-            ),
-          bottomAxis = rememberBottomAxis(),
-          persistentMarkers = mapOf(2f to marker, 3f to marker),
-        ),
-      model = model,
-    )
-  }
-}
-
-@Preview
-@Composable
-public fun SingleColumnChartWithNegativeValuesAndDataLabels() {
-  Surface {
-    CartesianChartHost(
-      chart =
-        rememberCartesianChart(
-          rememberColumnCartesianLayer(dataLabel = rememberTextComponent()),
-          startAxis = rememberStartAxis(),
-          bottomAxis = rememberBottomAxis(),
-        ),
-      model = model,
-    )
-  }
-}
-
-@Preview
-@Composable
-public fun SingleColumnChartWithNegativeValuesAndAxisValuesOverridden() {
-  Surface {
-    CartesianChartHost(
-      chart =
-        rememberCartesianChart(
-          rememberColumnCartesianLayer(
-            axisValueOverrider = AxisValueOverrider.fixed(minY = 1f, maxY = 4f)
-          ),
-          startAxis =
-            rememberStartAxis(
-              itemPlacer = remember { AxisItemPlacer.Vertical.count(count = { 4 }) }
-            ),
-          bottomAxis = rememberBottomAxis(),
-        ),
-      model = model,
-    )
-  }
-}
-
-@Preview
-@Composable
-public fun SingleColumnChartWithNegativeValuesAndAxisValuesOverridden2() {
-  Surface {
-    CartesianChartHost(
-      chart =
-        rememberCartesianChart(
-          rememberColumnCartesianLayer(
-            axisValueOverrider = AxisValueOverrider.fixed(minY = -2f, maxY = 0f)
-          ),
-          startAxis =
-            rememberStartAxis(
-              itemPlacer = remember { AxisItemPlacer.Vertical.count(count = { 3 }) }
-            ),
-          bottomAxis = rememberBottomAxis(),
-        ),
-      model = model,
-    )
-  }
-}
diff --git a/sample/src/main/java/com/patrykandpatrick/vico/sample/previews/ContainedChartsPreview.kt b/sample/src/main/java/com/patrykandpatrick/vico/sample/previews/ContainedChartsPreview.kt
deleted file mode 100644
index aa294b788..000000000
--- a/sample/src/main/java/com/patrykandpatrick/vico/sample/previews/ContainedChartsPreview.kt
+++ /dev/null
@@ -1,165 +0,0 @@
-/*
- * Copyright 2024 by Patryk Goworowski and Patrick Michalik.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.patrykandpatrick.vico.sample.previews
-
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.remember
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.tooling.preview.Preview
-import androidx.compose.ui.unit.dp
-import com.patrykandpatrick.vico.compose.cartesian.CartesianChartHost
-import com.patrykandpatrick.vico.compose.cartesian.axis.rememberBottomAxis
-import com.patrykandpatrick.vico.compose.cartesian.axis.rememberEndAxis
-import com.patrykandpatrick.vico.compose.cartesian.axis.rememberStartAxis
-import com.patrykandpatrick.vico.compose.cartesian.layer.rememberColumnCartesianLayer
-import com.patrykandpatrick.vico.compose.cartesian.layer.rememberLineCartesianLayer
-import com.patrykandpatrick.vico.compose.cartesian.layer.rememberLineSpec
-import com.patrykandpatrick.vico.compose.cartesian.rememberCartesianChart
-import com.patrykandpatrick.vico.compose.common.component.rememberLineComponent
-import com.patrykandpatrick.vico.compose.common.component.rememberTextComponent
-import com.patrykandpatrick.vico.compose.common.shader.color
-import com.patrykandpatrick.vico.compose.common.shader.verticalGradient
-import com.patrykandpatrick.vico.core.cartesian.axis.Axis
-import com.patrykandpatrick.vico.core.cartesian.axis.AxisItemPlacer
-import com.patrykandpatrick.vico.core.cartesian.axis.AxisPosition.Vertical
-import com.patrykandpatrick.vico.core.cartesian.axis.AxisPosition.Vertical.End
-import com.patrykandpatrick.vico.core.cartesian.axis.AxisPosition.Vertical.Start
-import com.patrykandpatrick.vico.core.cartesian.data.CartesianChartModel
-import com.patrykandpatrick.vico.core.cartesian.data.ColumnCartesianLayerModel
-import com.patrykandpatrick.vico.core.cartesian.data.LineCartesianLayerModel
-import com.patrykandpatrick.vico.core.cartesian.layer.ColumnCartesianLayer
-import com.patrykandpatrick.vico.core.cartesian.marker.CartesianMarker
-import com.patrykandpatrick.vico.core.common.shader.DynamicShader
-import com.patrykandpatrick.vico.core.common.shape.Shape
-import com.patrykandpatrick.vico.sample.showcase.rememberMarker
-
-private val model =
-  CartesianChartModel(
-    ColumnCartesianLayerModel.build { series(1, 2, 4, 1, 4) },
-    LineCartesianLayerModel.build { series(4, 1, 8, 12, 5) },
-  )
-
-private val markerMap: Map<Float, CartesianMarker>
-  @Composable get() = mapOf(4f to rememberMarker())
-
-@Composable
-private fun getColumnLayer(verticalAxisPosition: Vertical? = null) =
-  rememberColumnCartesianLayer(
-    columnProvider =
-      ColumnCartesianLayer.ColumnProvider.series(
-        rememberLineComponent(color = Color.Black, thickness = 8.dp, shape = Shape.Pill)
-      ),
-    verticalAxisPosition = verticalAxisPosition,
-  )
-
-@Composable
-private fun getLineLayer(verticalAxisPosition: Vertical? = null) =
-  rememberLineCartesianLayer(
-    lines =
-      listOf(
-        rememberLineSpec(
-          shader = DynamicShader.color(Color.DarkGray),
-          backgroundShader =
-            DynamicShader.verticalGradient(arrayOf(Color.DarkGray, Color.DarkGray.copy(alpha = 0f))),
-        )
-      ),
-    verticalAxisPosition = verticalAxisPosition,
-  )
-
-private val startAxis: Axis<Start>
-  @Composable
-  get() =
-    rememberStartAxis(
-      label = rememberTextComponent(color = Color.Black),
-      itemPlacer = remember { AxisItemPlacer.Vertical.count(count = { 5 }) },
-    )
-
-private val endAxis: Axis<End>
-  @Composable
-  get() =
-    rememberEndAxis(
-      label = rememberTextComponent(color = Color.DarkGray),
-      itemPlacer = remember { AxisItemPlacer.Vertical.count(count = { 7 }) },
-    )
-
-@Composable
-@Preview("Chart with independent axes", widthDp = 350)
-public fun ChartWithIndependentAxes(modifier: Modifier = Modifier) {
-  CartesianChartHost(
-    chart =
-      rememberCartesianChart(
-        getColumnLayer(Start),
-        getLineLayer(End),
-        startAxis = startAxis,
-        bottomAxis = rememberBottomAxis(),
-        endAxis = endAxis,
-      ),
-    model = model,
-    modifier = modifier,
-  )
-}
-
-@Composable
-@Preview("Chart with dependent axes", widthDp = 350)
-public fun ChartWithDependentAxes(modifier: Modifier = Modifier) {
-  CartesianChartHost(
-    chart =
-      rememberCartesianChart(
-        getColumnLayer(),
-        getLineLayer(),
-        startAxis = startAxis,
-        bottomAxis = rememberBottomAxis(),
-        endAxis = endAxis,
-        persistentMarkers = markerMap,
-      ),
-    model = model,
-    modifier = modifier,
-  )
-}
-
-@Composable
-@Preview("Column chart", widthDp = 350)
-public fun ColumnChart(modifier: Modifier = Modifier) {
-  CartesianChartHost(
-    chart =
-      rememberCartesianChart(
-        getColumnLayer(),
-        startAxis = startAxis,
-        bottomAxis = rememberBottomAxis(),
-        persistentMarkers = markerMap,
-      ),
-    model = model,
-    modifier = modifier,
-  )
-}
-
-@Composable
-@Preview("Line chart", widthDp = 350)
-public fun LineChart(modifier: Modifier = Modifier) {
-  CartesianChartHost(
-    chart =
-      rememberCartesianChart(
-        getLineLayer(),
-        startAxis = startAxis,
-        bottomAxis = rememberBottomAxis(),
-        persistentMarkers = markerMap,
-      ),
-    model = model,
-    modifier = modifier,
-  )
-}
diff --git a/sample/src/main/java/com/patrykandpatrick/vico/sample/previews/HorizontalDecorationPreviews.kt b/sample/src/main/java/com/patrykandpatrick/vico/sample/previews/HorizontalDecorationPreviews.kt
deleted file mode 100644
index 262088f3a..000000000
--- a/sample/src/main/java/com/patrykandpatrick/vico/sample/previews/HorizontalDecorationPreviews.kt
+++ /dev/null
@@ -1,264 +0,0 @@
-/*
- * Copyright 2024 by Patryk Goworowski and Patrick Michalik.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.patrykandpatrick.vico.sample.previews
-
-import androidx.compose.foundation.background
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.material3.Surface
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.Brush
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.tooling.preview.Preview
-import androidx.compose.ui.unit.dp
-import com.patrykandpatrick.vico.compose.cartesian.CartesianChartHost
-import com.patrykandpatrick.vico.compose.cartesian.axis.rememberBottomAxis
-import com.patrykandpatrick.vico.compose.cartesian.axis.rememberStartAxis
-import com.patrykandpatrick.vico.compose.cartesian.decoration.rememberHorizontalBox
-import com.patrykandpatrick.vico.compose.cartesian.decoration.rememberHorizontalLine
-import com.patrykandpatrick.vico.compose.cartesian.layer.rememberColumnCartesianLayer
-import com.patrykandpatrick.vico.compose.cartesian.rememberCartesianChart
-import com.patrykandpatrick.vico.compose.cartesian.rememberVicoScrollState
-import com.patrykandpatrick.vico.compose.common.ProvideVicoTheme
-import com.patrykandpatrick.vico.compose.common.component.rememberLineComponent
-import com.patrykandpatrick.vico.compose.common.component.rememberShapeComponent
-import com.patrykandpatrick.vico.compose.common.component.rememberTextComponent
-import com.patrykandpatrick.vico.compose.common.of
-import com.patrykandpatrick.vico.compose.common.shader.toDynamicShader
-import com.patrykandpatrick.vico.compose.common.vicoTheme
-import com.patrykandpatrick.vico.core.cartesian.data.CartesianChartModel
-import com.patrykandpatrick.vico.core.cartesian.data.ColumnCartesianLayerModel
-import com.patrykandpatrick.vico.core.common.Dimensions
-import com.patrykandpatrick.vico.core.common.VerticalPosition
-import com.patrykandpatrick.vico.core.common.shader.ComponentShader
-import com.patrykandpatrick.vico.core.common.shape.Shape
-
-private val model = CartesianChartModel(ColumnCartesianLayerModel.build { series(1, 2, 3, 4) })
-
-val Color.Companion.DimmedGray: Color
-  get() = Color(0xFFAAAAAA)
-
-@Composable
-private fun ProvidePreviewVicoTheme(content: @Composable () -> Unit) {
-  Surface(
-    color = Color.Transparent,
-    modifier =
-      Modifier.background(color = Color.LightGray, shape = RoundedCornerShape(size = 4.dp))
-        .padding(8.dp),
-  ) {
-    ProvideVicoTheme(
-      vicoTheme.copy(
-        columnCartesianLayerColors = listOf(Color.DimmedGray),
-        lineColor = Color.DimmedGray,
-        textColor = Color.DimmedGray,
-      ),
-      content,
-    )
-  }
-}
-
-@Preview(widthDp = 250)
-@Composable
-fun ThresholdLine() {
-  ProvidePreviewVicoTheme {
-    CartesianChartHost(
-      modifier = Modifier,
-      chart =
-        rememberCartesianChart(
-          rememberColumnCartesianLayer(),
-          startAxis = rememberStartAxis(),
-          bottomAxis = rememberBottomAxis(),
-          decorations =
-            listOf(
-              rememberHorizontalLine(
-                y = { 2f },
-                line = rememberLineComponent(color = Color.Black, thickness = 2.dp),
-                labelComponent =
-                  rememberTextComponent(Color.Black, padding = Dimensions.of(horizontal = 8.dp)),
-              )
-            ),
-        ),
-      model = model,
-      scrollState = rememberVicoScrollState(scrollEnabled = false),
-    )
-  }
-}
-
-@Preview(widthDp = 250)
-@Composable
-fun ThresholdLineWithCustomText() {
-  ProvidePreviewVicoTheme {
-    CartesianChartHost(
-      modifier = Modifier,
-      chart =
-        rememberCartesianChart(
-          rememberColumnCartesianLayer(),
-          decorations =
-            listOf(
-              rememberHorizontalLine(
-                y = { 2f },
-                line = rememberLineComponent(color = Color.Black, thickness = 2.dp),
-                labelComponent =
-                  rememberTextComponent(
-                    color = Color.White,
-                    lineCount = 3,
-                    background =
-                      rememberShapeComponent(
-                        shape = Shape.rounded(bottomLeftPercent = 25, bottomRightPercent = 25),
-                        color = Color.Black,
-                      ),
-                    padding = Dimensions.of(start = 8.dp, top = 2.dp, end = 8.dp, bottom = 4.dp),
-                    margins = Dimensions.of(horizontal = 4.dp),
-                  ),
-                label = { "Horizontal line 1 📐" },
-                verticalLabelPosition = VerticalPosition.Bottom,
-              ),
-              rememberHorizontalLine(
-                y = { 3f },
-                line = rememberLineComponent(color = Color.DarkGray, thickness = 2.dp),
-                labelComponent =
-                  rememberTextComponent(
-                    color = Color.White,
-                    lineCount = 3,
-                    background =
-                      rememberShapeComponent(
-                        shape = Shape.cut(topLeftPercent = 25, topRightPercent = 25),
-                        color = Color.DarkGray,
-                      ),
-                    padding = Dimensions.of(start = 8.dp, top = 4.dp, end = 8.dp, bottom = 2.dp),
-                    margins = Dimensions.of(horizontal = 4.dp),
-                  ),
-                label = { "Horizontal line 2 📐" },
-              ),
-            ),
-          startAxis = rememberStartAxis(),
-          bottomAxis = rememberBottomAxis(),
-        ),
-      model = model,
-      scrollState = rememberVicoScrollState(scrollEnabled = false),
-    )
-  }
-}
-
-@Preview(widthDp = 250)
-@Composable
-fun RangedThresholdLine() {
-  ProvidePreviewVicoTheme {
-    CartesianChartHost(
-      modifier = Modifier,
-      chart =
-        rememberCartesianChart(
-          rememberColumnCartesianLayer(),
-          decorations =
-            listOf(
-              rememberHorizontalBox(
-                y = { 2f..3f },
-                box = rememberShapeComponent(color = Color.Black.copy(alpha = .5f)),
-                labelComponent =
-                  rememberTextComponent(
-                    color = Color.Black,
-                    padding = Dimensions.of(horizontal = 8.dp),
-                  ),
-              )
-            ),
-          startAxis = rememberStartAxis(),
-          bottomAxis = rememberBottomAxis(),
-        ),
-      model = model,
-      scrollState = rememberVicoScrollState(scrollEnabled = false),
-    )
-  }
-}
-
-@Preview(widthDp = 250)
-@Composable
-fun RangedThresholdLineWithBrushShader() {
-  ProvidePreviewVicoTheme {
-    CartesianChartHost(
-      modifier = Modifier,
-      chart =
-        rememberCartesianChart(
-          rememberColumnCartesianLayer(),
-          decorations =
-            listOf(
-              rememberHorizontalBox(
-                y = { 2f..3f },
-                box =
-                  rememberShapeComponent(
-                    color = Color.Black,
-                    dynamicShader =
-                      Brush.verticalGradient(
-                          colors = listOf(Color.Black.copy(0.75f), Color.Black.copy(0.25f))
-                        )
-                        .toDynamicShader(),
-                  ),
-                labelComponent =
-                  rememberTextComponent(
-                    color = Color.Black,
-                    padding = Dimensions.of(horizontal = 8.dp),
-                  ),
-              )
-            ),
-          startAxis = rememberStartAxis(),
-          bottomAxis = rememberBottomAxis(),
-        ),
-      model = model,
-      scrollState = rememberVicoScrollState(scrollEnabled = false),
-    )
-  }
-}
-
-@Preview(widthDp = 250)
-@Composable
-fun RangedThresholdLineWithComponentShader() {
-  ProvidePreviewVicoTheme {
-    CartesianChartHost(
-      modifier = Modifier,
-      chart =
-        rememberCartesianChart(
-          rememberColumnCartesianLayer(),
-          decorations =
-            listOf(
-              rememberHorizontalBox(
-                y = { 2f..3f },
-                box =
-                  rememberShapeComponent(
-                    color = Color.Black,
-                    dynamicShader =
-                      ComponentShader(
-                        rememberShapeComponent(shape = Shape.Pill, color = Color.Black),
-                        componentSizeDp = 4f,
-                      ),
-                    strokeWidth = 2.dp,
-                    strokeColor = Color.Black,
-                  ),
-                labelComponent =
-                  rememberTextComponent(
-                    color = Color.Black,
-                    padding = Dimensions.of(horizontal = 8.dp),
-                  ),
-              )
-            ),
-          startAxis = rememberStartAxis(),
-          bottomAxis = rememberBottomAxis(),
-        ),
-      model = model,
-      scrollState = rememberVicoScrollState(scrollEnabled = false),
-    )
-  }
-}
diff --git a/sample/src/main/java/com/patrykandpatrick/vico/sample/previews/LineChartPreviews.kt b/sample/src/main/java/com/patrykandpatrick/vico/sample/previews/LineChartPreviews.kt
deleted file mode 100644
index 7343ea3f0..000000000
--- a/sample/src/main/java/com/patrykandpatrick/vico/sample/previews/LineChartPreviews.kt
+++ /dev/null
@@ -1,170 +0,0 @@
-/*
- * Copyright 2024 by Patryk Goworowski and Patrick Michalik.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.patrykandpatrick.vico.sample.previews
-
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.material.Surface
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.tooling.preview.Preview
-import androidx.compose.ui.unit.dp
-import com.patrykandpatrick.vico.compose.cartesian.CartesianChartHost
-import com.patrykandpatrick.vico.compose.cartesian.axis.rememberStartAxis
-import com.patrykandpatrick.vico.compose.cartesian.layer.rememberLineCartesianLayer
-import com.patrykandpatrick.vico.compose.cartesian.layer.rememberLineSpec
-import com.patrykandpatrick.vico.compose.cartesian.rememberCartesianChart
-import com.patrykandpatrick.vico.compose.common.shader.color
-import com.patrykandpatrick.vico.compose.common.shader.verticalGradient
-import com.patrykandpatrick.vico.core.cartesian.data.AxisValueOverrider
-import com.patrykandpatrick.vico.core.cartesian.data.CartesianChartModel
-import com.patrykandpatrick.vico.core.cartesian.data.LineCartesianLayerModel
-import com.patrykandpatrick.vico.core.common.shader.DynamicShader
-
-private val model1 = CartesianChartModel(LineCartesianLayerModel.build { series(0, 2, 4, 0, 2) })
-
-private val model2 =
-  CartesianChartModel(
-    LineCartesianLayerModel.build { series(0, 2, 4, 0, 2) },
-    LineCartesianLayerModel.build { series(1, 3, 4, 1, 3) },
-  )
-
-private val model3 =
-  CartesianChartModel(
-    LineCartesianLayerModel.build {
-      series(3, 2, 2, 3, 1)
-      series(1, 3, 1, 2, 3)
-    }
-  )
-
-@Preview("Line Chart Dark", widthDp = 200)
-@Composable
-fun LineChartDark() {
-  Surface(shape = RoundedCornerShape(8.dp), color = Color.Black) {
-    val yellow = Color(0xFFFFAA4A)
-    val pink = Color(0xFFFF4AAA)
-
-    CartesianChartHost(
-      modifier = Modifier.padding(8.dp),
-      chart =
-        rememberCartesianChart(
-          rememberLineCartesianLayer(
-            listOf(
-              rememberLineSpec(
-                shader = DynamicShader.color(yellow),
-                backgroundShader =
-                  DynamicShader.verticalGradient(
-                    arrayOf(yellow.copy(alpha = 0.5f), yellow.copy(alpha = 0f))
-                  ),
-              ),
-              rememberLineSpec(
-                shader = DynamicShader.color(pink),
-                backgroundShader =
-                  DynamicShader.verticalGradient(
-                    arrayOf(pink.copy(alpha = 0.5f), pink.copy(alpha = 0f))
-                  ),
-              ),
-            ),
-            axisValueOverrider = AxisValueOverrider.fixed(maxY = 4f),
-          )
-        ),
-      model = model3,
-    )
-  }
-}
-
-@Preview("Line Chart", widthDp = 200)
-@Composable
-fun RegularLineChart() {
-  CartesianChartHost(
-    chart = rememberCartesianChart(rememberLineCartesianLayer(), startAxis = rememberStartAxis()),
-    model = model1,
-  )
-}
-
-@Preview("Line Chart Expanded", widthDp = 200)
-@Composable
-fun RegularLineChartExpanded() {
-  CartesianChartHost(
-    chart =
-      rememberCartesianChart(
-        rememberLineCartesianLayer(
-          axisValueOverrider = AxisValueOverrider.fixed(minY = -1f, maxY = 5f)
-        ),
-        startAxis = rememberStartAxis(),
-      ),
-    model = model1,
-  )
-}
-
-@Preview("Line Chart Collapsed", widthDp = 200)
-@Composable
-fun RegularLineChartCollapsed() {
-  CartesianChartHost(
-    chart =
-      rememberCartesianChart(
-        rememberLineCartesianLayer(
-          axisValueOverrider = AxisValueOverrider.fixed(minY = 1f, maxY = 3f)
-        ),
-        startAxis = rememberStartAxis(),
-      ),
-    model = model1,
-  )
-}
-
-@Preview("Composed Chart", widthDp = 200)
-@Composable
-fun ComposedLineChart() {
-  CartesianChartHost(
-    chart =
-      rememberCartesianChart(
-        rememberLineCartesianLayer(),
-        rememberLineCartesianLayer(
-          listOf(
-            rememberLineSpec(
-              shader = DynamicShader.color(Color.Blue),
-              backgroundShader =
-                DynamicShader.verticalGradient(
-                  arrayOf(Color.Blue.copy(alpha = 0.4f), Color.Blue.copy(alpha = 0f))
-                ),
-            )
-          )
-        ),
-        startAxis = rememberStartAxis(),
-      ),
-    model = model2,
-  )
-}
-
-@Preview("Composed Chart Collapsed", widthDp = 200)
-@Composable
-fun ComposedLineChartCollapsed() {
-  CartesianChartHost(
-    chart =
-      rememberCartesianChart(
-        rememberLineCartesianLayer(
-          axisValueOverrider = AxisValueOverrider.fixed(minY = 1f, maxY = 3f)
-        ),
-        rememberLineCartesianLayer(
-          axisValueOverrider = AxisValueOverrider.fixed(minY = 1f, maxY = 3f)
-        ),
-        startAxis = rememberStartAxis(),
-      ),
-    model = model2,
-  )
-}
diff --git a/sample/src/main/java/com/patrykandpatrick/vico/sample/previews/LineChartsWithNegativeValuesPreviews.kt b/sample/src/main/java/com/patrykandpatrick/vico/sample/previews/LineChartsWithNegativeValuesPreviews.kt
deleted file mode 100644
index d6b648164..000000000
--- a/sample/src/main/java/com/patrykandpatrick/vico/sample/previews/LineChartsWithNegativeValuesPreviews.kt
+++ /dev/null
@@ -1,152 +0,0 @@
-/*
- * Copyright 2024 by Patryk Goworowski and Patrick Michalik.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.patrykandpatrick.vico.sample.previews
-
-import androidx.compose.foundation.layout.height
-import androidx.compose.material.Surface
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.remember
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.tooling.preview.Preview
-import androidx.compose.ui.unit.dp
-import com.patrykandpatrick.vico.compose.cartesian.CartesianChartHost
-import com.patrykandpatrick.vico.compose.cartesian.axis.rememberAxisLineComponent
-import com.patrykandpatrick.vico.compose.cartesian.axis.rememberBottomAxis
-import com.patrykandpatrick.vico.compose.cartesian.axis.rememberStartAxis
-import com.patrykandpatrick.vico.compose.cartesian.fullWidth
-import com.patrykandpatrick.vico.compose.cartesian.layer.rememberLineCartesianLayer
-import com.patrykandpatrick.vico.compose.cartesian.layer.rememberLineSpec
-import com.patrykandpatrick.vico.compose.cartesian.rememberCartesianChart
-import com.patrykandpatrick.vico.compose.common.component.rememberTextComponent
-import com.patrykandpatrick.vico.compose.common.shader.color
-import com.patrykandpatrick.vico.core.cartesian.HorizontalLayout
-import com.patrykandpatrick.vico.core.cartesian.axis.AxisItemPlacer
-import com.patrykandpatrick.vico.core.cartesian.data.AxisValueOverrider
-import com.patrykandpatrick.vico.core.cartesian.data.CartesianChartModel
-import com.patrykandpatrick.vico.core.cartesian.data.LineCartesianLayerModel
-import com.patrykandpatrick.vico.core.common.shader.DynamicShader
-import com.patrykandpatrick.vico.core.common.shader.TopBottomShader
-import com.patrykandpatrick.vico.sample.showcase.rememberMarker
-
-private val model =
-  CartesianChartModel(LineCartesianLayerModel.build { series(-2, -1, 4, -2, 1, 5, -3) })
-
-@Preview
-@Composable
-fun SingleLineChartWithNegativeValues() {
-  val marker = rememberMarker()
-  Surface {
-    CartesianChartHost(
-      modifier = Modifier.height(250.dp),
-      chart =
-        rememberCartesianChart(
-          rememberLineCartesianLayer(
-            lines =
-              listOf(
-                rememberLineSpec(
-                  shader =
-                    TopBottomShader(
-                      DynamicShader.color(Color(0xFF25BE53)),
-                      DynamicShader.color(Color(0xFFE73B3B)),
-                    )
-                )
-              )
-          ),
-          startAxis =
-            rememberStartAxis(
-              itemPlacer = remember { AxisItemPlacer.Vertical.count(count = { 4 }) },
-              guideline = rememberAxisLineComponent(),
-            ),
-          bottomAxis =
-            rememberBottomAxis(
-              guideline = rememberAxisLineComponent(),
-              itemPlacer = AxisItemPlacer.Horizontal.default(spacing = 2),
-            ),
-          persistentMarkers = mapOf(2f to marker, 3f to marker),
-        ),
-      model = model,
-      horizontalLayout = HorizontalLayout.fullWidth(),
-    )
-  }
-}
-
-@Preview
-@Composable
-fun SingleLineChartWithNegativeValuesAndDataLabels() {
-  Surface {
-    CartesianChartHost(
-      chart =
-        rememberCartesianChart(
-          rememberLineCartesianLayer(
-            lines =
-              listOf(
-                rememberLineSpec(
-                  shader = DynamicShader.color(Color.DarkGray),
-                  dataLabel = rememberTextComponent(),
-                )
-              )
-          ),
-          startAxis = rememberStartAxis(),
-          bottomAxis = rememberBottomAxis(),
-        ),
-      model = model,
-    )
-  }
-}
-
-@Preview
-@Composable
-fun SingleLineChartWithNegativeValuesAndAxisValuesOverridden() {
-  Surface {
-    CartesianChartHost(
-      chart =
-        rememberCartesianChart(
-          rememberLineCartesianLayer(
-            axisValueOverrider = AxisValueOverrider.fixed(minY = 1f, maxY = 4f)
-          ),
-          startAxis =
-            rememberStartAxis(
-              itemPlacer = remember { AxisItemPlacer.Vertical.count(count = { 4 }) }
-            ),
-          bottomAxis = rememberBottomAxis(),
-        ),
-      model = model,
-    )
-  }
-}
-
-@Preview
-@Composable
-fun SingleLineChartWithNegativeValuesAndAxisValuesOverridden2() {
-  Surface {
-    CartesianChartHost(
-      chart =
-        rememberCartesianChart(
-          rememberLineCartesianLayer(
-            axisValueOverrider = AxisValueOverrider.fixed(minY = -2f, maxY = 0f)
-          ),
-          startAxis =
-            rememberStartAxis(
-              itemPlacer = remember { AxisItemPlacer.Vertical.count(count = { 3 }) }
-            ),
-          bottomAxis = rememberBottomAxis(),
-        ),
-      model = model,
-    )
-  }
-}
diff --git a/sample/src/main/java/com/patrykandpatrick/vico/sample/previews/Previews.kt b/sample/src/main/java/com/patrykandpatrick/vico/sample/previews/Previews.kt
deleted file mode 100644
index d8852fdef..000000000
--- a/sample/src/main/java/com/patrykandpatrick/vico/sample/previews/Previews.kt
+++ /dev/null
@@ -1,201 +0,0 @@
-/*
- * Copyright 2024 by Patryk Goworowski and Patrick Michalik.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.patrykandpatrick.vico.sample.previews
-
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.ColumnScope
-import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.shape.CornerSize
-import androidx.compose.foundation.shape.CutCornerShape
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.material3.Card
-import androidx.compose.material3.CardDefaults
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.tooling.preview.Preview
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
-import com.patrykandpatrick.vico.compose.cartesian.CartesianChartHost
-import com.patrykandpatrick.vico.compose.cartesian.axis.rememberBottomAxis
-import com.patrykandpatrick.vico.compose.cartesian.axis.rememberStartAxis
-import com.patrykandpatrick.vico.compose.cartesian.layer.rememberColumnCartesianLayer
-import com.patrykandpatrick.vico.compose.cartesian.layer.rememberLineCartesianLayer
-import com.patrykandpatrick.vico.compose.cartesian.layer.rememberLineSpec
-import com.patrykandpatrick.vico.compose.cartesian.rememberCartesianChart
-import com.patrykandpatrick.vico.compose.common.component.rememberLineComponent
-import com.patrykandpatrick.vico.compose.common.component.rememberShapeComponent
-import com.patrykandpatrick.vico.compose.common.component.rememberTextComponent
-import com.patrykandpatrick.vico.compose.common.of
-import com.patrykandpatrick.vico.compose.common.shader.color
-import com.patrykandpatrick.vico.compose.common.shader.component
-import com.patrykandpatrick.vico.compose.common.shader.verticalGradient
-import com.patrykandpatrick.vico.compose.common.shape.toVicoShape
-import com.patrykandpatrick.vico.core.cartesian.axis.VerticalAxis
-import com.patrykandpatrick.vico.core.cartesian.data.AxisValueOverrider
-import com.patrykandpatrick.vico.core.cartesian.data.CartesianChartModel
-import com.patrykandpatrick.vico.core.cartesian.data.ColumnCartesianLayerModel
-import com.patrykandpatrick.vico.core.cartesian.data.LineCartesianLayerModel
-import com.patrykandpatrick.vico.core.cartesian.layer.ColumnCartesianLayer
-import com.patrykandpatrick.vico.core.common.Dimensions
-import com.patrykandpatrick.vico.core.common.shader.DynamicShader
-import com.patrykandpatrick.vico.core.common.shape.DashedShape
-import com.patrykandpatrick.vico.core.common.shape.Shape.Companion.Pill
-import com.patrykandpatrick.vico.core.common.shape.Shape.Companion.Rectangle
-import com.patrykandpatrick.vico.sample.VicoTheme
-
-private val chartModifier = Modifier.height(100.dp)
-
-@Preview("Sample Card With Column Chart", widthDp = 200)
-@Composable
-fun ColumnChartCard(): Unit = VicoTheme {
-  val colors = MaterialTheme.colorScheme
-
-  SampleCard {
-    CartesianChartHost(
-      modifier = chartModifier,
-      chart =
-        rememberCartesianChart(
-          rememberColumnCartesianLayer(
-            ColumnCartesianLayer.ColumnProvider.series(
-              rememberLineComponent(
-                color = colors.primary,
-                thickness = 8.dp,
-                shape = RoundedCornerShape(4.dp).toVicoShape(),
-                dynamicShader =
-                  DynamicShader.verticalGradient(arrayOf(colors.primary, colors.secondary)),
-              )
-            )
-          ),
-          startAxis =
-            rememberStartAxis(
-              label =
-                rememberTextComponent(
-                  color = colors.primary,
-                  textSize = 10.sp,
-                  background =
-                    rememberShapeComponent(
-                      shape =
-                        CutCornerShape(
-                            CornerSize(percent = 25),
-                            CornerSize(percent = 50),
-                            CornerSize(percent = 50),
-                            CornerSize(percent = 25),
-                          )
-                          .toVicoShape(),
-                      color = colors.primary.copy(alpha = 0.1f),
-                    ),
-                  padding = Dimensions.of(end = 8.dp, start = 4.dp),
-                ),
-              axis = null,
-              tick = null,
-              guideline = rememberLineComponent(colors.primary.copy(alpha = .1f)),
-            ),
-        ),
-      model = CartesianChartModel(ColumnCartesianLayerModel.build { series(1, 2, 3, 2) }),
-    )
-  }
-}
-
-@Preview("Sample Card With Line Chart", widthDp = 200)
-@Composable
-fun LineChartCard(): Unit = VicoTheme {
-  val colors = MaterialTheme.colorScheme
-
-  SampleCard {
-    CartesianChartHost(
-      modifier = Modifier.height(100.dp),
-      chart =
-        rememberCartesianChart(
-          rememberLineCartesianLayer(
-            listOf(
-              rememberLineSpec(
-                point = null,
-                shader = DynamicShader.color(colors.primary),
-                backgroundShader =
-                  DynamicShader.component(
-                    componentSize = 4.dp,
-                    component =
-                      rememberShapeComponent(
-                        shape = Pill,
-                        color = colors.primary,
-                        margins = Dimensions.of(0.5.dp),
-                      ),
-                  ),
-              )
-            ),
-            axisValueOverrider = AxisValueOverrider.fixed(minX = 0f, maxY = 3f),
-          ),
-          startAxis =
-            rememberStartAxis(
-              label =
-                rememberTextComponent(
-                  color = colors.onSurface,
-                  textSize = 10.sp,
-                  background = rememberShapeComponent(shape = Rectangle, color = Color.LightGray),
-                  padding = Dimensions.of(horizontal = 4.dp, vertical = 2.dp),
-                ),
-              axis = null,
-              tick = null,
-              guideline =
-                rememberLineComponent(
-                  color = Color.LightGray,
-                  shape =
-                    DashedShape(shape = Pill, dashLengthDp = 2.dp.value, gapLengthDp = 4.dp.value),
-                ),
-              horizontalLabelPosition = VerticalAxis.HorizontalLabelPosition.Inside,
-            ),
-          bottomAxis =
-            rememberBottomAxis(
-              label = null,
-              axis = rememberLineComponent(Color.LightGray),
-              tick = null,
-              guideline = null,
-            ),
-        ),
-      model =
-        CartesianChartModel(
-          LineCartesianLayerModel.build {
-            series(x = listOf(-1, 0, 1, 2, 3, 4, 5), y = listOf(0, 0, 1, 2, 0, 2, 1))
-          }
-        ),
-    )
-  }
-}
-
-@Composable
-private fun SampleCard(chart: @Composable ColumnScope.() -> Unit) {
-  Card(
-    modifier = Modifier.padding(8.dp),
-    shape = RoundedCornerShape(8.dp),
-    elevation = CardDefaults.elevatedCardElevation(4.dp),
-  ) {
-    Column(modifier = Modifier.padding(16.dp)) {
-      chart()
-      Spacer(modifier = Modifier.height(8.dp))
-      Text(text = "Title", style = MaterialTheme.typography.titleMedium)
-      Text(
-        text = "This is a subtitle. It may be long.",
-        style = MaterialTheme.typography.bodyMedium,
-      )
-    }
-  }
-}
diff --git a/sample/src/main/java/com/patrykandpatrick/vico/sample/previews/ShapePreviews.kt b/sample/src/main/java/com/patrykandpatrick/vico/sample/previews/ShapePreviews.kt
deleted file mode 100644
index b83b18b01..000000000
--- a/sample/src/main/java/com/patrykandpatrick/vico/sample/previews/ShapePreviews.kt
+++ /dev/null
@@ -1,176 +0,0 @@
-/*
- * Copyright 2024 by Patryk Goworowski and Patrick Michalik.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.patrykandpatrick.vico.sample.previews
-
-import android.graphics.Paint
-import android.graphics.Path
-import android.graphics.drawable.Drawable
-import androidx.annotation.DrawableRes
-import androidx.compose.foundation.Canvas
-import androidx.compose.foundation.background
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.width
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.material.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.remember
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.graphics.nativeCanvas
-import androidx.compose.ui.platform.LocalContext
-import androidx.compose.ui.tooling.preview.Preview
-import androidx.compose.ui.unit.dp
-import androidx.core.content.res.ResourcesCompat
-import com.patrykandpatrick.vico.R
-import com.patrykandpatrick.vico.compose.common.shape.dashed
-import com.patrykandpatrick.vico.compose.common.shape.toComposeShape
-import com.patrykandpatrick.vico.core.common.drawContext
-import com.patrykandpatrick.vico.core.common.shape.CorneredShape
-import com.patrykandpatrick.vico.core.common.shape.Shape
-
-@Composable
-private fun PreviewShape(shape: Shape) {
-  val black = 0xFF212121.toInt()
-  val paint = remember { Paint(Paint.ANTI_ALIAS_FLAG).apply { color = black } }
-  val path = remember { Path() }
-
-  Column(
-    modifier =
-      Modifier.width(100.dp)
-        .background(color = Color.White, shape = RoundedCornerShape(size = 4.dp))
-        .padding(8.dp),
-    verticalArrangement = Arrangement.spacedBy(8.dp),
-  ) {
-    Text(text = "Canvas")
-
-    Canvas(modifier = Modifier.fillMaxWidth().height(50.dp)) {
-      shape.drawShape(
-        context = drawContext(drawContext.canvas.nativeCanvas),
-        paint = paint,
-        path = path,
-        left = 0f,
-        top = 0f,
-        right = size.width,
-        bottom = size.height,
-      )
-    }
-
-    if (shape is CorneredShape) {
-      Spacer(modifier = Modifier.height(8.dp))
-
-      Text(text = "Compose Shape")
-
-      Box(
-        modifier =
-          Modifier.height(50.dp)
-            .fillMaxWidth()
-            .background(color = Color(black), shape = shape.toComposeShape())
-      )
-    }
-  }
-}
-
-@Composable
-@Preview
-public fun PreviewRectShape() {
-  PreviewShape(shape = Shape.Rectangle)
-}
-
-@Composable
-@Preview
-public fun PreviewPillShape() {
-  PreviewShape(shape = Shape.Pill)
-}
-
-@Composable
-@Preview
-public fun RoundedCorner25Shape() {
-  PreviewShape(shape = Shape.rounded(allPercent = 25))
-}
-
-@Composable
-@Preview
-public fun RoundedCornerCustom1Shape() {
-  PreviewShape(shape = Shape.rounded(topLeftPercent = 50, bottomRightPercent = 75))
-}
-
-@Composable
-@Preview
-public fun CutCorner25Shape() {
-  PreviewShape(shape = Shape.cut(allPercent = 25))
-}
-
-@Composable
-@Preview
-public fun CutCornerCustom1Shape() {
-  PreviewShape(shape = Shape.cut(topRightPercent = 100, bottomLeftPercent = 15))
-}
-
-@Composable
-@Preview
-public fun DrawableShape() {
-  PreviewShape(
-    shape =
-      Shape.drawable(
-        drawable = getDrawable(id = R.drawable.ic_baseline_android_24),
-        keepAspectRatio = true,
-        otherShape = Shape.Pill,
-      )
-  )
-}
-
-@Composable
-@Preview
-public fun DrawableShape2() {
-  PreviewShape(
-    shape =
-      Shape.drawable(
-        drawable = getDrawable(id = R.drawable.ic_baseline_android_24),
-        keepAspectRatio = true,
-        otherShape = Shape.Pill,
-      )
-  )
-}
-
-@Composable
-@Preview
-public fun DrawableShapeStretched() {
-  PreviewShape(shape = Shape.drawable(getDrawable(id = R.drawable.ic_baseline_android_24)))
-}
-
-@Composable
-@Preview
-public fun DashedCutCornerCustomShape() {
-  PreviewShape(
-    shape =
-      Shape.dashed(
-        shape = Shape.cut(topRightPercent = 50, bottomLeftPercent = 50),
-        dashLength = 24.dp,
-        gapLength = 8.dp,
-      )
-  )
-}
-
-@Composable
-private fun getDrawable(@DrawableRes id: Int): Drawable =
-  ResourcesCompat.getDrawable(LocalContext.current.resources, id, null)!!
diff --git a/sample/src/main/java/com/patrykandpatrick/vico/sample/previews/StackedColumnChartsWithNegativeValuesPreviews.kt b/sample/src/main/java/com/patrykandpatrick/vico/sample/previews/StackedColumnChartsWithNegativeValuesPreviews.kt
deleted file mode 100644
index 4ee9e08e6..000000000
--- a/sample/src/main/java/com/patrykandpatrick/vico/sample/previews/StackedColumnChartsWithNegativeValuesPreviews.kt
+++ /dev/null
@@ -1,151 +0,0 @@
-/*
- * Copyright 2024 by Patryk Goworowski and Patrick Michalik.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.patrykandpatrick.vico.sample.previews
-
-import androidx.compose.foundation.layout.height
-import androidx.compose.material.Surface
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.remember
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.tooling.preview.Preview
-import androidx.compose.ui.unit.dp
-import com.patrykandpatrick.vico.compose.cartesian.CartesianChartHost
-import com.patrykandpatrick.vico.compose.cartesian.axis.rememberBottomAxis
-import com.patrykandpatrick.vico.compose.cartesian.axis.rememberStartAxis
-import com.patrykandpatrick.vico.compose.cartesian.layer.rememberColumnCartesianLayer
-import com.patrykandpatrick.vico.compose.cartesian.rememberCartesianChart
-import com.patrykandpatrick.vico.compose.common.component.rememberLineComponent
-import com.patrykandpatrick.vico.compose.common.component.rememberTextComponent
-import com.patrykandpatrick.vico.core.cartesian.axis.AxisItemPlacer
-import com.patrykandpatrick.vico.core.cartesian.data.AxisValueOverrider
-import com.patrykandpatrick.vico.core.cartesian.data.CartesianChartModel
-import com.patrykandpatrick.vico.core.cartesian.data.ColumnCartesianLayerModel
-import com.patrykandpatrick.vico.core.cartesian.layer.ColumnCartesianLayer
-import com.patrykandpatrick.vico.sample.showcase.rememberMarker
-
-private val model =
-  CartesianChartModel(
-    ColumnCartesianLayerModel.build {
-      series(2, -1, -4, 2, 1, -5, -2, -3)
-      series(3, -2, 2, -1, 2, -3, -4, -1)
-      series(1, -2, 2, 1, -1, 4, 4, -2)
-    }
-  )
-
-private val columnProvider
-  @Composable
-  get() =
-    ColumnCartesianLayer.ColumnProvider.series(
-      rememberLineComponent(color = Color(0xFF494949), thickness = 8.dp),
-      rememberLineComponent(color = Color(0xFF7C7A7A), thickness = 8.dp),
-      rememberLineComponent(color = Color(0xFFFF5D73), thickness = 8.dp),
-    )
-
-@Preview
-@Composable
-public fun StackedColumnChartWithNegativeValues() {
-  val marker = rememberMarker()
-  Surface {
-    CartesianChartHost(
-      modifier = Modifier.height(250.dp),
-      chart =
-        rememberCartesianChart(
-          rememberColumnCartesianLayer(
-            columnProvider = columnProvider,
-            mergeMode = { ColumnCartesianLayer.MergeMode.Stacked },
-          ),
-          startAxis =
-            rememberStartAxis(
-              itemPlacer = remember { AxisItemPlacer.Vertical.count(count = { 8 }) }
-            ),
-          bottomAxis = rememberBottomAxis(),
-          persistentMarkers = mapOf(2f to marker, 3f to marker),
-        ),
-      model = model,
-    )
-  }
-}
-
-@Preview
-@Composable
-public fun StackedColumnChartWithNegativeValuesAndDataLabels() {
-  Surface {
-    CartesianChartHost(
-      chart =
-        rememberCartesianChart(
-          rememberColumnCartesianLayer(
-            columnProvider = columnProvider,
-            dataLabel = rememberTextComponent(),
-            mergeMode = { ColumnCartesianLayer.MergeMode.Stacked },
-          ),
-          startAxis =
-            rememberStartAxis(
-              itemPlacer = remember { AxisItemPlacer.Vertical.count(count = { 8 }) }
-            ),
-          bottomAxis = rememberBottomAxis(),
-        ),
-      model = model,
-    )
-  }
-}
-
-@Preview
-@Composable
-public fun StackedColumnChartWithNegativeValuesAndAxisValuesOverridden() {
-  Surface {
-    CartesianChartHost(
-      chart =
-        rememberCartesianChart(
-          rememberColumnCartesianLayer(
-            columnProvider = columnProvider,
-            axisValueOverrider = AxisValueOverrider.fixed(minY = 1f, maxY = 4f),
-            mergeMode = { ColumnCartesianLayer.MergeMode.Stacked },
-          ),
-          startAxis =
-            rememberStartAxis(
-              itemPlacer = remember { AxisItemPlacer.Vertical.count(count = { 4 }) }
-            ),
-          bottomAxis = rememberBottomAxis(),
-        ),
-      model = model,
-    )
-  }
-}
-
-@Preview
-@Composable
-public fun StackedColumnChartWithNegativeValuesAndAxisValuesOverridden2() {
-  Surface {
-    CartesianChartHost(
-      chart =
-        rememberCartesianChart(
-          rememberColumnCartesianLayer(
-            columnProvider = columnProvider,
-            axisValueOverrider = AxisValueOverrider.fixed(minY = -2f, maxY = 0f),
-            mergeMode = { ColumnCartesianLayer.MergeMode.Stacked },
-          ),
-          startAxis =
-            rememberStartAxis(
-              itemPlacer = remember { AxisItemPlacer.Vertical.count(count = { 3 }) }
-            ),
-          bottomAxis = rememberBottomAxis(),
-        ),
-      model = model,
-    )
-  }
-}
diff --git a/sample/src/main/java/com/patrykandpatrick/vico/sample/previews/composables/column/ColumnCharts.kt b/sample/src/main/java/com/patrykandpatrick/vico/sample/previews/composables/column/ColumnCharts.kt
index 1f5539a87..5b65e81b1 100644
--- a/sample/src/main/java/com/patrykandpatrick/vico/sample/previews/composables/column/ColumnCharts.kt
+++ b/sample/src/main/java/com/patrykandpatrick/vico/sample/previews/composables/column/ColumnCharts.kt
@@ -35,7 +35,6 @@ import com.patrykandpatrick.vico.sample.previews.resource.shortColumnModel
 @Composable
 public fun DefaultColumnChart(
   model: CartesianChartModel = shortColumnModel,
-  oldModel: CartesianChartModel? = null,
   scrollable: Boolean = true,
   initialScroll: Scroll.Absolute = Scroll.Absolute.Start,
   autoScrollCondition: AutoScrollCondition = AutoScrollCondition.Never,
@@ -49,7 +48,6 @@ public fun DefaultColumnChart(
           bottomAxis = rememberBottomAxis(),
         ),
       model = model,
-      oldModel = oldModel,
       scrollState =
         rememberVicoScrollState(
           scrollEnabled = scrollable,
diff --git a/sample/src/main/java/com/patrykandpatrick/vico/sample/showcase/Marker.kt b/sample/src/main/java/com/patrykandpatrick/vico/sample/showcase/Marker.kt
index 84dad1482..0dcfe765e 100644
--- a/sample/src/main/java/com/patrykandpatrick/vico/sample/showcase/Marker.kt
+++ b/sample/src/main/java/com/patrykandpatrick/vico/sample/showcase/Marker.kt
@@ -16,7 +16,6 @@
 
 package com.patrykandpatrick.vico.sample.showcase
 
-import android.graphics.Typeface
 import android.text.Layout
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.runtime.Composable
@@ -25,6 +24,7 @@ import androidx.compose.ui.unit.dp
 import com.patrykandpatrick.vico.compose.cartesian.axis.rememberAxisGuidelineComponent
 import com.patrykandpatrick.vico.compose.common.component.fixed
 import com.patrykandpatrick.vico.compose.common.component.rememberLayeredComponent
+import com.patrykandpatrick.vico.compose.common.component.rememberShadow
 import com.patrykandpatrick.vico.compose.common.component.rememberShapeComponent
 import com.patrykandpatrick.vico.compose.common.component.rememberTextComponent
 import com.patrykandpatrick.vico.compose.common.of
@@ -32,9 +32,13 @@ import com.patrykandpatrick.vico.compose.common.shape.markerCornered
 import com.patrykandpatrick.vico.core.cartesian.CartesianMeasureContext
 import com.patrykandpatrick.vico.core.cartesian.HorizontalDimensions
 import com.patrykandpatrick.vico.core.cartesian.Insets
+import com.patrykandpatrick.vico.core.cartesian.data.CartesianChartModel
 import com.patrykandpatrick.vico.core.cartesian.marker.CartesianMarker
 import com.patrykandpatrick.vico.core.cartesian.marker.DefaultCartesianMarker
 import com.patrykandpatrick.vico.core.common.Dimensions
+import com.patrykandpatrick.vico.core.common.LayeredComponent
+import com.patrykandpatrick.vico.core.common.component.Shadow
+import com.patrykandpatrick.vico.core.common.component.ShapeComponent
 import com.patrykandpatrick.vico.core.common.component.TextComponent
 import com.patrykandpatrick.vico.core.common.copyColor
 import com.patrykandpatrick.vico.core.common.shape.Corner
@@ -47,25 +51,27 @@ internal fun rememberMarker(
 ): CartesianMarker {
   val labelBackgroundShape = Shape.markerCornered(Corner.FullyRounded)
   val labelBackground =
-    rememberShapeComponent(labelBackgroundShape, MaterialTheme.colorScheme.surface)
-      .setShadow(
-        radius = LABEL_BACKGROUND_SHADOW_RADIUS_DP,
-        dy = LABEL_BACKGROUND_SHADOW_DY_DP,
-        applyElevationOverlay = true,
-      )
+    rememberShapeComponent(
+      color = MaterialTheme.colorScheme.surfaceBright,
+      shape = labelBackgroundShape,
+      shadow =
+        rememberShadow(
+          radius = LABEL_BACKGROUND_SHADOW_RADIUS_DP.dp,
+          dy = LABEL_BACKGROUND_SHADOW_DY_DP.dp,
+        ),
+    )
   val label =
     rememberTextComponent(
       color = MaterialTheme.colorScheme.onSurface,
-      background = labelBackground,
-      padding = Dimensions.of(8.dp, 4.dp),
-      typeface = Typeface.MONOSPACE,
       textAlignment = Layout.Alignment.ALIGN_CENTER,
+      padding = Dimensions.of(8.dp, 4.dp),
+      background = labelBackground,
       minWidth = TextComponent.MinWidth.fixed(40.dp),
     )
   val indicatorFrontComponent =
-    rememberShapeComponent(Shape.Pill, MaterialTheme.colorScheme.surface)
-  val indicatorCenterComponent = rememberShapeComponent(Shape.Pill)
-  val indicatorRearComponent = rememberShapeComponent(Shape.Pill)
+    rememberShapeComponent(MaterialTheme.colorScheme.surface, Shape.Pill)
+  val indicatorCenterComponent = rememberShapeComponent(shape = Shape.Pill)
+  val indicatorRearComponent = rememberShapeComponent(shape = Shape.Pill)
   val indicator =
     rememberLayeredComponent(
       rear = indicatorRearComponent,
@@ -83,31 +89,49 @@ internal fun rememberMarker(
       DefaultCartesianMarker(
         label = label,
         labelPosition = labelPosition,
-        indicator = if (showIndicator) indicator else null,
-        indicatorSizeDp = 36f,
-        setIndicatorColor =
+        indicator =
           if (showIndicator) {
             { color ->
-              indicatorRearComponent.color = color.copyColor(alpha = .15f)
-              indicatorCenterComponent.color = color
-              indicatorCenterComponent.setShadow(radius = 12f, color = color)
+              LayeredComponent(
+                rear = ShapeComponent(color.copyColor(alpha = 0.15f), Shape.Pill),
+                front =
+                  LayeredComponent(
+                    rear =
+                      ShapeComponent(
+                        color = color,
+                        shape = Shape.Pill,
+                        shadow = Shadow(radiusDp = 12f, color = color),
+                      ),
+                    front = indicatorFrontComponent,
+                    padding = Dimensions.of(5.dp),
+                  ),
+                padding = Dimensions.of(10.dp),
+              )
             }
           } else {
             null
           },
+        indicatorSizeDp = 36f,
         guideline = guideline,
       ) {
-      override fun getInsets(
+      override fun updateInsets(
         context: CartesianMeasureContext,
-        outInsets: Insets,
         horizontalDimensions: HorizontalDimensions,
+        model: CartesianChartModel,
+        insets: Insets,
       ) {
         with(context) {
-          super.getInsets(context, outInsets, horizontalDimensions)
           val baseShadowInsetDp =
             CLIPPING_FREE_SHADOW_RADIUS_MULTIPLIER * LABEL_BACKGROUND_SHADOW_RADIUS_DP
-          outInsets.top += (baseShadowInsetDp - LABEL_BACKGROUND_SHADOW_DY_DP).pixels
-          outInsets.bottom += (baseShadowInsetDp + LABEL_BACKGROUND_SHADOW_DY_DP).pixels
+          var topInset = (baseShadowInsetDp - LABEL_BACKGROUND_SHADOW_DY_DP).pixels
+          var bottomInset = (baseShadowInsetDp + LABEL_BACKGROUND_SHADOW_DY_DP).pixels
+          when (labelPosition) {
+            LabelPosition.Top,
+            LabelPosition.AbovePoint -> topInset += label.getHeight(context) + tickSizeDp.pixels
+            LabelPosition.Bottom -> bottomInset += label.getHeight(context) + tickSizeDp.pixels
+            LabelPosition.AroundPoint -> {}
+          }
+          insets.ensureValuesAtLeast(top = topInset, bottom = bottomInset)
         }
       }
     }
diff --git a/sample/src/main/java/com/patrykandpatrick/vico/sample/showcase/charts/Chart1.kt b/sample/src/main/java/com/patrykandpatrick/vico/sample/showcase/charts/Chart1.kt
index 8720b0d5c..62f777043 100644
--- a/sample/src/main/java/com/patrykandpatrick/vico/sample/showcase/charts/Chart1.kt
+++ b/sample/src/main/java/com/patrykandpatrick/vico/sample/showcase/charts/Chart1.kt
@@ -25,14 +25,16 @@ import androidx.compose.ui.viewinterop.AndroidViewBinding
 import com.patrykandpatrick.vico.compose.cartesian.CartesianChartHost
 import com.patrykandpatrick.vico.compose.cartesian.axis.rememberBottomAxis
 import com.patrykandpatrick.vico.compose.cartesian.axis.rememberStartAxis
+import com.patrykandpatrick.vico.compose.cartesian.layer.rememberLine
 import com.patrykandpatrick.vico.compose.cartesian.layer.rememberLineCartesianLayer
-import com.patrykandpatrick.vico.compose.cartesian.layer.rememberLineSpec
 import com.patrykandpatrick.vico.compose.cartesian.rememberCartesianChart
 import com.patrykandpatrick.vico.compose.cartesian.rememberVicoZoomState
+import com.patrykandpatrick.vico.compose.common.data.rememberExtraLambda
 import com.patrykandpatrick.vico.compose.common.shader.color
 import com.patrykandpatrick.vico.core.cartesian.axis.BaseAxis
 import com.patrykandpatrick.vico.core.cartesian.data.CartesianChartModelProducer
 import com.patrykandpatrick.vico.core.cartesian.data.lineSeries
+import com.patrykandpatrick.vico.core.cartesian.layer.LineCartesianLayer
 import com.patrykandpatrick.vico.core.common.shader.DynamicShader
 import com.patrykandpatrick.vico.databinding.Chart1Binding
 import com.patrykandpatrick.vico.sample.showcase.UIFramework
@@ -43,10 +45,10 @@ import kotlinx.coroutines.withContext
 
 @Composable
 internal fun Chart1(uiFramework: UIFramework, modifier: Modifier) {
-  val modelProducer = remember { CartesianChartModelProducer.build() }
+  val modelProducer = remember { CartesianChartModelProducer() }
   LaunchedEffect(Unit) {
     withContext(Dispatchers.Default) {
-      modelProducer.tryRunTransaction {
+      modelProducer.runTransaction {
         /* Learn more:
         https://patrykandpatrick.com/vico/wiki/cartesian-charts/layers/line-layer#data. */
         lineSeries { series(x, x.map { Random.nextFloat() * 15 }) }
@@ -66,15 +68,17 @@ private fun ComposeChart1(modelProducer: CartesianChartModelProducer, modifier:
     chart =
       rememberCartesianChart(
         rememberLineCartesianLayer(
-          listOf(rememberLineSpec(DynamicShader.color(Color(0xffa485e0))))
+          LineCartesianLayer.LineProvider.series(
+            rememberLine(DynamicShader.color(Color(0xffa485e0)))
+          )
         ),
         startAxis = rememberStartAxis(),
         bottomAxis = rememberBottomAxis(guideline = null),
-        persistentMarkers = mapOf(PERSISTENT_MARKER_X to marker),
+        marker = marker,
+        persistentMarkers = rememberExtraLambda(marker) { marker at PERSISTENT_MARKER_X },
       ),
     modelProducer = modelProducer,
     modifier = modifier,
-    marker = marker,
     zoomState = rememberVicoZoomState(zoomEnabled = false),
   )
 }
@@ -86,10 +90,10 @@ private fun ViewChart1(modelProducer: CartesianChartModelProducer, modifier: Mod
     { inflater, parent, attachToParent ->
       Chart1Binding.inflate(inflater, parent, attachToParent).apply {
         with(chartView) {
-          chart?.addPersistentMarker(PERSISTENT_MARKER_X, marker)
+          chart?.persistentMarkers = { marker at PERSISTENT_MARKER_X }
           this.modelProducer = modelProducer
           (chart?.bottomAxis as BaseAxis).guideline = null
-          this.marker = marker
+          chart?.marker = marker
         }
       }
     },
diff --git a/sample/src/main/java/com/patrykandpatrick/vico/sample/showcase/charts/Chart10.kt b/sample/src/main/java/com/patrykandpatrick/vico/sample/showcase/charts/Chart10.kt
index 09cfa4b25..90fbdbd21 100644
--- a/sample/src/main/java/com/patrykandpatrick/vico/sample/showcase/charts/Chart10.kt
+++ b/sample/src/main/java/com/patrykandpatrick/vico/sample/showcase/charts/Chart10.kt
@@ -28,7 +28,7 @@ import com.patrykandpatrick.vico.compose.cartesian.fullWidth
 import com.patrykandpatrick.vico.compose.cartesian.layer.rememberCandlestickCartesianLayer
 import com.patrykandpatrick.vico.compose.cartesian.rememberCartesianChart
 import com.patrykandpatrick.vico.core.cartesian.HorizontalLayout
-import com.patrykandpatrick.vico.core.cartesian.axis.AxisItemPlacer
+import com.patrykandpatrick.vico.core.cartesian.axis.HorizontalAxis
 import com.patrykandpatrick.vico.core.cartesian.data.CartesianChartModelProducer
 import com.patrykandpatrick.vico.core.cartesian.data.RandomCartesianModelGenerator
 import com.patrykandpatrick.vico.databinding.Chart10Binding
@@ -42,11 +42,11 @@ import kotlinx.coroutines.withContext
 
 @Composable
 internal fun Chart10(uiFramework: UIFramework, modifier: Modifier) {
-  val modelProducer = remember { CartesianChartModelProducer.build() }
+  val modelProducer = remember { CartesianChartModelProducer() }
   LaunchedEffect(key1 = Unit) {
     withContext(Dispatchers.Default) {
       while (isActive) {
-        modelProducer.tryRunTransaction {
+        modelProducer.runTransaction {
           /* Learn more:
           https://patrykandpatrick.com/vico/wiki/cartesian-charts/layers/candlestick-layer#data. */
           add(RandomCartesianModelGenerator.getRandomCandlestickLayerModelPartial())
@@ -74,14 +74,14 @@ private fun ComposeChart10(modelProducer: CartesianChartModelProducer, modifier:
             guideline = null,
             itemPlacer =
               remember {
-                AxisItemPlacer.Horizontal.default(spacing = 3, addExtremeLabelPadding = true)
+                HorizontalAxis.ItemPlacer.default(spacing = 3, addExtremeLabelPadding = true)
               },
           ),
+        marker = marker,
+        horizontalLayout = HorizontalLayout.fullWidth(),
       ),
     modelProducer = modelProducer,
-    marker = marker,
     modifier = modifier,
-    horizontalLayout = HorizontalLayout.fullWidth(),
   )
 }
 
@@ -90,6 +90,6 @@ private fun ViewChart10(modelProducer: CartesianChartModelProducer, modifier: Mo
   val marker = rememberMarker(showIndicator = false)
   AndroidViewBinding(Chart10Binding::inflate, modifier = modifier) {
     chartView.modelProducer = modelProducer
-    chartView.marker = marker
+    chartView.chart?.marker = marker
   }
 }
diff --git a/sample/src/main/java/com/patrykandpatrick/vico/sample/showcase/charts/Chart2.kt b/sample/src/main/java/com/patrykandpatrick/vico/sample/showcase/charts/Chart2.kt
index e552d0df4..4c83e1c77 100644
--- a/sample/src/main/java/com/patrykandpatrick/vico/sample/showcase/charts/Chart2.kt
+++ b/sample/src/main/java/com/patrykandpatrick/vico/sample/showcase/charts/Chart2.kt
@@ -16,7 +16,6 @@
 
 package com.patrykandpatrick.vico.sample.showcase.charts
 
-import android.graphics.Typeface
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.remember
@@ -36,8 +35,8 @@ import com.patrykandpatrick.vico.compose.common.component.rememberShapeComponent
 import com.patrykandpatrick.vico.compose.common.component.rememberTextComponent
 import com.patrykandpatrick.vico.compose.common.of
 import com.patrykandpatrick.vico.core.cartesian.HorizontalLayout
-import com.patrykandpatrick.vico.core.cartesian.axis.AxisItemPlacer
 import com.patrykandpatrick.vico.core.cartesian.axis.BaseAxis
+import com.patrykandpatrick.vico.core.cartesian.axis.HorizontalAxis
 import com.patrykandpatrick.vico.core.cartesian.data.CartesianChartModelProducer
 import com.patrykandpatrick.vico.core.cartesian.data.CartesianValueFormatter
 import com.patrykandpatrick.vico.core.cartesian.data.columnSeries
@@ -62,11 +61,11 @@ import kotlinx.coroutines.withContext
 
 @Composable
 internal fun Chart2(uiFramework: UIFramework, modifier: Modifier) {
-  val modelProducer = remember { CartesianChartModelProducer.build() }
+  val modelProducer = remember { CartesianChartModelProducer() }
   LaunchedEffect(Unit) {
     withContext(Dispatchers.Default) {
       while (isActive) {
-        modelProducer.tryRunTransaction {
+        modelProducer.runTransaction {
           /* Learn more:
           https://patrykandpatrick.com/vico/wiki/cartesian-charts/layers/column-layer#data. */
           columnSeries { series(List(47) { 2 + Random.nextFloat() * 18 }) }
@@ -101,15 +100,15 @@ private fun ComposeChart2(modelProducer: CartesianChartModelProducer, modifier:
             valueFormatter = bottomAxisValueFormatter,
             itemPlacer =
               remember {
-                AxisItemPlacer.Horizontal.default(spacing = 3, addExtremeLabelPadding = true)
+                HorizontalAxis.ItemPlacer.default(spacing = 3, addExtremeLabelPadding = true)
               },
           ),
+        marker = rememberMarker(),
+        horizontalLayout = HorizontalLayout.fullWidth(),
         decorations = listOf(rememberComposeHorizontalLine()),
       ),
     modelProducer = modelProducer,
     modifier = modifier,
-    marker = rememberMarker(),
-    horizontalLayout = HorizontalLayout.fullWidth(),
   )
 }
 
@@ -120,10 +119,10 @@ private fun ViewChart2(modelProducer: CartesianChartModelProducer, modifier: Mod
     { inflater, parent, attachToParent ->
       Chart2Binding.inflate(inflater, parent, attachToParent).apply {
         with(chartView) {
-          chart?.addDecoration(getViewHorizontalLine())
+          chart?.decorations = listOf(getViewHorizontalLine())
           this.modelProducer = modelProducer
           (chart?.bottomAxis as BaseAxis).valueFormatter = bottomAxisValueFormatter
-          this.marker = marker
+          chart?.marker = marker
         }
       }
     },
@@ -139,14 +138,13 @@ private fun rememberComposeHorizontalLine(): HorizontalLine {
     line = rememberLineComponent(color, HORIZONTAL_LINE_THICKNESS_DP.dp),
     labelComponent =
       rememberTextComponent(
-        background = rememberShapeComponent(Shape.Pill, color),
+        margins = Dimensions.of(HORIZONTAL_LINE_LABEL_MARGIN_DP.dp),
         padding =
           Dimensions.of(
             HORIZONTAL_LINE_LABEL_HORIZONTAL_PADDING_DP.dp,
             HORIZONTAL_LINE_LABEL_VERTICAL_PADDING_DP.dp,
           ),
-        margins = Dimensions.of(HORIZONTAL_LINE_LABEL_MARGIN_DP.dp),
-        typeface = Typeface.MONOSPACE,
+        background = rememberShapeComponent(color, Shape.Pill),
       ),
   )
 }
@@ -156,19 +154,18 @@ private fun getViewHorizontalLine() =
     y = { HORIZONTAL_LINE_Y },
     line = LineComponent(HORIZONTAL_LINE_COLOR, HORIZONTAL_LINE_THICKNESS_DP),
     labelComponent =
-      TextComponent.build {
-        background = ShapeComponent(Shape.Pill, HORIZONTAL_LINE_COLOR)
+      TextComponent(
+        margins = Dimensions(HORIZONTAL_LINE_LABEL_MARGIN_DP),
         padding =
           Dimensions(
             HORIZONTAL_LINE_LABEL_HORIZONTAL_PADDING_DP,
             HORIZONTAL_LINE_LABEL_VERTICAL_PADDING_DP,
-          )
-        margins = Dimensions(HORIZONTAL_LINE_LABEL_MARGIN_DP)
-        typeface = Typeface.MONOSPACE
-      },
+          ),
+        background = ShapeComponent(HORIZONTAL_LINE_COLOR, Shape.Pill),
+      ),
   )
 
-private const val HORIZONTAL_LINE_Y = 14f
+private const val HORIZONTAL_LINE_Y = 14.0
 private const val HORIZONTAL_LINE_COLOR = -2893786
 private const val HORIZONTAL_LINE_THICKNESS_DP = 2f
 private const val HORIZONTAL_LINE_LABEL_HORIZONTAL_PADDING_DP = 8f
diff --git a/sample/src/main/java/com/patrykandpatrick/vico/sample/showcase/charts/Chart3.kt b/sample/src/main/java/com/patrykandpatrick/vico/sample/showcase/charts/Chart3.kt
index 290fc2cf4..b5a662aa6 100644
--- a/sample/src/main/java/com/patrykandpatrick/vico/sample/showcase/charts/Chart3.kt
+++ b/sample/src/main/java/com/patrykandpatrick/vico/sample/showcase/charts/Chart3.kt
@@ -16,7 +16,6 @@
 
 package com.patrykandpatrick.vico.sample.showcase.charts
 
-import android.graphics.Typeface
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.remember
@@ -30,8 +29,8 @@ import com.patrykandpatrick.vico.compose.cartesian.CartesianChartHost
 import com.patrykandpatrick.vico.compose.cartesian.axis.rememberBottomAxis
 import com.patrykandpatrick.vico.compose.cartesian.axis.rememberStartAxis
 import com.patrykandpatrick.vico.compose.cartesian.fullWidth
+import com.patrykandpatrick.vico.compose.cartesian.layer.rememberLine
 import com.patrykandpatrick.vico.compose.cartesian.layer.rememberLineCartesianLayer
-import com.patrykandpatrick.vico.compose.cartesian.layer.rememberLineSpec
 import com.patrykandpatrick.vico.compose.cartesian.rememberCartesianChart
 import com.patrykandpatrick.vico.compose.cartesian.rememberFadingEdges
 import com.patrykandpatrick.vico.compose.cartesian.rememberVicoZoomState
@@ -61,11 +60,11 @@ import kotlinx.coroutines.withContext
 
 @Composable
 internal fun Chart3(uiFramework: UIFramework, modifier: Modifier) {
-  val modelProducer = remember { CartesianChartModelProducer.build() }
+  val modelProducer = remember { CartesianChartModelProducer() }
   LaunchedEffect(Unit) {
     withContext(Dispatchers.Default) {
       while (isActive) {
-        modelProducer.tryRunTransaction {
+        modelProducer.runTransaction {
           /* Learn more:
           https://patrykandpatrick.com/vico/wiki/cartesian-charts/layers/line-layer#data. */
           lineSeries { series(List(Defaults.ENTRY_COUNT) { Random.nextFloat() * 20 }) }
@@ -86,7 +85,8 @@ private fun ComposeChart3(modelProducer: CartesianChartModelProducer, modifier:
     chart =
       rememberCartesianChart(
         rememberLineCartesianLayer(
-          lines = listOf(rememberLineSpec(shader = DynamicShader.color(lineColor))),
+          lineProvider =
+            LineCartesianLayer.LineProvider.series(rememberLine(DynamicShader.color(lineColor))),
           axisValueOverrider = axisValueOverrider,
         ),
         startAxis =
@@ -96,10 +96,9 @@ private fun ComposeChart3(modelProducer: CartesianChartModelProducer, modifier:
             titleComponent =
               rememberTextComponent(
                 color = Color.Black,
-                background = rememberShapeComponent(Shape.Pill, lineColor),
-                padding = Dimensions.of(horizontal = 8.dp, vertical = 2.dp),
                 margins = Dimensions.of(end = 4.dp),
-                typeface = Typeface.MONOSPACE,
+                padding = Dimensions.of(8.dp, 2.dp),
+                background = rememberShapeComponent(lineColor, Shape.Pill),
               ),
             title = stringResource(R.string.y_axis),
           ),
@@ -107,21 +106,19 @@ private fun ComposeChart3(modelProducer: CartesianChartModelProducer, modifier:
           rememberBottomAxis(
             titleComponent =
               rememberTextComponent(
-                background = rememberShapeComponent(Shape.Pill, bottomAxisLabelBackgroundColor),
                 color = Color.White,
-                padding = Dimensions.of(horizontal = 8.dp, vertical = 2.dp),
                 margins = Dimensions.of(top = 4.dp),
-                typeface = Typeface.MONOSPACE,
+                padding = Dimensions.of(8.dp, 2.dp),
+                background = rememberShapeComponent(bottomAxisLabelBackgroundColor, Shape.Pill),
               ),
             title = stringResource(R.string.x_axis),
           ),
+        marker = rememberMarker(DefaultCartesianMarker.LabelPosition.AroundPoint),
+        horizontalLayout = HorizontalLayout.fullWidth(),
         fadingEdges = rememberFadingEdges(),
       ),
     modelProducer = modelProducer,
     modifier = modifier,
-    marker = rememberMarker(DefaultCartesianMarker.LabelPosition.AroundPoint),
-    runInitialAnimation = false,
-    horizontalLayout = HorizontalLayout.fullWidth(),
     zoomState = rememberVicoZoomState(zoomEnabled = false),
   )
 }
@@ -133,9 +130,8 @@ private fun ViewChart3(modelProducer: CartesianChartModelProducer, modifier: Mod
   AndroidViewBinding(Chart3Binding::inflate, modifier) {
     with(chartView) {
       (chart?.layers?.get(0) as LineCartesianLayer?)?.axisValueOverrider = axisValueOverrider
-      runInitialAnimation = false
       this.modelProducer = modelProducer
-      this.marker = marker
+      chart?.marker = marker
     }
   }
 }
diff --git a/sample/src/main/java/com/patrykandpatrick/vico/sample/showcase/charts/Chart4.kt b/sample/src/main/java/com/patrykandpatrick/vico/sample/showcase/charts/Chart4.kt
index d6fe313c9..89f1ecf24 100644
--- a/sample/src/main/java/com/patrykandpatrick/vico/sample/showcase/charts/Chart4.kt
+++ b/sample/src/main/java/com/patrykandpatrick/vico/sample/showcase/charts/Chart4.kt
@@ -27,18 +27,18 @@ import com.patrykandpatrick.vico.compose.cartesian.CartesianChartHost
 import com.patrykandpatrick.vico.compose.cartesian.axis.rememberEndAxis
 import com.patrykandpatrick.vico.compose.cartesian.axis.rememberTopAxis
 import com.patrykandpatrick.vico.compose.cartesian.layer.rememberColumnCartesianLayer
+import com.patrykandpatrick.vico.compose.cartesian.layer.rememberLine
 import com.patrykandpatrick.vico.compose.cartesian.layer.rememberLineCartesianLayer
-import com.patrykandpatrick.vico.compose.cartesian.layer.rememberLineSpec
 import com.patrykandpatrick.vico.compose.cartesian.rememberCartesianChart
 import com.patrykandpatrick.vico.compose.cartesian.rememberVicoZoomState
 import com.patrykandpatrick.vico.compose.common.component.rememberLineComponent
 import com.patrykandpatrick.vico.compose.common.shader.color
 import com.patrykandpatrick.vico.compose.common.shape.rounded
-import com.patrykandpatrick.vico.core.cartesian.DefaultPointConnector
 import com.patrykandpatrick.vico.core.cartesian.data.CartesianChartModelProducer
 import com.patrykandpatrick.vico.core.cartesian.data.columnSeries
 import com.patrykandpatrick.vico.core.cartesian.data.lineSeries
 import com.patrykandpatrick.vico.core.cartesian.layer.ColumnCartesianLayer
+import com.patrykandpatrick.vico.core.cartesian.layer.LineCartesianLayer
 import com.patrykandpatrick.vico.core.common.shader.DynamicShader
 import com.patrykandpatrick.vico.core.common.shape.Shape
 import com.patrykandpatrick.vico.databinding.Chart4Binding
@@ -53,11 +53,11 @@ import kotlinx.coroutines.withContext
 
 @Composable
 internal fun Chart4(uiFramework: UIFramework, modifier: Modifier) {
-  val modelProducer = remember { CartesianChartModelProducer.build() }
+  val modelProducer = remember { CartesianChartModelProducer() }
   LaunchedEffect(Unit) {
     withContext(Dispatchers.Default) {
       while (isActive) {
-        modelProducer.tryRunTransaction {
+        modelProducer.runTransaction {
           /* Learn more:
           https://patrykandpatrick.com/vico/wiki/cartesian-charts/layers/column-layer#data. */
           columnSeries {
@@ -98,21 +98,19 @@ private fun ComposeChart4(modelProducer: CartesianChartModelProducer, modifier:
             )
         ),
         rememberLineCartesianLayer(
-          lines =
-            listOf(
-              rememberLineSpec(
-                shader = DynamicShader.color(lineColor),
-                pointConnector = DefaultPointConnector(cubicStrength = 0f),
-              )
+          LineCartesianLayer.LineProvider.series(
+            rememberLine(
+              shader = DynamicShader.color(lineColor),
+              pointConnector = remember { LineCartesianLayer.PointConnector.cubic(curvature = 0f) },
             )
+          )
         ),
         topAxis = rememberTopAxis(),
         endAxis = rememberEndAxis(),
+        marker = rememberMarker(),
       ),
     modelProducer = modelProducer,
     modifier = modifier,
-    marker = rememberMarker(),
-    runInitialAnimation = false,
     zoomState = rememberVicoZoomState(zoomEnabled = false),
   )
 }
@@ -122,9 +120,8 @@ private fun ViewChart4(modelProducer: CartesianChartModelProducer, modifier: Mod
   val marker = rememberMarker()
   AndroidViewBinding(Chart4Binding::inflate, modifier) {
     with(chartView) {
-      runInitialAnimation = false
       this.modelProducer = modelProducer
-      this.marker = marker
+      chart?.marker = marker
     }
   }
 }
diff --git a/sample/src/main/java/com/patrykandpatrick/vico/sample/showcase/charts/Chart5.kt b/sample/src/main/java/com/patrykandpatrick/vico/sample/showcase/charts/Chart5.kt
index b76b1253b..e7e9ea7b2 100644
--- a/sample/src/main/java/com/patrykandpatrick/vico/sample/showcase/charts/Chart5.kt
+++ b/sample/src/main/java/com/patrykandpatrick/vico/sample/showcase/charts/Chart5.kt
@@ -30,7 +30,6 @@ import com.patrykandpatrick.vico.compose.cartesian.layer.rememberColumnCartesian
 import com.patrykandpatrick.vico.compose.cartesian.rememberCartesianChart
 import com.patrykandpatrick.vico.compose.cartesian.rememberVicoZoomState
 import com.patrykandpatrick.vico.compose.common.component.rememberLineComponent
-import com.patrykandpatrick.vico.core.cartesian.axis.AxisItemPlacer
 import com.patrykandpatrick.vico.core.cartesian.axis.VerticalAxis
 import com.patrykandpatrick.vico.core.cartesian.data.CartesianChartModelProducer
 import com.patrykandpatrick.vico.core.cartesian.data.columnSeries
@@ -48,11 +47,11 @@ import kotlinx.coroutines.withContext
 
 @Composable
 internal fun Chart5(uiFramework: UIFramework, modifier: Modifier) {
-  val modelProducer = remember { CartesianChartModelProducer.build() }
+  val modelProducer = remember { CartesianChartModelProducer() }
   LaunchedEffect(Unit) {
     withContext(Dispatchers.Default) {
       while (isActive) {
-        modelProducer.tryRunTransaction {
+        modelProducer.runTransaction {
           /* Learn more:
           https://patrykandpatrick.com/vico/wiki/cartesian-charts/layers/column-layer#data. */
           columnSeries {
@@ -113,11 +112,10 @@ private fun ComposeChart5(modelProducer: CartesianChartModelProducer, modifier:
             labelRotationDegrees = AXIS_LABEL_ROTATION_DEGREES,
           ),
         bottomAxis = rememberBottomAxis(labelRotationDegrees = AXIS_LABEL_ROTATION_DEGREES),
+        marker = rememberMarker(),
       ),
     modelProducer = modelProducer,
     modifier = modifier,
-    marker = rememberMarker(),
-    runInitialAnimation = false,
     zoomState = rememberVicoZoomState(zoomEnabled = false),
   )
 }
@@ -127,10 +125,9 @@ private fun ViewChart5(modelProducer: CartesianChartModelProducer, modifier: Mod
   val marker = rememberMarker()
   AndroidViewBinding(Chart5Binding::inflate, modifier) {
     with(chartView) {
-      runInitialAnimation = false
       this.modelProducer = modelProducer
       (chart?.startAxis as VerticalAxis).itemPlacer = startAxisItemPlacer
-      this.marker = marker
+      chart?.marker = marker
     }
   }
 }
@@ -142,4 +139,4 @@ private const val AXIS_LABEL_ROTATION_DEGREES = 45f
 private val color1 = Color(0xff6438a7)
 private val color2 = Color(0xff3490de)
 private val color3 = Color(0xff73e8dc)
-private val startAxisItemPlacer = AxisItemPlacer.Vertical.count({ 3 })
+private val startAxisItemPlacer = VerticalAxis.ItemPlacer.count({ 3 })
diff --git a/sample/src/main/java/com/patrykandpatrick/vico/sample/showcase/charts/Chart6.kt b/sample/src/main/java/com/patrykandpatrick/vico/sample/showcase/charts/Chart6.kt
index 61310f128..044ec1710 100644
--- a/sample/src/main/java/com/patrykandpatrick/vico/sample/showcase/charts/Chart6.kt
+++ b/sample/src/main/java/com/patrykandpatrick/vico/sample/showcase/charts/Chart6.kt
@@ -16,7 +16,6 @@
 
 package com.patrykandpatrick.vico.sample.showcase.charts
 
-import android.graphics.Typeface
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.remember
@@ -59,11 +58,11 @@ import kotlinx.coroutines.withContext
 
 @Composable
 internal fun Chart6(uiFramework: UIFramework, modifier: Modifier) {
-  val modelProducer = remember { CartesianChartModelProducer.build() }
+  val modelProducer = remember { CartesianChartModelProducer() }
   LaunchedEffect(Unit) {
     withContext(Dispatchers.Default) {
       while (isActive) {
-        modelProducer.tryRunTransaction {
+        modelProducer.runTransaction {
           /* Learn more:
           https://patrykandpatrick.com/vico/wiki/cartesian-charts/layers/column-layer#data. */
           columnSeries {
@@ -90,7 +89,6 @@ internal fun Chart6(uiFramework: UIFramework, modifier: Modifier) {
 
 @Composable
 private fun ComposeChart6(modelProducer: CartesianChartModelProducer, modifier: Modifier) {
-  val horizontalBox = rememberComposeHorizontalBox()
   val shape = remember { Shape.cut(topLeftPercent = 50) }
   CartesianChartHost(
     chart =
@@ -102,12 +100,11 @@ private fun ComposeChart6(modelProducer: CartesianChartModelProducer, modifier:
         ),
         startAxis = rememberStartAxis(),
         bottomAxis = rememberBottomAxis(valueFormatter = bottomAxisValueFormatter),
-        decorations = remember(horizontalBox) { listOf(horizontalBox) },
+        marker = rememberMarker(),
+        decorations = listOf(rememberComposeHorizontalBox()),
       ),
     modelProducer = modelProducer,
     modifier = modifier,
-    marker = rememberMarker(),
-    runInitialAnimation = false,
     zoomState = rememberVicoZoomState(zoomEnabled = false),
   )
 }
@@ -119,12 +116,11 @@ private fun ViewChart6(modelProducer: CartesianChartModelProducer, modifier: Mod
     { inflater, parent, attachToParent ->
       Chart6Binding.inflate(inflater, parent, attachToParent).apply {
         with(chartView) {
-          chart?.addDecoration(getViewHorizontalBox())
-          runInitialAnimation = false
+          chart?.decorations = listOf(getViewHorizontalBox())
           this.modelProducer = modelProducer
           (chart?.bottomAxis as HorizontalAxis<AxisPosition.Horizontal.Bottom>).valueFormatter =
             bottomAxisValueFormatter
-          this.marker = marker
+          chart?.marker = marker
         }
       }
     },
@@ -140,14 +136,13 @@ private fun rememberComposeHorizontalBox(): HorizontalBox {
     box = rememberShapeComponent(color = color.copy(HORIZONTAL_BOX_ALPHA)),
     labelComponent =
       rememberTextComponent(
-        background = rememberShapeComponent(Shape.Rectangle, color),
+        margins = Dimensions.of(HORIZONTAL_BOX_LABEL_MARGIN_DP.dp),
         padding =
           Dimensions.of(
             HORIZONTAL_BOX_LABEL_HORIZONTAL_PADDING_DP.dp,
             HORIZONTAL_BOX_LABEL_VERTICAL_PADDING_DP.dp,
           ),
-        margins = Dimensions.of(HORIZONTAL_BOX_LABEL_MARGIN_DP.dp),
-        typeface = Typeface.MONOSPACE,
+        background = rememberShapeComponent(color, Shape.Rectangle),
       ),
   )
 }
@@ -157,26 +152,25 @@ private fun getViewHorizontalBox() =
     y = { horizontalBoxY },
     box = ShapeComponent(color = HORIZONTAL_BOX_COLOR.copyColor(HORIZONTAL_BOX_ALPHA)),
     labelComponent =
-      TextComponent.build {
-        typeface = Typeface.MONOSPACE
-        background = ShapeComponent(Shape.Rectangle, HORIZONTAL_BOX_COLOR)
+      TextComponent(
+        margins = Dimensions(HORIZONTAL_BOX_LABEL_MARGIN_DP),
         padding =
           Dimensions(
             HORIZONTAL_BOX_LABEL_HORIZONTAL_PADDING_DP,
             HORIZONTAL_BOX_LABEL_VERTICAL_PADDING_DP,
-          )
-        margins = Dimensions(HORIZONTAL_BOX_LABEL_MARGIN_DP)
-      },
+          ),
+        background = ShapeComponent(HORIZONTAL_BOX_COLOR, Shape.Rectangle),
+      ),
   )
 
 private const val HORIZONTAL_BOX_COLOR = -1448529
-private const val HORIZONTAL_BOX_ALPHA = .36f
+private const val HORIZONTAL_BOX_ALPHA = 0.36f
 private const val HORIZONTAL_BOX_LABEL_HORIZONTAL_PADDING_DP = 8f
 private const val HORIZONTAL_BOX_LABEL_VERTICAL_PADDING_DP = 2f
 private const val HORIZONTAL_BOX_LABEL_MARGIN_DP = 4f
 
 private val columnColors = listOf(Color(0xff3e6558), Color(0xff5e836a), Color(0xffa5ba8e))
-private val horizontalBoxY = 7f..14f
+private val horizontalBoxY = 7.0..14.0
 private val daysOfWeek = listOf("Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun")
 private val bottomAxisValueFormatter = CartesianValueFormatter { x, _, _ ->
   daysOfWeek[x.toInt() % daysOfWeek.size]
diff --git a/sample/src/main/java/com/patrykandpatrick/vico/sample/showcase/charts/Chart7.kt b/sample/src/main/java/com/patrykandpatrick/vico/sample/showcase/charts/Chart7.kt
index d682dd21b..84c564a8b 100644
--- a/sample/src/main/java/com/patrykandpatrick/vico/sample/showcase/charts/Chart7.kt
+++ b/sample/src/main/java/com/patrykandpatrick/vico/sample/showcase/charts/Chart7.kt
@@ -16,7 +16,6 @@
 
 package com.patrykandpatrick.vico.sample.showcase.charts
 
-import android.graphics.Typeface
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.remember
@@ -24,15 +23,14 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
 import androidx.compose.ui.viewinterop.AndroidViewBinding
 import com.patrykandpatrick.vico.R
 import com.patrykandpatrick.vico.compose.cartesian.CartesianChartHost
 import com.patrykandpatrick.vico.compose.cartesian.axis.rememberAxisLabelComponent
 import com.patrykandpatrick.vico.compose.cartesian.axis.rememberBottomAxis
 import com.patrykandpatrick.vico.compose.cartesian.axis.rememberStartAxis
+import com.patrykandpatrick.vico.compose.cartesian.layer.rememberLine
 import com.patrykandpatrick.vico.compose.cartesian.layer.rememberLineCartesianLayer
-import com.patrykandpatrick.vico.compose.cartesian.layer.rememberLineSpec
 import com.patrykandpatrick.vico.compose.cartesian.rememberCartesianChart
 import com.patrykandpatrick.vico.compose.cartesian.rememberVicoZoomState
 import com.patrykandpatrick.vico.compose.common.component.rememberShapeComponent
@@ -48,6 +46,7 @@ import com.patrykandpatrick.vico.core.cartesian.CartesianMeasureContext
 import com.patrykandpatrick.vico.core.cartesian.axis.VerticalAxis
 import com.patrykandpatrick.vico.core.cartesian.data.CartesianChartModelProducer
 import com.patrykandpatrick.vico.core.cartesian.data.lineSeries
+import com.patrykandpatrick.vico.core.cartesian.layer.LineCartesianLayer
 import com.patrykandpatrick.vico.core.common.Dimensions
 import com.patrykandpatrick.vico.core.common.shader.DynamicShader
 import com.patrykandpatrick.vico.core.common.shape.Shape
@@ -63,11 +62,11 @@ import kotlinx.coroutines.withContext
 
 @Composable
 internal fun Chart7(uiFramework: UIFramework, modifier: Modifier) {
-  val modelProducer = remember { CartesianChartModelProducer.build() }
+  val modelProducer = remember { CartesianChartModelProducer() }
   LaunchedEffect(Unit) {
     withContext(Dispatchers.Default) {
       while (isActive) {
-        modelProducer.tryRunTransaction {
+        modelProducer.runTransaction {
           /* Learn more:
           https://patrykandpatrick.com/vico/wiki/cartesian-charts/layers/line-layer#data. */
           lineSeries {
@@ -98,10 +97,11 @@ private fun ComposeChart7(modelProducer: CartesianChartModelProducer, modifier:
     chart =
       rememberCartesianChart(
         rememberLineCartesianLayer(
-          lines =
+          LineCartesianLayer.LineProvider.series(
             chartColors.map { color ->
-              rememberLineSpec(shader = DynamicShader.color(color), backgroundShader = null)
+              rememberLine(shader = DynamicShader.color(color), backgroundShader = null)
             }
+          )
         ),
         startAxis =
           rememberStartAxis(
@@ -109,12 +109,11 @@ private fun ComposeChart7(modelProducer: CartesianChartModelProducer, modifier:
             horizontalLabelPosition = VerticalAxis.HorizontalLabelPosition.Inside,
           ),
         bottomAxis = rememberBottomAxis(),
+        marker = rememberMarker(),
         legend = rememberLegend(),
       ),
     modelProducer = modelProducer,
     modifier = modifier,
-    marker = rememberMarker(),
-    runInitialAnimation = false,
     zoomState = rememberVicoZoomState(zoomEnabled = false),
   )
 }
@@ -126,12 +125,11 @@ private fun ViewChart7(modelProducer: CartesianChartModelProducer, modifier: Mod
   val legend = rememberLegend()
   AndroidViewBinding(Chart7Binding::inflate, modifier) {
     with(chartView) {
-      runInitialAnimation = false
       this.modelProducer = modelProducer
       (chart?.startAxis as VerticalAxis).horizontalLabelPosition =
         VerticalAxis.HorizontalLabelPosition.Inside
       (chart?.startAxis as VerticalAxis).label = startAxisLabel
-      this.marker = marker
+      chart?.marker = marker
       chart?.legend = legend
     }
   }
@@ -141,9 +139,9 @@ private fun ViewChart7(modelProducer: CartesianChartModelProducer, modifier: Mod
 private fun rememberStartAxisLabel() =
   rememberAxisLabelComponent(
     color = Color.Black,
-    background = rememberShapeComponent(shape = Shape.rounded(4.dp), color = Color(0xfffab94d)),
-    padding = Dimensions.of(horizontal = 8.dp, vertical = 2.dp),
-    margins = Dimensions.of(all = 4.dp),
+    margins = Dimensions.of(4.dp),
+    padding = Dimensions.of(8.dp, 2.dp),
+    background = rememberShapeComponent(Color(0xfffab94d), Shape.rounded(4.dp)),
   )
 
 @Composable
@@ -152,14 +150,9 @@ private fun rememberLegend() =
     items =
       chartColors.mapIndexed { index, chartColor ->
         rememberLegendItem(
-          icon = rememberShapeComponent(Shape.Pill, chartColor),
-          label =
-            rememberTextComponent(
-              color = vicoTheme.textColor,
-              textSize = 12.sp,
-              typeface = Typeface.MONOSPACE,
-            ),
-          labelText = stringResource(R.string.series_x, index + 1),
+          icon = rememberShapeComponent(chartColor, Shape.Pill),
+          labelComponent = rememberTextComponent(vicoTheme.textColor),
+          label = stringResource(R.string.series_x, index + 1),
         )
       },
     iconSize = 8.dp,
diff --git a/sample/src/main/java/com/patrykandpatrick/vico/sample/showcase/charts/Chart8.kt b/sample/src/main/java/com/patrykandpatrick/vico/sample/showcase/charts/Chart8.kt
index edc808c7a..b7712b5c4 100644
--- a/sample/src/main/java/com/patrykandpatrick/vico/sample/showcase/charts/Chart8.kt
+++ b/sample/src/main/java/com/patrykandpatrick/vico/sample/showcase/charts/Chart8.kt
@@ -28,8 +28,8 @@ import com.patrykandpatrick.vico.compose.cartesian.axis.rememberBottomAxis
 import com.patrykandpatrick.vico.compose.cartesian.axis.rememberEndAxis
 import com.patrykandpatrick.vico.compose.cartesian.axis.rememberStartAxis
 import com.patrykandpatrick.vico.compose.cartesian.layer.rememberColumnCartesianLayer
+import com.patrykandpatrick.vico.compose.cartesian.layer.rememberLine
 import com.patrykandpatrick.vico.compose.cartesian.layer.rememberLineCartesianLayer
-import com.patrykandpatrick.vico.compose.cartesian.layer.rememberLineSpec
 import com.patrykandpatrick.vico.compose.cartesian.rememberCartesianChart
 import com.patrykandpatrick.vico.compose.cartesian.rememberVicoZoomState
 import com.patrykandpatrick.vico.compose.common.component.rememberLineComponent
@@ -55,11 +55,11 @@ import kotlinx.coroutines.withContext
 
 @Composable
 internal fun Chart8(uiFramework: UIFramework, modifier: Modifier) {
-  val modelProducer = remember { CartesianChartModelProducer.build() }
+  val modelProducer = remember { CartesianChartModelProducer() }
   LaunchedEffect(Unit) {
     withContext(Dispatchers.Default) {
       while (isActive) {
-        modelProducer.tryRunTransaction {
+        modelProducer.runTransaction {
           /* Learn more:
           https://patrykandpatrick.com/vico/wiki/cartesian-charts/layers/column-layer#data. */
           columnSeries {
@@ -103,17 +103,17 @@ private fun ComposeChart8(modelProducer: CartesianChartModelProducer, modifier:
           verticalAxisPosition = AxisPosition.Vertical.Start,
         ),
         rememberLineCartesianLayer(
-          lines = listOf(rememberLineSpec(shader = DynamicShader.color(color4))),
+          lineProvider =
+            LineCartesianLayer.LineProvider.series(rememberLine(DynamicShader.color(color4))),
           verticalAxisPosition = AxisPosition.Vertical.End,
         ),
         startAxis = rememberStartAxis(guideline = null),
         endAxis = rememberEndAxis(guideline = null),
         bottomAxis = rememberBottomAxis(),
+        marker = rememberMarker(),
       ),
     modelProducer = modelProducer,
     modifier = modifier,
-    marker = rememberMarker(),
-    runInitialAnimation = false,
     zoomState = rememberVicoZoomState(zoomEnabled = false),
   )
 }
@@ -126,10 +126,9 @@ private fun ViewChart8(modelProducer: CartesianChartModelProducer, modifier: Mod
       (chart?.layers?.get(0) as ColumnCartesianLayer).verticalAxisPosition =
         AxisPosition.Vertical.Start
       (chart?.layers?.get(1) as LineCartesianLayer).verticalAxisPosition = AxisPosition.Vertical.End
-      runInitialAnimation = false
       this.modelProducer = modelProducer
       (chart?.startAxis as BaseAxis).guideline = null
-      this.marker = marker
+      chart?.marker = marker
     }
   }
 }
diff --git a/sample/src/main/java/com/patrykandpatrick/vico/sample/showcase/charts/Chart9.kt b/sample/src/main/java/com/patrykandpatrick/vico/sample/showcase/charts/Chart9.kt
index b38eb0d70..ac8a0869a 100644
--- a/sample/src/main/java/com/patrykandpatrick/vico/sample/showcase/charts/Chart9.kt
+++ b/sample/src/main/java/com/patrykandpatrick/vico/sample/showcase/charts/Chart9.kt
@@ -34,8 +34,8 @@ import com.patrykandpatrick.vico.compose.cartesian.axis.rememberAxisLabelCompone
 import com.patrykandpatrick.vico.compose.cartesian.axis.rememberBottomAxis
 import com.patrykandpatrick.vico.compose.cartesian.axis.rememberStartAxis
 import com.patrykandpatrick.vico.compose.cartesian.fullWidth
+import com.patrykandpatrick.vico.compose.cartesian.layer.rememberLine
 import com.patrykandpatrick.vico.compose.cartesian.layer.rememberLineCartesianLayer
-import com.patrykandpatrick.vico.compose.cartesian.layer.rememberLineSpec
 import com.patrykandpatrick.vico.compose.cartesian.rememberCartesianChart
 import com.patrykandpatrick.vico.compose.common.component.rememberLineComponent
 import com.patrykandpatrick.vico.compose.common.component.rememberShapeComponent
@@ -45,8 +45,9 @@ import com.patrykandpatrick.vico.compose.common.shader.component
 import com.patrykandpatrick.vico.compose.common.shader.verticalGradient
 import com.patrykandpatrick.vico.compose.common.shape.dashed
 import com.patrykandpatrick.vico.core.cartesian.HorizontalLayout
-import com.patrykandpatrick.vico.core.cartesian.axis.AxisItemPlacer
 import com.patrykandpatrick.vico.core.cartesian.axis.BaseAxis
+import com.patrykandpatrick.vico.core.cartesian.axis.HorizontalAxis
+import com.patrykandpatrick.vico.core.cartesian.axis.VerticalAxis
 import com.patrykandpatrick.vico.core.cartesian.data.CartesianChartModelProducer
 import com.patrykandpatrick.vico.core.cartesian.data.lineSeries
 import com.patrykandpatrick.vico.core.cartesian.layer.LineCartesianLayer
@@ -67,11 +68,11 @@ import kotlinx.coroutines.withContext
 
 @Composable
 internal fun Chart9(uiFramework: UIFramework, modifier: Modifier) {
-  val modelProducer = remember { CartesianChartModelProducer.build() }
+  val modelProducer = remember { CartesianChartModelProducer() }
   LaunchedEffect(Unit) {
     withContext(Dispatchers.Default) {
       while (isActive) {
-        modelProducer.tryRunTransaction {
+        modelProducer.runTransaction {
           /* Learn more:
           https://patrykandpatrick.com/vico/wiki/cartesian-charts/layers/line-layer#data. */
           lineSeries { series(x = x, y = x.map { Random.nextFloat() * 30 - 10 }) }
@@ -95,9 +96,9 @@ private fun ComposeChart9(modelProducer: CartesianChartModelProducer, modifier:
     chart =
       rememberCartesianChart(
         rememberLineCartesianLayer(
-          lines =
-            listOf(
-              rememberLineSpec(
+          lineProvider =
+            LineCartesianLayer.LineProvider.series(
+              rememberLine(
                 shader =
                   TopBottomShader(DynamicShader.color(colors[0]), DynamicShader.color(colors[1])),
                 backgroundShader =
@@ -107,8 +108,8 @@ private fun ComposeChart9(modelProducer: CartesianChartModelProducer, modifier:
                         componentSize = 6.dp,
                         component =
                           rememberShapeComponent(
-                            shape = Shape.Pill,
                             color = colors[0],
+                            shape = Shape.Pill,
                             margins = Dimensions.of(1.dp),
                           ),
                       ),
@@ -120,8 +121,8 @@ private fun ComposeChart9(modelProducer: CartesianChartModelProducer, modifier:
                         componentSize = 5.dp,
                         component =
                           rememberShapeComponent(
-                            shape = Shape.Rectangle,
                             color = colors[1],
+                            shape = Shape.Rectangle,
                             margins = Dimensions.of(horizontal = 2.dp),
                           ),
                         checkeredArrangement = false,
@@ -138,17 +139,17 @@ private fun ComposeChart9(modelProducer: CartesianChartModelProducer, modifier:
             label =
               rememberAxisLabelComponent(
                 color = MaterialTheme.colorScheme.onBackground,
+                margins = Dimensions.of(end = 8.dp),
+                padding = Dimensions.of(6.dp, 2.dp),
                 background =
                   rememberShapeComponent(
-                    shape = Shape.Pill,
                     color = Color.Transparent,
+                    shape = Shape.Pill,
                     strokeColor = MaterialTheme.colorScheme.outlineVariant,
-                    strokeWidth = 1.dp,
+                    strokeThickness = 1.dp,
                   ),
-                padding = Dimensions.of(horizontal = 6.dp, vertical = 2.dp),
-                margins = Dimensions.of(end = 8.dp),
               ),
-            axis = null,
+            line = null,
             tick = null,
             guideline =
               rememberLineComponent(
@@ -156,22 +157,21 @@ private fun ComposeChart9(modelProducer: CartesianChartModelProducer, modifier:
                 shape =
                   remember { Shape.dashed(shape = Shape.Pill, dashLength = 4.dp, gapLength = 8.dp) },
               ),
-            itemPlacer = remember { AxisItemPlacer.Vertical.count(count = { 4 }) },
+            itemPlacer = remember { VerticalAxis.ItemPlacer.count(count = { 4 }) },
           ),
         bottomAxis =
           rememberBottomAxis(
             guideline = null,
             itemPlacer =
               remember {
-                AxisItemPlacer.Horizontal.default(spacing = 3, addExtremeLabelPadding = true)
+                HorizontalAxis.ItemPlacer.default(spacing = 3, addExtremeLabelPadding = true)
               },
           ),
+        marker = marker,
+        horizontalLayout = HorizontalLayout.fullWidth(),
       ),
     modelProducer = modelProducer,
     modifier = modifier,
-    marker = marker,
-    runInitialAnimation = false,
-    horizontalLayout = HorizontalLayout.fullWidth(),
   )
 }
 
@@ -179,53 +179,57 @@ private fun ComposeChart9(modelProducer: CartesianChartModelProducer, modifier:
 private fun ViewChart9(modelProducer: CartesianChartModelProducer, modifier: Modifier) {
   val marker = rememberMarker()
   val colors = chartColors
-  AndroidViewBinding(Chart9Binding::inflate, modifier) {
-    with(chartView) {
-      runInitialAnimation = false
-      this.modelProducer = modelProducer
-      (chart?.bottomAxis as BaseAxis).guideline = null
-      this.marker = marker
-      with(chart?.layers?.get(0) as LineCartesianLayer) {
-        lines =
-          listOf(
-            LineCartesianLayer.LineSpec(
-              shader =
-                TopBottomShader(DynamicShader.color(colors[0]), DynamicShader.color(colors[1])),
-              backgroundShader =
-                TopBottomShader(
-                  DynamicShader.compose(
-                    DynamicShader.component(
-                      componentSize = 6.dp,
-                      component =
-                        ShapeComponent(
-                          shape = Shape.Pill,
-                          color = colors[0].toArgb(),
-                          margins = Dimensions.of(1.dp),
+  AndroidViewBinding(
+    { inflater, parent, attachToParent ->
+      Chart9Binding.inflate(inflater, parent, attachToParent).apply {
+        with(chartView) {
+          this.modelProducer = modelProducer
+          (chart?.bottomAxis as BaseAxis).guideline = null
+          chart?.marker = marker
+          with(chart?.layers?.get(0) as LineCartesianLayer) {
+            lineProvider =
+              LineCartesianLayer.LineProvider.series(
+                LineCartesianLayer.Line(
+                  shader =
+                    TopBottomShader(DynamicShader.color(colors[0]), DynamicShader.color(colors[1])),
+                  backgroundShader =
+                    TopBottomShader(
+                      DynamicShader.compose(
+                        DynamicShader.component(
+                          componentSize = 6.dp,
+                          component =
+                            ShapeComponent(
+                              color = colors[0].toArgb(),
+                              shape = Shape.Pill,
+                              margins = Dimensions.of(1.dp),
+                            ),
                         ),
-                    ),
-                    DynamicShader.verticalGradient(arrayOf(Color.Black, Color.Transparent)),
-                    PorterDuff.Mode.DST_IN,
-                  ),
-                  DynamicShader.compose(
-                    DynamicShader.component(
-                      componentSize = 5.dp,
-                      component =
-                        ShapeComponent(
-                          shape = Shape.Rectangle,
-                          color = colors[1].toArgb(),
-                          margins = Dimensions.of(horizontal = 2.dp),
+                        DynamicShader.verticalGradient(arrayOf(Color.Black, Color.Transparent)),
+                        PorterDuff.Mode.DST_IN,
+                      ),
+                      DynamicShader.compose(
+                        DynamicShader.component(
+                          componentSize = 5.dp,
+                          component =
+                            ShapeComponent(
+                              color = colors[1].toArgb(),
+                              shape = Shape.Rectangle,
+                              margins = Dimensions.of(horizontal = 2.dp),
+                            ),
+                          checkeredArrangement = false,
                         ),
-                      checkeredArrangement = false,
+                        DynamicShader.verticalGradient(arrayOf(Color.Transparent, Color.Black)),
+                        PorterDuff.Mode.DST_IN,
+                      ),
                     ),
-                    DynamicShader.verticalGradient(arrayOf(Color.Transparent, Color.Black)),
-                    PorterDuff.Mode.DST_IN,
-                  ),
-                ),
-            )
-          )
+                )
+              )
+          }
+        }
       }
-    }
-  }
+    },
+    modifier,
+  )
 }
 
 private val chartColors
diff --git a/sample/src/main/res/values/chart_10_styles.xml b/sample/src/main/res/values/chart_10_styles.xml
index 989618271..c180198cf 100644
--- a/sample/src/main/res/values/chart_10_styles.xml
+++ b/sample/src/main/res/values/chart_10_styles.xml
@@ -18,6 +18,6 @@
     <style name="Chart10BottomAxisStyle">
         <item name="addExtremeHorizontalAxisLabelPadding">true</item>
         <item name="horizontalAxisLabelSpacing">3</item>
-        <item name="showGuideline">false</item>
+        <item name="showGuidelines">false</item>
     </style>
 </resources>
diff --git a/sample/src/main/res/values/chart_1_styles.xml b/sample/src/main/res/values/chart_1_styles.xml
index 4ebbda7d7..24340f96a 100644
--- a/sample/src/main/res/values/chart_1_styles.xml
+++ b/sample/src/main/res/values/chart_1_styles.xml
@@ -22,6 +22,6 @@
     </style>
 
     <style name="Chart1LineLayerStyle">
-        <item name="line1Spec">@style/Chart1Line1Style</item>
+        <item name="line1Style">@style/Chart1Line1Style</item>
     </style>
 </resources>
diff --git a/sample/src/main/res/values/chart_2_styles.xml b/sample/src/main/res/values/chart_2_styles.xml
index 267dbddf0..750aab04e 100644
--- a/sample/src/main/res/values/chart_2_styles.xml
+++ b/sample/src/main/res/values/chart_2_styles.xml
@@ -28,6 +28,6 @@
     </style>
 
     <style name="Chart2ColumnLayerStyle">
-        <item name="column1">@style/Chart2Column1Style</item>
+        <item name="column1Style">@style/Chart2Column1Style</item>
     </style>
 </resources>
diff --git a/sample/src/main/res/values/chart_3_styles.xml b/sample/src/main/res/values/chart_3_styles.xml
index ea172ec95..45b6bc87f 100644
--- a/sample/src/main/res/values/chart_3_styles.xml
+++ b/sample/src/main/res/values/chart_3_styles.xml
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?><!--
-  ~ Copyright 2023 by Patryk Goworowski and Patrick Michalik.
+  ~ Copyright 2024 by Patryk Goworowski and Patrick Michalik.
   ~
   ~ Licensed under the Apache License, Version 2.0 (the "License");
   ~ you may not use this file except in compliance with the License.
@@ -44,7 +44,7 @@
     </style>
 
     <style name="Chart3BottomAxisTitleStyle" parent="Chart3AxisTitleStyle">
-        <item name="labelColor">@android:color/white</item>
+        <item name="android:color">@android:color/white</item>
         <item name="backgroundStyle">@style/Chart3BottomAxisTitleBackgroundStyle</item>
         <item name="marginTop">4dp</item>
     </style>
@@ -58,7 +58,7 @@
     </style>
 
     <style name="Chart3StartAxisTitleStyle" parent="Chart3AxisTitleStyle">
-        <item name="labelColor">@android:color/black</item>
+        <item name="android:color">@android:color/black</item>
         <item name="backgroundStyle">@style/Chart3StartAxisTitleBackgroundStyle</item>
         <item name="marginEnd">4dp</item>
     </style>
@@ -69,11 +69,11 @@
     </style>
 
     <style name="Chart3LineLayerStyle">
-        <item name="line1Spec">@style/Chart3Line1Style</item>
+        <item name="line1Style">@style/Chart3Line1Style</item>
     </style>
 
     <style name="Chart3StartAxisStyle" parent="Chart3AxisStyle">
-        <item name="showGuideline">false</item>
+        <item name="showGuidelines">false</item>
         <item name="verticalAxisHorizontalLabelPosition">inside</item>
         <item name="titleStyle">@style/Chart3StartAxisTitleStyle</item>
         <item name="title">@string/y_axis</item>
diff --git a/sample/src/main/res/values/chart_4_styles.xml b/sample/src/main/res/values/chart_4_styles.xml
index b6ea074b3..ced3c97a9 100644
--- a/sample/src/main/res/values/chart_4_styles.xml
+++ b/sample/src/main/res/values/chart_4_styles.xml
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?><!--
-  ~ Copyright 2023 by Patryk Goworowski and Patrick Michalik.
+  ~ Copyright 2024 by Patryk Goworowski and Patrick Michalik.
   ~
   ~ Licensed under the Apache License, Version 2.0 (the "License");
   ~ you may not use this file except in compliance with the License.
@@ -42,16 +42,16 @@
 
     <style name="Chart4Line1Style">
         <item name="color">@color/chart_4_color_4</item>
-        <item name="cubicStrength">0%</item>
+        <item name="curvature">0%</item>
     </style>
 
     <style name="Chart4ColumnLayerStyle">
-        <item name="column1">@style/Chart4Column1Style</item>
-        <item name="column2">@style/Chart4Column2Style</item>
-        <item name="column3">@style/Chart4Column3Style</item>
+        <item name="column1Style">@style/Chart4Column1Style</item>
+        <item name="column2Style">@style/Chart4Column2Style</item>
+        <item name="column3Style">@style/Chart4Column3Style</item>
     </style>
 
     <style name="Chart4LineLayerStyle">
-        <item name="line1Spec">@style/Chart4Line1Style</item>
+        <item name="line1Style">@style/Chart4Line1Style</item>
     </style>
 </resources>
diff --git a/sample/src/main/res/values/chart_5_styles.xml b/sample/src/main/res/values/chart_5_styles.xml
index 92c1e2222..e18486b11 100644
--- a/sample/src/main/res/values/chart_5_styles.xml
+++ b/sample/src/main/res/values/chart_5_styles.xml
@@ -60,9 +60,9 @@
     </style>
 
     <style name="Chart5ColumnLayerStyle">
-        <item name="column1">@style/Chart5Column1Style</item>
-        <item name="column2">@style/Chart5Column2Style</item>
-        <item name="column3">@style/Chart5Column3Style</item>
+        <item name="column1Style">@style/Chart5Column1Style</item>
+        <item name="column2Style">@style/Chart5Column2Style</item>
+        <item name="column3Style">@style/Chart5Column3Style</item>
         <item name="mergeMode">stacked</item>
     </style>
 </resources>
diff --git a/sample/src/main/res/values/chart_6_styles.xml b/sample/src/main/res/values/chart_6_styles.xml
index 2b8b2d80e..75bc5c215 100644
--- a/sample/src/main/res/values/chart_6_styles.xml
+++ b/sample/src/main/res/values/chart_6_styles.xml
@@ -41,8 +41,8 @@
     </style>
 
     <style name="Chart6ColumnLayerStyle">
-        <item name="column1">@style/Chart6Column1Style</item>
-        <item name="column2">@style/Chart6Column2Style</item>
-        <item name="column3">@style/Chart6Column3Style</item>
+        <item name="column1Style">@style/Chart6Column1Style</item>
+        <item name="column2Style">@style/Chart6Column2Style</item>
+        <item name="column3Style">@style/Chart6Column3Style</item>
     </style>
 </resources>
diff --git a/sample/src/main/res/values/chart_7_styles.xml b/sample/src/main/res/values/chart_7_styles.xml
index f6eb57ffa..ad9aff17d 100644
--- a/sample/src/main/res/values/chart_7_styles.xml
+++ b/sample/src/main/res/values/chart_7_styles.xml
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?><!--
-  ~ Copyright 2023 by Patryk Goworowski and Patrick Michalik.
+  ~ Copyright 2024 by Patryk Goworowski and Patrick Michalik.
   ~
   ~ Licensed under the Apache License, Version 2.0 (the "License");
   ~ you may not use this file except in compliance with the License.
@@ -37,8 +37,8 @@
     </style>
 
     <style name="Chart7LineLayerStyle">
-        <item name="line1Spec">@style/Chart7Line1Style</item>
-        <item name="line2Spec">@style/Chart7Line2Style</item>
-        <item name="line3Spec">@style/Chart7Line3Style</item>
+        <item name="line1Style">@style/Chart7Line1Style</item>
+        <item name="line2Style">@style/Chart7Line2Style</item>
+        <item name="line3Style">@style/Chart7Line3Style</item>
     </style>
 </resources>
diff --git a/sample/src/main/res/values/chart_8_styles.xml b/sample/src/main/res/values/chart_8_styles.xml
index 533435f30..c7c6ba67a 100644
--- a/sample/src/main/res/values/chart_8_styles.xml
+++ b/sample/src/main/res/values/chart_8_styles.xml
@@ -21,7 +21,7 @@
     <color name="chart_8_color_4">#ffc3a1</color>
 
     <style name="Chart8VerticalAxisStyle">
-        <item name="showGuideline">false</item>
+        <item name="showGuidelines">false</item>
     </style>
 
     <style name="Chart8Column1Style">
@@ -41,13 +41,13 @@
     </style>
 
     <style name="Chart8ColumnLayerStyle">
-        <item name="column1">@style/Chart8Column1Style</item>
-        <item name="column2">@style/Chart8Column2Style</item>
-        <item name="column3">@style/Chart8Column3Style</item>
+        <item name="column1Style">@style/Chart8Column1Style</item>
+        <item name="column2Style">@style/Chart8Column2Style</item>
+        <item name="column3Style">@style/Chart8Column3Style</item>
         <item name="mergeMode">stacked</item>
     </style>
 
     <style name="Chart8LineLayerStyle">
-        <item name="line1Spec">@style/Chart8Line1Style</item>
+        <item name="line1Style">@style/Chart8Line1Style</item>
     </style>
 </resources>
diff --git a/sample/src/main/res/values/chart_9_styles.xml b/sample/src/main/res/values/chart_9_styles.xml
index 19ee1a7e7..87748505c 100644
--- a/sample/src/main/res/values/chart_9_styles.xml
+++ b/sample/src/main/res/values/chart_9_styles.xml
@@ -24,21 +24,21 @@
     </style>
 
     <style name="Chart9LineLayerStyle">
-        <item name="line1Spec">@style/Chart9Line1Style</item>
+        <item name="line1Style">@style/Chart9Line1Style</item>
     </style>
 
     <style name="Chart9BottomAxisStyle">
         <item name="horizontalAxisLabelSpacing">3</item>
-        <item name="showGuideline">false</item>
+        <item name="showGuidelines">false</item>
         <item name="addExtremeHorizontalAxisLabelPadding">true</item>
     </style>
 
     <style name="Chart9StartAxisStyle">
         <item name="verticalAxisItemCount">4</item>
-        <item name="axisLabelStyle">@style/Chart9StartAxisLabelStyle</item>
-        <item name="showTick">false</item>
-        <item name="showAxisLine">false</item>
-        <item name="axisGuidelineStyle">@style/Chart9AxisGuidelineStyle</item>
+        <item name="labelStyle">@style/Chart9StartAxisLabelStyle</item>
+        <item name="showTicks">false</item>
+        <item name="showLine">false</item>
+        <item name="guidelineStyle">@style/Chart9AxisGuidelineStyle</item>
     </style>
 
     <style name="Chart9StartAxisLabelStyle">
@@ -53,7 +53,7 @@
     <style name="Chart9StartAxisLabelBackgroundStyle">
         <item name="color">@android:color/transparent</item>
         <item name="shapeStyle">@style/Chart9StartAxisLabelBackgroundShapeStyle</item>
-        <item name="strokeWidth">1dp</item>
+        <item name="strokeThickness">1dp</item>
         <item name="strokeColor">?colorOutlineVariant</item>
     </style>
 
@@ -68,7 +68,7 @@
 
     <style name="Chart9AxisGuidelineShapeStyle">
         <item name="dashLength">4dp</item>
-        <item name="dashGapLength">8dp</item>
+        <item name="gapLength">8dp</item>
     </style>
 
     <style name="Chart9ThemeOverlay" parent="Theme.Vico">
diff --git a/sample/src/test/kotlin/com/patrykandpatrick/vico/sample/PaparazziTest.kt b/sample/src/test/kotlin/com/patrykandpatrick/vico/sample/PaparazziTest.kt
index 0cef94952..aac6c18c0 100644
--- a/sample/src/test/kotlin/com/patrykandpatrick/vico/sample/PaparazziTest.kt
+++ b/sample/src/test/kotlin/com/patrykandpatrick/vico/sample/PaparazziTest.kt
@@ -56,7 +56,7 @@ public class PaparazziTest {
     Paparazzi(
       deviceConfig = lightConfig,
       renderingMode = SessionParams.RenderingMode.SHRINK,
-      maxPercentDifference = .2,
+      maxPercentDifference = 0.2,
     )
 
   private fun List<Pair<String, @Composable () -> Unit>>.snapshotAll() {
diff --git a/tangem-demo/src/main/java/com/tangem/vico/demo/chart/MarketDetailsChart.kt b/tangem-demo/src/main/java/com/tangem/vico/demo/chart/MarketDetailsChart.kt
index ca138a00a..70cd3853a 100644
--- a/tangem-demo/src/main/java/com/tangem/vico/demo/chart/MarketDetailsChart.kt
+++ b/tangem-demo/src/main/java/com/tangem/vico/demo/chart/MarketDetailsChart.kt
@@ -17,6 +17,7 @@
 package com.tangem.vico.demo.chart
 
 import android.text.Layout
+import android.util.Log
 import androidx.compose.animation.core.LinearEasing
 import androidx.compose.animation.core.animate
 import androidx.compose.animation.core.tween
@@ -40,6 +41,7 @@ import androidx.compose.ui.graphics.Brush
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.toArgb
 import androidx.compose.ui.layout.onGloballyPositioned
+import androidx.compose.ui.platform.LocalConfiguration
 import androidx.compose.ui.platform.LocalDensity
 import androidx.compose.ui.text.TextStyle
 import androidx.compose.ui.text.rememberTextMeasurer
@@ -52,16 +54,16 @@ import com.patrykandpatrick.vico.compose.cartesian.axis.rememberAxisLabelCompone
 import com.patrykandpatrick.vico.compose.cartesian.axis.rememberBottomAxis
 import com.patrykandpatrick.vico.compose.cartesian.axis.rememberCustomStartAxis
 import com.patrykandpatrick.vico.compose.cartesian.fullWidth
+import com.patrykandpatrick.vico.compose.cartesian.layer.rememberLine
 import com.patrykandpatrick.vico.compose.cartesian.layer.rememberLineCartesianLayer
-import com.patrykandpatrick.vico.compose.cartesian.layer.rememberLineSpec
-import com.patrykandpatrick.vico.compose.cartesian.layer.rememberSplitLineSpec
+import com.patrykandpatrick.vico.compose.cartesian.layer.rememberSplitLine
 import com.patrykandpatrick.vico.compose.cartesian.rememberCartesianChart
 import com.patrykandpatrick.vico.compose.cartesian.rememberVicoZoomState
 import com.patrykandpatrick.vico.compose.common.of
-import com.patrykandpatrick.vico.compose.common.shader.BrushShader
+import com.patrykandpatrick.vico.compose.common.shader.color
+import com.patrykandpatrick.vico.compose.common.shader.toDynamicShader
 import com.patrykandpatrick.vico.core.cartesian.HorizontalLayout
 import com.patrykandpatrick.vico.core.cartesian.Zoom
-import com.patrykandpatrick.vico.core.cartesian.axis.AxisItemPlacer
 import com.patrykandpatrick.vico.core.cartesian.axis.AxisPosition
 import com.patrykandpatrick.vico.core.cartesian.axis.BaseAxis
 import com.patrykandpatrick.vico.core.cartesian.axis.HorizontalAxis
@@ -73,229 +75,38 @@ import com.patrykandpatrick.vico.core.cartesian.data.lineSeries
 import com.patrykandpatrick.vico.core.cartesian.layer.LineCartesianLayer
 import com.patrykandpatrick.vico.core.common.Dimensions
 import com.patrykandpatrick.vico.core.common.component.LineComponent
-import com.patrykandpatrick.vico.core.common.shader.ColorShader
+import com.patrykandpatrick.vico.core.common.shader.DynamicShader
 import com.patrykandpatrick.vico.core.common.shader.LinearGradientShader
 import com.patrykandpatrick.vico.core.common.shape.Shape
-import java.time.LocalDateTime
-import java.time.OffsetDateTime
-import java.time.ZoneOffset
-import java.time.format.DateTimeFormatter
-import java.util.Locale
-import java.util.concurrent.TimeUnit
+import java.math.BigDecimal
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
 
+// max = 721
+const val testNumberOfPoints = 721
 
-private val y = listOf(
-  59270, 61748, 61941, 62889, 62740, 62989, 63858, 63608, 63951, 63917,
-  63253, 63765, 63862, 64502, 63876, 64028, 63875, 64531, 64249, 63680,
-  63228, 63159, 63249, 63664, 63469, 63711, 63003, 62333, 62882, 62183,
-  62231, 62244, 62200, 61188, 61683, 61199, 61036, 62116, 62436, 63065,
-  62908, 63067, 63294, 60904, 60677, 60790, 60705, 61041, 60667, 61158,
-  61112, 60795, 60900, 60771, 61124, 61343, 61371, 61484, 61133, 62372,
-  62704, 63007, 63092, 62905, 62470, 62019, 61756, 61776, 61557, 61540,
-  61904, 62151, 62419, 64663, 65955, 66229, 65991, 66176, 66517, 65838,
-  65210, 65216, 65611, 66467, 66209, 67247, 66913, 67059, 66978, 66845,
-  67240, 66874, 66993, 66940, 67185, 67330, 67340, 66845, 66062, 66273,
-  66645, 66865, 67005, 67382, 70049, 71464, 71293, 70875, 71137, 69720,
-  69323, 70139, 69964, 69716, 69855, 70442, 69774, 69125, 69404, 69714,
-  69967, 68042, 67077, 67938, 67833, 67182, 67306, 68327, 69093, 68517,
-  68726, 68759, 69061, 68880, 69148, 69305, 69044, 69313, 69122, 68821,
-  68854, 68506, 68823, 68613, 68420, 70356, 69241, 69401, 68004, 67630,
-  68311, 68311, 68291, 68302, 68717, 67926, 67690, 67314, 67285, 67567,
-  68026, 67552, 67740, 68519, 68611, 68363, 68503, 68171, 68326, 67121,
-  67626, 67481, 67657, 67567, 67608, 67607, 67683, 67729, 67733, 67709,
-)
-val timestamps: List<Long> = listOf(
-  1714752000000,
-  1714766400000,
-  1714780800000,
-  1714795200000,
-  1714809600000,
-  1714824000000,
-  1714838400000,
-  1714852800000,
-  1714867200000,
-  1714881600000,
-  1714896000000,
-  1714910400000,
-  1714924800000,
-  1714939200000,
-  1714953600000,
-  1714968000000,
-  1714982400000,
-  1714996800000,
-  1715011200000,
-  1715025600000,
-  1715040000000,
-  1715054400000,
-  1715068800000,
-  1715083200000,
-  1715097600000,
-  1715112000000,
-  1715126400000,
-  1715140800000,
-  1715155200000,
-  1715169600000,
-  1715184000000,
-  1715198400000,
-  1715212800000,
-  1715227200000,
-  1715241600000,
-  1715256000000,
-  1715270400000,
-  1715284800000,
-  1715299200000,
-  1715313600000,
-  1715328000000,
-  1715342400000,
-  1715356800000,
-  1715371200000,
-  1715385600000,
-  1715400000000,
-  1715414400000,
-  1715428800000,
-  1715443200000,
-  1715457600000,
-  1715472000000,
-  1715486400000,
-  1715500800000,
-  1715515200000,
-  1715529600000,
-  1715544000000,
-  1715558400000,
-  1715572800000,
-  1715587200000,
-  1715601600000,
-  1715616000000,
-  1715630400000,
-  1715644800000,
-  1715659200000,
-  1715673600000,
-  1715688000000,
-  1715702400000,
-  1715716800000,
-  1715731200000,
-  1715745600000,
-  1715760000000,
-  1715774400000,
-  1715788800000,
-  1715803200000,
-  1715817600000,
-  1715832000000,
-  1715846400000,
-  1715860800000,
-  1715875200000,
-  1715889600000,
-  1715904000000,
-  1715918400000,
-  1715932800000,
-  1715947200000,
-  1715961600000,
-  1715976000000,
-  1715990400000,
-  1716004800000,
-  1716019200000,
-  1716033600000,
-  1716048000000,
-  1716062400000,
-  1716076800000,
-  1716091200000,
-  1716105600000,
-  1716120000000,
-  1716134400000,
-  1716148800000,
-  1716163200000,
-  1716177600000,
-  1716192000000,
-  1716206400000,
-  1716220800000,
-  1716235200000,
-  1716249600000,
-  1716264000000,
-  1716278400000,
-  1716292800000,
-  1716307200000,
-  1716321600000,
-  1716336000000,
-  1716350400000,
-  1716364800000,
-  1716379200000,
-  1716393600000,
-  1716408000000,
-  1716422400000,
-  1716436800000,
-  1716451200000,
-  1716465600000,
-  1716480000000,
-  1716494400000,
-  1716508800000,
-  1716523200000,
-  1716537600000,
-  1716552000000,
-  1716566400000,
-  1716580800000,
-  1716595200000,
-  1716609600000,
-  1716624000000,
-  1716638400000,
-  1716652800000,
-  1716667200000,
-  1716681600000,
-  1716696000000,
-  1716710400000,
-  1716724800000,
-  1716739200000,
-  1716753600000,
-  1716768000000,
-  1716782400000,
-  1716796800000,
-  1716811200000,
-  1716825600000,
-  1716840000000,
-  1716854400000,
-  1716868800000,
-  1716883200000,
-  1716897600000,
-  1716912000000,
-  1716926400000,
-  1716940800000,
-  1716955200000,
-  1716969600000,
-  1716984000000,
-  1716998400000,
-  1717012800000,
-  1717027200000,
-  1717041600000,
-  1717056000000,
-  1717070400000,
-  1717084800000,
-  1717099200000,
-  1717113600000,
-  1717128000000,
-  1717142400000,
-  1717156800000,
-  1717171200000,
-  1717185600000,
-  1717200000000,
-  1717214400000,
-  1717228800000,
-  1717243200000,
-  1717257600000,
-  1717272000000,
-  1717286400000,
-  1717300800000,
-  1717315200000,
-  1717329600000,
-)
-
-private val x = List(y.size) { index -> index }
+val sortedData = marketChartData.sortedBy { it.first.toLong() }
+
+val timestamps = sortedData.takeLast(testNumberOfPoints).map { it.first.toLong() }
+
+val sorted = timestamps.sorted().also {
+  Log.i( "ASDASD","""
+    sorted: $it
+    unsirt: $timestamps
+  """.trimIndent())
+}
+val minTimestamp = timestamps.min()
+val timestampsReady = timestamps.map { (it - minTimestamp) / 60000 }.takeLast(testNumberOfPoints)
+
+val y = sortedData.take(testNumberOfPoints).map { BigDecimal(it.second).toDouble() }
+private val x = timestampsReady.map { it.toDouble() }
 
 private val redColor = Color(0xFFFF3333)
 private val blueColor = Color(0xFF0099FF)
 
 @Composable
-fun MarketDetailsChart(modifier: Modifier = Modifier) {
+fun MarketDetailsChart() {
+  sorted
   val initDrawAnimationStart = remember { mutableStateOf(true) }
   var markerFraction: Float? by remember {
     mutableStateOf(null)
@@ -310,19 +121,46 @@ fun MarketDetailsChart(modifier: Modifier = Modifier) {
     markerFraction = markerFraction,
   )
 
+  var valueText by remember {
+    mutableStateOf("")
+  }
+  var dateText by remember {
+    mutableStateOf("")
+  }
+  var maxCanvasX by remember {
+    mutableIntStateOf(0)
+  }
+
   val chart = rememberCartesianChart(
     layer,
     startAxis = rememberMyStartAxis(),
     bottomAxis = rememberMyBottomAxis(),
+    horizontalLayout = HorizontalLayout.fullWidth(),
+    markerVisibilityListener = rememberMarkerVisibilityListener { y, x, xCanvas ->
+      valueText = y?.toString() ?: ""
+      dateText = x?.toString() ?: ""
+
+      markerFraction = if (xCanvas == null || xCanvas == 0f) {
+        null
+      } else {
+        val max = maxCanvasX.toFloat()
+        if (max == 0f) {
+          null
+        } else {
+          xCanvas / maxCanvasX.toFloat()
+        }
+      }
+    },
+    marker = rememberTangemChartMarker(color = lineColor),
   )
 
   val modelProducer = remember {
-    CartesianChartModelProducer.build()
+    CartesianChartModelProducer()
   }
 
   LaunchedEffect(Unit) {
     withContext(Dispatchers.Default) {
-      modelProducer.tryRunTransaction {
+      modelProducer.runTransaction {
         lineSeries {
           series(x, y)
         }
@@ -330,17 +168,17 @@ fun MarketDetailsChart(modifier: Modifier = Modifier) {
     }
   }
 
-  var valueText by remember {
-    mutableStateOf("")
-  }
-  var dateText by remember {
-    mutableStateOf("")
-  }
-  var maxCanvasX by remember {
-    mutableIntStateOf(0)
-  }
+  val width = LocalConfiguration.current.screenWidthDp
+  val height = LocalConfiguration.current.screenHeightDp
+  val density = LocalDensity.current
+
+  val widthPixels = with(density) { width.dp.toPx() }
+  val heightPixels = with(density) { height.dp.toPx() }
 
   Column {
+    Text("width: $width, height: $height")
+    Text("widthPixels: $widthPixels, heightPixels: $heightPixels")
+    Text("density: ${density.density}")
     Text(text = "Value: $valueText")
     Text(text = "Date: $dateText")
 
@@ -353,28 +191,9 @@ fun MarketDetailsChart(modifier: Modifier = Modifier) {
       chart = chart,
       modelProducer = modelProducer,
       zoomState = rememberVicoZoomState(initialZoom = Zoom.Content, zoomEnabled = false),
-      horizontalLayout = HorizontalLayout.fullWidth(),
-      diffAnimationSpec = null,
-      markerVisibilityListener = rememberMarkerVisibilityListener { y, x, xCanvas ->
-        valueText = y?.toString() ?: ""
-        dateText = x?.let {
-          timestamps[it.toInt()].toLocalDateTime()
-            .format(DateTimeFormatter.ofPattern("dd.MM", Locale.getDefault()))
-        } ?: ""
-
-        markerFraction = if (xCanvas == null || xCanvas == 0f) {
-          null
-        } else {
-          val max = maxCanvasX.toFloat()
-          if (max == 0f) {
-            null
-          } else {
-            xCanvas / maxCanvasX.toFloat()
-          }
-        }
-      },
-      marker = rememberTangemChartMarker(color = lineColor),
-    )
+      animationSpec = null,
+
+      )
 
     Spacer(modifier = Modifier.height(16.dp))
     Button(onClick = { initDrawAnimationStart.value = true }) {
@@ -395,9 +214,9 @@ fun MarketDetailsChart(modifier: Modifier = Modifier) {
 }
 
 @Composable
-fun rememberMyStartAxis(modifier: Modifier = Modifier): VerticalAxis<AxisPosition.Vertical.Start> {
+fun rememberMyStartAxis(): VerticalAxis<AxisPosition.Vertical.Start> {
   return rememberCustomStartAxis(
-    axis = null,
+    line = null,
     tick = null,
     guideline = rememberMyAxisGuidelineComponent(),
     label = rememberAxisLabelComponent(
@@ -410,13 +229,13 @@ fun rememberMyStartAxis(modifier: Modifier = Modifier): VerticalAxis<AxisPositio
     ),
     horizontalLabelPosition = VerticalAxis.HorizontalLabelPosition.Inside,
     verticalLabelPosition = VerticalAxis.VerticalLabelPosition.Center,
-    itemPlacer = remember { AxisItemPlacer.Vertical.count({ 3 }, false) },
+    itemPlacer = remember { VerticalAxis.ItemPlacer.count({ 3 }, false) },
     valueFormatter = remember { CartesianValueFormatter.decimal() },
   )
 }
 
 @Composable
-fun rememberMyBottomAxis(modifier: Modifier = Modifier): HorizontalAxis<AxisPosition.Horizontal.Bottom> {
+fun rememberMyBottomAxis(): HorizontalAxis<AxisPosition.Horizontal.Bottom> {
   return rememberBottomAxis(
     label = rememberAxisLabelComponent(
       color = Color(0xFF909090),
@@ -424,21 +243,20 @@ fun rememberMyBottomAxis(modifier: Modifier = Modifier): HorizontalAxis<AxisPosi
         top = 24.dp,
       ),
     ),
+    line = null,
     tick = null,
-    axis = null,
     guideline = null,
     sizeConstraint = BaseAxis.SizeConstraint.Auto(24.dp.value, 48.dp.value),
     itemPlacer = remember {
-      AxisItemPlacer.Horizontal.default(
+      HorizontalAxis.ItemPlacer.default(
         spacing = 20,
         offset = 60,
         shiftExtremeTicks = false,
         addExtremeLabelPadding = false,
       )
     },
-    valueFormatter = CartesianValueFormatter { value, chartValues, verticalAxisPosition ->
-      timestamps[value.toInt()].toLocalDateTime()
-        .format(DateTimeFormatter.ofPattern("dd.MM", Locale.getDefault()))
+    valueFormatter = { value, chartValues, verticalAxisPosition ->
+      value.toString()
     },
   )
 }
@@ -539,47 +357,34 @@ fun buildLayer(
 
   if (alineColorRight == null || backColorRight == null) {
     return rememberLineCartesianLayer(
-      listOf(
-        rememberLineSpec(
-          shader = ColorShader(
-            color = alineColor,
-          ),
-          thickness = 0.5.dp,
-          backgroundShader = BrushShader(
-            brush = Brush.verticalGradient(backColor),
+      LineCartesianLayer.LineProvider.series(
+        listOf(
+          rememberLine(
+            shader = DynamicShader.color(lineColor),
+            thickness = 0.5.dp,
+            backgroundShader = Brush.verticalGradient(backColor).toDynamicShader(),
           ),
         ),
       ),
-
-      )
+    )
   }
 
   return rememberLineCartesianLayer(
-    listOf(
-      rememberSplitLineSpec(
-        shader = LinearGradientShader(
-          colors = intArrayOf(alineColor, alineColorRight),
-          positions = floatArrayOf(fractionValue, fractionValue),
-          isHorizontal = true,
-        ),
-        backgroundShaderFirst = BrushShader(
-          brush = Brush.verticalGradient(backColor),
-        ),
-        backgroundShaderSecond = BrushShader(
-          brush = Brush.verticalGradient(backColorRight),
-        ),
+    lineProvider = LineCartesianLayer.LineProvider.series(
+      rememberSplitLine(
+        shader = remember(alineColor, alineColorRight, fractionValue) {
+          LinearGradientShader(
+            colors = intArrayOf(alineColor, alineColorRight),
+            positions = floatArrayOf(fractionValue, fractionValue),
+            isHorizontal = true,
+          )
+        },
+        backgroundShaderFirst = Brush.verticalGradient(backColor).toDynamicShader(),
+        backgroundShaderSecond = Brush.verticalGradient(backColorRight).toDynamicShader(),
         xSplitFraction = fractionValue,
       ),
     ),
-    axisValueOverrider = remember { AxisValueOverrider.fixed(minY = y.min().toFloat()) },
+    axisValueOverrider = remember { AxisValueOverrider.fixed(minY = y.min()) },
   )
 
 }
-
-
-fun Long.toLocalDateTime(isMillis: Boolean = true): LocalDateTime {
-  val zoneOffset = OffsetDateTime.now(ZoneOffset.systemDefault()).offset
-  val epochSeconds = if (isMillis) TimeUnit.MILLISECONDS.toSeconds(this) else this
-  return LocalDateTime.ofEpochSecond(epochSeconds, 0, zoneOffset)
-}
-
diff --git a/tangem-demo/src/main/java/com/tangem/vico/demo/chart/MarketDetailsChartData.kt b/tangem-demo/src/main/java/com/tangem/vico/demo/chart/MarketDetailsChartData.kt
new file mode 100644
index 000000000..82c960910
--- /dev/null
+++ b/tangem-demo/src/main/java/com/tangem/vico/demo/chart/MarketDetailsChartData.kt
@@ -0,0 +1,741 @@
+/*
+ * Copyright 2024 by Patryk Goworowski and Patrick Michalik.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.tangem.vico.demo.chart
+
+val marketChartData = listOf(
+  "1721210400000" to "0.1073006868952211",
+  "1721214000000" to "0.1077518467566104",
+  "1721217600000" to "0.1058061682874172",
+  "1721221200000" to "0.1049554245157478",
+  "1721224800000" to "0.1041657584058599",
+  "1721228400000" to "0.1027804073126634",
+  "1721232000000" to "0.0982639194587489",
+  "1721235600000" to "0.0945004463291826",
+  "1721239200000" to "0.0951046727575278",
+  "1721242800000" to "0.0967473195358595",
+  "1721246400000" to "0.0975047532340124",
+  "1721250000000" to "0.0989006909953572",
+  "1721253600000" to "0.1000406923722057",
+  "1721257200000" to "0.0978169798878708",
+  "1721260800000" to "0.0979433811194233",
+  "1721264400000" to "0.0992655695947791",
+  "1721268000000" to "0.0997766686906925",
+  "1721271600000" to "0.1000421029397076",
+  "1721275200000" to "0.1023586486221508",
+  "1721278800000" to "0.1023687658426529",
+  "1721282400000" to "0.103080321621239",
+  "1721286000000" to "0.1031180712835949",
+  "1721289600000" to "0.1042782907354827",
+  "1721293200000" to "0.1046562716771199",
+  "1721296800000" to "0.1062441326344913",
+  "1721300400000" to "0.1082604411481134",
+  "1721304000000" to "0.1127524345768063",
+  "1721307600000" to "0.1145571296049421",
+  "1721311200000" to "0.1120562185818159",
+  "1721314800000" to "0.1107430968702602",
+  "1721318400000" to "0.1091692019386162",
+  "1721322000000" to "0.1089411117216541",
+  "1721325600000" to "0.1087596009164306",
+  "1721329200000" to "0.1104983146100888",
+  "1721332800000" to "0.1114290169065746",
+  "1721336400000" to "0.1117225117239963",
+  "1721340000000" to "0.1130792334304704",
+  "1721343600000" to "0.1134119309087087",
+  "1721347200000" to "0.1130321591196014",
+  "1721350800000" to "0.1134730292912666",
+  "1721354400000" to "0.1138222482210114",
+  "1721358000000" to "0.1114462677274378",
+  "1721361600000" to "0.112921314590527",
+  "1721365200000" to "0.1129589668860931",
+  "1721368800000" to "0.1127573624203471",
+  "1721372400000" to "0.1153231086088586",
+  "1721376000000" to "0.1160070429696814",
+  "1721379600000" to "0.1170619164282327",
+  "1721383200000" to "0.1140286973975941",
+  "1721386800000" to "0.1138947639701077",
+  "1721390400000" to "0.1196191612091126",
+  "1721394000000" to "0.1184154522060711",
+  "1721397600000" to "0.1200064579465377",
+  "1721401200000" to "0.1207306618422302",
+  "1721404800000" to "0.1103102106039449",
+  "1721408400000" to "0.1117795016068173",
+  "1721412000000" to "0.1122307368926956",
+  "1721415600000" to "0.1137335982855491",
+  "1721419200000" to "0.1170340794180944",
+  "1721422800000" to "0.1183061436358901",
+  "1721426400000" to "0.1227474629251855",
+  "1721430000000" to "0.1211902255696592",
+  "1721433600000" to "0.1164132898767529",
+  "1721437200000" to "0.1173935731130694",
+  "1721440800000" to "0.1165004507955148",
+  "1721444400000" to "0.1169615012174304",
+  "1721448000000" to "0.1170352412958317",
+  "1721451600000" to "0.1180028135289996",
+  "1721455200000" to "0.1196576617105931",
+  "1721458800000" to "0.1196735113690029",
+  "1721462400000" to "0.1194769605860684",
+  "1721466000000" to "0.1205113018636619",
+  "1721469600000" to "0.1209999520091272",
+  "1721473200000" to "0.1165830367404864",
+  "1721476800000" to "0.1172200760167156",
+  "1721480400000" to "0.1178598404107523",
+  "1721484000000" to "0.1187315106964125",
+  "1721487600000" to "0.1196500505123833",
+  "1721491200000" to "0.120569186132149",
+  "1721494800000" to "0.1222179017482095",
+  "1721498400000" to "0.1181691463605056",
+  "1721502000000" to "0.1174597808741964",
+  "1721505600000" to "0.1141468783155063",
+  "1721509200000" to "0.1088607483912725",
+  "1721512800000" to "0.1098842672025917",
+  "1721516400000" to "0.109752510633533",
+  "1721520000000" to "0.1078520749795046",
+  "1721523600000" to "0.1065994511791164",
+  "1721527200000" to "0.1070737646207372",
+  "1721530800000" to "0.1077168130464067",
+  "1721534400000" to "0.1076049386600696",
+  "1721538000000" to "0.1074309955588466",
+  "1721541600000" to "0.1065876233669294",
+  "1721545200000" to "0.1063242780890781",
+  "1721548800000" to "0.1061713306550824",
+  "1721552400000" to "0.1055402864939761",
+  "1721556000000" to "0.105858167650336",
+  "1721559600000" to "0.1056523523750098",
+  "1721563200000" to "0.1055952228633626",
+  "1721566800000" to "0.1060869539512283",
+  "1721570400000" to "0.1055817419830774",
+  "1721574000000" to "0.1064036510465871",
+  "1721577600000" to "0.1088358498776394",
+  "1721581200000" to "0.1095121361912198",
+  "1721584800000" to "0.1085560382799883",
+  "1721588400000" to "0.1066756583222206",
+  "1721592000000" to "0.1070951156808537",
+  "1721595600000" to "0.1103425661665701",
+  "1721599200000" to "0.1102241185256905",
+  "1721602800000" to "0.1106730161112528",
+  "1721606400000" to "0.1111694505434174",
+  "1721610000000" to "0.1131445248924635",
+  "1721613600000" to "0.1143334638471881",
+  "1721617200000" to "0.1167964673031806",
+  "1721620800000" to "0.1185743596554386",
+  "1721624400000" to "0.1199410733578664",
+  "1721628000000" to "0.1224766478704964",
+  "1721631600000" to "0.1254528326713723",
+  "1721635200000" to "0.1236816066497327",
+  "1721638800000" to "0.1243152867337687",
+  "1721642400000" to "0.1257059550003153",
+  "1721646000000" to "0.1255985378941653",
+  "1721649600000" to "0.1263318969924381",
+  "1721653200000" to "0.1279420215828864",
+  "1721656800000" to "0.1290903628095817",
+  "1721660400000" to "0.1288371031701729",
+  "1721664000000" to "0.1311565762080963",
+  "1721667600000" to "0.1325391154532479",
+  "1721671200000" to "0.1335949570421654",
+  "1721674800000" to "0.1349534078309122",
+  "1721678400000" to "0.137288258612702",
+  "1721682000000" to "0.135617420590801",
+  "1721685600000" to "0.1343419286804461",
+  "1721689200000" to "0.1327159077364371",
+  "1721692800000" to "0.132231043706288",
+  "1721696400000" to "0.1326412207520786",
+  "1721700000000" to "0.1285251601348659",
+  "1721703600000" to "0.1182073124259745",
+  "1721707200000" to "0.1181921404502702",
+  "1721710800000" to "0.117461306000874",
+  "1721714400000" to "0.1156032233440406",
+  "1721718000000" to "0.1160169189416493",
+  "1721721600000" to "0.1158309017441349",
+  "1721725200000" to "0.1163599578036059",
+  "1721728800000" to "0.1162386973247179",
+  "1721732400000" to "0.118652279924097",
+  "1721736000000" to "0.1182368634737302",
+  "1721739600000" to "0.1191675021383448",
+  "1721743200000" to "0.1210449329109018",
+  "1721746800000" to "0.1249524449474399",
+  "1721750400000" to "0.1252453432311735",
+  "1721754000000" to "0.1238587214740337",
+  "1721757600000" to "0.1212637652450481",
+  "1721761200000" to "0.1227009216394058",
+  "1721764800000" to "0.1263294020037665",
+  "1721768400000" to "0.129370447221243",
+  "1721772000000" to "0.1296793095634296",
+  "1721775600000" to "0.1281714669250324",
+  "1721779200000" to "0.1275365019884357",
+  "1721782800000" to "0.1275921614584093",
+  "1721786400000" to "0.1268910808914661",
+  "1721790000000" to "0.1282135809345848",
+  "1721793600000" to "0.1289351703971556",
+  "1721797200000" to "0.128722674400291",
+  "1721800800000" to "0.129029145349904",
+  "1721804400000" to "0.1299155462042381",
+  "1721808000000" to "0.1311220890246343",
+  "1721811600000" to "0.1341781769002868",
+  "1719223200000" to "0.075396022386633",
+  "1719226800000" to "0.073616675493841",
+  "1719230400000" to "0.0734639673174368",
+  "1719234000000" to "0.0734488436988615",
+  "1719237600000" to "0.0736140272716853",
+  "1719241200000" to "0.0736519710365324",
+  "1719244800000" to "0.0726503060654912",
+  "1719248400000" to "0.0723198005904423",
+  "1719252000000" to "0.0730584893035345",
+  "1719255600000" to "0.0730616669594907",
+  "1719259200000" to "0.0726062645759073",
+  "1719262800000" to "0.0728441978039283",
+  "1719266400000" to "0.0740339492029415",
+  "1719270000000" to "0.0730020197278761",
+  "1719273600000" to "0.0731816557483786",
+  "1719277200000" to "0.0745054273613107",
+  "1719280800000" to "0.0746188999536736",
+  "1719284400000" to "0.0746320323045649",
+  "1719288000000" to "0.0747300044861077",
+  "1719291600000" to "0.0751878178919565",
+  "1719295200000" to "0.0754457979795949",
+  "1719298800000" to "0.0753524434943368",
+  "1719302400000" to "0.0752154210011971",
+  "1719306000000" to "0.0739299628772882",
+  "1719309600000" to "0.0753932397586832",
+  "1719313200000" to "0.0762246358809136",
+  "1719316800000" to "0.0766586168916549",
+  "1719320400000" to "0.0766017683983168",
+  "1719324000000" to "0.0766214819819811",
+  "1719327600000" to "0.0768661131557542",
+  "1719331200000" to "0.077241146966663",
+  "1719334800000" to "0.0772378260854304",
+  "1719338400000" to "0.0772748709920518",
+  "1719342000000" to "0.0773868892468588",
+  "1719345600000" to "0.0774521685753886",
+  "1719349200000" to "0.0803494485934452",
+  "1719352800000" to "0.0825413174641826",
+  "1719356400000" to "0.0835449306738668",
+  "1719360000000" to "0.0840538374464299",
+  "1719363600000" to "0.0843734198522305",
+  "1719367200000" to "0.0856028337370556",
+  "1719370800000" to "0.0863591150129817",
+  "1719374400000" to "0.0868900579377188",
+  "1719378000000" to "0.0864383067639867",
+  "1719381600000" to "0.086121353182999",
+  "1719385200000" to "0.0863325490197747",
+  "1719388800000" to "0.0870736912935326",
+  "1719392400000" to "0.0876712587421402",
+  "1719396000000" to "0.0877993855581927",
+  "1719399600000" to "0.088442618784455",
+  "1719403200000" to "0.0883639755194398",
+  "1719406800000" to "0.0885683804450142",
+  "1719410400000" to "0.0885688866423012",
+  "1719414000000" to "0.0882225909123112",
+  "1719417600000" to "0.0860049024979151",
+  "1719421200000" to "0.0833374719568199",
+  "1719424800000" to "0.0837359711052827",
+  "1719428400000" to "0.0837061767117801",
+  "1719432000000" to "0.0842153952485243",
+  "1719435600000" to "0.0836658331075542",
+  "1719439200000" to "0.0749663276470185",
+  "1719442800000" to "0.0748162059366489",
+  "1719446400000" to "0.0739342451180469",
+  "1719450000000" to "0.0750489087685236",
+  "1719453600000" to "0.0745836025002599",
+  "1719457200000" to "0.0731859248704452",
+  "1719460800000" to "0.073384367033257",
+  "1719464400000" to "0.0743977308273773",
+  "1719468000000" to "0.072972607778596",
+  "1719471600000" to "0.0733724451937015",
+  "1719475200000" to "0.0744122380868662",
+  "1719478800000" to "0.075355655492519",
+  "1719482400000" to "0.0760659651505642",
+  "1719486000000" to "0.0772596786699317",
+  "1719489600000" to "0.0791738374606753",
+  "1719493200000" to "0.0823017685687113",
+  "1719496800000" to "0.0861218342343417",
+  "1719500400000" to "0.0906867798793782",
+  "1719504000000" to "0.091178088982052",
+  "1719507600000" to "0.0913140980405103",
+  "1719511200000" to "0.0913749039946409",
+  "1719514800000" to "0.1193448789454297",
+  "1719518400000" to "0.1115772167717985",
+  "1719522000000" to "0.1616622105568043",
+  "1719525600000" to "0.2027918509353612",
+  "1719529200000" to "0.1678440439773926",
+  "1719532800000" to "0.1707846521162012",
+  "1719536400000" to "0.1858305325503587",
+  "1719540000000" to "0.1762158804452494",
+  "1719543600000" to "0.1651104653357302",
+  "1719547200000" to "0.1602401075791925",
+  "1719550800000" to "0.1638873574082294",
+  "1719554400000" to "0.1607055393000538",
+  "1719558000000" to "0.1684532259359949",
+  "1719561600000" to "0.1613613137368059",
+  "1719565200000" to "0.159515297865025",
+  "1719568800000" to "0.1594639897301979",
+  "1719572400000" to "0.1564711065893221",
+  "1719576000000" to "0.1598311483948024",
+  "1719579600000" to "0.1579955429791659",
+  "1719583200000" to "0.156714814204062",
+  "1719586800000" to "0.1522234149354035",
+  "1719590400000" to "0.153503570919151",
+  "1719594000000" to "0.1463562285111227",
+  "1719597600000" to "0.1491476863545356",
+  "1719601200000" to "0.1725810813620225",
+  "1719604800000" to "0.1777277870303941",
+  "1719608400000" to "0.1636568858619279",
+  "1719612000000" to "0.1612024044770052",
+  "1719615600000" to "0.1524486318768792",
+  "1719619200000" to "0.1511562324645756",
+  "1719622800000" to "0.1476333974060936",
+  "1719626400000" to "0.1401588675319003",
+  "1719630000000" to "0.1467581371870782",
+  "1719633600000" to "0.1356752179105659",
+  "1719637200000" to "0.1396533367526187",
+  "1719640800000" to "0.1370863808473272",
+  "1719644400000" to "0.1341468376615987",
+  "1719648000000" to "0.1325352889098346",
+  "1719651600000" to "0.1349059068213451",
+  "1719655200000" to "0.1360103383382925",
+  "1719658800000" to "0.1407022070499364",
+  "1719662400000" to "0.1413516850970345",
+  "1719666000000" to "0.1422133639690898",
+  "1719669600000" to "0.1375020498315628",
+  "1719673200000" to "0.1398163694492644",
+  "1719676800000" to "0.1389727680956235",
+  "1719680400000" to "0.1382347212416909",
+  "1719684000000" to "0.1384351801902013",
+  "1719687600000" to "0.1401543422681511",
+  "1719691200000" to "0.1449832842066158",
+  "1719694800000" to "0.142428797689008",
+  "1719698400000" to "0.1492960365423486",
+  "1719702000000" to "0.1483160192090345",
+  "1719705600000" to "0.1435908062526961",
+  "1719709200000" to "0.1417738539646887",
+  "1719712800000" to "0.1405380472475064",
+  "1719716400000" to "0.139474431767248",
+  "1719720000000" to "0.1397472414260982",
+  "1719723600000" to "0.1354672037995274",
+  "1719727200000" to "0.1334746578745252",
+  "1719730800000" to "0.1326239106813557",
+  "1719734400000" to "0.1341123483244038",
+  "1719738000000" to "0.1355590472088316",
+  "1719741600000" to "0.1294236784277194",
+  "1719745200000" to "0.127045522104186",
+  "1719748800000" to "0.1282874729643022",
+  "1719752400000" to "0.1293942649325936",
+  "1719756000000" to "0.1257395628195785",
+  "1719759600000" to "0.1320561618916618",
+  "1719763200000" to "0.1225196901829905",
+  "1719766800000" to "0.1191105143498338",
+  "1719770400000" to "0.121653101384419",
+  "1719774000000" to "0.1197815329557299",
+  "1719777600000" to "0.1213581199076015",
+  "1719781200000" to "0.1199999983484012",
+  "1719784800000" to "0.1237109930209407",
+  "1719788400000" to "0.1241241446644942",
+  "1719792000000" to "0.1262077244861382",
+  "1719795600000" to "0.1289126845940429",
+  "1719799200000" to "0.1310418111805968",
+  "1719802800000" to "0.1315046141252493",
+  "1719806400000" to "0.1314993966662703",
+  "1719810000000" to "0.1252999665674409",
+  "1719813600000" to "0.1202305731639638",
+  "1719817200000" to "0.1215751824259917",
+  "1719820800000" to "0.1227441707574794",
+  "1719824400000" to "0.1183551438010199",
+  "1719828000000" to "0.1158707111510269",
+  "1719831600000" to "0.1160585536316657",
+  "1719835200000" to "0.1161642687902146",
+  "1719838800000" to "0.1165649990979795",
+  "1719842400000" to "0.1168844857593736",
+  "1719846000000" to "0.1193471028823538",
+  "1719849600000" to "0.1201041154813538",
+  "1719853200000" to "0.1215803550478849",
+  "1719856800000" to "0.1233106517947013",
+  "1719860400000" to "0.1257393674964068",
+  "1719864000000" to "0.1259751607474229",
+  "1719867600000" to "0.1278421867101415",
+  "1719871200000" to "0.1284031570041418",
+  "1719874800000" to "0.1277233468066074",
+  "1719878400000" to "0.1300891968740698",
+  "1719882000000" to "0.1277819026114757",
+  "1719885600000" to "0.1275679388666504",
+  "1719889200000" to "0.1270926087395692",
+  "1719892800000" to "0.1277752818236367",
+  "1719896400000" to "0.1278138641709004",
+  "1719900000000" to "0.1273341278289951",
+  "1719903600000" to "0.1397503002706546",
+  "1719907200000" to "0.1344960120433552",
+  "1719910800000" to "0.1345118301486837",
+  "1719914400000" to "0.13452156405441",
+  "1719918000000" to "0.1343130789424529",
+  "1719921600000" to "0.1306919142104885",
+  "1719925200000" to "0.133211214683805",
+  "1719928800000" to "0.1295764580554889",
+  "1719932400000" to "0.1266385876159318",
+  "1719936000000" to "0.125707144072493",
+  "1719939600000" to "0.1270667567294178",
+  "1719943200000" to "0.1269633179991374",
+  "1719946800000" to "0.111957822549949",
+  "1719950400000" to "0.1140957394167005",
+  "1719954000000" to "0.1146749093023569",
+  "1719957600000" to "0.111511154780767",
+  "1719961200000" to "0.110797689005687",
+  "1719964800000" to "0.1123436316675962",
+  "1719968400000" to "0.1098261782655962",
+  "1719972000000" to "0.1077621450827321",
+  "1719975600000" to "0.1070301636851413",
+  "1719979200000" to "0.1063397932708642",
+  "1719982800000" to "0.1055641261848474",
+  "1719986400000" to "0.1047859366285088",
+  "1719990000000" to "0.1038073063883657",
+  "1719993600000" to "0.1021845842285198",
+  "1719997200000" to "0.1014132873721952",
+  "1720000800000" to "0.1003016984280211",
+  "1720004400000" to "0.0979307444571283",
+  "1720008000000" to "0.0926995662574577",
+  "1720011600000" to "0.0843910052707822",
+  "1720015200000" to "0.0918432432772597",
+  "1720018800000" to "0.091759886320687",
+  "1720022400000" to "0.0918112296809117",
+  "1720026000000" to "0.0916521957731441",
+  "1720029600000" to "0.0935912980073654",
+  "1720033200000" to "0.0945291561073651",
+  "1720036800000" to "0.0939867630934406",
+  "1720040400000" to "0.0934531617772999",
+  "1720044000000" to "0.0932641898138646",
+  "1720047600000" to "0.0929574478532191",
+  "1720051200000" to "0.0924695048836957",
+  "1720054800000" to "0.0918384701932778",
+  "1720058400000" to "0.0885060544808916",
+  "1720062000000" to "0.0883194618007504",
+  "1720065600000" to "0.0873284339773392",
+  "1720069200000" to "0.0878931960115",
+  "1720072800000" to "0.0874834061458057",
+  "1720076400000" to "0.0863634058943024",
+  "1720080000000" to "0.0852729671638765",
+  "1720083600000" to "0.0849308788613284",
+  "1720087200000" to "0.0863154448105409",
+  "1720090800000" to "0.0857034122185345",
+  "1720094400000" to "0.0860452827650328",
+  "1720098000000" to "0.0860753402584873",
+  "1720101600000" to "0.085666289600457",
+  "1720105200000" to "0.0815121481082136",
+  "1720108800000" to "0.0811646060933371",
+  "1720112400000" to "0.0810055057411927",
+  "1720116000000" to "0.0820218410429409",
+  "1720119600000" to "0.0829062341049621",
+  "1720123200000" to "0.0844411672083035",
+  "1720126800000" to "0.085235514780735",
+  "1720130400000" to "0.0861388846413372",
+  "1720134000000" to "0.0841896775104112",
+  "1720137600000" to "0.0777030176076253",
+  "1720141200000" to "0.0755939440312492",
+  "1720144800000" to "0.0756452080059105",
+  "1720148400000" to "0.0736678466309968",
+  "1720152000000" to "0.0719156918166641",
+  "1720155600000" to "0.069013107839132",
+  "1720159200000" to "0.0699211344039789",
+  "1720162800000" to "0.0724099447220728",
+  "1720166400000" to "0.0734550253314003",
+  "1720170000000" to "0.0724584484789637",
+  "1720173600000" to "0.0731192986560919",
+  "1720177200000" to "0.0754809654421225",
+  "1720180800000" to "0.0770957774333553",
+  "1720184400000" to "0.0773216268787753",
+  "1720188000000" to "0.0790332314139234",
+  "1720191600000" to "0.0797283693320618",
+  "1720195200000" to "0.0832920763294247",
+  "1720198800000" to "0.0841121480792123",
+  "1720202400000" to "0.0841320287293262",
+  "1720206000000" to "0.0870410331922503",
+  "1720209600000" to "0.0902356420492678",
+  "1720213200000" to "0.0930596330170468",
+  "1720216800000" to "0.0945868989250222",
+  "1720220400000" to "0.0955829126823882",
+  "1720224000000" to "0.0947779861429092",
+  "1720227600000" to "0.0940016832993818",
+  "1720231200000" to "0.0921568429465372",
+  "1720234800000" to "0.0929267194429026",
+  "1720238400000" to "0.0933398597673369",
+  "1720242000000" to "0.0931241549874507",
+  "1720245600000" to "0.0932487251834741",
+  "1720249200000" to "0.0937398987402644",
+  "1720252800000" to "0.0946817850489796",
+  "1720256400000" to "0.0969746547247879",
+  "1720260000000" to "0.1002169221197943",
+  "1720263600000" to "0.100186132130899",
+  "1720267200000" to "0.100255893281134",
+  "1720270800000" to "0.0955378782556124",
+  "1720274400000" to "0.0959865833247599",
+  "1720278000000" to "0.0963911563028176",
+  "1720281600000" to "0.0962244554654068",
+  "1720285200000" to "0.0972666432122359",
+  "1720288800000" to "0.0977299586220594",
+  "1720292400000" to "0.0966147638911476",
+  "1720296000000" to "0.0979020311312848",
+  "1720299600000" to "0.0980922683795229",
+  "1720303200000" to "0.0975626846786079",
+  "1720306800000" to "0.0965457556974598",
+  "1720310400000" to "0.0933984225027114",
+  "1720314000000" to "0.0938645283273478",
+  "1720317600000" to "0.0934594540785354",
+  "1720321200000" to "0.0909382248824989",
+  "1720324800000" to "0.0911095884722694",
+  "1720328400000" to "0.0910570334325251",
+  "1720332000000" to "0.0906209245142566",
+  "1720335600000" to "0.0909150398403465",
+  "1720339200000" to "0.0902553237822216",
+  "1720342800000" to "0.0901024295163512",
+  "1720346400000" to "0.0887681100592243",
+  "1720350000000" to "0.0885120272742997",
+  "1720353600000" to "0.088589430581975",
+  "1720357200000" to "0.088342449984296",
+  "1720360800000" to "0.0862519180293328",
+  "1720364400000" to "0.0855752290288879",
+  "1720368000000" to "0.0839714995482308",
+  "1720371600000" to "0.0820621268095554",
+  "1720375200000" to "0.0816867203898351",
+  "1720378800000" to "0.0823850744171507",
+  "1720382400000" to "0.0820893104599602",
+  "1720386000000" to "0.0822272455791967",
+  "1720389600000" to "0.0821118401907168",
+  "1720393200000" to "0.0818195191537743",
+  "1720396800000" to "0.0822742947735628",
+  "1720400400000" to "0.0826141525944949",
+  "1720404000000" to "0.0808965334085527",
+  "1720407600000" to "0.0813547427163451",
+  "1720411200000" to "0.0808128684535017",
+  "1720414800000" to "0.0808815922618213",
+  "1720418400000" to "0.0818228469390862",
+  "1720422000000" to "0.081631760159473",
+  "1720425600000" to "0.0812928783478909",
+  "1720429200000" to "0.082194972470159",
+  "1720432800000" to "0.0822351895477116",
+  "1720436400000" to "0.0831675765384412",
+  "1720440000000" to "0.0833289931288296",
+  "1720443600000" to "0.0820615421160951",
+  "1720447200000" to "0.082621490552028",
+  "1720450800000" to "0.0816853903616626",
+  "1720454400000" to "0.0822899643240808",
+  "1720458000000" to "0.0818167745937942",
+  "1720461600000" to "0.0827216298589008",
+  "1720465200000" to "0.0825428464256276",
+  "1720468800000" to "0.0823081017030724",
+  "1720472400000" to "0.0819109213805638",
+  "1720476000000" to "0.082609058218826",
+  "1720479600000" to "0.0821555777885384",
+  "1720483200000" to "0.0815673349838855",
+  "1720486800000" to "0.0816182854113044",
+  "1720490400000" to "0.0810847903977707",
+  "1720494000000" to "0.0819206409525478",
+  "1720497600000" to "0.0845800898182773",
+  "1720501200000" to "0.0859176889337202",
+  "1720504800000" to "0.0868821228482021",
+  "1720508400000" to "0.0872589592155137",
+  "1720512000000" to "0.0876907946310209",
+  "1720515600000" to "0.0891195363989602",
+  "1720519200000" to "0.0900387160721606",
+  "1720522800000" to "0.0899143512495356",
+  "1720526400000" to "0.089635164305364",
+  "1720530000000" to "0.0885358040037241",
+  "1720533600000" to "0.0885389872906893",
+  "1720537200000" to "0.0885955162968534",
+  "1720540800000" to "0.0888283549336314",
+  "1720544400000" to "0.0898730726611704",
+  "1720548000000" to "0.0900866299108271",
+  "1720551600000" to "0.088973235756023",
+  "1720555200000" to "0.0884322792101308",
+  "1720558800000" to "0.0900140859036635",
+  "1720562400000" to "0.0893040682320373",
+  "1720566000000" to "0.0889258278047466",
+  "1720569600000" to "0.0883997101181664",
+  "1720573200000" to "0.0885833360415286",
+  "1720576800000" to "0.0882566147647664",
+  "1720580400000" to "0.0888260371363789",
+  "1720584000000" to "0.0861932245607613",
+  "1720587600000" to "0.0870635347315829",
+  "1720591200000" to "0.0836800194505735",
+  "1720594800000" to "0.0838365613093161",
+  "1720598400000" to "0.0838297486817762",
+  "1720602000000" to "0.0837623233432836",
+  "1720605600000" to "0.0836827255774263",
+  "1720609200000" to "0.0842674160369382",
+  "1720612800000" to "0.0843251951336163",
+  "1720616400000" to "0.0836517629832702",
+  "1720620000000" to "0.0805753322185088",
+  "1720623600000" to "0.0802615339578774",
+  "1720627200000" to "0.0810523202497057",
+  "1720630800000" to "0.0802648599679309",
+  "1720634400000" to "0.0785804255136747",
+  "1720638000000" to "0.0752768908796154",
+  "1720641600000" to "0.0764803450591717",
+  "1720645200000" to "0.0771992187241281",
+  "1720648800000" to "0.0778929379824183",
+  "1720652400000" to "0.077526606363246",
+  "1720656000000" to "0.0777492345604255",
+  "1720659600000" to "0.0774496494361661",
+  "1720663200000" to "0.0776934425410844",
+  "1720666800000" to "0.0778410991086674",
+  "1720670400000" to "0.0767400660263282",
+  "1720674000000" to "0.0768300261264065",
+  "1720677600000" to "0.0770114002928776",
+  "1720681200000" to "0.0764636369149876",
+  "1720684800000" to "0.0763599115447053",
+  "1720688400000" to "0.0764503003177289",
+  "1720692000000" to "0.0765639455975442",
+  "1720695600000" to "0.0765884764478394",
+  "1720699200000" to "0.0770233981205429",
+  "1720702800000" to "0.077560123926754",
+  "1720706400000" to "0.0780711608087586",
+  "1720710000000" to "0.0799622266528225",
+  "1720713600000" to "0.0794138028701674",
+  "1720717200000" to "0.0793747582669146",
+  "1720720800000" to "0.0793633375689458",
+  "1720724400000" to "0.0791667224084435",
+  "1720728000000" to "0.0719037635119411",
+  "1720731600000" to "0.0732372734128418",
+  "1720735200000" to "0.0749051257652133",
+  "1720738800000" to "0.0749953222541625",
+  "1720742400000" to "0.0750059173441683",
+  "1720746000000" to "0.0749907811264932",
+  "1720749600000" to "0.0748377602061325",
+  "1720753200000" to "0.0751040930822836",
+  "1720756800000" to "0.0752487935277309",
+  "1720760400000" to "0.0750354669283106",
+  "1720764000000" to "0.0762725198428168",
+  "1720767600000" to "0.0763750729590853",
+  "1720771200000" to "0.0766716064056639",
+  "1720774800000" to "0.076036009160992",
+  "1720778400000" to "0.076021173462928",
+  "1720782000000" to "0.075955318267521",
+  "1720785600000" to "0.0757105528070849",
+  "1720789200000" to "0.0760792271540722",
+  "1720792800000" to "0.0771506338419891",
+  "1720796400000" to "0.0777958285193921",
+  "1720800000000" to "0.0786968831162485",
+  "1720803600000" to "0.0775022786799441",
+  "1720807200000" to "0.0776794830775493",
+  "1720810800000" to "0.0780493521072568",
+  "1720814400000" to "0.0779445572174698",
+  "1720818000000" to "0.0773724981560503",
+  "1720821600000" to "0.0769815001832915",
+  "1720825200000" to "0.0767355262247582",
+  "1720828800000" to "0.0771405043417665",
+  "1720832400000" to "0.077396074406489",
+  "1720836000000" to "0.0774504674497984",
+  "1720839600000" to "0.0774513998327645",
+  "1720843200000" to "0.0769031002793055",
+  "1720846800000" to "0.0766873885259851",
+  "1720850400000" to "0.0770956009885178",
+  "1720854000000" to "0.0771627441812606",
+  "1720857600000" to "0.0772790024068904",
+  "1720861200000" to "0.0772904632293213",
+  "1720864800000" to "0.077287179856176",
+  "1720868400000" to "0.0773715675979633",
+  "1720872000000" to "0.0771704209458809",
+  "1720875600000" to "0.0769886990366569",
+  "1720879200000" to "0.0768498807662912",
+  "1720882800000" to "0.0769103207714283",
+  "1720886400000" to "0.0767660857719978",
+  "1720890000000" to "0.0765221694291332",
+  "1720893600000" to "0.0760160226842017",
+  "1720897200000" to "0.0760633205645943",
+  "1720900800000" to "0.0774676189347143",
+  "1720904400000" to "0.0776206906570514",
+  "1720908000000" to "0.0780085197178586",
+  "1720911600000" to "0.0791605792339802",
+  "1720915200000" to "0.0790467516240764",
+  "1720918800000" to "0.0795893212508448",
+  "1720922400000" to "0.0810567970057749",
+  "1720926000000" to "0.0805080970074297",
+  "1720929600000" to "0.0802210052131007",
+  "1720933200000" to "0.0796340389353191",
+  "1720936800000" to "0.0796799529817933",
+  "1720940400000" to "0.0792477325540124",
+  "1720944000000" to "0.0792413269367426",
+  "1720947600000" to "0.0795263691026158",
+  "1720951200000" to "0.0800770969736435",
+  "1720954800000" to "0.0798642036736453",
+  "1720958400000" to "0.0799431648308809",
+  "1720962000000" to "0.0794303679103129",
+  "1720965600000" to "0.0789285081506402",
+  "1720969200000" to "0.0800709401015862",
+  "1720972800000" to "0.0801598789208857",
+  "1720976400000" to "0.0791687304022247",
+  "1720980000000" to "0.0789476880887655",
+  "1720983600000" to "0.0793376568661497",
+  "1720987200000" to "0.0797954999863256",
+  "1720990800000" to "0.0799670854607535",
+  "1720994400000" to "0.0804119134977117",
+  "1720998000000" to "0.0807948605943265",
+  "1721001600000" to "0.0815099675207153",
+  "1721005200000" to "0.0825474732106533",
+  "1721008800000" to "0.082310762490797",
+  "1721012400000" to "0.0824444917330141",
+  "1721016000000" to "0.0821962033211753",
+  "1721019600000" to "0.0823694241140223",
+  "1721023200000" to "0.0817388849341497",
+  "1721026800000" to "0.0807444229681003",
+  "1721030400000" to "0.0798292068939816",
+  "1721034000000" to "0.076833433155481",
+  "1721037600000" to "0.0765273670044171",
+  "1721041200000" to "0.0764565589018841",
+  "1721044800000" to "0.076044018283345",
+  "1721048400000" to "0.0759742832661128",
+  "1721052000000" to "0.076014266568573",
+  "1721055600000" to "0.076126094468727",
+  "1721059200000" to "0.075824807603627",
+  "1721062800000" to "0.076046775154176",
+  "1721066400000" to "0.0740871908565346",
+  "1721070000000" to "0.0751356372905444",
+  "1721073600000" to "0.0761482857187194",
+  "1721077200000" to "0.0763729786093801",
+  "1721080800000" to "0.0766069687364844",
+  "1721084400000" to "0.0774471457078855",
+  "1721088000000" to "0.07814529295967",
+  "1721091600000" to "0.0774715373544065",
+  "1721095200000" to "0.0779040537828321",
+  "1721098800000" to "0.077992587424982",
+  "1721102400000" to "0.0784506163187004",
+  "1721106000000" to "0.0790990426937669",
+  "1721109600000" to "0.0785294961830574",
+  "1721113200000" to "0.0782626687881729",
+  "1721116800000" to "0.0782040189517115",
+  "1721120400000" to "0.078056037804723",
+  "1721124000000" to "0.0782697704287902",
+  "1721127600000" to "0.0785129990575837",
+  "1721131200000" to "0.0791583996177496",
+  "1721134800000" to "0.0790612115596713",
+  "1721138400000" to "0.0891511938299322",
+  "1721142000000" to "0.0893661172650441",
+  "1721145600000" to "0.0843824308367268",
+  "1721149200000" to "0.0897412710710718",
+  "1721152800000" to "0.0907639973774543",
+  "1721156400000" to "0.1044124263178743",
+  "1721160000000" to "0.1004542595269034",
+  "1721163600000" to "0.0979424251278106",
+  "1721167200000" to "0.0974276780367265",
+  "1721170800000" to "0.0995840096239179",
+  "1721174400000" to "0.1000072599195587",
+  "1721178000000" to "0.1009386835700657",
+  "1721181600000" to "0.1055510197182964",
+  "1721185200000" to "0.1060402381409754",
+  "1721188800000" to "0.1062135401686361",
+  "1721192400000" to "0.1055860391234057",
+  "1721196000000" to "0.1078787643258486",
+  "1721199600000" to "0.1072806479359868",
+  "1721203200000" to "0.1063336873816862",
+  "1721206800000" to "0.1065047495176094",
+  "1721812920000" to "0.1337979326720176",
+)
diff --git a/tangem-demo/src/main/java/com/tangem/vico/demo/chart/TangemChartMarker.kt b/tangem-demo/src/main/java/com/tangem/vico/demo/chart/TangemChartMarker.kt
index 53f80c554..91bd30348 100644
--- a/tangem-demo/src/main/java/com/tangem/vico/demo/chart/TangemChartMarker.kt
+++ b/tangem-demo/src/main/java/com/tangem/vico/demo/chart/TangemChartMarker.kt
@@ -26,9 +26,6 @@ import com.patrykandpatrick.vico.compose.common.component.rememberShapeComponent
 import com.patrykandpatrick.vico.compose.common.component.rememberUnboundedLineComponent
 import com.patrykandpatrick.vico.compose.common.of
 import com.patrykandpatrick.vico.compose.common.shape.dashed
-import com.patrykandpatrick.vico.core.cartesian.CartesianMeasureContext
-import com.patrykandpatrick.vico.core.cartesian.HorizontalDimensions
-import com.patrykandpatrick.vico.core.cartesian.Insets
 import com.patrykandpatrick.vico.core.cartesian.marker.CartesianMarker
 import com.patrykandpatrick.vico.core.cartesian.marker.DefaultCartesianMarker
 import com.patrykandpatrick.vico.core.common.Defaults
@@ -41,14 +38,14 @@ fun rememberTangemChartMarker(
   color: Color,
 ): CartesianMarker {
   val indicatorFrontComponent =
-    rememberShapeComponent(Shape.Pill, MaterialTheme.colorScheme.surface)
+    rememberShapeComponent(shape = Shape.Pill, color = MaterialTheme.colorScheme.surface)
   val indicatorCenterComponent = rememberShapeComponent(
-      shape = Shape.Pill,
-      color = color,
+    shape = Shape.Pill,
+    color = color,
   )
   val indicatorRearComponent = rememberShapeComponent(
-    Shape.Pill,
-    color = color.copy(alpha = .24f)
+    shape = Shape.Pill,
+    color = color.copy(alpha = .24f),
   )
   val indicator =
     rememberLayeredComponent(
@@ -61,35 +58,16 @@ fun rememberTangemChartMarker(
       padding = Dimensions.of(3.dp),
     )
   val guideline = rememberUnboundedLineComponent(
-      color = color,
-      verticalAddDrawSpace = 24.dp,
-      shape = Shape.dashed(Shape.Rectangle, Defaults.DASH_LENGTH.dp, Defaults.DASH_GAP.dp),
+    color = color,
+    verticalAddDrawSpace = 24.dp,
+    shape = Shape.dashed(Shape.Rectangle, Defaults.DASH_LENGTH.dp, Defaults.DASH_GAP.dp),
   )
   return remember(indicator, guideline) {
-    object :
-      DefaultCartesianMarker(
-        label = TextComponent.build { textSizeSp = 0f },
-        indicator = indicator,
-        indicatorSizeDp = 16f,
-        guideline = guideline,
-      ) {
-      override fun getInsets(
-        context: CartesianMeasureContext,
-        outInsets: Insets,
-        horizontalDimensions: HorizontalDimensions,
-      ) {
-        with(context) {
-          super.getInsets(context, outInsets, horizontalDimensions)
-          val baseShadowInsetDp =
-            CLIPPING_FREE_SHADOW_RADIUS_MULTIPLIER * LABEL_BACKGROUND_SHADOW_RADIUS_DP
-          outInsets.top += (baseShadowInsetDp - LABEL_BACKGROUND_SHADOW_DY_DP).pixels
-          outInsets.bottom += (baseShadowInsetDp + LABEL_BACKGROUND_SHADOW_DY_DP).pixels
-        }
-      }
-    }
+    DefaultCartesianMarker(
+      label = TextComponent(textSizeSp = 0f),
+      indicator = { indicator },
+      indicatorSizeDp = 16f,
+      guideline = guideline,
+    )
   }
 }
-
-private const val LABEL_BACKGROUND_SHADOW_RADIUS_DP = 4f
-private const val LABEL_BACKGROUND_SHADOW_DY_DP = 2f
-private const val CLIPPING_FREE_SHADOW_RADIUS_MULTIPLIER = 1.4f
diff --git a/tangem-demo/src/main/java/com/tangem/vico/demo/chart/TangemMarkerVisibilityListener.kt b/tangem-demo/src/main/java/com/tangem/vico/demo/chart/TangemMarkerVisibilityListener.kt
index f278a3eeb..7aa835a16 100644
--- a/tangem-demo/src/main/java/com/tangem/vico/demo/chart/TangemMarkerVisibilityListener.kt
+++ b/tangem-demo/src/main/java/com/tangem/vico/demo/chart/TangemMarkerVisibilityListener.kt
@@ -26,7 +26,7 @@ import com.patrykandpatrick.vico.core.cartesian.marker.LineCartesianLayerMarkerT
 
 @Composable
 fun rememberMarkerVisibilityListener(
-  yxFractionCallback : (y : Float?, x : Float?, xCanvas : Float?) -> Unit
+  yxFractionCallback : (y : Double?, x : Double?, xCanvas : Float?) -> Unit
 ): CartesianMarkerVisibilityListener {
   val hapticFeedback = LocalHapticFeedback.current
 
diff --git a/versions.gradle b/versions.gradle
index 4d2c5dd34..4b7b5d7ca 100644
--- a/versions.gradle
+++ b/versions.gradle
@@ -1,5 +1,5 @@
 /*
- * Copyright 2023 by Patryk Goworowski and Patrick Michalik.
+ * Copyright 2024 by Patryk Goworowski and Patrick Michalik.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -19,7 +19,7 @@ ext {
     library = [
             groupId        : "com.patrykandpatrick.vico",
             publishGroupId : "com.tangem.vico",
-            version_name   : "2.0.0-alpha.21",
+            version_name   : "2.0.0-alpha.25",
             publishVersion : project.hasProperty('publishVersion') ? project.getProperty('publishVersion') : '0.0.1',
             version_code   : 1,
             target_sdk     : 34,
diff --git a/vico/build.gradle b/vico/build.gradle
index a38691951..3605754e3 100644
--- a/vico/build.gradle
+++ b/vico/build.gradle
@@ -1,5 +1,5 @@
 /*
- * Copyright 2023 by Patryk Goworowski and Patrick Michalik.
+ * Copyright 2024 by Patryk Goworowski and Patrick Michalik.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -27,6 +27,7 @@ subprojects {
     apply plugin: "org.jetbrains.dokka"
     tasks.withType(DokkaTaskPartial.class).configureEach {
         dokkaSourceSets.configureEach { includes.from "Module.md" }
+        suppressInheritedMembers = true
     }
 }
 
diff --git a/vico/compose-m2/src/main/java/com/patrykandpatrick/vico/compose/m2/common/M2VicoTheme.kt b/vico/compose-m2/src/main/java/com/patrykandpatrick/vico/compose/m2/common/M2VicoTheme.kt
index b183e7911..cef948f48 100644
--- a/vico/compose-m2/src/main/java/com/patrykandpatrick/vico/compose/m2/common/M2VicoTheme.kt
+++ b/vico/compose-m2/src/main/java/com/patrykandpatrick/vico/compose/m2/common/M2VicoTheme.kt
@@ -16,7 +16,6 @@
 
 package com.patrykandpatrick.vico.compose.m2.common
 
-import androidx.compose.foundation.isSystemInDarkTheme
 import androidx.compose.material.MaterialTheme
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.remember
@@ -32,16 +31,13 @@ public fun rememberM2VicoTheme(
   columnCartesianLayerColors: List<Color> =
     listOf(MaterialTheme.colors.primary, MaterialTheme.colors.secondary),
   lineCartesianLayerColors: List<Color> = columnCartesianLayerColors,
-  elevationOverlayColor: Color =
-    if (isSystemInDarkTheme()) MaterialTheme.colors.onBackground else Color.Transparent,
-  lineColor: Color = MaterialTheme.colors.onBackground.copy(alpha = .2f),
+  lineColor: Color = MaterialTheme.colors.onBackground.copy(alpha = 0.2f),
   textColor: Color = MaterialTheme.colors.onBackground,
 ): VicoTheme =
   remember(
     candlestickCartesianLayerColors,
     columnCartesianLayerColors,
     lineCartesianLayerColors,
-    elevationOverlayColor,
     lineColor,
     textColor,
   ) {
@@ -49,7 +45,6 @@ public fun rememberM2VicoTheme(
       candlestickCartesianLayerColors,
       columnCartesianLayerColors,
       lineCartesianLayerColors,
-      elevationOverlayColor,
       lineColor,
       textColor,
     )
diff --git a/vico/compose-m3/src/main/java/com/patrykandpatrick/vico/compose/m3/common/M3VicoTheme.kt b/vico/compose-m3/src/main/java/com/patrykandpatrick/vico/compose/m3/common/M3VicoTheme.kt
index ae065c741..426c8392c 100644
--- a/vico/compose-m3/src/main/java/com/patrykandpatrick/vico/compose/m3/common/M3VicoTheme.kt
+++ b/vico/compose-m3/src/main/java/com/patrykandpatrick/vico/compose/m3/common/M3VicoTheme.kt
@@ -31,7 +31,6 @@ public fun rememberM3VicoTheme(
   columnCartesianLayerColors: List<Color> =
     MaterialTheme.colorScheme.run { listOf(primary, secondary, tertiary) },
   lineCartesianLayerColors: List<Color> = columnCartesianLayerColors,
-  elevationOverlayColor: Color = MaterialTheme.colorScheme.primary,
   lineColor: Color = MaterialTheme.colorScheme.outline,
   textColor: Color = MaterialTheme.colorScheme.onBackground,
 ): VicoTheme =
@@ -39,7 +38,6 @@ public fun rememberM3VicoTheme(
     candlestickCartesianLayerColors,
     columnCartesianLayerColors,
     lineCartesianLayerColors,
-    elevationOverlayColor,
     lineColor,
     textColor,
   ) {
@@ -47,7 +45,6 @@ public fun rememberM3VicoTheme(
       candlestickCartesianLayerColors,
       columnCartesianLayerColors,
       lineCartesianLayerColors,
-      elevationOverlayColor,
       lineColor,
       textColor,
     )
diff --git a/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/CartesianChart.kt b/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/CartesianChart.kt
index d916ef16f..8d03223ad 100644
--- a/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/CartesianChart.kt
+++ b/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/CartesianChart.kt
@@ -18,23 +18,28 @@ package com.patrykandpatrick.vico.compose.cartesian
 
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.remember
+import com.patrykandpatrick.vico.compose.cartesian.layer.rememberCandlestickCartesianLayer
 import com.patrykandpatrick.vico.compose.cartesian.layer.rememberColumnCartesianLayer
 import com.patrykandpatrick.vico.compose.cartesian.layer.rememberLineCartesianLayer
 import com.patrykandpatrick.vico.core.cartesian.CartesianChart
 import com.patrykandpatrick.vico.core.cartesian.CartesianDrawContext
 import com.patrykandpatrick.vico.core.cartesian.CartesianMeasureContext
 import com.patrykandpatrick.vico.core.cartesian.FadingEdges
+import com.patrykandpatrick.vico.core.cartesian.HorizontalLayout
 import com.patrykandpatrick.vico.core.cartesian.axis.Axis
 import com.patrykandpatrick.vico.core.cartesian.axis.AxisPosition
+import com.patrykandpatrick.vico.core.cartesian.data.CartesianChartModel
 import com.patrykandpatrick.vico.core.cartesian.decoration.Decoration
 import com.patrykandpatrick.vico.core.cartesian.layer.CartesianLayer
 import com.patrykandpatrick.vico.core.cartesian.marker.CartesianMarker
+import com.patrykandpatrick.vico.core.cartesian.marker.CartesianMarkerVisibilityListener
 import com.patrykandpatrick.vico.core.common.Legend
+import com.patrykandpatrick.vico.core.common.data.ExtraStore
 
 /**
- * Creates and remembers a [CartesianChart] with the given [CartesianLayer]s, axes, [Legend], and
- * [FadingEdges] instance. Adds the given [Decoration]s and persistent [CartesianMarker]s.
+ * Creates and remembers a [CartesianChart].
  *
+ * @see rememberCandlestickCartesianLayer
  * @see rememberColumnCartesianLayer
  * @see rememberLineCartesianLayer
  */
@@ -45,19 +50,28 @@ public fun rememberCartesianChart(
   topAxis: Axis<AxisPosition.Horizontal.Top>? = null,
   endAxis: Axis<AxisPosition.Vertical.End>? = null,
   bottomAxis: Axis<AxisPosition.Horizontal.Bottom>? = null,
+  marker: CartesianMarker? = null,
+  markerVisibilityListener: CartesianMarkerVisibilityListener? = null,
+  horizontalLayout: HorizontalLayout = HorizontalLayout.segmented(),
   legend: Legend<CartesianMeasureContext, CartesianDrawContext>? = null,
   fadingEdges: FadingEdges? = null,
-  decorations: List<Decoration>? = null,
-  persistentMarkers: Map<Float, CartesianMarker>? = null,
-): CartesianChart =
-  remember(*layers) { CartesianChart(*layers) }
+  decorations: List<Decoration> = emptyList(),
+  persistentMarkers: (CartesianChart.PersistentMarkerScope.(ExtraStore) -> Unit)? = null,
+  getXStep: ((CartesianChartModel) -> Double) = { it.getXDeltaGcd() },
+): CartesianChart {
+  return remember(*layers) { CartesianChart(*layers) }
     .apply {
       this.startAxis = startAxis
       this.topAxis = topAxis
       this.endAxis = endAxis
       this.bottomAxis = bottomAxis
+      this.marker = marker
+      this.markerVisibilityListener = markerVisibilityListener
+      this.horizontalLayout = horizontalLayout
       this.legend = legend
       this.fadingEdges = fadingEdges
-      decorations?.let(::setDecorations)
-      persistentMarkers?.let(::setPersistentMarkers)
+      this.decorations = decorations
+      this.persistentMarkers = persistentMarkers
+      this.getXStep = getXStep
     }
+}
diff --git a/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/CartesianChartHost.kt b/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/CartesianChartHost.kt
index 28042b9ed..ef4ea31db 100644
--- a/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/CartesianChartHost.kt
+++ b/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/CartesianChartHost.kt
@@ -34,25 +34,19 @@ import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.nativeCanvas
-import androidx.compose.ui.graphics.toArgb
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.unit.dp
 import com.patrykandpatrick.vico.compose.cartesian.data.component1
 import com.patrykandpatrick.vico.compose.cartesian.data.component2
 import com.patrykandpatrick.vico.compose.cartesian.data.component3
-import com.patrykandpatrick.vico.compose.common.vicoTheme
 import com.patrykandpatrick.vico.core.cartesian.CartesianChart
 import com.patrykandpatrick.vico.core.cartesian.CartesianDrawContext
-import com.patrykandpatrick.vico.core.cartesian.HorizontalLayout
 import com.patrykandpatrick.vico.core.cartesian.MutableHorizontalDimensions
 import com.patrykandpatrick.vico.core.cartesian.data.CartesianChartModel
 import com.patrykandpatrick.vico.core.cartesian.data.CartesianChartModelProducer
 import com.patrykandpatrick.vico.core.cartesian.data.ChartValues
 import com.patrykandpatrick.vico.core.cartesian.data.MutableChartValues
 import com.patrykandpatrick.vico.core.cartesian.data.toImmutable
-import com.patrykandpatrick.vico.core.cartesian.drawMarker
-import com.patrykandpatrick.vico.core.cartesian.marker.CartesianMarker
-import com.patrykandpatrick.vico.core.cartesian.marker.CartesianMarkerVisibilityListener
 import com.patrykandpatrick.vico.core.common.Defaults.CHART_HEIGHT
 import com.patrykandpatrick.vico.core.common.Point
 import com.patrykandpatrick.vico.core.common.ValueWrapper
@@ -60,8 +54,6 @@ import com.patrykandpatrick.vico.core.common.getValue
 import com.patrykandpatrick.vico.core.common.set
 import com.patrykandpatrick.vico.core.common.setValue
 import com.patrykandpatrick.vico.core.common.spToPx
-import kotlinx.coroutines.CoroutineDispatcher
-import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 
 /**
@@ -70,21 +62,14 @@ import kotlinx.coroutines.launch
  * @param chart the [CartesianChart].
  * @param modelProducer creates and updates the [CartesianChartModel].
  * @param modifier the modifier to be applied to the chart.
- * @param marker appears when the chart is touched, highlighting the entry or entries nearest to the
- *   touch point.
- * @param markerVisibilityListener allows for listening to [marker] visibility changes.
  * @param scrollState houses information on the [CartesianChart]’s scroll value. Allows for scroll
  *   customization and programmatic scrolling.
  * @param zoomState houses information on the [CartesianChart]’s zoom factor. Allows for zoom
  *   customization.
- * @param diffAnimationSpec the animation spec used for difference animations.
+ * @param animationSpec the [AnimationSpec] for difference animations.
  * @param runInitialAnimation whether to display an animation when the chart is created. In this
  *   animation, the value of each chart entry is animated from zero to the actual value. This
  *   animation isn’t run in previews.
- * @param horizontalLayout defines how the chart’s content is positioned horizontally.
- * @param getXStep overrides the _x_ step (the difference between the _x_ values of neighboring
- *   major entries). If this is null, the output of [CartesianChartModel.getXDeltaGcd] is used.
- * @param dispatcher used for handling [CartesianChartModel] updates.
  * @param placeholder shown when no [CartesianChartModel] is available.
  */
 @Composable
@@ -92,27 +77,15 @@ public fun CartesianChartHost(
   chart: CartesianChart,
   modelProducer: CartesianChartModelProducer,
   modifier: Modifier = Modifier,
-  marker: CartesianMarker? = null,
-  markerVisibilityListener: CartesianMarkerVisibilityListener? = null,
   scrollState: VicoScrollState = rememberVicoScrollState(),
   zoomState: VicoZoomState = rememberDefaultVicoZoomState(scrollState.scrollEnabled),
-  diffAnimationSpec: AnimationSpec<Float>? = defaultCartesianDiffAnimationSpec,
+  animationSpec: AnimationSpec<Float>? = defaultCartesianDiffAnimationSpec,
   runInitialAnimation: Boolean = true,
-  horizontalLayout: HorizontalLayout = HorizontalLayout.segmented(),
-  getXStep: ((CartesianChartModel) -> Float)? = null,
-  dispatcher: CoroutineDispatcher = Dispatchers.Default,
   placeholder: @Composable BoxScope.() -> Unit = {},
 ) {
   val mutableChartValues = remember(chart) { MutableChartValues() }
   val modelWrapper by
-    modelProducer.collectAsState(
-      chart,
-      diffAnimationSpec,
-      runInitialAnimation,
-      mutableChartValues,
-      getXStep,
-      dispatcher,
-    )
+    modelProducer.collectAsState(chart, animationSpec, runInitialAnimation, mutableChartValues)
   val (model, previousModel, chartValues) = modelWrapper
 
   CartesianChartHostBox(modifier) {
@@ -120,13 +93,10 @@ public fun CartesianChartHost(
       CartesianChartHostImpl(
         chart = chart,
         model = model,
-        oldModel = previousModel,
-        marker = marker,
-        markerVisibilityListener = markerVisibilityListener,
         scrollState = scrollState,
         zoomState = zoomState,
-        horizontalLayout = horizontalLayout,
         chartValues = chartValues,
+        previousModel = previousModel,
       )
     } else {
       placeholder()
@@ -141,18 +111,10 @@ public fun CartesianChartHost(
  * @param chart the [CartesianChart].
  * @param model the [CartesianChartModel].
  * @param modifier the modifier to be applied to the chart.
- * @param marker appears when the chart is touched, highlighting the entry or entries nearest to the
- *   touch point.
- * @param markerVisibilityListener allows for listening to [marker] visibility changes.
  * @param scrollState houses information on the [CartesianChart]’s scroll value. Allows for scroll
  *   customization and programmatic scrolling.
  * @param zoomState houses information on the [CartesianChart]’s zoom factor. Allows for zoom
  *   customization.
- * @param oldModel the chart’s previous [CartesianChartModel]. This is used to determine whether to
- *   perform an automatic scroll.
- * @param horizontalLayout defines how the chart’s content is positioned horizontally.
- * @param getXStep overrides the _x_ step (the difference between the _x_ values of neighboring
- *   major entries). If this is null, the output of [CartesianChartModel.getXDeltaGcd] is used.
  */
 @Composable
 @SuppressLint("RememberReturnType")
@@ -160,29 +122,20 @@ public fun CartesianChartHost(
   chart: CartesianChart,
   model: CartesianChartModel,
   modifier: Modifier = Modifier,
-  marker: CartesianMarker? = null,
-  markerVisibilityListener: CartesianMarkerVisibilityListener? = null,
   scrollState: VicoScrollState = rememberVicoScrollState(),
   zoomState: VicoZoomState = rememberDefaultVicoZoomState(scrollState.scrollEnabled),
-  oldModel: CartesianChartModel? = null,
-  horizontalLayout: HorizontalLayout = HorizontalLayout.segmented(),
-  getXStep: ((CartesianChartModel) -> Float)? = null,
 ) {
   val chartValues = remember(chart) { MutableChartValues() }
-  remember(chartValues, model, getXStep) {
+  remember(chartValues, chart, model) {
     chartValues.reset()
-    chart.updateChartValues(chartValues, model, getXStep?.invoke(model))
+    chart.updateChartValues(chartValues, model)
   }
   CartesianChartHostBox(modifier) {
     CartesianChartHostImpl(
       chart = chart,
       model = model,
-      marker = marker,
-      markerVisibilityListener = markerVisibilityListener,
       scrollState = scrollState,
       zoomState = zoomState,
-      oldModel = oldModel,
-      horizontalLayout = horizontalLayout,
       chartValues = chartValues.toImmutable(),
     )
   }
@@ -192,27 +145,23 @@ public fun CartesianChartHost(
 internal fun CartesianChartHostImpl(
   chart: CartesianChart,
   model: CartesianChartModel,
-  marker: CartesianMarker?,
-  markerVisibilityListener: CartesianMarkerVisibilityListener?,
   scrollState: VicoScrollState,
   zoomState: VicoZoomState,
-  oldModel: CartesianChartModel?,
-  horizontalLayout: HorizontalLayout,
   chartValues: ChartValues,
+  previousModel: CartesianChartModel? = null,
 ) {
-  val bounds = remember { RectF() }
+  val canvasBounds = remember { RectF() }
   val markerTouchPoint = remember { mutableStateOf<Point?>(null) }
   val measureContext =
     rememberCartesianMeasureContext(
-      scrollState.scrollEnabled,
-      bounds,
-      horizontalLayout,
-      with(LocalContext.current) { ::spToPx },
-      chartValues,
+      scrollEnabled = scrollState.scrollEnabled,
+      zoomEnabled = scrollState.scrollEnabled && zoomState.zoomEnabled,
+      canvasBounds = canvasBounds,
+      horizontalLayout = chart.horizontalLayout,
+      spToPx = with(LocalContext.current) { ::spToPx },
+      chartValues = chartValues,
     )
-  val previousMarkerTargetHashCode = remember { ValueWrapper<Int?>(null) }
 
-  val elevationOverlayColor = vicoTheme.elevationOverlayColor.toArgb()
   val coroutineScope = rememberCoroutineScope()
   var previousModelID by remember { ValueWrapper(model.id) }
   val horizontalDimensions = remember { MutableHorizontalDimensions() }
@@ -230,8 +179,8 @@ internal fun CartesianChartHostImpl(
       Modifier.fillMaxSize()
         .chartTouchEvent(
           setTouchPoint =
-            remember(marker == null) {
-              if (marker != null) markerTouchPoint.component2() else null
+            remember(chart.marker == null) {
+              if (chart.marker != null) markerTouchPoint.component2() else null
             },
           isScrollEnabled = scrollState.scrollEnabled,
           scrollState = scrollState,
@@ -239,8 +188,8 @@ internal fun CartesianChartHostImpl(
             remember(zoomState, scrollState, chart, coroutineScope) {
               if (zoomState.zoomEnabled) {
                 { factor, centroid ->
-                  zoomState.zoom(factor, centroid.x, scrollState.value, chart.bounds).let { scroll
-                    ->
+                  zoomState.zoom(factor, centroid.x, scrollState.value, chart.layerBounds).let {
+                    scroll ->
                     coroutineScope.launch { scrollState.scroll(scroll) }
                   }
                 }
@@ -250,46 +199,33 @@ internal fun CartesianChartHostImpl(
             },
         )
   ) {
-    bounds.set(left = 0, top = 0, right = size.width, bottom = size.height)
+    canvasBounds.set(left = 0, top = 0, right = size.width, bottom = size.height)
 
     horizontalDimensions.clear()
-    chart.prepare(measureContext, model, horizontalDimensions, bounds, marker)
+    chart.prepare(measureContext, model, horizontalDimensions, canvasBounds)
 
-    if (chart.bounds.isEmpty) return@Canvas
+    if (chart.layerBounds.isEmpty) return@Canvas
 
-    zoomState.update(measureContext, horizontalDimensions, chart.bounds)
-    scrollState.update(measureContext, chart.bounds, horizontalDimensions)
+    zoomState.update(measureContext, horizontalDimensions, chart.layerBounds)
+    scrollState.update(measureContext, chart.layerBounds, horizontalDimensions)
 
     if (model.id != previousModelID) {
-      coroutineScope.launch { scrollState.autoScroll(model, oldModel) }
+      coroutineScope.launch { scrollState.autoScroll(model, previousModel) }
       previousModelID = model.id
     }
 
     val cartesianDrawContext =
       CartesianDrawContext(
         canvas = drawContext.canvas.nativeCanvas,
-        elevationOverlayColor = elevationOverlayColor,
         measureContext = measureContext,
         markerTouchPoint = markerTouchPoint.value,
         horizontalDimensions = horizontalDimensions,
-        chartBounds = chart.bounds,
-        horizontalScroll = scrollState.value,
+        layerBounds = chart.layerBounds,
+        scroll = scrollState.value,
         zoom = zoomState.value,
       )
 
-    chart.draw(cartesianDrawContext, model)
-
-    if (marker != null) {
-      previousMarkerTargetHashCode.value =
-        cartesianDrawContext.drawMarker(
-          marker,
-          markerTouchPoint.value,
-          chart,
-          markerVisibilityListener,
-          previousMarkerTargetHashCode.value,
-        )
-    }
-
+    chart.draw(cartesianDrawContext, model, markerTouchPoint.value)
     measureContext.reset()
   }
 }
diff --git a/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/CartesianChartModelProducer.kt b/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/CartesianChartModelProducer.kt
index d83ee80fd..4951be121 100644
--- a/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/CartesianChartModelProducer.kt
+++ b/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/CartesianChartModelProducer.kt
@@ -28,7 +28,6 @@ import androidx.compose.ui.platform.LocalInspectionMode
 import com.patrykandpatrick.vico.compose.cartesian.data.CartesianChartModelWrapper
 import com.patrykandpatrick.vico.compose.cartesian.data.CartesianChartModelWrapperState
 import com.patrykandpatrick.vico.core.cartesian.CartesianChart
-import com.patrykandpatrick.vico.core.cartesian.data.CartesianChartModel
 import com.patrykandpatrick.vico.core.cartesian.data.CartesianChartModelProducer
 import com.patrykandpatrick.vico.core.cartesian.data.ChartValues
 import com.patrykandpatrick.vico.core.cartesian.data.MutableChartValues
@@ -39,7 +38,7 @@ import com.patrykandpatrick.vico.core.common.ValueWrapper
 import com.patrykandpatrick.vico.core.common.data.MutableExtraStore
 import com.patrykandpatrick.vico.core.common.getValue
 import com.patrykandpatrick.vico.core.common.setValue
-import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.cancelAndJoin
 import kotlinx.coroutines.launch
@@ -53,8 +52,6 @@ internal fun CartesianChartModelProducer.collectAsState(
   animationSpec: AnimationSpec<Float>?,
   runInitialAnimation: Boolean,
   mutableChartValues: MutableChartValues,
-  getXStep: ((CartesianChartModel) -> Float)?,
-  dispatcher: CoroutineDispatcher,
 ): State<CartesianChartModelWrapper> {
   var previousHashCode by remember { ValueWrapper<Int?>(null) }
   val hashCode = hashCode()
@@ -79,7 +76,7 @@ internal fun CartesianChartModelProducer.collectAsState(
         ) {
           isAnimationRunning = true
           mainAnimationJob =
-            scope.launch(dispatcher) {
+            scope.launch {
               animate(
                 initialValue = Animation.range.start,
                 targetValue = Animation.range.endInclusive,
@@ -90,14 +87,14 @@ internal fun CartesianChartModelProducer.collectAsState(
                   !isAnimationFrameGenerationRunning -> {
                     isAnimationFrameGenerationRunning = true
                     animationFrameJob =
-                      scope.launch(dispatcher) {
+                      scope.launch {
                         transformModel(chart, fraction)
                         isAnimationFrameGenerationRunning = false
                       }
                   }
                   fraction == 1f -> {
                     finalAnimationFrameJob =
-                      scope.launch(dispatcher) {
+                      scope.launch(Dispatchers.Default) {
                         animationFrameJob?.cancelAndJoin()
                         transformModel(chart, fraction)
                         isAnimationFrameGenerationRunning = false
@@ -108,10 +105,10 @@ internal fun CartesianChartModelProducer.collectAsState(
             }
         } else {
           finalAnimationFrameJob =
-            scope.launch(dispatcher) { transformModel(chart, Animation.range.endInclusive) }
+            scope.launch { transformModel(chart, Animation.range.endInclusive) }
         }
       }
-    scope.launch(dispatcher) {
+    scope.launch {
       registerForUpdates(
         key = chart,
         cancelAnimation = {
@@ -128,7 +125,7 @@ internal fun CartesianChartModelProducer.collectAsState(
         updateChartValues = { model ->
           mutableChartValues.reset()
           if (model != null) {
-            chart.updateChartValues(mutableChartValues, model, getXStep?.invoke(model))
+            chart.updateChartValues(mutableChartValues, model)
             mutableChartValues.toImmutable()
           } else {
             ChartValues.Empty
diff --git a/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/FadingEdges.kt b/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/FadingEdges.kt
index 759bc3775..960dae518 100644
--- a/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/FadingEdges.kt
+++ b/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/FadingEdges.kt
@@ -41,18 +41,18 @@ import com.patrykandpatrick.vico.core.common.Defaults.FADING_EDGE_WIDTH_DP
 @Composable
 public fun rememberFadingEdges(
   startEdgeWidth: Dp = FadingEdgesDefaults.edgeWidth,
-  endEdgeWidth: Dp = startEdgeWidth,
+  endEdgeWidth: Dp = FadingEdgesDefaults.edgeWidth,
   visibilityThreshold: Dp = FadingEdgesDefaults.visibilityThreshold,
   visibilityEasing: Easing = FadingEdgesDefaults.visibilityEasing,
 ): FadingEdges =
-  remember { FadingEdges() }
-    .apply {
-      startEdgeWidthDp = startEdgeWidth.value
-      endEdgeWidthDp = endEdgeWidth.value
-      visibilityThresholdDp = visibilityThreshold.value
-      this.visibilityInterpolator =
-        remember(visibilityEasing) { TimeInterpolator(visibilityEasing::transform) }
-    }
+  remember(startEdgeWidth, endEdgeWidth, visibilityThreshold, visibilityEasing) {
+    FadingEdges(
+      startEdgeWidth.value,
+      endEdgeWidth.value,
+      visibilityThreshold.value,
+      TimeInterpolator(visibilityEasing::transform),
+    )
+  }
 
 /**
  * Creates and remembers a [FadingEdges] instance.
diff --git a/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/HorizontalLayout.kt b/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/HorizontalLayout.kt
index 787748365..8085f0545 100644
--- a/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/HorizontalLayout.kt
+++ b/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/HorizontalLayout.kt
@@ -20,11 +20,11 @@ import androidx.compose.ui.unit.Dp
 import androidx.compose.ui.unit.dp
 import com.patrykandpatrick.vico.core.cartesian.HorizontalLayout
 
-/** Returns an instance of [HorizontalLayout.Segmented]. */
+/** Returns a [HorizontalLayout.Segmented] instance. */
 public fun HorizontalLayout.Companion.segmented(): HorizontalLayout.Segmented =
   HorizontalLayout.Segmented
 
-/** Creates and returns an instance of [HorizontalLayout.FullWidth]. */
+/** Creates a [HorizontalLayout.FullWidth] instance. */
 public fun HorizontalLayout.Companion.fullWidth(
   scalableStartPadding: Dp = 0.dp,
   scalableEndPadding: Dp = 0.dp,
diff --git a/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/MeasureContext.kt b/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/MeasureContext.kt
index 752d477e4..a5fb98c7f 100644
--- a/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/MeasureContext.kt
+++ b/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/MeasureContext.kt
@@ -29,6 +29,7 @@ import com.patrykandpatrick.vico.core.cartesian.data.ChartValues
 @Composable
 internal fun rememberCartesianMeasureContext(
   scrollEnabled: Boolean,
+  zoomEnabled: Boolean,
   canvasBounds: RectF,
   horizontalLayout: HorizontalLayout,
   spToPx: (Float) -> Float,
@@ -39,15 +40,19 @@ internal fun rememberCartesianMeasureContext(
         canvasBounds = canvasBounds,
         density = 0f,
         isLtr = true,
-        spToPx = spToPx,
+        scrollEnabled = scrollEnabled,
+        zoomEnabled = zoomEnabled,
+        horizontalLayout = horizontalLayout,
         chartValues = chartValues,
+        spToPx = spToPx,
       )
     }
     .apply {
       this.density = LocalDensity.current.density
       this.isLtr = LocalLayoutDirection.current == LayoutDirection.Ltr
       this.scrollEnabled = scrollEnabled
+      this.zoomEnabled = zoomEnabled
       this.horizontalLayout = horizontalLayout
-      this.spToPx = spToPx
       this.chartValues = chartValues
+      this.spToPx = spToPx
     }
diff --git a/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/VicoScrollState.kt b/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/VicoScrollState.kt
index 5ddd8deee..2f182c312 100644
--- a/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/VicoScrollState.kt
+++ b/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/VicoScrollState.kt
@@ -63,8 +63,12 @@ public class VicoScrollState {
     val oldValue = value
     value += delta
     val consumedValue = value - oldValue
-    if (consumedValue != delta) pointerXDeltas.tryEmit(consumedValue - delta)
-    delta
+    if (oldValue + delta == value) {
+      delta
+    } else {
+      pointerXDeltas.tryEmit(consumedValue - delta)
+      consumedValue
+    }
   }
 
   /** The current scroll value (in pixels). */
@@ -107,7 +111,7 @@ public class VicoScrollState {
    * Houses information on a [CartesianChart]’s scroll value. Allows for scroll customization and
    * programmatic scrolling.
    *
-   * @param scrollEnabled whether scrolling is enabled.
+   * @param scrollEnabled whether scroll is enabled.
    * @param initialScroll represents the initial scroll value.
    * @param autoScroll represents the scroll value or delta for automatic scrolling.
    * @param autoScrollCondition defines when an automatic scroll should occur.
diff --git a/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/VicoZoomState.kt b/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/VicoZoomState.kt
index b240f7319..1718cedf5 100644
--- a/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/VicoZoomState.kt
+++ b/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/VicoZoomState.kt
@@ -77,7 +77,7 @@ public class VicoZoomState {
   /**
    * Houses information on a [CartesianChart]’s zoom factor. Allows for zoom customization.
    *
-   * @param zoomEnabled whether zooming is enabled.
+   * @param zoomEnabled whether zoom is enabled.
    * @param initialZoom represents the initial zoom factor.
    * @param minZoom represents the minimum zoom factor.
    * @param maxZoom represents the maximum zoom factor.
diff --git a/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/axis/AxisComponents.kt b/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/axis/AxisComponents.kt
index e83f03b4b..c172cdd5c 100644
--- a/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/axis/AxisComponents.kt
+++ b/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/axis/AxisComponents.kt
@@ -14,15 +14,15 @@
  * limitations under the License.
  */
 
+@file:Suppress("DeprecatedCallableAddReplaceWith")
+
 package com.patrykandpatrick.vico.compose.cartesian.axis
 
 import android.graphics.Typeface
 import android.text.Layout
 import android.text.TextUtils
 import androidx.compose.runtime.Composable
-import androidx.compose.ui.graphics.Brush
 import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.graphics.RectangleShape
 import androidx.compose.ui.unit.Dp
 import androidx.compose.ui.unit.TextUnit
 import androidx.compose.ui.unit.dp
@@ -30,174 +30,115 @@ import androidx.compose.ui.unit.sp
 import com.patrykandpatrick.vico.compose.common.component.rememberLineComponent
 import com.patrykandpatrick.vico.compose.common.component.rememberTextComponent
 import com.patrykandpatrick.vico.compose.common.of
-import com.patrykandpatrick.vico.compose.common.shader.BrushShader
 import com.patrykandpatrick.vico.compose.common.shape.dashed
-import com.patrykandpatrick.vico.compose.common.shape.toVicoShape
 import com.patrykandpatrick.vico.compose.common.vicoTheme
+import com.patrykandpatrick.vico.core.cartesian.axis.Axis
 import com.patrykandpatrick.vico.core.common.Defaults
 import com.patrykandpatrick.vico.core.common.Dimensions
+import com.patrykandpatrick.vico.core.common.component.Component
 import com.patrykandpatrick.vico.core.common.component.LineComponent
-import com.patrykandpatrick.vico.core.common.component.ShapeComponent
+import com.patrykandpatrick.vico.core.common.component.Shadow
 import com.patrykandpatrick.vico.core.common.component.TextComponent
 import com.patrykandpatrick.vico.core.common.shader.DynamicShader
 import com.patrykandpatrick.vico.core.common.shape.Shape
 
-/**
- * Creates and remembers a [TextComponent] to be used for axis labels.
- *
- * @param color the text color.
- * @param textSize the text size.
- * @param background an optional [ShapeComponent] to be displayed behind the text.
- * @param ellipsize the text truncation behavior.
- * @param lineCount the line count.
- * @param padding the padding between the text and the background.
- * @param margins the margins around the background.
- * @param typeface the [Typeface] for the text.
- * @param textAlignment the text alignment.
- */
+/** A [rememberTextComponent] alias with defaults for [Axis] labels. */
 @Composable
 public fun rememberAxisLabelComponent(
   color: Color = vicoTheme.textColor,
+  typeface: Typeface = Typeface.DEFAULT,
   textSize: TextUnit = Defaults.AXIS_LABEL_SIZE.sp,
-  background: ShapeComponent? = null,
-  ellipsize: TextUtils.TruncateAt = TextUtils.TruncateAt.END,
+  textAlignment: Layout.Alignment = Layout.Alignment.ALIGN_NORMAL,
   lineCount: Int = Defaults.AXIS_LABEL_MAX_LINES,
+  truncateAt: TextUtils.TruncateAt = TextUtils.TruncateAt.END,
+  margins: Dimensions =
+    Dimensions.of(Defaults.AXIS_LABEL_HORIZONTAL_MARGIN.dp, Defaults.AXIS_LABEL_VERTICAL_MARGIN.dp),
   padding: Dimensions =
     Dimensions.of(
       Defaults.AXIS_LABEL_HORIZONTAL_PADDING.dp,
       Defaults.AXIS_LABEL_VERTICAL_PADDING.dp,
     ),
-  margins: Dimensions =
-    Dimensions.of(Defaults.AXIS_LABEL_HORIZONTAL_MARGIN.dp, Defaults.AXIS_LABEL_VERTICAL_MARGIN.dp),
-  typeface: Typeface = Typeface.MONOSPACE,
-  textAlignment: Layout.Alignment = Layout.Alignment.ALIGN_NORMAL,
+  background: Component? = null,
+  minWidth: TextComponent.MinWidth = TextComponent.MinWidth.fixed(),
 ): TextComponent =
   rememberTextComponent(
     color,
+    typeface,
     textSize,
-    background,
-    ellipsize,
+    textAlignment,
     lineCount,
-    padding,
+    truncateAt,
     margins,
-    typeface,
-    textAlignment,
+    padding,
+    background,
+    minWidth,
   )
 
-/**
- * Creates and remembers a [LineComponent] styled as an axis line.
- *
- * @param color the background color.
- * @param thickness the thickness of the line.
- * @param shape the [Shape] to use for the line.
- * @param strokeWidth the stroke width.
- * @param strokeColor the stroke color.
- * @param brush an optional [Brush] to apply to the line.
- * @param margins the margins of the line.
- */
+/** A [rememberLineComponent] alias with defaults for [Axis] lines. */
 @Composable
 public fun rememberAxisLineComponent(
   color: Color = vicoTheme.lineColor,
   thickness: Dp = Defaults.AXIS_LINE_WIDTH.dp,
   shape: Shape = Shape.Rectangle,
-  strokeWidth: Dp = 0.dp,
-  strokeColor: Color = Color.Transparent,
-  brush: Brush? = null,
   margins: Dimensions = Dimensions.Empty,
+  strokeColor: Color = Color.Transparent,
+  strokeThickness: Dp = 0.dp,
+  shader: DynamicShader? = null,
+  shadow: Shadow? = null,
 ): LineComponent =
   rememberLineComponent(
-    color = color,
-    thickness = thickness,
-    shape = shape,
-    dynamicShader = brush?.let(::BrushShader),
-    margins = margins,
-    strokeWidth = strokeWidth,
-    strokeColor = strokeColor,
+    color,
+    thickness,
+    shape,
+    margins,
+    strokeColor,
+    strokeThickness,
+    shader,
+    shadow,
   )
 
-/**
- * Creates and remembers a [LineComponent] styled as a tick line.
- *
- * @param color the background color.
- * @param thickness the thickness of the tick.
- * @param shape the [Shape] to use for the tick.
- * @param strokeWidth the stroke width.
- * @param strokeColor the stroke color.
- * @param dynamicShader an optional [DynamicShader] to apply to the tick.
- */
+/** A [rememberLineComponent] alias with defaults for [Axis] ticks. */
 @Composable
 public fun rememberAxisTickComponent(
   color: Color = vicoTheme.lineColor,
   thickness: Dp = Defaults.AXIS_LINE_WIDTH.dp,
   shape: Shape = Shape.Rectangle,
-  strokeWidth: Dp = 0.dp,
-  strokeColor: Color = Color.Transparent,
-  dynamicShader: DynamicShader? = null,
-): LineComponent =
-  rememberLineComponent(
-    color = color,
-    thickness = thickness,
-    dynamicShader = dynamicShader,
-    shape = shape,
-    strokeWidth = strokeWidth,
-    strokeColor = strokeColor,
-  )
-
-/**
- * Creates and remembers a [LineComponent] styled as a tick line.
- *
- * @param color the background color.
- * @param thickness the thickness of the line.
- * @param shape the [androidx.compose.ui.graphics.Shape] to use for the line.
- * @param strokeWidth the stroke width.
- * @param strokeColor the stroke color.
- * @param brush an optional [Brush] to apply to the line.
- */
-@Composable
-public fun rememberAxisTickComponent(
-  color: Color,
-  thickness: Dp = Defaults.AXIS_LINE_WIDTH.dp,
-  shape: androidx.compose.ui.graphics.Shape = RectangleShape,
-  strokeWidth: Dp = 0.dp,
+  margins: Dimensions = Dimensions.Empty,
   strokeColor: Color = Color.Transparent,
-  brush: Brush? = null,
+  strokeThickness: Dp = 0.dp,
+  shader: DynamicShader? = null,
+  shadow: Shadow? = null,
 ): LineComponent =
   rememberLineComponent(
-    color = color,
-    thickness = thickness,
-    dynamicShader = brush?.let(::BrushShader),
-    shape = shape.toVicoShape(),
-    strokeWidth = strokeWidth,
-    strokeColor = strokeColor,
+    color,
+    thickness,
+    shape,
+    margins,
+    strokeColor,
+    strokeThickness,
+    shader,
+    shadow,
   )
 
-/**
- * Creates and remembers a [LineComponent] styled as a guideline.
- *
- * @param color the background color.
- * @param thickness the line thickness.
- * @param shape the [Shape] to use for the guideline.
- * @param strokeWidth the stroke width.
- * @param strokeColor the stroke color.
- * @param dynamicShader an optional [DynamicShader] to apply to the guideline.
- * @param margins the margins of the guideline.
- */
+/** A [rememberLineComponent] alias with defaults for [Axis] guidelines. */
 @Composable
 public fun rememberAxisGuidelineComponent(
   color: Color = vicoTheme.lineColor,
   thickness: Dp = Defaults.AXIS_GUIDELINE_WIDTH.dp,
   shape: Shape = Shape.dashed(Shape.Rectangle, Defaults.DASH_LENGTH.dp, Defaults.DASH_GAP.dp),
-  strokeWidth: Dp = 0.dp,
-  strokeColor: Color = Color.Transparent,
-  dynamicShader: DynamicShader? = null,
   margins: Dimensions = Dimensions.Empty,
+  strokeColor: Color = Color.Transparent,
+  strokeThickness: Dp = 0.dp,
+  shader: DynamicShader? = null,
+  shadow: Shadow? = null,
 ): LineComponent =
   rememberLineComponent(
-    color = color,
-    thickness = thickness,
-    dynamicShader = dynamicShader,
-    shape = shape,
-    margins = margins,
-    strokeWidth = strokeWidth,
-    strokeColor = strokeColor,
+    color,
+    thickness,
+    shape,
+    margins,
+    strokeColor,
+    strokeThickness,
+    shader,
+    shadow,
   )
diff --git a/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/axis/CustomVerticalAxis.kt b/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/axis/CustomVerticalAxis.kt
index 87d71845a..1f4f9e955 100644
--- a/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/axis/CustomVerticalAxis.kt
+++ b/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/axis/CustomVerticalAxis.kt
@@ -20,7 +20,6 @@ import androidx.compose.runtime.Composable
 import androidx.compose.runtime.remember
 import androidx.compose.ui.unit.Dp
 import androidx.compose.ui.unit.dp
-import com.patrykandpatrick.vico.core.cartesian.axis.AxisItemPlacer
 import com.patrykandpatrick.vico.core.cartesian.axis.AxisPosition
 import com.patrykandpatrick.vico.core.cartesian.axis.BaseAxis
 import com.patrykandpatrick.vico.core.cartesian.axis.CustomVerticalAxis
@@ -30,67 +29,49 @@ import com.patrykandpatrick.vico.core.common.Defaults
 import com.patrykandpatrick.vico.core.common.component.LineComponent
 import com.patrykandpatrick.vico.core.common.component.TextComponent
 
-/**
- * Creates and remembers a start axis (i.e., a [VerticalAxis] with [AxisPosition.Vertical.Start]).
- *
- * @param label the [TextComponent] to use for the labels.
- * @param axis the [LineComponent] to use for the axis line.
- * @param tick the [LineComponent] to use for the ticks.
- * @param tickLength the length of the ticks.
- * @param guideline the [LineComponent] to use for the guidelines.
- * @param labelGuideline the [LineComponent] to use for the guidelines which starts from label text.
- * @param valueFormatter formats the labels.
- * @param sizeConstraint defines how the [VerticalAxis] is to size itself.
- * @param horizontalLabelPosition the horizontal position of the labels.
- * @param verticalLabelPosition the vertical position of the labels.
- * @param itemPlacer determines for what _y_ values the [VerticalAxis] is to display labels, ticks,
- *   and guidelines.
- * @param labelRotationDegrees the rotation of the axis labels (in degrees).
- * @param titleComponent an optional [TextComponent] to use as the axis title.
- * @param title the axis title.
- */
+/** Creates and remembers a start [CustomVerticalAxis]. */
 @Composable
 public fun rememberCustomStartAxis(
+  line: LineComponent? = rememberAxisLineComponent(),
   label: TextComponent? = rememberAxisLabelComponent(),
-  axis: LineComponent? = rememberAxisLineComponent(),
-  tick: LineComponent? = rememberAxisTickComponent(),
-  tickLength: Dp = Defaults.AXIS_TICK_LENGTH.dp,
-  guideline: LineComponent? = rememberAxisGuidelineComponent(),
-  labelGuideline: LineComponent? = null,
-  valueFormatter: CartesianValueFormatter = remember { CartesianValueFormatter.decimal() },
-  sizeConstraint: BaseAxis.SizeConstraint = BaseAxis.SizeConstraint.Auto(),
+  labelRotationDegrees: Float = Defaults.AXIS_LABEL_ROTATION_DEGREES,
   horizontalLabelPosition: VerticalAxis.HorizontalLabelPosition =
     VerticalAxis.HorizontalLabelPosition.Outside,
   verticalLabelPosition: VerticalAxis.VerticalLabelPosition =
     VerticalAxis.VerticalLabelPosition.Center,
-  itemPlacer: AxisItemPlacer.Vertical = remember { AxisItemPlacer.Vertical.step() },
-  labelRotationDegrees: Float = Defaults.AXIS_LABEL_ROTATION_DEGREES,
+  valueFormatter: CartesianValueFormatter = remember { CartesianValueFormatter.decimal() },
+  tick: LineComponent? = rememberAxisTickComponent(),
+  tickLength: Dp = Defaults.AXIS_TICK_LENGTH.dp,
+  guideline: LineComponent? = rememberAxisGuidelineComponent(),
+  itemPlacer: VerticalAxis.ItemPlacer = remember { VerticalAxis.ItemPlacer.step() },
+  sizeConstraint: BaseAxis.SizeConstraint = remember { BaseAxis.SizeConstraint.Auto() },
   titleComponent: TextComponent? = null,
   title: CharSequence? = null,
+  labelGuideline: LineComponent? = null,
 ): CustomVerticalAxis<AxisPosition.Vertical.Start> =
-  remember { CustomVerticalAxis.build<AxisPosition.Vertical.Start>() }
+  remember { CustomVerticalAxis.start() }
     .apply {
-      this.labelGuideline = labelGuideline
+      this.line = line
       this.label = label
-      axisLine = axis
-      this.tick = tick
-      this.guideline = guideline
-      this.valueFormatter = valueFormatter
-      tickLengthDp = tickLength.value
-      this.sizeConstraint = sizeConstraint
+      this.labelRotationDegrees = labelRotationDegrees
       this.horizontalLabelPosition = horizontalLabelPosition
       this.verticalLabelPosition = verticalLabelPosition
+      this.valueFormatter = valueFormatter
+      this.tick = tick
+      tickLengthDp = tickLength.value
+      this.guideline = guideline
       this.itemPlacer = itemPlacer
-      this.labelRotationDegrees = labelRotationDegrees
+      this.sizeConstraint = sizeConstraint
       this.titleComponent = titleComponent
       this.title = title
+      this.labelGuideline = labelGuideline
     }
 
 /**
  * Creates and remembers an end axis (i.e., a [VerticalAxis] with [AxisPosition.Vertical.End]).
  *
  * @param label the [TextComponent] to use for the labels.
- * @param axis the [LineComponent] to use for the axis line.
+ * @param line the [LineComponent] to use for the axis line.
  * @param tick the [LineComponent] to use for the ticks.
  * @param tickLength the length of the ticks.
  * @param guideline the [LineComponent] to use for the guidelines.
@@ -107,37 +88,37 @@ public fun rememberCustomStartAxis(
  */
 @Composable
 public fun rememberCustomEndAxis(
+  line: LineComponent? = rememberAxisLineComponent(),
   label: TextComponent? = rememberAxisLabelComponent(),
-  axis: LineComponent? = rememberAxisLineComponent(),
-  tick: LineComponent? = rememberAxisTickComponent(),
-  tickLength: Dp = Defaults.AXIS_TICK_LENGTH.dp,
-  guideline: LineComponent? = rememberAxisGuidelineComponent(),
-  labelGuideline: LineComponent? = null,
-  valueFormatter: CartesianValueFormatter = remember { CartesianValueFormatter.decimal() },
-  sizeConstraint: BaseAxis.SizeConstraint = BaseAxis.SizeConstraint.Auto(),
+  labelRotationDegrees: Float = Defaults.AXIS_LABEL_ROTATION_DEGREES,
   horizontalLabelPosition: VerticalAxis.HorizontalLabelPosition =
     VerticalAxis.HorizontalLabelPosition.Outside,
   verticalLabelPosition: VerticalAxis.VerticalLabelPosition =
     VerticalAxis.VerticalLabelPosition.Center,
-  itemPlacer: AxisItemPlacer.Vertical = remember { AxisItemPlacer.Vertical.step() },
-  labelRotationDegrees: Float = Defaults.AXIS_LABEL_ROTATION_DEGREES,
+  valueFormatter: CartesianValueFormatter = remember { CartesianValueFormatter.decimal() },
+  tick: LineComponent? = rememberAxisTickComponent(),
+  tickLength: Dp = Defaults.AXIS_TICK_LENGTH.dp,
+  guideline: LineComponent? = rememberAxisGuidelineComponent(),
+  itemPlacer: VerticalAxis.ItemPlacer = remember { VerticalAxis.ItemPlacer.step() },
+  sizeConstraint: BaseAxis.SizeConstraint = remember { BaseAxis.SizeConstraint.Auto() },
   titleComponent: TextComponent? = null,
   title: CharSequence? = null,
+  labelGuideline: LineComponent? = null,
 ): CustomVerticalAxis<AxisPosition.Vertical.End> =
-  remember { CustomVerticalAxis.build<AxisPosition.Vertical.End>() }
+  remember { CustomVerticalAxis.end() }
     .apply {
-      this.labelGuideline = labelGuideline
+      this.line = line
       this.label = label
-      axisLine = axis
-      this.tick = tick
-      this.guideline = guideline
-      this.valueFormatter = valueFormatter
-      tickLengthDp = tickLength.value
-      this.sizeConstraint = sizeConstraint
+      this.labelRotationDegrees = labelRotationDegrees
       this.horizontalLabelPosition = horizontalLabelPosition
       this.verticalLabelPosition = verticalLabelPosition
+      this.valueFormatter = valueFormatter
+      this.tick = tick
+      tickLengthDp = tickLength.value
+      this.guideline = guideline
       this.itemPlacer = itemPlacer
-      this.labelRotationDegrees = labelRotationDegrees
+      this.sizeConstraint = sizeConstraint
       this.titleComponent = titleComponent
       this.title = title
+      this.labelGuideline = labelGuideline
     }
diff --git a/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/axis/HorizontalAxis.kt b/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/axis/HorizontalAxis.kt
index dcfba29ac..46bbc0de6 100644
--- a/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/axis/HorizontalAxis.kt
+++ b/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/axis/HorizontalAxis.kt
@@ -20,7 +20,6 @@ import androidx.compose.runtime.Composable
 import androidx.compose.runtime.remember
 import androidx.compose.ui.unit.Dp
 import androidx.compose.ui.unit.dp
-import com.patrykandpatrick.vico.core.cartesian.axis.AxisItemPlacer
 import com.patrykandpatrick.vico.core.cartesian.axis.AxisPosition
 import com.patrykandpatrick.vico.core.cartesian.axis.BaseAxis
 import com.patrykandpatrick.vico.core.cartesian.axis.HorizontalAxis
@@ -29,93 +28,62 @@ import com.patrykandpatrick.vico.core.common.Defaults
 import com.patrykandpatrick.vico.core.common.component.LineComponent
 import com.patrykandpatrick.vico.core.common.component.TextComponent
 
-/**
- * Creates and remembers a top axis (i.e., a [HorizontalAxis] with [AxisPosition.Horizontal.Top]).
- *
- * @param label the [TextComponent] to use for the labels.
- * @param axis the [LineComponent] to use for the axis line.
- * @param tick the [LineComponent] to use for the ticks.
- * @param tickLength the length of the ticks.
- * @param guideline the [LineComponent] to use for the guidelines.
- * @param valueFormatter formats the labels.
- * @param sizeConstraint defines how the [HorizontalAxis] is to size itself.
- * @param labelRotationDegrees the rotation of the axis labels (in degrees).
- * @param titleComponent an optional [TextComponent] to use as the axis title.
- * @param title the axis title.
- * @param itemPlacer determines for what _x_ values the [HorizontalAxis] is to display labels,
- *   ticks, and guidelines.
- */
+/** Creates and remembers a top [HorizontalAxis]. */
 @Composable
 public fun rememberTopAxis(
+  line: LineComponent? = rememberAxisLineComponent(),
   label: TextComponent? = rememberAxisLabelComponent(),
-  axis: LineComponent? = rememberAxisLineComponent(),
+  labelRotationDegrees: Float = Defaults.AXIS_LABEL_ROTATION_DEGREES,
+  valueFormatter: CartesianValueFormatter = remember { CartesianValueFormatter.decimal() },
   tick: LineComponent? = rememberAxisTickComponent(),
   tickLength: Dp = Defaults.AXIS_TICK_LENGTH.dp,
   guideline: LineComponent? = rememberAxisGuidelineComponent(),
-  valueFormatter: CartesianValueFormatter = remember { CartesianValueFormatter.decimal() },
-  sizeConstraint: BaseAxis.SizeConstraint = BaseAxis.SizeConstraint.Auto(),
-  labelRotationDegrees: Float = Defaults.AXIS_LABEL_ROTATION_DEGREES,
+  itemPlacer: HorizontalAxis.ItemPlacer = remember { HorizontalAxis.ItemPlacer.default() },
+  sizeConstraint: BaseAxis.SizeConstraint = remember { BaseAxis.SizeConstraint.Auto() },
   titleComponent: TextComponent? = null,
   title: CharSequence? = null,
-  itemPlacer: AxisItemPlacer.Horizontal = remember { AxisItemPlacer.Horizontal.default() },
 ): HorizontalAxis<AxisPosition.Horizontal.Top> =
-  remember { HorizontalAxis.build<AxisPosition.Horizontal.Top>() }
+  remember { HorizontalAxis.top() }
     .apply {
+      this.line = line
       this.label = label
-      axisLine = axis
-      this.tick = tick
-      this.guideline = guideline
+      this.labelRotationDegrees = labelRotationDegrees
       this.valueFormatter = valueFormatter
+      this.tick = tick
       tickLengthDp = tickLength.value
+      this.guideline = guideline
+      this.itemPlacer = itemPlacer
       this.sizeConstraint = sizeConstraint
-      this.labelRotationDegrees = labelRotationDegrees
       this.titleComponent = titleComponent
       this.title = title
-      this.itemPlacer = itemPlacer
     }
 
-/**
- * Creates and remembers a bottom axis (i.e., a [HorizontalAxis] with
- * [AxisPosition.Horizontal.Bottom]).
- *
- * @param label the [TextComponent] to use for the labels.
- * @param axis the [LineComponent] to use for the axis line.
- * @param tick the [LineComponent] to use for the ticks.
- * @param tickLength the length of the ticks.
- * @param guideline the [LineComponent] to use for the guidelines.
- * @param valueFormatter formats the labels.
- * @param sizeConstraint defines how the [HorizontalAxis] is to size itself.
- * @param titleComponent an optional [TextComponent] to use as the axis title.
- * @param title the axis title.
- * @param labelRotationDegrees the rotation of the axis labels (in degrees).
- * @param itemPlacer determines for what _x_ values the [HorizontalAxis] is to display labels,
- *   ticks, and guidelines.
- */
+/** Creates and remembers a bottom [HorizontalAxis]. */
 @Composable
 public fun rememberBottomAxis(
+  line: LineComponent? = rememberAxisLineComponent(),
   label: TextComponent? = rememberAxisLabelComponent(),
-  axis: LineComponent? = rememberAxisLineComponent(),
+  labelRotationDegrees: Float = Defaults.AXIS_LABEL_ROTATION_DEGREES,
+  valueFormatter: CartesianValueFormatter = remember { CartesianValueFormatter.decimal() },
   tick: LineComponent? = rememberAxisTickComponent(),
   tickLength: Dp = Defaults.AXIS_TICK_LENGTH.dp,
   guideline: LineComponent? = rememberAxisGuidelineComponent(),
-  valueFormatter: CartesianValueFormatter = remember { CartesianValueFormatter.decimal() },
-  sizeConstraint: BaseAxis.SizeConstraint = BaseAxis.SizeConstraint.Auto(),
+  itemPlacer: HorizontalAxis.ItemPlacer = remember { HorizontalAxis.ItemPlacer.default() },
+  sizeConstraint: BaseAxis.SizeConstraint = remember { BaseAxis.SizeConstraint.Auto() },
   titleComponent: TextComponent? = null,
   title: CharSequence? = null,
-  labelRotationDegrees: Float = Defaults.AXIS_LABEL_ROTATION_DEGREES,
-  itemPlacer: AxisItemPlacer.Horizontal = remember { AxisItemPlacer.Horizontal.default() },
 ): HorizontalAxis<AxisPosition.Horizontal.Bottom> =
-  remember { HorizontalAxis.build<AxisPosition.Horizontal.Bottom>() }
+  remember { HorizontalAxis.bottom() }
     .apply {
+      this.line = line
       this.label = label
-      axisLine = axis
-      this.tick = tick
-      this.guideline = guideline
+      this.labelRotationDegrees = labelRotationDegrees
       this.valueFormatter = valueFormatter
+      this.tick = tick
       tickLengthDp = tickLength.value
+      this.guideline = guideline
+      this.itemPlacer = itemPlacer
       this.sizeConstraint = sizeConstraint
-      this.labelRotationDegrees = labelRotationDegrees
       this.titleComponent = titleComponent
       this.title = title
-      this.itemPlacer = itemPlacer
     }
diff --git a/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/axis/VerticalAxis.kt b/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/axis/VerticalAxis.kt
index 7bf942df4..e1eef051d 100644
--- a/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/axis/VerticalAxis.kt
+++ b/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/axis/VerticalAxis.kt
@@ -20,7 +20,6 @@ import androidx.compose.runtime.Composable
 import androidx.compose.runtime.remember
 import androidx.compose.ui.unit.Dp
 import androidx.compose.ui.unit.dp
-import com.patrykandpatrick.vico.core.cartesian.axis.AxisItemPlacer
 import com.patrykandpatrick.vico.core.cartesian.axis.AxisPosition
 import com.patrykandpatrick.vico.core.cartesian.axis.BaseAxis
 import com.patrykandpatrick.vico.core.cartesian.axis.VerticalAxis
@@ -29,108 +28,74 @@ import com.patrykandpatrick.vico.core.common.Defaults
 import com.patrykandpatrick.vico.core.common.component.LineComponent
 import com.patrykandpatrick.vico.core.common.component.TextComponent
 
-/**
- * Creates and remembers a start axis (i.e., a [VerticalAxis] with [AxisPosition.Vertical.Start]).
- *
- * @param label the [TextComponent] to use for the labels.
- * @param axis the [LineComponent] to use for the axis line.
- * @param tick the [LineComponent] to use for the ticks.
- * @param tickLength the length of the ticks.
- * @param guideline the [LineComponent] to use for the guidelines.
- * @param valueFormatter formats the labels.
- * @param sizeConstraint defines how the [VerticalAxis] is to size itself.
- * @param horizontalLabelPosition the horizontal position of the labels.
- * @param verticalLabelPosition the vertical position of the labels.
- * @param itemPlacer determines for what _y_ values the [VerticalAxis] is to display labels, ticks,
- *   and guidelines.
- * @param labelRotationDegrees the rotation of the axis labels (in degrees).
- * @param titleComponent an optional [TextComponent] to use as the axis title.
- * @param title the axis title.
- */
+/** Creates and remembers a start [VerticalAxis]. */
 @Composable
 public fun rememberStartAxis(
+  line: LineComponent? = rememberAxisLineComponent(),
   label: TextComponent? = rememberAxisLabelComponent(),
-  axis: LineComponent? = rememberAxisLineComponent(),
-  tick: LineComponent? = rememberAxisTickComponent(),
-  tickLength: Dp = Defaults.AXIS_TICK_LENGTH.dp,
-  guideline: LineComponent? = rememberAxisGuidelineComponent(),
-  valueFormatter: CartesianValueFormatter = remember { CartesianValueFormatter.decimal() },
-  sizeConstraint: BaseAxis.SizeConstraint = BaseAxis.SizeConstraint.Auto(),
+  labelRotationDegrees: Float = Defaults.AXIS_LABEL_ROTATION_DEGREES,
   horizontalLabelPosition: VerticalAxis.HorizontalLabelPosition =
     VerticalAxis.HorizontalLabelPosition.Outside,
   verticalLabelPosition: VerticalAxis.VerticalLabelPosition =
     VerticalAxis.VerticalLabelPosition.Center,
-  itemPlacer: AxisItemPlacer.Vertical = remember { AxisItemPlacer.Vertical.step() },
-  labelRotationDegrees: Float = Defaults.AXIS_LABEL_ROTATION_DEGREES,
+  valueFormatter: CartesianValueFormatter = remember { CartesianValueFormatter.decimal() },
+  tick: LineComponent? = rememberAxisTickComponent(),
+  tickLength: Dp = Defaults.AXIS_TICK_LENGTH.dp,
+  guideline: LineComponent? = rememberAxisGuidelineComponent(),
+  itemPlacer: VerticalAxis.ItemPlacer = remember { VerticalAxis.ItemPlacer.step() },
+  sizeConstraint: BaseAxis.SizeConstraint = remember { BaseAxis.SizeConstraint.Auto() },
   titleComponent: TextComponent? = null,
   title: CharSequence? = null,
 ): VerticalAxis<AxisPosition.Vertical.Start> =
-  remember { VerticalAxis.build<AxisPosition.Vertical.Start>() }
+  remember { VerticalAxis.start() }
     .apply {
+      this.line = line
       this.label = label
-      axisLine = axis
-      this.tick = tick
-      this.guideline = guideline
-      this.valueFormatter = valueFormatter
-      tickLengthDp = tickLength.value
-      this.sizeConstraint = sizeConstraint
+      this.labelRotationDegrees = labelRotationDegrees
       this.horizontalLabelPosition = horizontalLabelPosition
       this.verticalLabelPosition = verticalLabelPosition
+      this.valueFormatter = valueFormatter
+      this.tick = tick
+      tickLengthDp = tickLength.value
+      this.guideline = guideline
       this.itemPlacer = itemPlacer
-      this.labelRotationDegrees = labelRotationDegrees
+      this.sizeConstraint = sizeConstraint
       this.titleComponent = titleComponent
       this.title = title
     }
 
-/**
- * Creates and remembers an end axis (i.e., a [VerticalAxis] with [AxisPosition.Vertical.End]).
- *
- * @param label the [TextComponent] to use for the labels.
- * @param axis the [LineComponent] to use for the axis line.
- * @param tick the [LineComponent] to use for the ticks.
- * @param tickLength the length of the ticks.
- * @param guideline the [LineComponent] to use for the guidelines.
- * @param valueFormatter formats the labels.
- * @param sizeConstraint defines how the [VerticalAxis] is to size itself.
- * @param horizontalLabelPosition the horizontal position of the labels.
- * @param verticalLabelPosition the vertical position of the labels.
- * @param itemPlacer determines for what _y_ values the [VerticalAxis] is to display labels, ticks,
- *   and guidelines.
- * @param labelRotationDegrees the rotation of the axis labels (in degrees).
- * @param titleComponent an optional [TextComponent] to use as the axis title.
- * @param title the axis title.
- */
+/** Creates and remembers an end [VerticalAxis]. */
 @Composable
 public fun rememberEndAxis(
+  line: LineComponent? = rememberAxisLineComponent(),
   label: TextComponent? = rememberAxisLabelComponent(),
-  axis: LineComponent? = rememberAxisLineComponent(),
-  tick: LineComponent? = rememberAxisTickComponent(),
-  tickLength: Dp = Defaults.AXIS_TICK_LENGTH.dp,
-  guideline: LineComponent? = rememberAxisGuidelineComponent(),
-  valueFormatter: CartesianValueFormatter = remember { CartesianValueFormatter.decimal() },
-  sizeConstraint: BaseAxis.SizeConstraint = BaseAxis.SizeConstraint.Auto(),
+  labelRotationDegrees: Float = Defaults.AXIS_LABEL_ROTATION_DEGREES,
   horizontalLabelPosition: VerticalAxis.HorizontalLabelPosition =
     VerticalAxis.HorizontalLabelPosition.Outside,
   verticalLabelPosition: VerticalAxis.VerticalLabelPosition =
     VerticalAxis.VerticalLabelPosition.Center,
-  itemPlacer: AxisItemPlacer.Vertical = remember { AxisItemPlacer.Vertical.step() },
-  labelRotationDegrees: Float = Defaults.AXIS_LABEL_ROTATION_DEGREES,
+  valueFormatter: CartesianValueFormatter = remember { CartesianValueFormatter.decimal() },
+  tick: LineComponent? = rememberAxisTickComponent(),
+  tickLength: Dp = Defaults.AXIS_TICK_LENGTH.dp,
+  guideline: LineComponent? = rememberAxisGuidelineComponent(),
+  itemPlacer: VerticalAxis.ItemPlacer = remember { VerticalAxis.ItemPlacer.step() },
+  sizeConstraint: BaseAxis.SizeConstraint = remember { BaseAxis.SizeConstraint.Auto() },
   titleComponent: TextComponent? = null,
   title: CharSequence? = null,
 ): VerticalAxis<AxisPosition.Vertical.End> =
-  remember { VerticalAxis.build<AxisPosition.Vertical.End>() }
+  remember { VerticalAxis.end() }
     .apply {
+      this.line = line
       this.label = label
-      axisLine = axis
-      this.tick = tick
-      this.guideline = guideline
-      this.valueFormatter = valueFormatter
-      tickLengthDp = tickLength.value
-      this.sizeConstraint = sizeConstraint
+      this.labelRotationDegrees = labelRotationDegrees
       this.horizontalLabelPosition = horizontalLabelPosition
       this.verticalLabelPosition = verticalLabelPosition
+      this.valueFormatter = valueFormatter
+      this.tick = tick
+      tickLengthDp = tickLength.value
+      this.guideline = guideline
       this.itemPlacer = itemPlacer
-      this.labelRotationDegrees = labelRotationDegrees
+      this.sizeConstraint = sizeConstraint
       this.titleComponent = titleComponent
       this.title = title
     }
diff --git a/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/decoration/HorizontalBox.kt b/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/decoration/HorizontalBox.kt
index ce01d3014..63f82661a 100644
--- a/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/decoration/HorizontalBox.kt
+++ b/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/decoration/HorizontalBox.kt
@@ -26,10 +26,10 @@ import com.patrykandpatrick.vico.core.common.component.ShapeComponent
 import com.patrykandpatrick.vico.core.common.component.TextComponent
 import com.patrykandpatrick.vico.core.common.data.ExtraStore
 
-/** Creates and remembers a [HorizontalBox] */
+/** Creates and remembers a [HorizontalBox]. */
 @Composable
 public fun rememberHorizontalBox(
-  y: (ExtraStore) -> ClosedFloatingPointRange<Float>,
+  y: (ExtraStore) -> ClosedFloatingPointRange<Double>,
   box: ShapeComponent,
   labelComponent: TextComponent? = null,
   label: (ExtraStore) -> CharSequence = { HorizontalBox.getLabel(y(it)) },
diff --git a/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/decoration/HorizontalLine.kt b/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/decoration/HorizontalLine.kt
index 1e46ee407..7f9d2cde2 100644
--- a/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/decoration/HorizontalLine.kt
+++ b/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/decoration/HorizontalLine.kt
@@ -26,10 +26,10 @@ import com.patrykandpatrick.vico.core.common.component.LineComponent
 import com.patrykandpatrick.vico.core.common.component.TextComponent
 import com.patrykandpatrick.vico.core.common.data.ExtraStore
 
-/** Creates and remembers a [HorizontalLine] */
+/** Creates and remembers a [HorizontalLine]. */
 @Composable
 public fun rememberHorizontalLine(
-  y: (ExtraStore) -> Float,
+  y: (ExtraStore) -> Double,
   line: LineComponent,
   labelComponent: TextComponent? = null,
   label: (ExtraStore) -> CharSequence = { HorizontalLine.getLabel(y(it)) },
diff --git a/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/layer/Candle.kt b/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/layer/Candle.kt
index a9d35354a..ae6384ff9 100644
--- a/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/layer/Candle.kt
+++ b/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/layer/Candle.kt
@@ -43,14 +43,14 @@ private fun Candle.Companion.sharpFilledCandle(
 private fun Candle.Companion.sharpHollowCandle(
   color: Color,
   thickness: Dp = Defaults.CANDLE_BODY_WIDTH_DP.dp,
-  strokeWidth: Dp = Defaults.HOLLOW_CANDLE_STROKE_WIDTH_DP.dp,
+  strokeThickness: Dp = Defaults.HOLLOW_CANDLE_STROKE_THICKNESS_DP.dp,
 ) =
   rememberCandle(
     rememberLineComponent(
       color = Color.Transparent,
       thickness = thickness,
-      strokeWidth = strokeWidth,
       strokeColor = color,
+      strokeThickness = strokeThickness,
     )
   )
 
diff --git a/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/layer/ColumnCartesianLayer.kt b/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/layer/ColumnCartesianLayer.kt
index 4b99a6441..b8ef334fa 100644
--- a/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/layer/ColumnCartesianLayer.kt
+++ b/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/layer/ColumnCartesianLayer.kt
@@ -49,9 +49,8 @@ public fun rememberColumnCartesianLayer(
         )
       }
     ),
-  spacing: Dp = Defaults.COLUMN_OUTSIDE_SPACING.dp,
-  innerSpacing: Dp = Defaults.COLUMN_INSIDE_SPACING.dp,
-  mergeMode: (ExtraStore) -> MergeMode = { MergeMode.Grouped },
+  columnCollectionSpacing: Dp = Defaults.COLUMN_COLLECTION_SPACING.dp,
+  mergeMode: (ExtraStore) -> MergeMode = { MergeMode.grouped() },
   verticalAxisPosition: AxisPosition.Vertical? = null,
   dataLabel: TextComponent? = null,
   dataLabelVerticalPosition: VerticalPosition = VerticalPosition.Top,
@@ -70,8 +69,7 @@ public fun rememberColumnCartesianLayer(
   remember { ColumnCartesianLayer(columnProvider) }
     .apply {
       this.columnProvider = columnProvider
-      this.spacingDp = spacing.value
-      this.innerSpacingDp = innerSpacing.value
+      this.columnCollectionSpacingDp = columnCollectionSpacing.value
       this.mergeMode = mergeMode
       this.dataLabel = dataLabel
       this.dataLabelVerticalPosition = dataLabelVerticalPosition
@@ -81,3 +79,11 @@ public fun rememberColumnCartesianLayer(
       this.verticalAxisPosition = verticalAxisPosition
       this.drawingModelInterpolator = drawingModelInterpolator
     }
+
+/** Creates a [MergeMode.Grouped] instance. */
+public fun MergeMode.Companion.grouped(
+  columnSpacing: Dp = Defaults.GROUPED_COLUMN_SPACING.dp
+): MergeMode.Grouped = MergeMode.Grouped(columnSpacing.value)
+
+/** Returns a [MergeMode.Stacked] instance. */
+public fun MergeMode.Companion.stacked(): MergeMode.Stacked = MergeMode.Stacked
diff --git a/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/layer/LineCartesianLayer.kt b/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/layer/LineCartesianLayer.kt
index b3bfde9eb..fe0f12a45 100644
--- a/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/layer/LineCartesianLayer.kt
+++ b/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/layer/LineCartesianLayer.kt
@@ -24,18 +24,14 @@ import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.StrokeCap
 import androidx.compose.ui.unit.Dp
 import androidx.compose.ui.unit.dp
-import com.patrykandpatrick.vico.compose.common.shader.BrushShader
 import com.patrykandpatrick.vico.compose.common.shader.color
+import com.patrykandpatrick.vico.compose.common.shader.toDynamicShader
 import com.patrykandpatrick.vico.compose.common.vicoTheme
-import com.patrykandpatrick.vico.core.cartesian.DefaultPointConnector
 import com.patrykandpatrick.vico.core.cartesian.axis.AxisPosition
-import com.patrykandpatrick.vico.core.cartesian.axis.VerticalAxis
 import com.patrykandpatrick.vico.core.cartesian.data.AxisValueOverrider
 import com.patrykandpatrick.vico.core.cartesian.data.CartesianValueFormatter
 import com.patrykandpatrick.vico.core.cartesian.data.LineCartesianLayerDrawingModel
-import com.patrykandpatrick.vico.core.cartesian.layer.CartesianLayer
 import com.patrykandpatrick.vico.core.cartesian.layer.LineCartesianLayer
-import com.patrykandpatrick.vico.core.cartesian.layer.LineCartesianLayer.LineSpec
 import com.patrykandpatrick.vico.core.common.DefaultAlpha
 import com.patrykandpatrick.vico.core.common.Defaults
 import com.patrykandpatrick.vico.core.common.VerticalPosition
@@ -47,25 +43,14 @@ import com.patrykandpatrick.vico.core.common.shader.ColorShader
 import com.patrykandpatrick.vico.core.common.shader.DynamicShader
 import com.patrykandpatrick.vico.core.common.shader.TopBottomShader
 
-/**
- * Creates a [LineCartesianLayer].
- *
- * @param lines the [LineCartesianLayer.LineSpec]s to use for the lines. This list is iterated
- *   through as many times as there are lines.
- * @param spacing the distance between neighboring major entries’ points.
- * @param axisValueOverrider overrides the _x_ and _y_ ranges.
- * @param verticalAxisPosition the position of the [VerticalAxis] with which the
- *   [LineCartesianLayer] should be associated. Use this for independent [CartesianLayer] scaling.
- * @param drawingModelInterpolator interpolates the [LineCartesianLayer]’s
- *   [LineCartesianLayerDrawingModel]s.
- */
+/** Creates and remembers a [LineCartesianLayer]. */
 @Composable
 public fun rememberLineCartesianLayer(
-  lines: List<LineSpec> =
-    vicoTheme.lineCartesianLayerColors.map {
-      rememberLineSpec(remember { DynamicShader.color(it) })
-    },
-  spacing: Dp = Defaults.POINT_SPACING.dp,
+  lineProvider: LineCartesianLayer.LineProvider =
+    LineCartesianLayer.LineProvider.series(
+      vicoTheme.lineCartesianLayerColors.map { rememberLine(DynamicShader.color(it)) }
+    ),
+  pointSpacing: Dp = Defaults.POINT_SPACING.dp,
   axisValueOverrider: AxisValueOverrider = remember { AxisValueOverrider.auto() },
   verticalAxisPosition: AxisPosition.Vertical? = null,
   drawingModelInterpolator:
@@ -77,97 +62,85 @@ public fun rememberLineCartesianLayer(
       DefaultDrawingModelInterpolator()
     },
 ): LineCartesianLayer =
-  remember { LineCartesianLayer(lines) }
+  remember { LineCartesianLayer(lineProvider) }
     .apply {
-      this.lines = lines
-      this.spacingDp = spacing.value
+      this.lineProvider = lineProvider
+      this.pointSpacingDp = pointSpacing.value
       this.axisValueOverrider = axisValueOverrider
       this.verticalAxisPosition = verticalAxisPosition
       this.drawingModelInterpolator = drawingModelInterpolator
     }
 
-/**
- * Creates and remembers a [LineCartesianLayer.LineSpec] for use in [LineCartesianLayer]s.
- *
- * @param shader the [DynamicShader] for the line.
- * @param thickness the thickness of the line.
- * @param backgroundShader an optional [DynamicShader] to use for the areas bounded by the
- *   [LineCartesianLayer] line and the zero line (_y_ = 0).
- * @param cap the stroke cap for the line.
- * @param point an optional [Component] that can be drawn at a given point on the line.
- * @param pointSize the size of the [point].
- * @param dataLabel an optional [TextComponent] to use for data labels.
- * @param dataLabelVerticalPosition the vertical position of data labels relative to the line.
- * @param dataLabelValueFormatter the [CartesianValueFormatter] to use for data labels.
- * @param dataLabelRotationDegrees the rotation of data labels in degrees.
- * @param pointConnector the [LineSpec.PointConnector] for the line.
- */
+/** Creates and remembers a [LineCartesianLayer.Line]. */
 @Composable
-public fun rememberLineSpec(
-  shader: DynamicShader = DynamicShader.color(Color.Black),
+public fun rememberLine(
+  shader: DynamicShader = DynamicShader.color(vicoTheme.lineCartesianLayerColors.first()),
   thickness: Dp = Defaults.LINE_SPEC_THICKNESS_DP.dp,
   backgroundShader: DynamicShader? = shader.getDefaultBackgroundShader(),
   cap: StrokeCap = StrokeCap.Round,
-  point: Component? = null,
-  pointSize: Dp = Defaults.POINT_SIZE.dp,
+  pointProvider: LineCartesianLayer.PointProvider? = null,
+  pointConnector: LineCartesianLayer.PointConnector = remember {
+    LineCartesianLayer.PointConnector.cubic()
+  },
   dataLabel: TextComponent? = null,
   dataLabelVerticalPosition: VerticalPosition = VerticalPosition.Top,
   dataLabelValueFormatter: CartesianValueFormatter = remember { CartesianValueFormatter.decimal() },
   dataLabelRotationDegrees: Float = 0f,
-  pointConnector: LineSpec.PointConnector = DefaultPointConnector(),
-): LineSpec =
+): LineCartesianLayer.Line =
   remember(
     shader,
     thickness,
     backgroundShader,
     cap,
-    point,
-    pointSize,
+    pointProvider,
+    pointConnector,
     dataLabel,
     dataLabelVerticalPosition,
     dataLabelRotationDegrees,
     dataLabelRotationDegrees,
-    pointConnector,
   ) {
-    LineSpec(
-      shader = shader,
-      thicknessDp = thickness.value,
-      backgroundShader = backgroundShader,
-      cap = cap.paintCap,
-      point = point,
-      pointSizeDp = pointSize.value,
-      dataLabel = dataLabel,
-      dataLabelVerticalPosition = dataLabelVerticalPosition,
-      dataLabelValueFormatter = dataLabelValueFormatter,
-      dataLabelRotationDegrees = dataLabelRotationDegrees,
-      pointConnector = pointConnector,
+    LineCartesianLayer.Line(
+      shader,
+      thickness.value,
+      backgroundShader,
+      cap.paintCap,
+      pointProvider,
+      pointConnector,
+      dataLabel,
+      dataLabelVerticalPosition,
+      dataLabelValueFormatter,
+      dataLabelRotationDegrees,
     )
   }
 
+/** Creates and remembers a [LineCartesianLayer.Point]. */
+@Composable
+public fun rememberPoint(
+  component: Component,
+  size: Dp = Defaults.POINT_SIZE.dp,
+): LineCartesianLayer.Point =
+  remember(component, size) { LineCartesianLayer.Point(component, size.value) }
+
 internal fun DynamicShader.getDefaultBackgroundShader(): DynamicShader? =
   when (this) {
     is ColorShader ->
       TopBottomShader(
         topShader =
-          BrushShader(
-            brush =
-              Brush.verticalGradient(
-                listOf(
-                  Color(color).copy(alpha = DefaultAlpha.LINE_BACKGROUND_SHADER_START),
-                  Color(color).copy(alpha = DefaultAlpha.LINE_BACKGROUND_SHADER_END),
-                )
+          Brush.verticalGradient(
+              listOf(
+                Color(color).copy(DefaultAlpha.LINE_BACKGROUND_SHADER_START),
+                Color(color).copy(DefaultAlpha.LINE_BACKGROUND_SHADER_END),
               )
-          ),
+            )
+            .toDynamicShader(),
         bottomShader =
-          BrushShader(
-            brush =
-              Brush.verticalGradient(
-                listOf(
-                  Color(color).copy(alpha = DefaultAlpha.LINE_BACKGROUND_SHADER_END),
-                  Color(color).copy(alpha = DefaultAlpha.LINE_BACKGROUND_SHADER_START),
-                )
+          Brush.verticalGradient(
+              listOf(
+                Color(color).copy(DefaultAlpha.LINE_BACKGROUND_SHADER_END),
+                Color(color).copy(DefaultAlpha.LINE_BACKGROUND_SHADER_START),
               )
-          ),
+            )
+            .toDynamicShader(),
       )
     is TopBottomShader -> {
       val topShader = topShader
@@ -175,26 +148,21 @@ internal fun DynamicShader.getDefaultBackgroundShader(): DynamicShader? =
       if (topShader is ColorShader && bottomShader is ColorShader) {
         TopBottomShader(
           topShader =
-            BrushShader(
-              brush =
-                Brush.verticalGradient(
-                  listOf(
-                    Color(topShader.color).copy(alpha = DefaultAlpha.LINE_BACKGROUND_SHADER_START),
-                    Color(topShader.color).copy(alpha = DefaultAlpha.LINE_BACKGROUND_SHADER_END),
-                  )
+            Brush.verticalGradient(
+                listOf(
+                  Color(topShader.color).copy(DefaultAlpha.LINE_BACKGROUND_SHADER_START),
+                  Color(topShader.color).copy(DefaultAlpha.LINE_BACKGROUND_SHADER_END),
                 )
-            ),
+              )
+              .toDynamicShader(),
           bottomShader =
-            BrushShader(
-              brush =
-                Brush.verticalGradient(
-                  listOf(
-                    Color(bottomShader.color).copy(alpha = DefaultAlpha.LINE_BACKGROUND_SHADER_END),
-                    Color(bottomShader.color)
-                      .copy(alpha = DefaultAlpha.LINE_BACKGROUND_SHADER_START),
-                  )
+            Brush.verticalGradient(
+                listOf(
+                  Color(bottomShader.color).copy(DefaultAlpha.LINE_BACKGROUND_SHADER_END),
+                  Color(bottomShader.color).copy(DefaultAlpha.LINE_BACKGROUND_SHADER_START),
                 )
-            ),
+              )
+              .toDynamicShader(),
         )
       } else {
         null
diff --git a/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/layer/SplitLineSpec.kt b/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/layer/SplitLine.kt
similarity index 85%
rename from vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/layer/SplitLineSpec.kt
rename to vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/layer/SplitLine.kt
index c4438e225..1704197e3 100644
--- a/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/layer/SplitLineSpec.kt
+++ b/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/layer/SplitLine.kt
@@ -24,43 +24,37 @@ import androidx.compose.ui.graphics.StrokeCap
 import androidx.compose.ui.unit.Dp
 import androidx.compose.ui.unit.dp
 import com.patrykandpatrick.vico.compose.common.shader.color
-import com.patrykandpatrick.vico.core.cartesian.DefaultPointConnector
 import com.patrykandpatrick.vico.core.cartesian.data.CartesianValueFormatter
 import com.patrykandpatrick.vico.core.cartesian.layer.LineCartesianLayer
-import com.patrykandpatrick.vico.core.cartesian.layer.spec.SplitLineSpec
+import com.patrykandpatrick.vico.core.cartesian.layer.spec.SplitLine
 import com.patrykandpatrick.vico.core.common.Defaults
 import com.patrykandpatrick.vico.core.common.VerticalPosition
-import com.patrykandpatrick.vico.core.common.component.Component
 import com.patrykandpatrick.vico.core.common.component.TextComponent
 import com.patrykandpatrick.vico.core.common.shader.DynamicShader
 
-/**
- * TODO
- */
 @Composable
-public fun rememberSplitLineSpec(
+public fun rememberSplitLine(
   shader: DynamicShader = DynamicShader.color(Color.Black),
   thickness: Dp = Defaults.LINE_SPEC_THICKNESS_DP.dp,
   backgroundShaderFirst: DynamicShader? = shader.getDefaultBackgroundShader(),
   backgroundShaderSecond: DynamicShader? = shader.getDefaultBackgroundShader(),
   cap: StrokeCap = StrokeCap.Round,
-  point: Component? = null,
-  pointSize: Dp = Defaults.POINT_SIZE.dp,
+  pointProvider: LineCartesianLayer.PointProvider? = null,
+  pointConnector: LineCartesianLayer.PointConnector = remember {
+    LineCartesianLayer.PointConnector.cubic()
+  },
   dataLabel: TextComponent? = null,
   dataLabelVerticalPosition: VerticalPosition = VerticalPosition.Top,
   dataLabelValueFormatter: CartesianValueFormatter = remember { CartesianValueFormatter.decimal() },
   dataLabelRotationDegrees: Float = 0f,
-  pointConnector: LineCartesianLayer.LineSpec.PointConnector = DefaultPointConnector(),
   @FloatRange(from = 0.0, to = 1.0) xSplitFraction: Float = 0f,
-): LineCartesianLayer.LineSpec =
+): LineCartesianLayer.Line =
   remember(
     shader,
     thickness,
     backgroundShaderFirst,
     backgroundShaderSecond,
     cap,
-    point,
-    pointSize,
     dataLabel,
     dataLabelVerticalPosition,
     dataLabelRotationDegrees,
@@ -68,14 +62,13 @@ public fun rememberSplitLineSpec(
     pointConnector,
     xSplitFraction
   ) {
-    SplitLineSpec(
+    SplitLine(
       shader = shader,
       thicknessDp = thickness.value,
       backgroundShaderFirst = backgroundShaderFirst,
       backgroundShaderSecond = backgroundShaderSecond,
       cap = cap.paintCap,
-      point = point,
-      pointSizeDp = pointSize.value,
+      pointProvider = pointProvider,
       dataLabel = dataLabel,
       dataLabelVerticalPosition = dataLabelVerticalPosition,
       dataLabelValueFormatter = dataLabelValueFormatter,
diff --git a/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/marker/DefaultCartesianMarker.kt b/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/marker/DefaultCartesianMarker.kt
index 3f825db73..2b36c3dcf 100644
--- a/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/marker/DefaultCartesianMarker.kt
+++ b/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/cartesian/marker/DefaultCartesianMarker.kt
@@ -18,6 +18,7 @@ package com.patrykandpatrick.vico.compose.cartesian.marker
 
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.remember
+import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.unit.Dp
 import androidx.compose.ui.unit.dp
 import com.patrykandpatrick.vico.core.cartesian.marker.CartesianMarkerValueFormatter
@@ -36,7 +37,7 @@ public fun rememberDefaultCartesianMarker(
     DefaultCartesianMarkerValueFormatter()
   },
   labelPosition: DefaultCartesianMarker.LabelPosition = DefaultCartesianMarker.LabelPosition.Top,
-  indicator: Component? = null,
+  indicator: ((Color) -> Component)? = null,
   indicatorSize: Dp = Defaults.MARKER_INDICATOR_SIZE.dp,
   setIndicatorColor: ((Int) -> Unit)? = null,
   guideline: LineComponent? = null,
@@ -51,12 +52,11 @@ public fun rememberDefaultCartesianMarker(
     guideline,
   ) {
     DefaultCartesianMarker(
-      label,
-      valueFormatter,
-      labelPosition,
-      indicator,
-      indicatorSize.value,
-      setIndicatorColor,
-      guideline,
+      label = label,
+      valueFormatter = valueFormatter,
+      labelPosition = labelPosition,
+      indicator = if (indicator != null) ({ indicator(Color(it)) }) else null,
+      indicatorSizeDp = indicatorSize.value,
+      guideline = guideline,
     )
   }
diff --git a/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/common/Dimensions.kt b/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/common/Dimensions.kt
index 46b8e7154..ef4ce608f 100644
--- a/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/common/Dimensions.kt
+++ b/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/common/Dimensions.kt
@@ -16,21 +16,18 @@
 
 package com.patrykandpatrick.vico.compose.common
 
-import androidx.compose.runtime.Stable
 import androidx.compose.ui.unit.Dp
 import androidx.compose.ui.unit.dp
 import com.patrykandpatrick.vico.core.common.Dimensions
 
 /** Creates a [Dimensions] instance with a common value for each coordinate. */
-@Stable public fun Dimensions.Companion.of(all: Dp): Dimensions = Dimensions(all.value)
+public fun Dimensions.Companion.of(all: Dp): Dimensions = Dimensions(all.value)
 
 /** Creates a [Dimensions] instance using the provided measurements. */
-@Stable
 public fun Dimensions.Companion.of(horizontal: Dp = 0.dp, vertical: Dp = 0.dp): Dimensions =
   Dimensions(horizontal.value, vertical.value)
 
 /** Creates a [Dimensions] instance using the provided measurements. */
-@Stable
 public fun Dimensions.Companion.of(
   start: Dp = 0.dp,
   top: Dp = 0.dp,
diff --git a/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/common/Legends.kt b/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/common/Legends.kt
index 7a3c6e436..dc70134d1 100644
--- a/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/common/Legends.kt
+++ b/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/common/Legends.kt
@@ -23,23 +23,13 @@ import androidx.compose.ui.unit.dp
 import com.patrykandpatrick.vico.core.common.Dimensions
 import com.patrykandpatrick.vico.core.common.DrawContext
 import com.patrykandpatrick.vico.core.common.HorizontalLegend
-import com.patrykandpatrick.vico.core.common.Legend
 import com.patrykandpatrick.vico.core.common.LegendItem
 import com.patrykandpatrick.vico.core.common.MeasureContext
 import com.patrykandpatrick.vico.core.common.VerticalLegend
 import com.patrykandpatrick.vico.core.common.component.Component
 import com.patrykandpatrick.vico.core.common.component.TextComponent
 
-/**
- * Creates a [VerticalLegend].
- *
- * @param items a [Collection] of [LegendItem]s to be displayed by this [VerticalLegend].
- * @param iconSize defines the size of all [LegendItem.icon]s.
- * @param iconPadding defines the padding between each [LegendItem.icon] and its corresponding
- *   [LegendItem.label].
- * @param spacing defines the vertical spacing between each [LegendItem].
- * @param padding defines the padding of the content.
- */
+/** Creates and remembers a [VerticalLegend]. */
 @Composable
 public fun <M : MeasureContext, D : DrawContext> rememberVerticalLegend(
   items: Collection<LegendItem>,
@@ -58,32 +48,15 @@ public fun <M : MeasureContext, D : DrawContext> rememberVerticalLegend(
     )
   }
 
-/**
- * Defines the appearance of an item of a [Legend].
- *
- * @param icon the [Component] used as the item’s icon.
- * @param label the [TextComponent] used for the label.
- * @param labelText the text content of the label.
- */
+/** Creates and remembers a [LegendItem]. */
 @Composable
 public fun rememberLegendItem(
   icon: Component,
-  label: TextComponent,
-  labelText: CharSequence,
-): LegendItem =
-  remember(icon, label, labelText) { LegendItem(icon = icon, label = label, labelText = labelText) }
+  labelComponent: TextComponent,
+  label: CharSequence,
+): LegendItem = remember(icon, labelComponent, label) { LegendItem(icon, labelComponent, label) }
 
-/**
- * Creates a [HorizontalLegend].
- *
- * @param items a [Collection] of [LegendItem]s to be displayed by this [HorizontalLegend].
- * @param iconSize defines the size of all [LegendItem.icon]s.
- * @param iconPadding defines the padding between each [LegendItem.icon] and its corresponding
- *   [LegendItem.label].
- * @param lineSpacing defines the spacing between adjacent lines.
- * @param spacing defines the horizontal spacing between adjacent [LegendItem]s.
- * @param padding defines the padding of the content.
- */
+/** Creates and remembers a [HorizontalLegend]. */
 @Composable
 public fun <M : MeasureContext, D : DrawContext> rememberHorizontalLegend(
   items: Collection<LegendItem>,
diff --git a/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/common/VicoTheme.kt b/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/common/VicoTheme.kt
index 7e099c6a1..3029110fb 100644
--- a/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/common/VicoTheme.kt
+++ b/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/common/VicoTheme.kt
@@ -35,8 +35,7 @@ import com.patrykandpatrick.vico.core.common.component.LineComponent
  *
  * @param candlestickCartesianLayerColors houses default [CandlestickCartesianLayer.Candle] colors.
  * @param columnCartesianLayerColors used for [ColumnCartesianLayer]&#0020;[LineComponent]s.
- * @param lineCartesianLayerColors used for [LineCartesianLayer.LineSpec]s.
- * @param elevationOverlayColor used for elevation overlays.
+ * @param lineCartesianLayerColors used for [LineCartesianLayer.Line]s.
  * @param lineColor used for [HorizontalAxis] and [VerticalAxis] lines.
  * @param textColor used for [HorizontalAxis] and [VerticalAxis] labels.
  */
@@ -44,7 +43,6 @@ public data class VicoTheme(
   val candlestickCartesianLayerColors: CandlestickCartesianLayerColors,
   val columnCartesianLayerColors: List<Color>,
   val lineCartesianLayerColors: List<Color> = columnCartesianLayerColors,
-  val elevationOverlayColor: Color,
   val lineColor: Color,
   val textColor: Color,
 ) {
@@ -78,7 +76,6 @@ public data class VicoTheme(
         candlestickCartesianLayerColors =
           CandlestickCartesianLayerColors.fromDefaultColors(defaultColors),
         columnCartesianLayerColors = defaultColors.cartesianLayerColors.map(::Color),
-        elevationOverlayColor = Color(defaultColors.elevationOverlayColor),
         lineColor = Color(defaultColors.lineColor),
         textColor = Color(defaultColors.textColor),
       )
diff --git a/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/common/component/Components.kt b/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/common/component/Components.kt
index 92006a9a2..aa0c35246 100644
--- a/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/common/component/Components.kt
+++ b/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/common/component/Components.kt
@@ -21,9 +21,7 @@ import android.graphics.Typeface
 import android.text.Layout
 import android.text.TextUtils
 import androidx.compose.runtime.Composable
-import androidx.compose.runtime.Stable
 import androidx.compose.runtime.remember
-import androidx.compose.ui.graphics.Brush
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.toArgb
 import androidx.compose.ui.unit.Dp
@@ -31,79 +29,76 @@ import androidx.compose.ui.unit.TextUnit
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
 import com.patrykandpatrick.vico.compose.common.pixelSize
-import com.patrykandpatrick.vico.compose.common.shader.toDynamicShader
 import com.patrykandpatrick.vico.core.common.Defaults
 import com.patrykandpatrick.vico.core.common.Dimensions
 import com.patrykandpatrick.vico.core.common.LayeredComponent
 import com.patrykandpatrick.vico.core.common.component.Component
 import com.patrykandpatrick.vico.core.common.component.LineComponent
+import com.patrykandpatrick.vico.core.common.component.Shadow
 import com.patrykandpatrick.vico.core.common.component.ShapeComponent
 import com.patrykandpatrick.vico.core.common.component.TextComponent
 import com.patrykandpatrick.vico.core.common.shader.DynamicShader
 import com.patrykandpatrick.vico.core.common.shape.Shape
 
-/** Creates and remembers a [LineComponent] with the specified properties. */
+/** Creates and remembers a [LineComponent]. */
 @Composable
 public fun rememberLineComponent(
   color: Color = Color.Black,
   thickness: Dp = Defaults.LINE_COMPONENT_THICKNESS_DP.dp,
   shape: Shape = Shape.Rectangle,
-  dynamicShader: DynamicShader? = null,
   margins: Dimensions = Dimensions.Empty,
-  strokeWidth: Dp = 0.dp,
   strokeColor: Color = Color.Transparent,
+  strokeThickness: Dp = 0.dp,
+  shader: DynamicShader? = null,
+  shadow: Shadow? = null,
 ): LineComponent =
-  remember(color, thickness, shape, dynamicShader, margins, strokeWidth, strokeColor) {
+  remember(color, shape, thickness, margins, strokeColor, strokeThickness, shader, shadow) {
     LineComponent(
-      color = color.toArgb(),
-      thicknessDp = thickness.value,
-      shape = shape,
-      dynamicShader = dynamicShader,
-      margins = margins,
-      strokeWidthDp = strokeWidth.value,
-      strokeColor = strokeColor.toArgb(),
+      color.toArgb(),
+      thickness.value,
+      shape,
+      margins,
+      strokeColor.toArgb(),
+      strokeThickness.value,
+      shader,
+      shadow,
     )
   }
 
-/** Creates and remembers a [ShapeComponent] with the specified properties. */
-@Composable
-public fun rememberShapeComponent(
-  shape: Shape = Shape.Rectangle,
+/** Creates a [ShapeComponent]. */
+public fun shapeComponent(
   color: Color = Color.Black,
-  dynamicShader: DynamicShader? = null,
+  shape: Shape = Shape.Rectangle,
   margins: Dimensions = Dimensions.Empty,
-  strokeWidth: Dp = 0.dp,
   strokeColor: Color = Color.Transparent,
+  strokeThickness: Dp = 0.dp,
+  shader: DynamicShader? = null,
+  shadow: Shadow? = null,
 ): ShapeComponent =
-  remember(shape, color, dynamicShader, margins, strokeWidth, strokeColor) {
-    ShapeComponent(
-      shape = shape,
-      color = color.toArgb(),
-      dynamicShader = dynamicShader,
-      margins = margins,
-      strokeWidthDp = strokeWidth.value,
-      strokeColor = strokeColor.toArgb(),
-    )
-  }
+  ShapeComponent(
+    color.toArgb(),
+    shape,
+    margins,
+    strokeColor.toArgb(),
+    strokeThickness.value,
+    shader,
+    shadow,
+  )
 
-/** Creates and remembers a [ShapeComponent] with the specified properties. */
+/** Creates and remembers a [ShapeComponent]. */
 @Composable
 public fun rememberShapeComponent(
-  shape: Shape = Shape.Rectangle,
   color: Color = Color.Black,
-  brush: Brush,
+  shape: Shape = Shape.Rectangle,
   margins: Dimensions = Dimensions.Empty,
-  strokeWidth: Dp = 0.dp,
   strokeColor: Color = Color.Transparent,
+  strokeThickness: Dp = 0.dp,
+  shader: DynamicShader? = null,
+  shadow: Shadow? = null,
 ): ShapeComponent =
-  rememberShapeComponent(
-    shape = shape,
-    color = color,
-    dynamicShader = brush.toDynamicShader(),
-    margins = margins,
-    strokeWidth = strokeWidth,
-    strokeColor = strokeColor,
-  )
+  remember(color, shape, margins, strokeColor, strokeThickness, shader, shadow) {
+    shapeComponent(color, shape, margins, strokeColor, strokeThickness, shader, shadow)
+  }
 
 /** Creates and remembers a [LayeredComponent]. */
 @Composable
@@ -115,86 +110,55 @@ public fun rememberLayeredComponent(
 ): LayeredComponent =
   remember(rear, front, padding, margins) { LayeredComponent(rear, front, padding, margins) }
 
-/**
- * Creates and remembers a [TextComponent].
- *
- * @param color the text color.
- * @param textSize the text size.
- * @param background an optional [ShapeComponent] to be displayed behind the text.
- * @param ellipsize the text truncation behavior.
- * @param lineCount the line count.
- * @param padding the padding between the text and the background.
- * @param margins the margins around the background.
- * @param typeface the [Typeface] for the text.
- * @param textAlignment the text alignment.
- * @param minWidth defines the minimum width.
- */
+/** Creates and remembers a [TextComponent]. */
 @Composable
 public fun rememberTextComponent(
   color: Color = Color.Black,
+  typeface: Typeface = Typeface.DEFAULT,
   textSize: TextUnit = Defaults.TEXT_COMPONENT_TEXT_SIZE.sp,
-  background: ShapeComponent? = null,
-  ellipsize: TextUtils.TruncateAt = TextUtils.TruncateAt.END,
-  lineCount: Int = Defaults.LABEL_LINE_COUNT,
-  padding: Dimensions = Dimensions.Empty,
-  margins: Dimensions = Dimensions.Empty,
-  typeface: Typeface? = null,
   textAlignment: Layout.Alignment = Layout.Alignment.ALIGN_NORMAL,
+  lineCount: Int = Defaults.TEXT_COMPONENT_LINE_COUNT,
+  truncateAt: TextUtils.TruncateAt = TextUtils.TruncateAt.END,
+  margins: Dimensions = Dimensions.Empty,
+  padding: Dimensions = Dimensions.Empty,
+  background: Component? = null,
   minWidth: TextComponent.MinWidth = TextComponent.MinWidth.fixed(),
 ): TextComponent =
   remember(
     color,
+    typeface,
     textSize,
-    background,
-    ellipsize,
+    textAlignment,
     lineCount,
-    padding,
+    truncateAt,
     margins,
-    typeface,
-    textAlignment,
+    padding,
+    background,
     minWidth,
   ) {
-    TextComponent.build {
-      this.color = color.toArgb()
-      textSizeSp = textSize.pixelSize()
-      this.ellipsize = ellipsize
-      this.lineCount = lineCount
-      this.background = background
-      this.padding = padding
-      this.margins = margins
-      this.typeface = typeface
-      this.textAlignment = textAlignment
-      this.minWidth = minWidth
-    }
+    TextComponent(
+      color.toArgb(),
+      typeface,
+      textSize.pixelSize(),
+      textAlignment,
+      lineCount,
+      truncateAt,
+      margins,
+      padding,
+      background,
+      minWidth,
+    )
   }
 
+/** Creates a [Shadow]. */
+public fun shadow(radius: Dp, dx: Dp = 0.dp, dy: Dp = 0.dp, color: Color? = null): Shadow =
+  Shadow(radius.value, dx.value, dy.value, color?.toArgb() ?: Defaults.SHADOW_COLOR)
+
+/** Creates and remembers a [Shadow]. */
+@Composable
+public fun rememberShadow(radius: Dp, dx: Dp = 0.dp, dy: Dp = 0.dp, color: Color? = null): Shadow =
+  remember(radius, dx, dy, color) { shadow(radius, dx, dy, color) }
+
 /** A [Dp] version of [TextComponent.MinWidth.fixed]. */
-@Stable
 public fun TextComponent.MinWidth.Companion.fixed(value: Dp = 0.dp): TextComponent.MinWidth =
   fixed(value.value)
-
-/**
- * Applies a drop shadow to this [ShapeComponent].
- *
- * @param radius the blur radius.
- * @param dx the horizontal offset.
- * @param dy the vertical offset.
- * @param color the shadow color.
- * @param applyElevationOverlay whether to apply an elevation overlay to the [ShapeComponent].
- */
-@Suppress("UNCHECKED_CAST")
-public fun <T : ShapeComponent> T.setShadow(
-  radius: Dp,
-  dx: Dp = 0.dp,
-  dy: Dp = 0.dp,
-  color: Color = Color(Defaults.SHADOW_COLOR),
-  applyElevationOverlay: Boolean = false,
-): T =
-  setShadow(
-    radius = radius.value,
-    dx = dx.value,
-    dy = dy.value,
-    color = color.toArgb(),
-    applyElevationOverlay = applyElevationOverlay,
-  )
-    as T
diff --git a/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/common/component/CustomComponents.kt b/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/common/component/CustomComponents.kt
index c22ef8edd..85ee76c11 100644
--- a/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/common/component/CustomComponents.kt
+++ b/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/common/component/CustomComponents.kt
@@ -57,9 +57,9 @@ public fun rememberUnboundedLineComponent(
       color = color.toArgb(),
       thicknessDp = thickness.value,
       shape = shape,
-      dynamicShader = dynamicShader,
+      shader = dynamicShader,
       margins = margins,
-      strokeWidthDp = strokeWidth.value,
+      strokeThicknessDp = strokeWidth.value,
       strokeColor = strokeColor.toArgb(),
       verticalAddDrawSpaceDp = verticalAddDrawSpace.value,
       horizontalAddDrawSpaceDp = horizontalAddDrawSpace.value,
diff --git a/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/common/data/ExtraStore.kt b/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/common/data/ExtraStore.kt
new file mode 100644
index 000000000..c468e5d5a
--- /dev/null
+++ b/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/common/data/ExtraStore.kt
@@ -0,0 +1,32 @@
+/*
+ * Copyright 2024 by Patryk Goworowski and Patrick Michalik.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.patrykandpatrick.vico.compose.common.data
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.remember
+import com.patrykandpatrick.vico.core.common.data.ExtraStore
+
+/**
+ * Remembers an [ExtraStore] lambda. When either initially composed or recomposed with new [keys]
+ * values, this function saves and returns [lambda]. When recomposed with unchanged [keys] values,
+ * it ignores [lambda] and returns the lambda that was last saved.
+ */
+@Composable
+public fun <R> rememberExtraLambda(
+  vararg keys: Any?,
+  lambda: R.(ExtraStore) -> Unit,
+): R.(ExtraStore) -> Unit = remember(*keys) { lambda }
diff --git a/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/common/shader/BrushShader.kt b/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/common/shader/BrushShader.kt
deleted file mode 100644
index 61437bb36..000000000
--- a/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/common/shader/BrushShader.kt
+++ /dev/null
@@ -1,55 +0,0 @@
-/*
- * Copyright 2024 by Patryk Goworowski and Patrick Michalik.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.patrykandpatrick.vico.compose.common.shader
-
-import android.graphics.Matrix
-import android.graphics.Shader
-import androidx.compose.ui.geometry.Size
-import androidx.compose.ui.graphics.Brush
-import androidx.compose.ui.graphics.Paint
-import com.patrykandpatrick.vico.core.common.DrawContext
-import com.patrykandpatrick.vico.core.common.shader.CacheableDynamicShader
-import com.patrykandpatrick.vico.core.common.shader.DynamicShader
-import kotlin.math.abs
-
-/**
- * Creates a [DynamicShader] out of a [Brush].
- *
- * @property brush the [Brush] to be converted to a [Shader].
- */
-public class BrushShader(private val brush: Brush) : CacheableDynamicShader() {
-  private val matrix = Matrix()
-
-  override fun createShader(
-    context: DrawContext,
-    left: Float,
-    top: Float,
-    right: Float,
-    bottom: Float,
-  ): Shader {
-    val tempPaint = Paint()
-    brush.applyTo(size = Size(abs(left - right), abs(top - bottom)), p = tempPaint, alpha = 1f)
-    return requireNotNull(tempPaint.shader).apply {
-      matrix.postTranslate(left, top)
-      setLocalMatrix(matrix)
-      matrix.reset()
-    }
-  }
-}
-
-/** Converts this [Brush] to a [DynamicShader] using [BrushShader]. */
-public fun Brush.toDynamicShader(): DynamicShader = BrushShader(this)
diff --git a/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/common/shader/DynamicShader.kt b/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/common/shader/DynamicShader.kt
index ae04ace2d..c0ccc0477 100644
--- a/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/common/shader/DynamicShader.kt
+++ b/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/common/shader/DynamicShader.kt
@@ -19,10 +19,16 @@
 package com.patrykandpatrick.vico.compose.common.shader
 
 import android.graphics.Shader
+import androidx.compose.ui.geometry.Size
+import androidx.compose.ui.graphics.Brush
 import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.Paint
 import androidx.compose.ui.graphics.toArgb
 import androidx.compose.ui.unit.Dp
+import androidx.core.graphics.translationMatrix
+import com.patrykandpatrick.vico.core.common.DrawContext
 import com.patrykandpatrick.vico.core.common.component.Component
+import com.patrykandpatrick.vico.core.common.shader.CacheableDynamicShader
 import com.patrykandpatrick.vico.core.common.shader.ColorShader
 import com.patrykandpatrick.vico.core.common.shader.ComponentShader
 import com.patrykandpatrick.vico.core.common.shader.DynamicShader
@@ -76,3 +82,19 @@ public fun DynamicShader.Companion.verticalGradient(
   positions: FloatArray? = null,
 ): DynamicShader =
   LinearGradientShader(IntArray(colors.size) { colors[it].toArgb() }, positions, false)
+
+/** Converts this [Brush] to a [DynamicShader]. */
+public fun Brush.toDynamicShader(): DynamicShader =
+  object : CacheableDynamicShader() {
+    override fun createShader(
+      context: DrawContext,
+      left: Float,
+      top: Float,
+      right: Float,
+      bottom: Float,
+    ): Shader {
+      val paint = Paint()
+      applyTo(size = Size(right - left, bottom - top), p = paint, alpha = 1f)
+      return paint.shader!!.apply { setLocalMatrix(translationMatrix(left, top)) }
+    }
+  }
diff --git a/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/common/shape/Shape.kt b/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/common/shape/Shape.kt
index 2a9cb3938..4b697785b 100644
--- a/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/common/shape/Shape.kt
+++ b/vico/compose/src/main/java/com/patrykandpatrick/vico/compose/common/shape/Shape.kt
@@ -71,7 +71,7 @@ public fun androidx.compose.ui.graphics.Shape.toVicoShape(): Shape =
     private val radii by lazy { FloatArray(RADII_ARRAY_SIZE) }
     private val matrix: Matrix by lazy { Matrix() }
 
-    override fun drawShape(
+    override fun draw(
       context: DrawContext,
       paint: Paint,
       path: Path,
@@ -104,6 +104,22 @@ public fun androidx.compose.ui.graphics.Shape.toVicoShape(): Shape =
       }
       context.canvas.drawPath(path, paint)
     }
+
+    @Deprecated(
+      "Use `draw`.",
+      replaceWith = ReplaceWith("draw(context, paint, path, left, top, right, bottom)"),
+    )
+    override fun drawShape(
+      context: DrawContext,
+      paint: Paint,
+      path: Path,
+      left: Float,
+      top: Float,
+      right: Float,
+      bottom: Float,
+    ) {
+      draw(context, paint, path, left, top, right, bottom)
+    }
   }
 
 /** Converts this [CorneredShape] to an instance of [androidx.compose.ui.graphics.Shape]. */
diff --git a/vico/core/build.gradle b/vico/core/build.gradle
index d26fa0af3..d9356167b 100644
--- a/vico/core/build.gradle
+++ b/vico/core/build.gradle
@@ -1,5 +1,5 @@
 /*
- * Copyright 2023 by Patryk Goworowski and Patrick Michalik.
+ * Copyright 2024 by Patryk Goworowski and Patrick Michalik.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -40,6 +40,7 @@ dependencies {
     implementation libs.androidXAnnotation
     implementation libs.coroutinesCore
     implementation libs.kotlinStdLib
+    compileOnly libs.composeStableMarker
     testImplementation libs.JUnit
     testImplementation libs.jupiter
     testImplementation libs.jupiterParams
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/CartesianChart.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/CartesianChart.kt
index bb3adc037..2f9f37d7c 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/CartesianChart.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/CartesianChart.kt
@@ -17,6 +17,8 @@
 package com.patrykandpatrick.vico.core.cartesian
 
 import android.graphics.RectF
+import androidx.annotation.RestrictTo
+import com.patrykandpatrick.vico.core.cartesian.CartesianChart.PersistentMarkerScope
 import com.patrykandpatrick.vico.core.cartesian.axis.Axis
 import com.patrykandpatrick.vico.core.cartesian.axis.AxisManager
 import com.patrykandpatrick.vico.core.cartesian.axis.AxisPosition
@@ -30,32 +32,62 @@ import com.patrykandpatrick.vico.core.cartesian.layer.CartesianLayer
 import com.patrykandpatrick.vico.core.cartesian.layer.ColumnCartesianLayer
 import com.patrykandpatrick.vico.core.cartesian.layer.LineCartesianLayer
 import com.patrykandpatrick.vico.core.cartesian.marker.CartesianMarker
-import com.patrykandpatrick.vico.core.common.BoundsAware
+import com.patrykandpatrick.vico.core.cartesian.marker.CartesianMarkerVisibilityListener
 import com.patrykandpatrick.vico.core.common.Legend
+import com.patrykandpatrick.vico.core.common.Point
+import com.patrykandpatrick.vico.core.common.data.ExtraStore
 import com.patrykandpatrick.vico.core.common.data.MutableExtraStore
-import com.patrykandpatrick.vico.core.common.inClip
-import com.patrykandpatrick.vico.core.common.set
-import com.patrykandpatrick.vico.core.common.setAll
+import com.patrykandpatrick.vico.core.common.orZero
+import java.util.Objects
 import java.util.SortedMap
+import kotlin.collections.component1
+import kotlin.collections.component2
+import kotlin.collections.set
+import kotlin.math.abs
 
 /**
  * A chart based on a Cartesian coordinate plane, composed of [CartesianLayer]s.
  *
+ * @param startAxis the start [Axis].
+ * @param topAxis the top [Axis].
+ * @param endAxis the end [Axis].
+ * @param bottomAxis the bottom [Axis].
+ * @property layers the [CartesianLayer]s.
+ * @property marker appears when the [CartesianChart] is tapped.
+ * @property markerVisibilityListener allows for listening to [marker] visibility changes.
+ * @property horizontalLayout defines how the [CartesianChart]’s content is positioned horizontally.
  * @property legend the legend.
  * @property fadingEdges applies a horizontal fade to the edges of the [CartesianChart], provided
  *   that it’s scrollable.
+ * @property decorations the [Decoration]s.
+ * @property persistentMarkers adds persistent [CartesianMarker]s.
+ * @property getXStep defines the _x_ step (the difference between the _x_ values of neighboring
+ *   major entries).
  */
 public open class CartesianChart(
-  layers: List<CartesianLayer<*>>,
+  vararg layers: CartesianLayer<*>,
+  startAxis: Axis<AxisPosition.Vertical.Start>? = null,
+  topAxis: Axis<AxisPosition.Horizontal.Top>? = null,
+  endAxis: Axis<AxisPosition.Vertical.End>? = null,
+  bottomAxis: Axis<AxisPosition.Horizontal.Bottom>? = null,
+  public var marker: CartesianMarker? = null,
+  public var markerVisibilityListener: CartesianMarkerVisibilityListener? = null,
+  public var horizontalLayout: HorizontalLayout = HorizontalLayout.Segmented,
   public var legend: Legend<CartesianMeasureContext, CartesianDrawContext>? = null,
   public var fadingEdges: FadingEdges? = null,
-) : BoundsAware, ChartInsetter {
-  private val decorations = mutableListOf<Decoration>()
-  private val persistentMarkers = mutableMapOf<Float, CartesianMarker>()
-  private val tempInsets = Insets()
+  public var decorations: List<Decoration> = emptyList(),
+  public var persistentMarkers: (PersistentMarkerScope.(ExtraStore) -> Unit)? = null,
+  public var getXStep: ((CartesianChartModel) -> Double) = { it.getXDeltaGcd() },
+) : ChartInsetter<CartesianChartModel> {
+  private val persistentMarkerMap = mutableMapOf<Double, CartesianMarker>()
+  private val persistentMarkerScope = PersistentMarkerScope {
+    persistentMarkerMap[it.toDouble()] = this
+  }
+  private var previousPersistentMarkerHashCode: Int? = null
+  private val insets = Insets()
   private val axisManager = AxisManager()
-  private val virtualLayout = VirtualLayout(axisManager)
-  private val _markerTargets = sortedMapOf<Float, MutableList<CartesianMarker.Target>>()
+  private val _markerTargets = sortedMapOf<Double, MutableList<CartesianMarker.Target>>()
+  private var previousMarkerTargetHashCode: Int? = null
 
   private val drawingModelAndLayerConsumer =
     object : ModelAndLayerConsumer {
@@ -88,6 +120,28 @@ public open class CartesianChart(
       }
     }
 
+  private val insetUpdateModelAndLayerConsumer =
+    object : ModelAndLayerConsumer {
+      lateinit var context: CartesianMeasureContext
+      lateinit var horizontalDimensions: HorizontalDimensions
+      lateinit var insets: Insets
+
+      override fun <T : CartesianLayerModel> invoke(model: T?, layer: CartesianLayer<T>) {
+        layer.updateInsets(context, horizontalDimensions, model ?: return, insets)
+      }
+    }
+
+  private val horizontalInsetUpdateModelAndLayerConsumer =
+    object : ModelAndLayerConsumer {
+      lateinit var context: CartesianMeasureContext
+      var freeHeight: Float = 0f
+      lateinit var insets: HorizontalInsets
+
+      override fun <T : CartesianLayerModel> invoke(model: T?, layer: CartesianLayer<T>) {
+        layer.updateHorizontalInsets(context, freeHeight, model ?: return, insets)
+      }
+    }
+
   private val transformationPreparationModelAndLayerConsumer =
     object : ModelAndLayerConsumer {
       lateinit var extraStore: MutableExtraStore
@@ -98,16 +152,16 @@ public open class CartesianChart(
       }
     }
 
+  /** @suppress */
+  @RestrictTo(RestrictTo.Scope.LIBRARY_GROUP) public val layerBounds: RectF = RectF()
+
   /** The [CartesianLayer]s of which this [CartesianChart] is composed. */
   public val layers: List<CartesianLayer<*>> = layers.toList()
 
-  /** The [CartesianChart]’s [ChartInsetter]s (persistent [CartesianMarker]s). */
-  public val chartInsetters: Collection<ChartInsetter> = persistentMarkers.values
-
   /** Links _x_ values to [CartesianMarker.Target]s. */
   @Suppress("UNCHECKED_CAST")
-  public val markerTargets: SortedMap<Float, List<CartesianMarker.Target>> =
-    _markerTargets as SortedMap<Float, List<CartesianMarker.Target>>
+  public val markerTargets: SortedMap<Double, List<CartesianMarker.Target>> =
+    _markerTargets as SortedMap<Double, List<CartesianMarker.Target>>
 
   /** The start axis. */
   public var startAxis: Axis<AxisPosition.Vertical.Start>? by axisManager::startAxis
@@ -121,17 +175,15 @@ public open class CartesianChart(
   /** The bottom axis. */
   public var bottomAxis: Axis<AxisPosition.Horizontal.Bottom>? by axisManager::bottomAxis
 
-  override val bounds: RectF = RectF()
-
-  public constructor(
-    vararg layers: CartesianLayer<*>,
-    legend: Legend<CartesianMeasureContext, CartesianDrawContext>? = null,
-    fadingEdges: FadingEdges? = null,
-  ) : this(layers.toList(), legend, fadingEdges)
+  init {
+    axisManager.startAxis = startAxis
+    axisManager.topAxis = topAxis
+    axisManager.endAxis = endAxis
+    axisManager.bottomAxis = bottomAxis
+  }
 
-  override fun setBounds(left: Number, top: Number, right: Number, bottom: Number) {
-    bounds.set(left, top, right, bottom)
-    layers.forEach { it.setBounds(left, top, right, bottom) }
+  private fun setLayerBounds(left: Float, top: Float, right: Float, bottom: Float) {
+    layerBounds.set(left, top, right, bottom)
   }
 
   /** Prepares the [CartesianChart] for drawing. */
@@ -139,10 +191,16 @@ public open class CartesianChart(
     context: CartesianMeasureContext,
     model: CartesianChartModel,
     horizontalDimensions: MutableHorizontalDimensions,
-    bounds: RectF,
-    marker: CartesianMarker?,
+    canvasBounds: RectF,
   ) {
     _markerTargets.clear()
+    insets.clear()
+    val persistentMarkerHashCode = Objects.hash(persistentMarkers, model.extraStore)
+    if (persistentMarkerHashCode != previousPersistentMarkerHashCode) {
+      persistentMarkerMap.clear()
+      persistentMarkers?.invoke(persistentMarkerScope, model.extraStore)
+      previousPersistentMarkerHashCode = persistentMarkerHashCode
+    }
     model.forEachWithLayer(
       horizontalDimensionUpdateModelAndLayerConsumer.apply {
         this.context = context
@@ -153,59 +211,90 @@ public open class CartesianChart(
     topAxis?.updateHorizontalDimensions(context, horizontalDimensions)
     endAxis?.updateHorizontalDimensions(context, horizontalDimensions)
     bottomAxis?.updateHorizontalDimensions(context, horizontalDimensions)
-    virtualLayout.setBounds(context, bounds, this, legend, horizontalDimensions, marker)
+    val insetters = buildList {
+      add(this@CartesianChart)
+      addAll(axisManager.axisCache)
+      marker?.let(::add)
+      addAll(persistentMarkerMap.values)
+    }
+    insetters.forEach { it.updateInsets(context, horizontalDimensions, model, insets) }
+    val legendHeight = legend?.getHeight(context, canvasBounds.width()).orZero
+    val freeHeight = canvasBounds.height() - insets.vertical - legendHeight
+    insetters.forEach { it.updateHorizontalInsets(context, freeHeight, model, insets) }
+    setLayerBounds(
+      canvasBounds.left + insets.getLeft(context.isLtr),
+      canvasBounds.top + insets.top,
+      canvasBounds.right - insets.getRight(context.isLtr),
+      canvasBounds.bottom - insets.bottom - legendHeight,
+    )
+    axisManager.setAxesBounds(context, canvasBounds, layerBounds, insets)
+    legend?.setBounds(
+      left = canvasBounds.left,
+      top = layerBounds.bottom + insets.bottom,
+      right = canvasBounds.right,
+      bottom = layerBounds.bottom + insets.bottom + legendHeight,
+    )
   }
 
   /** Draws the [CartesianChart]. */
-  public fun draw(context: CartesianDrawContext, model: CartesianChartModel) {
+  public fun draw(
+    context: CartesianDrawContext,
+    model: CartesianChartModel,
+    pointerPosition: Point?,
+  ) {
     val canvasSaveCount = if (fadingEdges != null) context.saveLayer() else -1
-    axisManager.drawBehindChart(context)
-    decorations.forEach { it.onDrawBehindChart(context, bounds) }
+    axisManager.drawUnderLayers(context)
+    decorations.forEach { it.drawUnderLayers(context) }
     model.forEachWithLayer(drawingModelAndLayerConsumer.apply { this.context = context })
     fadingEdges?.run {
-      applyFadingEdges(context, bounds)
+      draw(context)
       context.restoreCanvasToCount(canvasSaveCount)
     }
-    axisManager.drawAboveChart(context)
-    context.canvas.inClip(bounds.left, 0f, bounds.right, context.canvas.height.toFloat()) {
-      decorations.forEach { it.onDrawAboveChart(context, bounds) }
-    }
-    persistentMarkers.forEach { (x, marker) ->
+    axisManager.drawOverLayers(context)
+    decorations.forEach { it.drawOverLayers(context) }
+    persistentMarkerMap.forEach { (x, marker) ->
       markerTargets[x]?.let { targets -> marker.draw(context, targets) }
     }
-    legend?.draw(context, bounds)
+    legend?.draw(context)
+    drawMarker(context, pointerPosition)
   }
 
   /** Updates [chartValues] in accordance with [model]. */
-  public fun updateChartValues(
-    chartValues: MutableChartValues,
-    model: CartesianChartModel,
-    xStep: Float?,
-  ) {
-    chartValues.update(xStep ?: model.getXDeltaGcd(), model)
+  public fun updateChartValues(chartValues: MutableChartValues, model: CartesianChartModel) {
+    chartValues.update(getXStep(model), model)
     model.forEachWithLayer(
       chartValueUpdateModelAndLayerConsumer.apply { this.chartValues = chartValues }
     )
   }
 
-  override fun getInsets(
+  override fun updateInsets(
     context: CartesianMeasureContext,
-    outInsets: Insets,
     horizontalDimensions: HorizontalDimensions,
+    model: CartesianChartModel,
+    insets: Insets,
   ) {
-    tempInsets.clear()
-    layers.forEach { it.getInsets(context, tempInsets, horizontalDimensions) }
-    outInsets.setValuesIfGreater(tempInsets)
+    model.forEachWithLayer(
+      insetUpdateModelAndLayerConsumer.apply {
+        this.context = context
+        this.horizontalDimensions = horizontalDimensions
+        this.insets = insets
+      }
+    )
   }
 
-  override fun getHorizontalInsets(
+  override fun updateHorizontalInsets(
     context: CartesianMeasureContext,
-    availableHeight: Float,
-    outInsets: HorizontalInsets,
+    freeHeight: Float,
+    model: CartesianChartModel,
+    insets: HorizontalInsets,
   ) {
-    tempInsets.clear()
-    layers.forEach { it.getHorizontalInsets(context, availableHeight, tempInsets) }
-    outInsets.setValuesIfGreater(start = tempInsets.start, end = tempInsets.end)
+    model.forEachWithLayer(
+      horizontalInsetUpdateModelAndLayerConsumer.apply {
+        this.context = context
+        this.freeHeight = freeHeight
+        this.insets = insets
+      }
+    )
   }
 
   /** Prepares the [CartesianLayer]s for a difference animation. */
@@ -227,36 +316,7 @@ public open class CartesianChart(
     layers.forEach { it.transform(extraStore, fraction) }
   }
 
-  /** Adds the provided [Decoration]. */
-  public fun addDecoration(decoration: Decoration) {
-    decorations.add(decoration)
-  }
-
-  /** Removes all [Decoration]s and adds the provided ones. */
-  public fun setDecorations(decorations: List<Decoration>) {
-    this.decorations.setAll(decorations)
-  }
-
-  /** Removes the specified [Decoration], provided that it’s present. */
-  public fun removeDecoration(decoration: Decoration): Boolean = decorations.remove(decoration)
-
-  /** Adds the provided persistent [CartesianMarker] at [x]. */
-  public fun addPersistentMarker(x: Float, marker: CartesianMarker) {
-    persistentMarkers[x] = marker
-  }
-
-  /** Removes all persistent [CartesianMarker]s and adds the provided ones. */
-  public fun setPersistentMarkers(markers: Map<Float, CartesianMarker>) {
-    persistentMarkers.setAll(markers)
-  }
-
-  /**
-   * Removes the persistent [CartesianMarker] at [x], provided that there is such a
-   * [CartesianMarker].
-   */
-  public fun removePersistentMarker(x: Float): Boolean = persistentMarkers.remove(x) != null
-
-  protected fun CartesianChartModel.forEachWithLayer(consumer: ModelAndLayerConsumer) {
+  protected open fun CartesianChartModel.forEachWithLayer(consumer: ModelAndLayerConsumer) {
     val freeModels = models.toMutableList()
     layers.forEach { layer ->
       when (layer) {
@@ -268,7 +328,33 @@ public open class CartesianChart(
     }
   }
 
-  private inline fun <reified T : CartesianLayerModel> MutableList<CartesianLayerModel>.consume(
+  protected open fun drawMarker(context: CartesianDrawContext, pointerPosition: Point?) {
+    val marker = marker ?: return
+    if (pointerPosition == null || markerTargets.isEmpty()) {
+      if (previousMarkerTargetHashCode != null) markerVisibilityListener?.onHidden(marker)
+      previousMarkerTargetHashCode = null
+      return
+    }
+    var targets = emptyList<CartesianMarker.Target>()
+    var previousDistance = Float.POSITIVE_INFINITY
+    for (xTargets in markerTargets.values) {
+      val (distance, canvasXTargets) =
+        xTargets.groupBy { abs(pointerPosition.x - it.canvasX) }.minBy { it.key }
+      if (distance > previousDistance) break
+      targets = canvasXTargets
+      previousDistance = distance
+    }
+    marker.draw(context, targets)
+    val targetHashCode = targets.hashCode()
+    if (previousMarkerTargetHashCode == null) {
+      markerVisibilityListener?.onShown(marker, targets)
+    } else if (targetHashCode != previousMarkerTargetHashCode) {
+      markerVisibilityListener?.onUpdated(marker, targets)
+    }
+    previousMarkerTargetHashCode = targetHashCode
+  }
+
+  protected inline fun <reified T : CartesianLayerModel> MutableList<CartesianLayerModel>.consume(
     layer: CartesianLayer<T>,
     consumer: ModelAndLayerConsumer,
   ) {
@@ -280,4 +366,10 @@ public open class CartesianChart(
   protected interface ModelAndLayerConsumer {
     public operator fun <T : CartesianLayerModel> invoke(model: T?, layer: CartesianLayer<T>)
   }
+
+  /** Facilitates adding persistent [CartesianMarker]s to [CartesianChart]s. */
+  public fun interface PersistentMarkerScope {
+    /** Adds this [CartesianMarker] at [x]. */
+    public infix fun CartesianMarker.at(x: Number)
+  }
 }
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/CartesianDrawContext.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/CartesianDrawContext.kt
index 7b629d936..308311f4d 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/CartesianDrawContext.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/CartesianDrawContext.kt
@@ -19,17 +19,15 @@ package com.patrykandpatrick.vico.core.cartesian
 import android.graphics.Canvas
 import android.graphics.RectF
 import androidx.annotation.RestrictTo
-import com.patrykandpatrick.vico.core.cartesian.marker.CartesianMarker
-import com.patrykandpatrick.vico.core.cartesian.marker.CartesianMarkerVisibilityListener
+import com.patrykandpatrick.vico.core.cartesian.layer.CartesianLayer
 import com.patrykandpatrick.vico.core.common.DrawContext
 import com.patrykandpatrick.vico.core.common.Point
-import com.patrykandpatrick.vico.core.common.ceil
-import kotlin.math.abs
+import kotlin.math.ceil
 
 /** A [DrawContext] extension with [CartesianChart]-specific data. */
 public interface CartesianDrawContext : DrawContext, CartesianMeasureContext {
-  /** The bounds in which the [CartesianChart] will be drawn. */
-  public val chartBounds: RectF
+  /** The bounds of the [CartesianLayer] area. */
+  public val layerBounds: RectF
 
   /** Holds information on the [CartesianChart]’s horizontal dimensions. */
   public val horizontalDimensions: HorizontalDimensions
@@ -37,8 +35,13 @@ public interface CartesianDrawContext : DrawContext, CartesianMeasureContext {
   /** The point inside the chart’s coordinates where physical touch is occurring. */
   public val markerTouchPoint: Point?
 
-  /** The current amount of horizontal scroll. */
+  /** The scroll value (in pixels). */
+  public val scroll: Float
+
+  /** The scroll value (in pixels). */
+  @Deprecated("Use `scroll`.", ReplaceWith("scroll"))
   public val horizontalScroll: Float
+    get() = scroll
 
   /** The zoom factor. */
   public val zoom: Float
@@ -50,39 +53,38 @@ public fun CartesianMeasureContext.getMaxScrollDistance(
   chartWidth: Float,
   horizontalDimensions: HorizontalDimensions,
 ): Float =
-  (layoutDirectionMultiplier * (horizontalDimensions.getContentWidth(this) - chartWidth))
-    .run { if (isLtr) coerceAtLeast(minimumValue = 0f) else coerceAtMost(maximumValue = 0f) }
-    .ceil
+  ceil(
+    (layoutDirectionMultiplier * (horizontalDimensions.getContentWidth(this) - chartWidth)).run {
+      if (isLtr) coerceAtLeast(0f) else coerceAtMost(0f)
+    }
+  )
 
 internal fun CartesianDrawContext.getMaxScrollDistance() =
-  getMaxScrollDistance(chartBounds.width(), horizontalDimensions)
+  getMaxScrollDistance(layerBounds.width(), horizontalDimensions)
 
 /** @suppress */
 @RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
 public fun CartesianDrawContext(
   canvas: Canvas,
-  elevationOverlayColor: Int,
   measureContext: CartesianMeasureContext,
   markerTouchPoint: Point?,
   horizontalDimensions: HorizontalDimensions,
-  chartBounds: RectF,
-  horizontalScroll: Float,
+  layerBounds: RectF,
+  scroll: Float,
   zoom: Float,
 ): CartesianDrawContext =
   object : CartesianDrawContext, CartesianMeasureContext by measureContext {
-    override val chartBounds: RectF = chartBounds
+    override val layerBounds: RectF = layerBounds
 
     override var canvas: Canvas = canvas
 
-    override val elevationOverlayColor: Long = elevationOverlayColor.toLong()
-
     override val markerTouchPoint: Point? = markerTouchPoint
 
-    override val zoom: Float = zoom
-
     override val horizontalDimensions: HorizontalDimensions = horizontalDimensions
 
-    override val horizontalScroll: Float = horizontalScroll
+    override val scroll: Float = scroll
+
+    override val zoom: Float = zoom
 
     override fun withOtherCanvas(canvas: Canvas, block: (DrawContext) -> Unit) {
       val originalCanvas = this.canvas
@@ -91,35 +93,3 @@ public fun CartesianDrawContext(
       this.canvas = originalCanvas
     }
   }
-
-/** @suppress */
-@RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
-public fun CartesianDrawContext.drawMarker(
-  marker: CartesianMarker,
-  markerTouchPoint: Point?,
-  chart: CartesianChart,
-  visibilityListener: CartesianMarkerVisibilityListener?,
-  previousTargetHashCode: Int?,
-): Int? {
-  if (markerTouchPoint == null || chart.markerTargets.isEmpty()) {
-    if (previousTargetHashCode != null) visibilityListener?.onHidden(marker)
-    return null
-  }
-  var targets = emptyList<CartesianMarker.Target>()
-  var previousDistance = Float.POSITIVE_INFINITY
-  for (xTargets in chart.markerTargets.values) {
-    val (distance, canvasXTargets) =
-      xTargets.groupBy { abs(markerTouchPoint.x - it.canvasX) }.minBy { it.key }
-    if (distance > previousDistance) break
-    targets = canvasXTargets
-    previousDistance = distance
-  }
-  marker.draw(this, targets)
-  val targetHashCode = targets.hashCode()
-  if (previousTargetHashCode == null) {
-    visibilityListener?.onShown(marker, targets)
-  } else if (targetHashCode != previousTargetHashCode) {
-    visibilityListener?.onUpdated(marker, targets)
-  }
-  return targetHashCode
-}
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/CartesianMeasureContext.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/CartesianMeasureContext.kt
index b2bae633d..cbfde7021 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/CartesianMeasureContext.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/CartesianMeasureContext.kt
@@ -27,9 +27,12 @@ public interface CartesianMeasureContext : MeasureContext {
   /** The chart’s [ChartValues]. */
   public val chartValues: ChartValues
 
-  /** Whether horizontal scrolling is enabled. */
+  /** Whether scroll is enabled. */
   public val scrollEnabled: Boolean
 
+  /** Whether zoom is enabled. */
+  public val zoomEnabled: Boolean
+
   /** Defines how the chart’s content is positioned horizontally. */
   public val horizontalLayout: HorizontalLayout
 }
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/ChartInsetter.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/ChartInsetter.kt
index 0630f0274..4b6751633 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/ChartInsetter.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/ChartInsetter.kt
@@ -17,41 +17,30 @@
 package com.patrykandpatrick.vico.core.cartesian
 
 import com.patrykandpatrick.vico.core.cartesian.axis.Axis
+import com.patrykandpatrick.vico.core.cartesian.layer.CartesianLayer
 import com.patrykandpatrick.vico.core.cartesian.marker.CartesianMarker
 
 /**
  * Enables a component to add insets to [CartesianChart]s to make room for itself. This is used by
  * [Axis], [CartesianMarker], and the like.
  */
-public interface ChartInsetter {
-  /**
-   * Called during the measurement phase, before [getHorizontalInsets]. Both horizontal and vertical
-   * insets can be requested from this function. The final inset for a given edge of the associated
-   * [CartesianChart] is the largest of the insets requested for the edge.
-   *
-   * @param context holds data used for the measuring of components.
-   * @param outInsets used to store the requested insets.
-   * @param horizontalDimensions the [CartesianChart]’s [HorizontalDimensions].
-   */
-  public fun getInsets(
+public interface ChartInsetter<M> {
+  /** Ensures that there are sufficient insets. */
+  public fun updateInsets(
     context: CartesianMeasureContext,
-    outInsets: Insets,
     horizontalDimensions: HorizontalDimensions,
-  ): Unit = Unit
+    model: M,
+    insets: Insets,
+  ) {}
 
   /**
-   * Called during the measurement phase, after [getInsets]. Only horizontal insets can be requested
-   * from this function. Unless the available height is of interest, [getInsets] can be used to set
-   * all insets. The final inset for a given edge of the associated [CartesianChart] is the largest
-   * of the insets requested for the edge.
-   *
-   * @param context holds data used for the measuring of components.
-   * @param availableHeight the available height. The vertical insets are considered here.
-   * @param outInsets used to store the requested insets.
+   * Ensures that there are sufficient horizontal insets. [freeHeight] is the height of the
+   * [CartesianLayer] area.
    */
-  public fun getHorizontalInsets(
+  public fun updateHorizontalInsets(
     context: CartesianMeasureContext,
-    availableHeight: Float,
-    outInsets: HorizontalInsets,
-  ): Unit = Unit
+    freeHeight: Float,
+    model: M,
+    insets: HorizontalInsets,
+  ) {}
 }
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/CubicPointConnector.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/CubicPointConnector.kt
new file mode 100644
index 000000000..6d56dd674
--- /dev/null
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/CubicPointConnector.kt
@@ -0,0 +1,51 @@
+/*
+ * Copyright 2024 by Patryk Goworowski and Patrick Michalik.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.patrykandpatrick.vico.core.cartesian
+
+import android.graphics.Path
+import com.patrykandpatrick.vico.core.cartesian.layer.LineCartesianLayer
+import kotlin.math.abs
+
+internal data class CubicPointConnector(private val curvature: Float) :
+  LineCartesianLayer.PointConnector {
+  init {
+    require(curvature in 0f..1f) { "`curvature` must be in the interval [0, 1]." }
+  }
+
+  override fun connect(
+    context: CartesianDrawContext,
+    path: Path,
+    x1: Float,
+    y1: Float,
+    x2: Float,
+    y2: Float,
+  ) {
+    if (curvature == 0f) {
+      path.lineTo(x2, y2)
+    } else {
+      val xDelta =
+        (Y_MULTIPLIER * abs(y2 - y1) / context.layerBounds.height()).coerceAtMost(1f) *
+          curvature *
+          (x2 - x1)
+      path.cubicTo(x1 + xDelta, y1, x2 - xDelta, y2, x2, y2)
+    }
+  }
+
+  private companion object {
+    const val Y_MULTIPLIER = 4
+  }
+}
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/DefaultPointConnector.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/DefaultPointConnector.kt
deleted file mode 100644
index 3b48f1dcc..000000000
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/DefaultPointConnector.kt
+++ /dev/null
@@ -1,76 +0,0 @@
-/*
- * Copyright 2024 by Patryk Goworowski and Patrick Michalik.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.patrykandpatrick.vico.core.cartesian
-
-import android.graphics.Path
-import android.graphics.RectF
-import com.patrykandpatrick.vico.core.cartesian.layer.LineCartesianLayer
-import com.patrykandpatrick.vico.core.common.Defaults
-import com.patrykandpatrick.vico.core.common.half
-import kotlin.math.abs
-
-/**
- * The default implementation of [LineCartesianLayer.LineSpec.PointConnector]. This uses cubic
- * bezier curves.
- *
- * @property cubicStrength the strength of the cubic bezier curve between each point on the line.
- */
-public class DefaultPointConnector(private val cubicStrength: Float = Defaults.CUBIC_STRENGTH) :
-  LineCartesianLayer.LineSpec.PointConnector {
-  public override fun connect(
-    path: Path,
-    prevX: Float,
-    prevY: Float,
-    x: Float,
-    y: Float,
-    horizontalDimensions: HorizontalDimensions,
-    bounds: RectF,
-  ) {
-    path.horizontalCubicTo(
-      prevX = prevX,
-      prevY = prevY,
-      x = x,
-      y = y,
-      curvature =
-        abs(x - prevX).half *
-          cubicStrength *
-          (abs(x = y - prevY) / bounds.bottom * CUBIC_Y_MULTIPLIER).coerceAtMost(maximumValue = 1f),
-    )
-  }
-
-  private companion object {
-    const val CUBIC_Y_MULTIPLIER = 4
-  }
-}
-
-private fun Path.horizontalCubicTo(
-  prevX: Float,
-  prevY: Float,
-  x: Float,
-  y: Float,
-  curvature: Float,
-) {
-  val directionMultiplier = if (x >= prevX) 1f else -1f
-  cubicTo(
-    prevX + directionMultiplier * curvature,
-    prevY,
-    x - directionMultiplier * curvature,
-    y,
-    x,
-    y,
-  )
-}
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/FadingEdges.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/FadingEdges.kt
index dd8d56f5c..2fd0eb4f9 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/FadingEdges.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/FadingEdges.kt
@@ -24,6 +24,7 @@ import android.graphics.PorterDuffXfermode
 import android.graphics.RectF
 import android.graphics.Shader
 import android.view.animation.AccelerateDecelerateInterpolator
+import androidx.compose.runtime.Immutable
 import com.patrykandpatrick.vico.core.common.Defaults.FADING_EDGE_VISIBILITY_THRESHOLD_DP
 import com.patrykandpatrick.vico.core.common.Defaults.FADING_EDGE_WIDTH_DP
 import com.patrykandpatrick.vico.core.common.copyColor
@@ -44,11 +45,12 @@ private const val NO_FADE: Int = 0x00000000
  *   a mapping of the degree to which [visibilityThresholdDp] has been satisfied to the opacity of
  *   the fading edges.
  */
+@Immutable
 public open class FadingEdges(
-  public var startEdgeWidthDp: Float = FADING_EDGE_WIDTH_DP,
-  public var endEdgeWidthDp: Float = startEdgeWidthDp,
-  public var visibilityThresholdDp: Float = FADING_EDGE_VISIBILITY_THRESHOLD_DP,
-  public var visibilityInterpolator: TimeInterpolator = AccelerateDecelerateInterpolator(),
+  protected val startEdgeWidthDp: Float = FADING_EDGE_WIDTH_DP,
+  protected val endEdgeWidthDp: Float = FADING_EDGE_WIDTH_DP,
+  protected val visibilityThresholdDp: Float = FADING_EDGE_VISIBILITY_THRESHOLD_DP,
+  protected val visibilityInterpolator: TimeInterpolator = AccelerateDecelerateInterpolator(),
 ) {
   private val paint: Paint = Paint()
 
@@ -82,45 +84,39 @@ public open class FadingEdges(
     paint.xfermode = PorterDuffXfermode(PorterDuff.Mode.DST_OUT)
   }
 
-  /**
-   * Applies fading edges inside of the given [bounds] accordingly to the scroll state.
-   *
-   * @param context the drawing context that holds the information necessary to draw the fading
-   *   edges.
-   * @param bounds the bounds within which the fading edges will be drawn.
-   */
-  public fun applyFadingEdges(context: CartesianDrawContext, bounds: RectF): Unit =
+  /** Applies the fade. */
+  public fun draw(context: CartesianDrawContext) {
     with(context) {
       val maxScroll = getMaxScrollDistance()
       var fadeAlphaFraction: Float
 
-      if (scrollEnabled && startEdgeWidthDp > 0f && horizontalScroll > 0f) {
-        fadeAlphaFraction = (horizontalScroll / visibilityThresholdDp.pixels).coerceAtMost(1f)
+      if (scrollEnabled && startEdgeWidthDp > 0f && scroll > 0f) {
+        fadeAlphaFraction = (scroll / visibilityThresholdDp.pixels).coerceAtMost(1f)
 
         drawFadingEdge(
-          left = bounds.left,
-          top = bounds.top,
-          right = bounds.left + startEdgeWidthDp.pixels,
-          bottom = bounds.bottom,
+          left = layerBounds.left,
+          top = layerBounds.top,
+          right = layerBounds.left + startEdgeWidthDp.pixels,
+          bottom = layerBounds.bottom,
           direction = -1,
           alpha = (visibilityInterpolator.getInterpolation(fadeAlphaFraction) * FULL_ALPHA).toInt(),
         )
       }
 
-      if (scrollEnabled && endEdgeWidthDp > 0f && horizontalScroll < maxScroll) {
-        fadeAlphaFraction =
-          ((maxScroll - horizontalScroll) / visibilityThresholdDp.pixels).coerceAtMost(1f)
+      if (scrollEnabled && endEdgeWidthDp > 0f && scroll < maxScroll) {
+        fadeAlphaFraction = ((maxScroll - scroll) / visibilityThresholdDp.pixels).coerceAtMost(1f)
 
         drawFadingEdge(
-          left = bounds.right - endEdgeWidthDp.pixels,
-          top = bounds.top,
-          right = bounds.right,
-          bottom = bounds.bottom,
+          left = layerBounds.right - endEdgeWidthDp.pixels,
+          top = layerBounds.top,
+          right = layerBounds.right,
+          bottom = layerBounds.bottom,
           direction = 1,
           alpha = (visibilityInterpolator.getInterpolation(fadeAlphaFraction) * FULL_ALPHA).toInt(),
         )
       }
     }
+  }
 
   private fun CartesianDrawContext.drawFadingEdge(
     left: Float,
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/HorizontalDimensions.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/HorizontalDimensions.kt
index c65d83469..7c43ee5ff 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/HorizontalDimensions.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/HorizontalDimensions.kt
@@ -67,7 +67,9 @@ public interface HorizontalDimensions {
 
   /** Calculates the width of the [CartesianChart]’s scalable content (in pixels). */
   public fun getScalableContentWidth(context: CartesianMeasureContext): Float =
-    with(context) { xSpacing * chartValues.xLength / chartValues.xStep + scalablePadding }
+    with(context) {
+      xSpacing * (chartValues.xLength / chartValues.xStep).toFloat() + scalablePadding
+    }
 
   /** Calculates the width of the [CartesianChart]’s content (in pixels). */
   public fun getContentWidth(context: CartesianMeasureContext): Float =
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/HorizontalInsets.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/HorizontalInsets.kt
index 7d8033214..169185f8c 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/HorizontalInsets.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/HorizontalInsets.kt
@@ -23,12 +23,29 @@ package com.patrykandpatrick.vico.core.cartesian
  * @see Insets
  */
 public interface HorizontalInsets {
-  /** Sets the start and end insets. */
-  public fun set(start: Float, end: Float)
-
-  /**
-   * For the start and end insets, updates the value of the inset to the corresponding provided
-   * value if the provided value is greater than the current value.
-   */
-  public fun setValuesIfGreater(start: Float, end: Float)
+  /** The start inset’s size (in pixels). */
+  public val start: Float
+
+  /** The end inset’s size (in pixels). */
+  public val end: Float
+
+  /** The sum of [start] and [end]. */
+  public val horizontal: Float
+    get() = start + end
+
+  /** Returns the left inset’s size (in pixels). */
+  public fun getLeft(isLtr: Boolean): Float = if (isLtr) start else end
+
+  /** Returns the right inset’s size (in pixels). */
+  public fun getRight(isLtr: Boolean): Float = if (isLtr) end else start
+
+  /** Ensures that the stored values are no smaller than the provided ones. */
+  public fun ensureValuesAtLeast(start: Float = this.start, end: Float = this.end)
+
+  /** Ensures that the stored values are no smaller than the provided ones. */
+  @Suppress("DeprecatedCallableAddReplaceWith")
+  @Deprecated("Use `ensureValuesAtLeast`.")
+  public fun setValuesIfGreater(start: Float, end: Float) {
+    ensureValuesAtLeast(start, end)
+  }
 }
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/HorizontalLayout.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/HorizontalLayout.kt
index 455a7bcac..cdf71b328 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/HorizontalLayout.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/HorizontalLayout.kt
@@ -16,19 +16,22 @@
 
 package com.patrykandpatrick.vico.core.cartesian
 
+import androidx.compose.runtime.Immutable
 import com.patrykandpatrick.vico.core.cartesian.axis.HorizontalAxis
+import com.patrykandpatrick.vico.core.cartesian.layer.CartesianLayer
 
 /**
- * Defines how a chart’s content is positioned horizontally. This affects the [CartesianChart] and
- * the [HorizontalAxis] instances.
+ * Defines how a [CartesianChart]’s content is positioned horizontally. This affects the
+ * [CartesianLayer]s and the [HorizontalAxis] instances.
  */
+@Immutable
 public sealed interface HorizontalLayout {
   /**
    * When this is applied, the [CartesianChart] centers each major entry in a designated segment.
    * Some empty space is visible at the start and end of the [CartesianChart]. [HorizontalAxis]
    * instances display ticks and guidelines at the edges of the segments.
    */
-  public object Segmented : HorizontalLayout
+  public data object Segmented : HorizontalLayout
 
   /**
    * When this is applied, the [CartesianChart]’s content takes up the [CartesianChart]’s entire
@@ -44,7 +47,23 @@ public sealed interface HorizontalLayout {
     public val scalableEndPaddingDp: Float = 0f,
     public val unscalableStartPaddingDp: Float = 0f,
     public val unscalableEndPaddingDp: Float = 0f,
-  ) : HorizontalLayout
+  ) : HorizontalLayout {
+    override fun equals(other: Any?): Boolean =
+      this === other ||
+        other is FullWidth &&
+          scalableStartPaddingDp == other.scalableStartPaddingDp &&
+          scalableEndPaddingDp == other.scalableEndPaddingDp &&
+          unscalableStartPaddingDp == other.unscalableStartPaddingDp &&
+          unscalableEndPaddingDp == other.unscalableEndPaddingDp
+
+    override fun hashCode(): Int {
+      var result = scalableStartPaddingDp.hashCode()
+      result = 31 * result + scalableEndPaddingDp.hashCode()
+      result = 31 * result + unscalableStartPaddingDp.hashCode()
+      result = 31 * result + unscalableEndPaddingDp.hashCode()
+      return result
+    }
+  }
 
   public companion object
 }
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/Insets.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/Insets.kt
index b0bc85091..2777401a3 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/Insets.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/Insets.kt
@@ -16,127 +16,82 @@
 
 package com.patrykandpatrick.vico.core.cartesian
 
-import com.patrykandpatrick.vico.core.common.half
-import kotlin.math.max
-
 /**
  * Used to store the insets requested by [ChartInsetter]s.
  *
- * @param start the start inset.
- * @param top the top inset.
- * @param end the end inset.
- * @param bottom the bottom inset.
  * @see ChartInsetter
  */
-public class Insets(
-  public var start: Float = 0f,
-  public var top: Float = 0f,
-  public var end: Float = 0f,
-  public var bottom: Float = 0f,
-) : HorizontalInsets {
-  /** The sum of the sizes of the start inset and the end inset. */
-  public val horizontal: Float
-    get() = start + end
+public class Insets : HorizontalInsets {
+  /** The start inset’s size (in pixels). */
+  public override var start: Float = 0f
+    private set
+
+  /** The top inset’s size (in pixels). */
+  public var top: Float = 0f
+    private set
+
+  /** The end inset’s size (in pixels). */
+  public override var end: Float = 0f
+    private set
 
-  /** The sum of the sizes of the top inset and the bottom inset. */
+  /** The bottom inset’s size (in pixels). */
+  public var bottom: Float = 0f
+    private set
+
+  /** The sum of [top] and [bottom]. */
   public val vertical: Float
     get() = top + bottom
 
-  /** The largest of the four insets. */
+  /** The largest of [start], [top], [end], and [bottom]. */
   public val max: Float
     get() = maxOf(start, top, end, bottom)
 
-  /**
-   * Updates the size of each of the four insets to match the size of its corresponding inset from
-   * the provided [Insets] instance.
-   */
-  public fun set(other: Insets): Insets = set(other.start, other.top, other.end, other.bottom)
-
-  /** Sets a common size for all four insets. */
-  public fun set(all: Float): Insets = set(all, all, all, all)
-
-  /** Updates the size of each of the four insets individually. */
-  public fun set(start: Float = 0f, top: Float = 0f, end: Float = 0f, bottom: Float = 0f): Insets =
-    apply {
-      this.start = start
-      this.top = top
-      this.end = end
-      this.bottom = bottom
-    }
-
-  /** Updates the sizes of the start inset and the end inset. */
-  override fun set(start: Float, end: Float) {
-    this.start = start
-    this.end = end
-  }
-
-  /**
-   * Returns the size of the left inset, taking into account the layout direction.
-   *
-   * @param isLtr whether the layout is left-to-right.
-   */
-  public fun getLeft(isLtr: Boolean): Float = if (isLtr) start else end
-
-  /**
-   * Returns the size of the right inset, taking into account the layout direction.
-   *
-   * @param isLtr whether the layout is left-to-right.
-   */
-  public fun getRight(isLtr: Boolean): Float = if (isLtr) end else start
-
-  /**
-   * Sets the sizes of the start inset and the end inset. [value] represents the sum of the two
-   * insets’ sizes, meaning the size of either inset will be half of [value].
-   */
-  public fun setHorizontal(value: Float): Insets = apply {
-    start = value.half
-    end = value.half
-  }
-
-  /**
-   * Sets the sizes of the top inset and the bottom inset. [value] represents the sum of the two
-   * insets’ sizes, meaning the size of either inset will be half of [value].
-   */
-  public fun setVertical(value: Float): Insets = apply {
-    top = value.half
-    bottom = value.half
-  }
-
-  override fun setValuesIfGreater(start: Float, end: Float) {
-    this.start = max(start, this.start)
-    this.end = max(end, this.end)
+  override fun ensureValuesAtLeast(start: Float, end: Float) {
+    this.start = this.start.coerceAtLeast(start)
+    this.end = this.end.coerceAtLeast(end)
   }
 
-  /**
-   * For each of the four insets, updates the size of the inset to the size of the corresponding
-   * inset from the provided [Insets] instance if the size of the corresponding inset from the
-   * provided [Insets] instance is greater.
-   */
-  public fun setValuesIfGreater(other: Insets) {
-    start = max(start, other.start)
-    top = max(top, other.top)
-    end = max(end, other.end)
-    bottom = max(bottom, other.bottom)
+  /** Ensures that the stored values are no smaller than the provided ones. */
+  public fun ensureValuesAtLeast(
+    start: Float = this.start,
+    top: Float = this.top,
+    end: Float = this.end,
+    bottom: Float = this.bottom,
+  ) {
+    this.start = this.start.coerceAtLeast(start)
+    this.top = this.top.coerceAtLeast(top)
+    this.end = this.end.coerceAtLeast(end)
+    this.bottom = this.bottom.coerceAtLeast(bottom)
   }
 
-  /**
-   * For each of the four insets, updates the size of the inset to the corresponding provided value
-   * if the corresponding provided value is greater.
-   */
+  /** Ensures that the stored values are no smaller than the provided ones. */
+  @Deprecated(
+    "Use `ensureValuesAtLeast`.",
+    ReplaceWith("ensureValuesAtLeast(start, top, end, bottom)"),
+  )
   public fun setAllIfGreater(
     start: Float = this.start,
     top: Float = this.top,
     end: Float = this.end,
     bottom: Float = this.bottom,
   ) {
-    this.start = max(start, this.start)
-    this.top = max(top, this.top)
-    this.end = max(end, this.end)
-    this.bottom = max(bottom, this.bottom)
+    ensureValuesAtLeast(start, top, end, bottom)
+  }
+
+  /** Ensures that the stored values are no smaller than those in [other]. */
+  @Deprecated(
+    "Use `ensureValuesAtLeast`.",
+    ReplaceWith("ensureValuesAtLeast(other.start, other.top, other.end, other.bottom)"),
+  )
+  public fun setValuesIfGreater(other: Insets) {
+    ensureValuesAtLeast(other.start, other.top, other.end, other.bottom)
   }
 
-  /** Sets the size of each of the four insets to zero. */
+  /** Clears the stored values. */
   public fun clear() {
-    set(0f)
+    start = 0f
+    top = 0f
+    end = 0f
+    bottom = 0f
   }
 }
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/MutableCartesianMeasureContext.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/MutableCartesianMeasureContext.kt
index 77a2aa20f..1123031b4 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/MutableCartesianMeasureContext.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/MutableCartesianMeasureContext.kt
@@ -17,19 +17,19 @@
 package com.patrykandpatrick.vico.core.cartesian
 
 import android.graphics.RectF
+import androidx.annotation.RestrictTo
 import com.patrykandpatrick.vico.core.cartesian.data.ChartValues
 import com.patrykandpatrick.vico.core.common.MutableMeasureContext
 
-/**
- * A [CartesianMeasureContext] implementation that facilitates the mutation of some of its
- * properties.
- */
+/** @suppress */
+@RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
 public class MutableCartesianMeasureContext(
   override val canvasBounds: RectF,
   override var density: Float,
   override var isLtr: Boolean,
-  override var scrollEnabled: Boolean = false,
-  override var horizontalLayout: HorizontalLayout = HorizontalLayout.Segmented,
+  override var scrollEnabled: Boolean,
+  override var zoomEnabled: Boolean,
+  override var horizontalLayout: HorizontalLayout,
   override var chartValues: ChartValues,
   spToPx: (Float) -> Float,
 ) :
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/Scroll.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/Scroll.kt
index 33b585363..3f1b96e01 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/Scroll.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/Scroll.kt
@@ -48,10 +48,10 @@ public sealed interface Scroll {
        * Scrolls to the specified _x_ coordinate, positioning it anywhere between the start edge
        * ([bias] = 0) and the end edge ([bias] = 1) of the [CartesianChart].
        */
-      public fun x(x: Float, bias: Float = 0f): Absolute =
+      public fun x(x: Double, bias: Float = 0f): Absolute =
         Absolute { context, horizontalDimensions, bounds, _ ->
           horizontalDimensions.startPadding +
-            (x - context.chartValues.minX) / context.chartValues.xStep *
+            ((x - context.chartValues.minX) / context.chartValues.xStep).toFloat() *
               horizontalDimensions.xSpacing - bias * bounds.width()
         }
     }
@@ -73,8 +73,8 @@ public sealed interface Scroll {
       public fun pixels(pixels: Float): Relative = Relative { _, _, _, _ -> pixels }
 
       /** Scrolls by the specified number of _x_ units. */
-      public fun x(x: Float): Relative = Relative { context, horizontalDimensions, _, _ ->
-        x / context.chartValues.xStep * horizontalDimensions.xSpacing
+      public fun x(x: Double): Relative = Relative { context, horizontalDimensions, _, _ ->
+        (x / context.chartValues.xStep).toFloat() * horizontalDimensions.xSpacing
       }
     }
   }
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/VirtualLayout.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/VirtualLayout.kt
deleted file mode 100644
index d8ee427c5..000000000
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/VirtualLayout.kt
+++ /dev/null
@@ -1,104 +0,0 @@
-/*
- * Copyright 2024 by Patryk Goworowski and Patrick Michalik.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.patrykandpatrick.vico.core.cartesian
-
-import android.graphics.RectF
-import com.patrykandpatrick.vico.core.cartesian.axis.AxisManager
-import com.patrykandpatrick.vico.core.common.Legend
-import com.patrykandpatrick.vico.core.common.orZero
-
-internal class VirtualLayout(private val axisManager: AxisManager) {
-  private val tempInsetters = ArrayList<ChartInsetter>(TEMP_INSETTERS_INITIAL_SIZE)
-
-  private val finalInsets: Insets = Insets()
-
-  private val tempInsets: Insets = Insets()
-
-  /**
-   * Measures and sets the bounds for the components of the chart.
-   *
-   * @param context holds data used for the measuring of components.
-   * @param contentBounds the bounds in which the chart should be drawn.
-   * @param chart the chart itself.
-   * @param legend the legend for the chart.
-   * @param horizontalDimensions the [HorizontalDimensions] of the chart.
-   * @param chartInsetter additional components that influence the chart layout, such as markers.
-   * @return the bounds applied to the chart.
-   */
-  fun setBounds(
-    context: CartesianMeasureContext,
-    contentBounds: RectF,
-    chart: CartesianChart,
-    legend: Legend<CartesianMeasureContext, *>?,
-    horizontalDimensions: HorizontalDimensions,
-    vararg chartInsetter: ChartInsetter?,
-  ): RectF =
-    with(context) {
-      tempInsetters.clear()
-      finalInsets.clear()
-      tempInsets.clear()
-
-      val legendHeight = legend?.getHeight(context, contentBounds.width()).orZero
-
-      axisManager.addInsetters(tempInsetters)
-      chartInsetter.filterNotNull().forEach(tempInsetters::add)
-      tempInsetters.addAll(chart.chartInsetters)
-      tempInsetters.add(chart)
-
-      tempInsetters.forEach { insetter ->
-        insetter.getInsets(context, tempInsets, horizontalDimensions)
-        finalInsets.setValuesIfGreater(tempInsets)
-      }
-
-      val availableHeight = contentBounds.height() - finalInsets.vertical - legendHeight
-
-      tempInsetters.forEach { insetter ->
-        insetter.getHorizontalInsets(context, availableHeight, tempInsets)
-        finalInsets.setValuesIfGreater(tempInsets)
-      }
-
-      val chartBounds =
-        RectF().apply {
-          left = contentBounds.left + finalInsets.getLeft(isLtr)
-          top = contentBounds.top + finalInsets.top
-          right = contentBounds.right - finalInsets.getRight(isLtr)
-          bottom = contentBounds.bottom - finalInsets.bottom - legendHeight
-        }
-
-      chart.setBounds(
-        left = chartBounds.left,
-        top = chartBounds.top,
-        right = chartBounds.right,
-        bottom = chartBounds.bottom,
-      )
-
-      axisManager.setAxesBounds(context, contentBounds, chartBounds, finalInsets)
-
-      legend?.setBounds(
-        left = contentBounds.left,
-        top = chart.bounds.bottom + finalInsets.bottom,
-        right = contentBounds.right,
-        bottom = chart.bounds.bottom + finalInsets.bottom + legendHeight,
-      )
-
-      chartBounds
-    }
-
-  private companion object {
-    const val TEMP_INSETTERS_INITIAL_SIZE = 5
-  }
-}
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/Zoom.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/Zoom.kt
index 91a56dd43..01e8e0844 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/Zoom.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/Zoom.kt
@@ -45,8 +45,8 @@ public fun interface Zoom {
     public fun static(value: Float = 1f): Zoom = Zoom { _, _, _ -> value }
 
     /** Ensures the specified number of _x_ units is visible. */
-    public fun x(x: Float): Zoom = Zoom { context, horizontalDimensions, bounds ->
-      bounds.width() * context.chartValues.xStep / (x * horizontalDimensions.xSpacing)
+    public fun x(x: Double): Zoom = Zoom { context, horizontalDimensions, bounds ->
+      bounds.width() * (context.chartValues.xStep / x).toFloat() / horizontalDimensions.xSpacing
     }
 
     /** Uses the smaller of [a]’s zoom factor and [b]’s zoom factor. */
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/axis/Axis.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/axis/Axis.kt
index c80388c2e..7fd53df95 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/axis/Axis.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/axis/Axis.kt
@@ -22,32 +22,23 @@ import com.patrykandpatrick.vico.core.cartesian.CartesianDrawContext
 import com.patrykandpatrick.vico.core.cartesian.CartesianMeasureContext
 import com.patrykandpatrick.vico.core.cartesian.ChartInsetter
 import com.patrykandpatrick.vico.core.cartesian.MutableHorizontalDimensions
-import com.patrykandpatrick.vico.core.common.BoundsAware
+import com.patrykandpatrick.vico.core.cartesian.data.CartesianChartModel
+import com.patrykandpatrick.vico.core.cartesian.layer.CartesianLayer
+import com.patrykandpatrick.vico.core.common.Bounded
 
 /**
  * Defines the minimal set of properties and functions required by other parts of the library to
  * draw an axis.
  */
-public interface Axis<Position : AxisPosition> : BoundsAware, ChartInsetter {
+public interface Axis<Position : AxisPosition> : Bounded, ChartInsetter<CartesianChartModel> {
   /** Defines the position of the axis relative to the [CartesianChart]. */
   public val position: Position
 
-  /**
-   * Called before the [CartesianChart] is drawn. Implementations should rely on this function to
-   * draw themselves, unless they need to draw something above the [CartesianChart].
-   *
-   * @param context holds the information needed to draw the axis.
-   * @see drawAboveChart
-   */
-  public fun drawBehindChart(context: CartesianDrawContext)
+  /** Draws content under the [CartesianLayer]s. */
+  public fun drawUnderLayers(context: CartesianDrawContext)
 
-  /**
-   * Called after the [CartesianChart] is drawn. Implementations can use this function to draw
-   * content above the [CartesianChart].
-   *
-   * @param context holds the information needed to draw the axis.
-   */
-  public fun drawAboveChart(context: CartesianDrawContext)
+  /** Draws content over the [CartesianLayer]s. */
+  public fun drawOverLayers(context: CartesianDrawContext)
 
   /** The bounds ([RectF]) passed here define the area where the [Axis] shouldn’t draw anything. */
   public fun setRestrictedBounds(vararg bounds: RectF?)
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/axis/AxisItemPlacer.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/axis/AxisItemPlacer.kt
deleted file mode 100644
index 972d435d4..000000000
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/axis/AxisItemPlacer.kt
+++ /dev/null
@@ -1,239 +0,0 @@
-/*
- * Copyright 2024 by Patryk Goworowski and Patrick Michalik.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.patrykandpatrick.vico.core.cartesian.axis
-
-import com.patrykandpatrick.vico.core.cartesian.CartesianChart
-import com.patrykandpatrick.vico.core.cartesian.CartesianDrawContext
-import com.patrykandpatrick.vico.core.cartesian.CartesianMeasureContext
-import com.patrykandpatrick.vico.core.cartesian.HorizontalDimensions
-import com.patrykandpatrick.vico.core.cartesian.HorizontalLayout
-import com.patrykandpatrick.vico.core.cartesian.data.ChartValues
-import com.patrykandpatrick.vico.core.common.data.ExtraStore
-
-/**
- * Determines for what values a [HorizontalAxis] or a [VerticalAxis] is to display labels, ticks,
- * and guidelines.
- */
-public interface AxisItemPlacer {
-  /** An [AxisItemPlacer] subinterface for [HorizontalAxis] instances. */
-  public interface Horizontal : AxisItemPlacer {
-    /**
-     * Whether ticks whose _x_ values are bounds of the _x_-axis value range should be shifted to
-     * the edges of the axis bounds, to be aligned with the vertical axes.
-     */
-    public fun getShiftExtremeTicks(context: CartesianDrawContext): Boolean = true
-
-    /**
-     * If the [HorizontalAxis] is to reserve room for the first label, returns the first label’s _x_
-     * value. Otherwise, returns `null`.
-     */
-    public fun getFirstLabelValue(context: CartesianMeasureContext, maxLabelWidth: Float): Float? =
-      null
-
-    /**
-     * If the [HorizontalAxis] is to reserve room for the last label, returns the last label’s _x_
-     * value. Otherwise, returns `null`.
-     */
-    public fun getLastLabelValue(context: CartesianMeasureContext, maxLabelWidth: Float): Float? =
-      null
-
-    /**
-     * Returns, as a list, the _x_ values for which labels are to be displayed, restricted to
-     * [visibleXRange] and with two extra values on either side (if applicable).
-     */
-    public fun getLabelValues(
-      context: CartesianDrawContext,
-      visibleXRange: ClosedFloatingPointRange<Float>,
-      fullXRange: ClosedFloatingPointRange<Float>,
-      maxLabelWidth: Float,
-    ): List<Float>
-
-    /**
-     * Returns, as a list, the _x_ values for which the [HorizontalAxis] is to create labels and
-     * measure their widths during the measuring phase. The width of the widest label is passed to
-     * other functions.
-     */
-    public fun getWidthMeasurementLabelValues(
-      context: CartesianMeasureContext,
-      horizontalDimensions: HorizontalDimensions,
-      fullXRange: ClosedFloatingPointRange<Float>,
-    ): List<Float>
-
-    /**
-     * Returns, as a list, the _x_ values for which the [HorizontalAxis] is to create labels and
-     * measure their heights during the measuring phase. This affects how much vertical space the
-     * [HorizontalAxis] requests.
-     */
-    public fun getHeightMeasurementLabelValues(
-      context: CartesianMeasureContext,
-      horizontalDimensions: HorizontalDimensions,
-      fullXRange: ClosedFloatingPointRange<Float>,
-      maxLabelWidth: Float,
-    ): List<Float>
-
-    /**
-     * Returns, as a list, the _x_ values for which ticks and guidelines are to be displayed,
-     * restricted to [visibleXRange] and with an extra value on either side (if applicable). If
-     * `null` is returned, the values returned by [getLabelValues] are used.
-     */
-    public fun getLineValues(
-      context: CartesianDrawContext,
-      visibleXRange: ClosedFloatingPointRange<Float>,
-      fullXRange: ClosedFloatingPointRange<Float>,
-      maxLabelWidth: Float,
-    ): List<Float>? = null
-
-    /** Returns the start inset required by the [HorizontalAxis]. */
-    public fun getStartHorizontalAxisInset(
-      context: CartesianMeasureContext,
-      horizontalDimensions: HorizontalDimensions,
-      tickThickness: Float,
-      maxLabelWidth: Float,
-    ): Float
-
-    /** Returns the end inset required by the [HorizontalAxis]. */
-    public fun getEndHorizontalAxisInset(
-      context: CartesianMeasureContext,
-      horizontalDimensions: HorizontalDimensions,
-      tickThickness: Float,
-      maxLabelWidth: Float,
-    ): Float
-
-    /** Houses an [AxisItemPlacer.Horizontal] factory function. */
-    public companion object {
-      /**
-       * Creates a base [AxisItemPlacer.Horizontal] implementation. [spacing] defines how often
-       * items should be drawn (relative to [ChartValues.xStep]). [offset] is the number of labels
-       * (and, for [HorizontalLayout.FullWidth], their corresponding ticks and guidelines) to skip
-       * from the start. [shiftExtremeTicks] defines whether ticks whose _x_ values are bounds of
-       * the _x_-axis value range should be shifted to the edges of the axis bounds, to be aligned
-       * with the vertical axes. [addExtremeLabelPadding] specifies whether, for
-       * [HorizontalLayout.FullWidth], padding should be added for the first and last labels,
-       * ensuring their visibility.
-       */
-      public fun default(
-        spacing: Int = 1,
-        offset: Int = 0,
-        shiftExtremeTicks: Boolean = true,
-        addExtremeLabelPadding: Boolean = false,
-      ): Horizontal =
-        DefaultHorizontalAxisItemPlacer(spacing, offset, shiftExtremeTicks, addExtremeLabelPadding)
-    }
-  }
-
-  /** An [AxisItemPlacer] subinterface for [VerticalAxis] instances. */
-  public interface Vertical {
-    /**
-     * Returns a boolean indicating whether to shift the lines whose _y_ values are equal to
-     * [ChartValues.YRange.maxY], if such lines are present, such that they’re immediately above the
-     * [CartesianChart]’s bounds. If the chart has a top axis, the shifted tick will then be aligned
-     * with this axis, and the shifted guideline will be hidden.
-     */
-    public fun getShiftTopLines(context: CartesianDrawContext): Boolean = true
-
-    /** Returns, as a list, the _y_ values for which labels are to be displayed. */
-    public fun getLabelValues(
-      context: CartesianDrawContext,
-      axisHeight: Float,
-      maxLabelHeight: Float,
-      position: AxisPosition.Vertical,
-    ): List<Float>
-
-    /**
-     * Returns, as a list, the _y_ values for which the [VerticalAxis] is to create labels and
-     * measure their widths during the measuring phase. This affects how much horizontal space the
-     * [VerticalAxis] requests.
-     */
-    public fun getWidthMeasurementLabelValues(
-      context: CartesianMeasureContext,
-      axisHeight: Float,
-      maxLabelHeight: Float,
-      position: AxisPosition.Vertical,
-    ): List<Float>
-
-    /**
-     * Returns, as a list, the _y_ values for which the [VerticalAxis] is to create labels and
-     * measure their heights during the measuring phase. The height of the tallest label is passed
-     * to other functions.
-     */
-    public fun getHeightMeasurementLabelValues(
-      context: CartesianMeasureContext,
-      position: AxisPosition.Vertical,
-    ): List<Float>
-
-    /** Returns, as a list, the _y_ values for which ticks and guidelines are to be displayed. */
-    public fun getLineValues(
-      context: CartesianDrawContext,
-      axisHeight: Float,
-      maxLabelHeight: Float,
-      position: AxisPosition.Vertical,
-    ): List<Float>? = null
-
-    /** Returns the top inset required by the [VerticalAxis]. */
-    public fun getTopVerticalAxisInset(
-      context: CartesianMeasureContext,
-      verticalLabelPosition: VerticalAxis.VerticalLabelPosition,
-      maxLabelHeight: Float,
-      maxLineThickness: Float,
-    ): Float
-
-    /** Returns the bottom inset required by the [VerticalAxis]. */
-    public fun getBottomVerticalAxisInset(
-      context: CartesianMeasureContext,
-      verticalLabelPosition: VerticalAxis.VerticalLabelPosition,
-      maxLabelHeight: Float,
-      maxLineThickness: Float,
-    ): Float
-
-    /** Houses [AxisItemPlacer.Vertical] factory functions. */
-    public companion object {
-      /**
-       * Creates a step-based [AxisItemPlacer.Vertical] implementation. [step] returns the
-       * difference between the _y_ values of neighboring labels (and their corresponding line
-       * pairs). A multiple of this may be used for overlap prevention. If `null` is returned, the
-       * step will be determined automatically. [shiftTopLines] defines whether to shift the lines
-       * whose _y_ values are equal to [ChartValues.YRange.maxY], if such lines are present, such
-       * that they’re immediately above the [CartesianChart]’s bounds. If the chart has a top axis,
-       * the shifted tick will then be aligned with this axis, and the shifted guideline will be
-       * hidden.
-       */
-      public fun step(
-        step: (ExtraStore) -> Float? = { null },
-        shiftTopLines: Boolean = true,
-      ): Vertical =
-        DefaultVerticalAxisItemPlacer(DefaultVerticalAxisItemPlacer.Mode.Step(step), shiftTopLines)
-
-      /**
-       * Creates a count-based [AxisItemPlacer.Vertical] implementation. [count] returns the number
-       * of labels (and their corresponding line pairs) to be displayed. This may be reduced for
-       * overlap prevention. If `null` is returned, the [VerticalAxis] will display as many items as
-       * possible. [shiftTopLines] defines whether to shift the lines whose _y_ values are equal to
-       * [ChartValues.YRange.maxY], if such lines are present, such that they’re immediately above
-       * the [CartesianChart]’s bounds. If the chart has a top axis, the shifted tick will then be
-       * aligned with this axis, and the shifted guideline will be hidden.
-       */
-      public fun count(
-        count: (ExtraStore) -> Int? = { null },
-        shiftTopLines: Boolean = true,
-      ): Vertical =
-        DefaultVerticalAxisItemPlacer(
-          DefaultVerticalAxisItemPlacer.Mode.Count(count),
-          shiftTopLines,
-        )
-    }
-  }
-}
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/axis/AxisManager.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/axis/AxisManager.kt
index 5df79c4e1..e4d42d2cd 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/axis/AxisManager.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/axis/AxisManager.kt
@@ -19,7 +19,6 @@ package com.patrykandpatrick.vico.core.cartesian.axis
 import android.graphics.RectF
 import com.patrykandpatrick.vico.core.cartesian.CartesianDrawContext
 import com.patrykandpatrick.vico.core.cartesian.CartesianMeasureContext
-import com.patrykandpatrick.vico.core.cartesian.ChartInsetter
 import com.patrykandpatrick.vico.core.cartesian.Insets
 import kotlin.properties.ReadWriteProperty
 import kotlin.reflect.KProperty
@@ -32,108 +31,78 @@ internal class AxisManager {
   var endAxis: Axis<AxisPosition.Vertical.End>? by cacheInList()
   var bottomAxis: Axis<AxisPosition.Horizontal.Bottom>? by cacheInList()
 
-  fun addInsetters(destination: MutableList<ChartInsetter>) {
-    startAxis?.let(destination::add)
-    topAxis?.let(destination::add)
-    endAxis?.let(destination::add)
-    bottomAxis?.let(destination::add)
-  }
-
   fun setAxesBounds(
     measureContext: CartesianMeasureContext,
-    contentBounds: RectF,
-    chartBounds: RectF,
+    canvasBounds: RectF,
+    layerBounds: RectF,
     insets: Insets,
   ) {
-    startAxis?.setStartAxisBounds(
-      context = measureContext,
-      contentBounds = contentBounds,
-      chartBounds = chartBounds,
-      insets = insets,
-    )
-
-    topAxis?.setTopAxisBounds(
-      context = measureContext,
-      contentBounds = contentBounds,
-      insets = insets,
-    )
-
-    endAxis?.setEndAxisBounds(
-      context = measureContext,
-      contentBounds = contentBounds,
-      chartBounds = chartBounds,
-      insets = insets,
-    )
-
-    bottomAxis?.setBottomAxisBounds(
-      context = measureContext,
-      contentBounds = contentBounds,
-      chartBounds = chartBounds,
-      insets = insets,
-    )
-
+    startAxis?.setStartAxisBounds(measureContext, canvasBounds, layerBounds, insets)
+    topAxis?.setTopAxisBounds(measureContext, canvasBounds, insets)
+    endAxis?.setEndAxisBounds(measureContext, canvasBounds, layerBounds, insets)
+    bottomAxis?.setBottomAxisBounds(measureContext, canvasBounds, layerBounds, insets)
     setRestrictedBounds()
   }
 
   private fun Axis<AxisPosition.Vertical.Start>.setStartAxisBounds(
     context: CartesianMeasureContext,
-    contentBounds: RectF,
-    chartBounds: RectF,
+    canvasBounds: RectF,
+    layerBounds: RectF,
     insets: Insets,
   ) {
     with(context) {
       setBounds(
-        left = if (isLtr) contentBounds.left else contentBounds.right - insets.start,
-        top = chartBounds.top,
-        right = if (isLtr) contentBounds.left + insets.start else contentBounds.right,
-        bottom = chartBounds.bottom,
+        left = if (isLtr) canvasBounds.left else canvasBounds.right - insets.start,
+        top = layerBounds.top,
+        right = if (isLtr) canvasBounds.left + insets.start else canvasBounds.right,
+        bottom = layerBounds.bottom,
       )
     }
   }
 
   private fun Axis<AxisPosition.Horizontal.Top>.setTopAxisBounds(
     context: CartesianMeasureContext,
-    contentBounds: RectF,
+    canvasBounds: RectF,
     insets: Insets,
   ) {
     with(context) {
       setBounds(
-        left = contentBounds.left + if (isLtr) insets.start else insets.end,
-        top = contentBounds.top,
-        right = contentBounds.right - if (isLtr) insets.end else insets.start,
-        bottom = contentBounds.top + insets.top,
+        left = canvasBounds.left + if (isLtr) insets.start else insets.end,
+        top = canvasBounds.top,
+        right = canvasBounds.right - if (isLtr) insets.end else insets.start,
+        bottom = canvasBounds.top + insets.top,
       )
     }
   }
 
   private fun Axis<AxisPosition.Vertical.End>.setEndAxisBounds(
     context: CartesianMeasureContext,
-    contentBounds: RectF,
-    chartBounds: RectF,
+    canvasBounds: RectF,
+    layerBounds: RectF,
     insets: Insets,
   ) {
     with(context) {
       setBounds(
-        left = if (isLtr) contentBounds.right - insets.end else contentBounds.left,
-        top = chartBounds.top,
-        right = if (isLtr) contentBounds.right else contentBounds.left + insets.end,
-        bottom = chartBounds.bottom,
+        left = if (isLtr) canvasBounds.right - insets.end else canvasBounds.left,
+        top = layerBounds.top,
+        right = if (isLtr) canvasBounds.right else canvasBounds.left + insets.end,
+        bottom = layerBounds.bottom,
       )
     }
   }
 
   private fun Axis<AxisPosition.Horizontal.Bottom>.setBottomAxisBounds(
     context: CartesianMeasureContext,
-    contentBounds: RectF,
-    chartBounds: RectF,
+    canvasBounds: RectF,
+    layerBounds: RectF,
     insets: Insets,
   ) {
     with(context) {
       setBounds(
-        left = contentBounds.left + if (isLtr) insets.start else insets.end,
-        top = chartBounds.bottom,
-        right = contentBounds.right - if (isLtr) insets.end else insets.start,
-        bottom = chartBounds.bottom + insets.bottom,
+        left = canvasBounds.left + if (isLtr) insets.start else insets.end,
+        top = layerBounds.bottom,
+        right = canvasBounds.right - if (isLtr) insets.end else insets.start,
+        bottom = layerBounds.bottom + insets.bottom,
       )
     }
   }
@@ -145,12 +114,12 @@ internal class AxisManager {
     bottomAxis?.setRestrictedBounds(topAxis?.bounds, endAxis?.bounds, startAxis?.bounds)
   }
 
-  fun drawBehindChart(context: CartesianDrawContext) {
-    axisCache.forEach { axis -> axis.drawBehindChart(context) }
+  fun drawUnderLayers(context: CartesianDrawContext) {
+    axisCache.forEach { axis -> axis.drawUnderLayers(context) }
   }
 
-  fun drawAboveChart(context: CartesianDrawContext) {
-    axisCache.forEach { axis -> axis.drawAboveChart(context) }
+  fun drawOverLayers(context: CartesianDrawContext) {
+    axisCache.forEach { axis -> axis.drawOverLayers(context) }
   }
 
   private fun <S, T : Axis<S>?> cacheInList(): ReadWriteProperty<AxisManager, T?> =
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/axis/BaseAxis.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/axis/BaseAxis.kt
index 7c0fe8e93..136c15523 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/axis/BaseAxis.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/axis/BaseAxis.kt
@@ -14,14 +14,10 @@
  * limitations under the License.
  */
 
-@file:Suppress("DeprecatedCallableAddReplaceWith")
-
 package com.patrykandpatrick.vico.core.cartesian.axis
 
 import android.graphics.RectF
-import androidx.annotation.RestrictTo
 import com.patrykandpatrick.vico.core.cartesian.data.CartesianValueFormatter
-import com.patrykandpatrick.vico.core.common.Defaults
 import com.patrykandpatrick.vico.core.common.MeasureContext
 import com.patrykandpatrick.vico.core.common.component.LineComponent
 import com.patrykandpatrick.vico.core.common.component.TextComponent
@@ -29,19 +25,37 @@ import com.patrykandpatrick.vico.core.common.orZero
 import com.patrykandpatrick.vico.core.common.setAll
 
 /**
- * A basic implementation of [Axis] used throughout the library.
+ * A base [Axis] implementation. This is extended by [HorizontalAxis] and [VerticalAxis].
  *
- * @see Axis
- * @see HorizontalAxis
- * @see VerticalAxis
+ * @property line used for the axis line.
+ * @property label used for the labels.
+ * @property labelRotationDegrees the label rotation (in degrees).
+ * @property valueFormatter formats the values.
+ * @property tick used for the ticks.
+ * @property tickLengthDp the tick length (in dp).
+ * @property guideline used for the guidelines.
+ * @property sizeConstraint determines how the [BaseAxis] sizes itself.
+ * @property titleComponent the title [TextComponent].
+ * @property title the title text.
  */
-public abstract class BaseAxis<Position : AxisPosition> : Axis<Position> {
+public abstract class BaseAxis<Position : AxisPosition>(
+  public var line: LineComponent?,
+  public var label: TextComponent?,
+  public var labelRotationDegrees: Float,
+  public var valueFormatter: CartesianValueFormatter,
+  public var tick: LineComponent?,
+  public var tickLengthDp: Float,
+  public var guideline: LineComponent?,
+  public var sizeConstraint: SizeConstraint,
+  public var titleComponent: TextComponent?,
+  public var title: CharSequence?,
+) : Axis<Position> {
   private val restrictedBounds: MutableList<RectF> = mutableListOf()
 
   override val bounds: RectF = RectF()
 
-  protected val MeasureContext.axisThickness: Float
-    get() = axisLine?.thicknessDp.orZero.pixels
+  protected val MeasureContext.lineThickness: Float
+    get() = line?.thicknessDp.orZero.pixels
 
   protected val MeasureContext.tickThickness: Float
     get() = tick?.thicknessDp.orZero.pixels
@@ -52,36 +66,6 @@ public abstract class BaseAxis<Position : AxisPosition> : Axis<Position> {
   protected val MeasureContext.tickLength: Float
     get() = if (tick != null) tickLengthDp.pixels else 0f
 
-  /** The [TextComponent] to use for labels. */
-  public var label: TextComponent? = null
-
-  /** The [LineComponent] to use for the axis line. */
-  public var axisLine: LineComponent? = null
-
-  /** The [LineComponent] to use for ticks. */
-  public var tick: LineComponent? = null
-
-  /** The [LineComponent] to use for guidelines. */
-  public var guideline: LineComponent? = null
-
-  /** The tick length (in dp). */
-  public var tickLengthDp: Float = 0f
-
-  /** Used by [BaseAxis] subclasses for sizing and layout. */
-  public var sizeConstraint: SizeConstraint = SizeConstraint.Auto()
-
-  /** The [CartesianValueFormatter] for the axis. */
-  public var valueFormatter: CartesianValueFormatter = CartesianValueFormatter.decimal()
-
-  /** The rotation of axis labels (in degrees). */
-  public var labelRotationDegrees: Float = 0f
-
-  /** An optional [TextComponent] to use as the axis title. */
-  public var titleComponent: TextComponent? = null
-
-  /** The axis title. */
-  public var title: CharSequence? = null
-
   override fun setRestrictedBounds(vararg bounds: RectF?) {
     restrictedBounds.setAll(bounds.filterNotNull())
   }
@@ -96,47 +80,10 @@ public abstract class BaseAxis<Position : AxisPosition> : Axis<Position> {
       it.contains(left, top, right, bottom) || it.intersects(left, top, right, bottom)
     }
 
-  /** Used to construct [BaseAxis] instances. */
-  public open class Builder<Position : AxisPosition>(builder: Builder<Position>? = null) {
-    /** The [TextComponent] to use for labels. */
-    public var label: TextComponent? = builder?.label
-
-    /** The [LineComponent] to use for the axis line. */
-    public var axis: LineComponent? = builder?.axis
-
-    /** The [LineComponent] to use for axis ticks. */
-    public var tick: LineComponent? = builder?.tick
-
-    /** The tick length (in dp). */
-    public var tickLengthDp: Float = builder?.tickLengthDp ?: Defaults.AXIS_TICK_LENGTH
-
-    /** The [LineComponent] to use for guidelines. */
-    public var guideline: LineComponent? = builder?.guideline
-
-    /** The [CartesianValueFormatter] for the axis. */
-    public var valueFormatter: CartesianValueFormatter =
-      builder?.valueFormatter ?: CartesianValueFormatter.decimal()
-
-    /** Used by [BaseAxis] subclasses for sizing and layout. */
-    public var sizeConstraint: SizeConstraint = SizeConstraint.Auto()
-
-    /** An optional [TextComponent] to use as the axis title. */
-    public var titleComponent: TextComponent? = builder?.titleComponent
-
-    /** The axis title. */
-    public var title: CharSequence? = builder?.title
-
-    /** The rotation of axis labels (in degrees). */
-    public var labelRotationDegrees: Float = builder?.labelRotationDegrees ?: 0f
-  }
-
   /**
-   * Defines how a [BaseAxis] is to size itself.
+   * Determines how a [BaseAxis] sizes itself.
    * - For [VerticalAxis], this defines the width.
    * - For [HorizontalAxis], this defines the height.
-   *
-   * @see [VerticalAxis]
-   * @see [HorizontalAxis]
    */
   public sealed class SizeConstraint {
     /**
@@ -177,21 +124,3 @@ public abstract class BaseAxis<Position : AxisPosition> : Axis<Position> {
     public class TextWidth(public val text: String) : SizeConstraint()
   }
 }
-
-/** @suppress */
-@RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
-public fun <Position : AxisPosition, A : BaseAxis<Position>> BaseAxis.Builder<Position>.setTo(
-  axis: A
-): A {
-  axis.axisLine = this.axis
-  axis.tick = tick
-  axis.guideline = guideline
-  axis.label = label
-  axis.tickLengthDp = tickLengthDp
-  axis.valueFormatter = valueFormatter
-  axis.sizeConstraint = sizeConstraint
-  axis.titleComponent = titleComponent
-  axis.title = title
-  axis.labelRotationDegrees = labelRotationDegrees
-  return axis
-}
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/axis/CustomVerticalAxis.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/axis/CustomVerticalAxis.kt
index a48e45881..4b6bf3a72 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/axis/CustomVerticalAxis.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/axis/CustomVerticalAxis.kt
@@ -16,26 +16,56 @@
 
 package com.patrykandpatrick.vico.core.cartesian.axis
 
-import android.graphics.Color
 import com.patrykandpatrick.vico.core.cartesian.CartesianDrawContext
+import com.patrykandpatrick.vico.core.cartesian.axis.VerticalAxis.HorizontalLabelPosition.Outside
+import com.patrykandpatrick.vico.core.cartesian.axis.VerticalAxis.VerticalLabelPosition.Center
+import com.patrykandpatrick.vico.core.cartesian.data.CartesianValueFormatter
 import com.patrykandpatrick.vico.core.common.component.LineComponent
 import com.patrykandpatrick.vico.core.common.component.TextComponent
+import com.patrykandpatrick.vico.core.common.translate
 
 
 /**
  * Custom implementation of vertical axis. It extends the VerticalAxis class and
  * provides additional functionality for handling vertical axis labels and guidelines.
  *
- * @param position The position of the axis
- *
  * @see VerticalAxis
  * @see AxisPosition.Vertical
  */
-public class CustomVerticalAxis<Position : AxisPosition.Vertical>(position: Position) :
-  VerticalAxis<Position>(position = position) {
-
+public class CustomVerticalAxis<Position : AxisPosition.Vertical>(
+  override val position: Position,
+  line: LineComponent?,
+  label: TextComponent?,
+  labelRotationDegrees: Float,
+  _horizontalLabelPosition: HorizontalLabelPosition = Outside,
+  _verticalLabelPosition: VerticalLabelPosition = Center,
+  valueFormatter: CartesianValueFormatter,
+  tick: LineComponent?,
+  tickLengthDp: Float,
+  guideline: LineComponent?,
+  _itemPlacer: ItemPlacer = ItemPlacer.step(),
+  sizeConstraint: SizeConstraint,
+  titleComponent: TextComponent?,
+  title: CharSequence?,
   /** The [LineComponent] to use for guidelines that aware of label width. */
-  public var labelGuideline: LineComponent? = null
+  public var labelGuideline: LineComponent? = null,
+) :
+  VerticalAxis<Position>(
+    position = position,
+    line = line,
+    label = label,
+    labelRotationDegrees = labelRotationDegrees,
+    horizontalLabelPosition = _horizontalLabelPosition,
+    verticalLabelPosition = _verticalLabelPosition,
+    valueFormatter = valueFormatter,
+    tick = tick,
+    tickLengthDp = tickLengthDp,
+    guideline = guideline,
+    itemPlacer = _itemPlacer,
+    sizeConstraint = sizeConstraint,
+    titleComponent = titleComponent,
+    title = title,
+  ) {
 
   /**
    * This function checks if the axis is not in restricted bounds.
@@ -56,74 +86,107 @@ public class CustomVerticalAxis<Position : AxisPosition.Vertical>(position: Posi
 
   override fun drawLabel(
     context: CartesianDrawContext,
-    label: TextComponent,
-    labelText: CharSequence,
+    labelComponent: TextComponent,
+    label: CharSequence,
     labelX: Float,
     tickCenterY: Float,
   ) {
     with(context) {
-      val textBounds =
-        label.getTextBounds(this, labelText, rotationDegrees = labelRotationDegrees)
+        val textBounds =
+          labelComponent
+            .getBounds(context = this, text = label, rotationDegrees = labelRotationDegrees)
+            .apply { translate(labelX, tickCenterY - centerY()) }
 
       if (position.isStart) {
         labelGuideline?.drawHorizontal(
           context = context,
-          left = chartBounds.left + textBounds.width(),
-          right = chartBounds.right,
+          left = layerBounds.left + textBounds.width(),
+          right = layerBounds.right,
           centerY = tickCenterY,
         )
       } else {
         labelGuideline?.drawHorizontal(
           context = context,
-          left = chartBounds.left,
-          right = chartBounds.right - textBounds.width(),
+          left = layerBounds.left,
+          right = layerBounds.right - textBounds.width(),
           centerY = tickCenterY,
         )
       }
     }
 
-    super.drawLabel(context, label, labelText, labelX, tickCenterY)
-  }
-
-  public class Builder<Position : AxisPosition.Vertical>(
-    builder: BaseAxis.Builder<Position>? = null,
-  ) : BaseAxis.Builder<Position>(builder) {
-    /**
-     * Determines for what _y_ values this [VerticalAxis] is to display labels, ticks, and
-     * guidelines.
-     */
-    public var itemPlacer: AxisItemPlacer.Vertical = AxisItemPlacer.Vertical.step()
-
-    /** Defines the horizontal position of each axis label relative to the axis line. */
-    public var horizontalLabelPosition: HorizontalLabelPosition = HorizontalLabelPosition.Outside
-
-    /** Defines the vertical position of each axis label relative to its corresponding tick. */
-    public var verticalLabelPosition: VerticalLabelPosition = VerticalLabelPosition.Center
-
-    /** Creates a [VerticalAxis] instance with the properties from this [Builder]. */
-    @Suppress("UNCHECKED_CAST")
-    public inline fun <reified T : Position> build(): CustomVerticalAxis<T> {
-      val position =
-        when (T::class.java) {
-          AxisPosition.Vertical.Start::class.java -> AxisPosition.Vertical.Start
-          AxisPosition.Vertical.End::class.java -> AxisPosition.Vertical.End
-          else ->
-            throw IllegalStateException("Got unknown AxisPosition class ${T::class.java.name}")
-        }
-          as Position
-      return setTo(CustomVerticalAxis(position)).also { axis ->
-        axis.itemPlacer = itemPlacer
-        axis.horizontalLabelPosition = horizontalLabelPosition
-        axis.verticalLabelPosition = verticalLabelPosition
-      } as CustomVerticalAxis<T>
-    }
+    super.drawLabel(context, labelComponent, label, labelX, tickCenterY)
   }
 
-  /** Houses a [VerticalAxis] factory function. */
+  /** Houses [VerticalAxis] factory functions. */
   public companion object {
-    /** Creates a [VerticalAxis] via [Builder]. */
-    public inline fun <reified P : AxisPosition.Vertical> build(
-      block: Builder<P>.() -> Unit = {},
-    ): CustomVerticalAxis<P> = Builder<P>().apply(block).build()
+    /** Creates a start [VerticalAxis]. */
+    public fun start(
+      line: LineComponent? = null,
+      label: TextComponent? = null,
+      labelRotationDegrees: Float = 0f,
+      horizontalLabelPosition: HorizontalLabelPosition = Outside,
+      verticalLabelPosition: VerticalLabelPosition = Center,
+      valueFormatter: CartesianValueFormatter = CartesianValueFormatter.decimal(),
+      tick: LineComponent? = null,
+      tickLengthDp: Float = 0f,
+      guideline: LineComponent? = null,
+      itemPlacer: ItemPlacer = ItemPlacer.step(),
+      sizeConstraint: SizeConstraint = SizeConstraint.Auto(),
+      titleComponent: TextComponent? = null,
+      title: CharSequence? = null,
+      labelGuideline: LineComponent? = null,
+    ): CustomVerticalAxis<AxisPosition.Vertical.Start> =
+      CustomVerticalAxis(
+        AxisPosition.Vertical.Start,
+        line,
+        label,
+        labelRotationDegrees,
+        horizontalLabelPosition,
+        verticalLabelPosition,
+        valueFormatter,
+        tick,
+        tickLengthDp,
+        guideline,
+        itemPlacer,
+        sizeConstraint,
+        titleComponent,
+        title,
+        labelGuideline,
+      )
+
+    /** Creates an end [VerticalAxis]. */
+    public fun end(
+      line: LineComponent? = null,
+      label: TextComponent? = null,
+      labelRotationDegrees: Float = 0f,
+      horizontalLabelPosition: HorizontalLabelPosition = Outside,
+      verticalLabelPosition: VerticalLabelPosition = Center,
+      valueFormatter: CartesianValueFormatter = CartesianValueFormatter.decimal(),
+      tick: LineComponent? = null,
+      tickLengthDp: Float = 0f,
+      guideline: LineComponent? = null,
+      itemPlacer: ItemPlacer = ItemPlacer.step(),
+      sizeConstraint: SizeConstraint = SizeConstraint.Auto(),
+      titleComponent: TextComponent? = null,
+      title: CharSequence? = null,
+      labelGuideline: LineComponent? = null,
+    ): CustomVerticalAxis<AxisPosition.Vertical.End> =
+      CustomVerticalAxis(
+        AxisPosition.Vertical.End,
+        line,
+        label,
+        labelRotationDegrees,
+        horizontalLabelPosition,
+        verticalLabelPosition,
+        valueFormatter,
+        tick,
+        tickLengthDp,
+        guideline,
+        itemPlacer,
+        sizeConstraint,
+        titleComponent,
+        title,
+        labelGuideline,
+      )
   }
 }
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/axis/DefaultHorizontalAxisItemPlacer.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/axis/DefaultHorizontalAxisItemPlacer.kt
index 4b6233e0d..64f4a5874 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/axis/DefaultHorizontalAxisItemPlacer.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/axis/DefaultHorizontalAxisItemPlacer.kt
@@ -21,17 +21,17 @@ import com.patrykandpatrick.vico.core.cartesian.CartesianMeasureContext
 import com.patrykandpatrick.vico.core.cartesian.HorizontalDimensions
 import com.patrykandpatrick.vico.core.cartesian.HorizontalLayout
 import com.patrykandpatrick.vico.core.cartesian.data.ChartValues
-import com.patrykandpatrick.vico.core.common.ceil
-import com.patrykandpatrick.vico.core.common.floor
 import com.patrykandpatrick.vico.core.common.half
-import com.patrykandpatrick.vico.core.common.round
+import com.patrykandpatrick.vico.core.common.roundedToNearest
+import kotlin.math.ceil
+import kotlin.math.floor
 
 internal class DefaultHorizontalAxisItemPlacer(
   private val spacing: Int,
   private val offset: Int,
   private val shiftExtremeTicks: Boolean,
   private val addExtremeLabelPadding: Boolean,
-) : AxisItemPlacer.Horizontal {
+) : HorizontalAxis.ItemPlacer {
   private val CartesianMeasureContext.addExtremeLabelPadding
     get() =
       this@DefaultHorizontalAxisItemPlacer.addExtremeLabelPadding &&
@@ -41,11 +41,11 @@ internal class DefaultHorizontalAxisItemPlacer(
     get() = buildList {
       add(minX)
       if (xLength < xStep) return@buildList
-      add(minX + xStep * (xLength / xStep).floor)
-      if (xLength >= 2 * xStep) add(minX + xStep * (xLength.half / xStep).round)
+      add(minX + xStep * floor(xLength / xStep))
+      if (xLength >= 2 * xStep) add(minX + xStep * (xLength.half / xStep).roundedToNearest)
     }
 
-  override fun getShiftExtremeTicks(context: CartesianDrawContext): Boolean = shiftExtremeTicks
+  override fun getShiftExtremeLines(context: CartesianDrawContext): Boolean = shiftExtremeTicks
 
   override fun getFirstLabelValue(context: CartesianMeasureContext, maxLabelWidth: Float) =
     if (context.addExtremeLabelPadding)
@@ -61,15 +61,15 @@ internal class DefaultHorizontalAxisItemPlacer(
 
   override fun getLabelValues(
     context: CartesianDrawContext,
-    visibleXRange: ClosedFloatingPointRange<Float>,
-    fullXRange: ClosedFloatingPointRange<Float>,
+    visibleXRange: ClosedFloatingPointRange<Double>,
+    fullXRange: ClosedFloatingPointRange<Double>,
     maxLabelWidth: Float,
-  ): List<Float> {
+  ): List<Double> {
     with(context) {
       val dynamicSpacing =
         spacing *
           if (this.addExtremeLabelPadding) {
-            (maxLabelWidth / (horizontalDimensions.xSpacing * spacing)).ceil.toInt()
+            ceil(maxLabelWidth / (horizontalDimensions.xSpacing * spacing)).toInt()
           } else {
             1
           }
@@ -78,13 +78,14 @@ internal class DefaultHorizontalAxisItemPlacer(
       val firstValue =
         visibleXRange.start + (dynamicSpacing - remainder) % dynamicSpacing * chartValues.xStep
       val minXOffset = chartValues.minX % chartValues.xStep
-      val values = mutableListOf<Float>()
+      val values = mutableListOf<Double>()
       var multiplier = -LABEL_OVERFLOW_SIZE
       var hasEndOverflow = false
       while (true) {
         var potentialValue = firstValue + multiplier++ * dynamicSpacing * chartValues.xStep
         potentialValue =
-          chartValues.xStep * ((potentialValue - minXOffset) / chartValues.xStep).round + minXOffset
+          chartValues.xStep * ((potentialValue - minXOffset) / chartValues.xStep).roundedToNearest +
+            minXOffset
         if (potentialValue < chartValues.minX || potentialValue == fullXRange.start) continue
         if (potentialValue > chartValues.maxX || potentialValue == fullXRange.endInclusive) break
         values += potentialValue
@@ -101,29 +102,29 @@ internal class DefaultHorizontalAxisItemPlacer(
   override fun getWidthMeasurementLabelValues(
     context: CartesianMeasureContext,
     horizontalDimensions: HorizontalDimensions,
-    fullXRange: ClosedFloatingPointRange<Float>,
+    fullXRange: ClosedFloatingPointRange<Double>,
   ) = if (context.addExtremeLabelPadding) context.chartValues.measuredLabelValues else emptyList()
 
   override fun getHeightMeasurementLabelValues(
     context: CartesianMeasureContext,
     horizontalDimensions: HorizontalDimensions,
-    fullXRange: ClosedFloatingPointRange<Float>,
+    fullXRange: ClosedFloatingPointRange<Double>,
     maxLabelWidth: Float,
   ) = context.chartValues.measuredLabelValues
 
   override fun getLineValues(
     context: CartesianDrawContext,
-    visibleXRange: ClosedFloatingPointRange<Float>,
-    fullXRange: ClosedFloatingPointRange<Float>,
+    visibleXRange: ClosedFloatingPointRange<Double>,
+    fullXRange: ClosedFloatingPointRange<Double>,
     maxLabelWidth: Float,
-  ): List<Float>? =
+  ): List<Double>? =
     with(context) {
       when (horizontalLayout) {
         is HorizontalLayout.Segmented -> {
           val remainder = (visibleXRange.start - fullXRange.start) % chartValues.xStep
           val firstValue = visibleXRange.start + (chartValues.xStep - remainder) % chartValues.xStep
           var multiplier = -TICK_OVERFLOW_SIZE
-          val values = mutableListOf<Float>()
+          val values = mutableListOf<Double>()
           while (true) {
             val potentialValue = firstValue + multiplier++ * chartValues.xStep
             if (potentialValue < fullXRange.start) continue
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/axis/DefaultVerticalAxisItemPlacer.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/axis/DefaultVerticalAxisItemPlacer.kt
index 520e61e6e..ebf33e090 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/axis/DefaultVerticalAxisItemPlacer.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/axis/DefaultVerticalAxisItemPlacer.kt
@@ -18,12 +18,13 @@ package com.patrykandpatrick.vico.core.cartesian.axis
 
 import com.patrykandpatrick.vico.core.cartesian.CartesianDrawContext
 import com.patrykandpatrick.vico.core.cartesian.CartesianMeasureContext
-import com.patrykandpatrick.vico.core.common.ceil
+import com.patrykandpatrick.vico.core.common.data.CacheStore
 import com.patrykandpatrick.vico.core.common.data.ExtraStore
-import com.patrykandpatrick.vico.core.common.floor
 import com.patrykandpatrick.vico.core.common.getDivisors
 import com.patrykandpatrick.vico.core.common.half
 import kotlin.math.abs
+import kotlin.math.ceil
+import kotlin.math.floor
 import kotlin.math.log10
 import kotlin.math.max
 import kotlin.math.pow
@@ -31,7 +32,7 @@ import kotlin.math.pow
 internal class DefaultVerticalAxisItemPlacer(
   private val mode: Mode,
   private val shiftTopLines: Boolean,
-) : AxisItemPlacer.Vertical {
+) : VerticalAxis.ItemPlacer {
   override fun getShiftTopLines(context: CartesianDrawContext): Boolean = shiftTopLines
 
   override fun getLabelValues(
@@ -46,12 +47,12 @@ internal class DefaultVerticalAxisItemPlacer(
     axisHeight: Float,
     maxLabelHeight: Float,
     position: AxisPosition.Vertical,
-  ): List<Float> = mode.getLabelValues(context, axisHeight, maxLabelHeight, position)
+  ): List<Double> = mode.getLabelValues(context, axisHeight, maxLabelHeight, position)
 
   override fun getHeightMeasurementLabelValues(
     context: CartesianMeasureContext,
     position: AxisPosition.Vertical,
-  ): List<Float> {
+  ): List<Double> {
     val yRange = context.chartValues.getYRange(position)
     return listOf(yRange.minY, (yRange.minY + yRange.maxY).half, yRange.maxY)
   }
@@ -83,7 +84,7 @@ internal class DefaultVerticalAxisItemPlacer(
       !mode.insetsRequired(context) -> 0f
       verticalLabelPosition == VerticalAxis.VerticalLabelPosition.Top -> maxLineThickness
       verticalLabelPosition == VerticalAxis.VerticalLabelPosition.Center ->
-        (maxOf(maxLabelHeight, maxLineThickness) + maxLineThickness).half
+        (max(maxLabelHeight, maxLineThickness) + maxLineThickness).half
       else -> maxLabelHeight + maxLineThickness.half
     }
 
@@ -93,14 +94,14 @@ internal class DefaultVerticalAxisItemPlacer(
       axisHeight: Float,
       maxLabelHeight: Float,
       position: AxisPosition.Vertical,
-    ): List<Float>
+    ): List<Double>
 
     fun getMixedLabelValues(
       context: CartesianMeasureContext,
       axisHeight: Float,
       maxLabelHeight: Float,
       position: AxisPosition.Vertical,
-    ): List<Float>
+    ): List<Double>
 
     fun insetsRequired(context: CartesianMeasureContext): Boolean = true
 
@@ -116,7 +117,7 @@ internal class DefaultVerticalAxisItemPlacer(
         getMixedLabelValues(context, axisHeight, maxLabelHeight, position)
       }
 
-    class Step(private val step: (ExtraStore) -> Float?) : Mode {
+    class Step(private val step: (ExtraStore) -> Double?) : Mode {
       private fun CartesianMeasureContext.getStepOrThrow() =
         step(chartValues.model.extraStore)?.also {
           require(it > 0) { "`step` must return a positive value." }
@@ -124,28 +125,40 @@ internal class DefaultVerticalAxisItemPlacer(
 
       private fun getPartialLabelValues(
         context: CartesianMeasureContext,
-        minY: Float,
-        maxY: Float,
+        minY: Double,
+        maxY: Double,
         freeHeight: Float,
         maxLabelHeight: Float,
         multiplier: Int = 1,
-      ): List<Float> {
-        val values = mutableListOf<Float>()
-        val requestedStep = context.getStepOrThrow() ?: 10f.pow(log10(maxY).floor - 1)
-        val step =
-          if (maxLabelHeight != 0f) {
-            val minStep = (maxY - minY) / (freeHeight / maxLabelHeight).floor
-            ((maxY - minY) / requestedStep)
-              .takeIf { it == it.floor }
-              ?.toInt()
-              ?.getDivisors(includeDividend = false)
-              ?.firstOrNull { it * requestedStep >= minStep }
-              ?.let { it * requestedStep } ?: ((minStep / requestedStep).ceil * requestedStep)
-          } else {
-            requestedStep
-          }
-        repeat(((maxY - minY) / step).toInt()) { values += multiplier * (minY + (it + 1) * step) }
-        return values
+      ): List<Double> {
+        val requestedStep = context.getStepOrThrow()
+        return context.cacheStore.getOrSet(
+          cacheKeyNamespace,
+          requestedStep,
+          maxY,
+          minY,
+          freeHeight,
+          maxLabelHeight,
+          multiplier,
+        ) {
+          val values = mutableListOf<Double>()
+          val requestedOrDefaultStep = requestedStep ?: 10.0.pow(floor(log10(maxY)) - 1)
+          val step =
+            if (maxLabelHeight != 0f) {
+              val minStep = (maxY - minY) / floor(freeHeight / maxLabelHeight)
+              ((maxY - minY) / requestedOrDefaultStep)
+                .takeIf { it == floor(it) }
+                ?.toInt()
+                ?.getDivisors(includeDividend = false)
+                ?.firstOrNull { it * requestedOrDefaultStep >= minStep }
+                ?.let { it * requestedOrDefaultStep }
+                ?: (ceil(minStep / requestedOrDefaultStep) * requestedOrDefaultStep)
+            } else {
+              requestedOrDefaultStep
+            }
+          repeat(((maxY - minY) / step).toInt()) { values += multiplier * (minY + (it + 1) * step) }
+          values
+        }
       }
 
       override fun getSimpleLabelValues(
@@ -153,7 +166,7 @@ internal class DefaultVerticalAxisItemPlacer(
         axisHeight: Float,
         maxLabelHeight: Float,
         position: AxisPosition.Vertical,
-      ): List<Float> =
+      ): List<Double> =
         context.chartValues.getYRange(position).run {
           if (maxY > 0) {
             getPartialLabelValues(context, minY, maxY, axisHeight, maxLabelHeight) + minY
@@ -174,27 +187,31 @@ internal class DefaultVerticalAxisItemPlacer(
         axisHeight: Float,
         maxLabelHeight: Float,
         position: AxisPosition.Vertical,
-      ): List<Float> =
+      ): List<Double> =
         context.chartValues.getYRange(position).run {
           val topLabelValues =
             getPartialLabelValues(
               context = context,
-              minY = 0f,
+              minY = 0.0,
               maxY = maxY,
-              freeHeight = maxY / length * axisHeight,
+              freeHeight = (maxY / length).toFloat() * axisHeight,
               maxLabelHeight = maxLabelHeight,
             )
           val bottomLabelValues =
             getPartialLabelValues(
               context = context,
-              minY = 0f,
+              minY = 0.0,
               maxY = abs(minY),
-              freeHeight = -minY / length * axisHeight,
+              freeHeight = (-minY / length).toFloat() * axisHeight,
               maxLabelHeight = maxLabelHeight,
               multiplier = -1,
             )
-          topLabelValues + bottomLabelValues + 0f
+          topLabelValues + bottomLabelValues + 0.0
         }
+
+      private companion object {
+        val cacheKeyNamespace = CacheStore.KeyNamespace()
+      }
     }
 
     class Count(private val count: (ExtraStore) -> Int?) : Mode {
@@ -208,8 +225,8 @@ internal class DefaultVerticalAxisItemPlacer(
         axisHeight: Float,
         maxLabelHeight: Float,
         position: AxisPosition.Vertical,
-      ): List<Float> {
-        val values = mutableListOf<Float>()
+      ): List<Double> {
+        val values = mutableListOf<Double>()
         val requestedItemCount = context.getCountOrThrow()
         if (requestedItemCount == 0) return values
         val yRange = context.chartValues.getYRange(position)
@@ -232,11 +249,11 @@ internal class DefaultVerticalAxisItemPlacer(
         axisHeight: Float,
         maxLabelHeight: Float,
         position: AxisPosition.Vertical,
-      ): List<Float> {
-        val values = mutableListOf<Float>()
+      ): List<Double> {
+        val values = mutableListOf<Double>()
         val requestedItemCount = context.getCountOrThrow()
         if (requestedItemCount == 0) return values
-        values += 0f
+        values += 0.0
         if (requestedItemCount == 1) return values
         val yRange = context.chartValues.getYRange(position)
         if (maxLabelHeight == 0f) {
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/axis/HorizontalAxis.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/axis/HorizontalAxis.kt
index 0bc3c93fa..bd6c283e1 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/axis/HorizontalAxis.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/axis/HorizontalAxis.kt
@@ -16,44 +16,92 @@
 
 package com.patrykandpatrick.vico.core.cartesian.axis
 
+import androidx.annotation.RestrictTo
 import com.patrykandpatrick.vico.core.cartesian.CartesianDrawContext
 import com.patrykandpatrick.vico.core.cartesian.CartesianMeasureContext
 import com.patrykandpatrick.vico.core.cartesian.HorizontalDimensions
+import com.patrykandpatrick.vico.core.cartesian.HorizontalLayout
 import com.patrykandpatrick.vico.core.cartesian.Insets
 import com.patrykandpatrick.vico.core.cartesian.MutableHorizontalDimensions
+import com.patrykandpatrick.vico.core.cartesian.data.CartesianChartModel
+import com.patrykandpatrick.vico.core.cartesian.data.CartesianValueFormatter
+import com.patrykandpatrick.vico.core.cartesian.data.ChartValues
+import com.patrykandpatrick.vico.core.cartesian.layer.CartesianLayer
 import com.patrykandpatrick.vico.core.common.VerticalPosition
-import com.patrykandpatrick.vico.core.common.ceil
+import com.patrykandpatrick.vico.core.common.component.LineComponent
+import com.patrykandpatrick.vico.core.common.component.TextComponent
 import com.patrykandpatrick.vico.core.common.doubled
 import com.patrykandpatrick.vico.core.common.getStart
 import com.patrykandpatrick.vico.core.common.half
 import com.patrykandpatrick.vico.core.common.isBoundOf
 import com.patrykandpatrick.vico.core.common.orZero
+import kotlin.math.ceil
+import kotlin.math.max
 import kotlin.math.min
 
 /**
- * An implementation of [Axis] used for horizontal axes. This class extends [BaseAxis].
+ * Draws horizontal axes. See the [BaseAxis] documentation for descriptions of the inherited
+ * properties.
  *
- * @see Axis
- * @see BaseAxis
+ * @property itemPlacer determines for what _x_ values the [HorizontalAxis] displays labels, ticks,
+ *   and guidelines.
  */
-public open class HorizontalAxis<Position : AxisPosition.Horizontal>(
-  override val position: Position
-) : BaseAxis<Position>() {
+public open class HorizontalAxis<Position : AxisPosition.Horizontal>
+protected constructor(
+  override val position: Position,
+  line: LineComponent?,
+  label: TextComponent?,
+  labelRotationDegrees: Float,
+  valueFormatter: CartesianValueFormatter,
+  tick: LineComponent?,
+  tickLengthDp: Float,
+  guideline: LineComponent?,
+  public var itemPlacer: ItemPlacer,
+  sizeConstraint: SizeConstraint,
+  titleComponent: TextComponent?,
+  title: CharSequence?,
+) :
+  BaseAxis<Position>(
+    line,
+    label,
+    labelRotationDegrees,
+    valueFormatter,
+    tick,
+    tickLengthDp,
+    guideline,
+    sizeConstraint,
+    titleComponent,
+    title,
+  ) {
   protected val AxisPosition.Horizontal.textVerticalPosition: VerticalPosition
     get() = if (isBottom) VerticalPosition.Bottom else VerticalPosition.Top
 
-  /**
-   * Determines for what _x_ values this [HorizontalAxis] is to display labels, ticks, and
-   * guidelines.
-   */
-  public var itemPlacer: AxisItemPlacer.Horizontal = AxisItemPlacer.Horizontal.default()
-
-  override fun drawBehindChart(context: CartesianDrawContext): Unit =
+  /** @suppress */
+  @RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
+  public constructor(
+    position: Position,
+    itemPlacer: ItemPlacer,
+  ) : this(
+    position = position,
+    line = null,
+    label = null,
+    labelRotationDegrees = 0f,
+    valueFormatter = CartesianValueFormatter.decimal(),
+    tick = null,
+    tickLengthDp = 0f,
+    guideline = null,
+    itemPlacer = itemPlacer,
+    sizeConstraint = SizeConstraint.Auto(),
+    titleComponent = null,
+    title = null,
+  )
+
+  override fun drawUnderLayers(context: CartesianDrawContext) {
     with(context) {
       val clipRestoreCount = canvas.save()
-      val tickMarkTop =
-        if (position.isBottom) bounds.top else bounds.bottom - axisThickness - tickLength
-      val tickMarkBottom = tickMarkTop + axisThickness + tickLength
+      val tickTop =
+        if (position.isBottom) bounds.top else bounds.bottom - lineThickness - tickLength
+      val tickBottom = tickTop + lineThickness + tickLength
       val fullXRange = getFullXRange(horizontalDimensions)
       val maxLabelWidth = getMaxLabelWidth(horizontalDimensions, fullXRange)
 
@@ -65,7 +113,7 @@ public open class HorizontalAxis<Position : AxisPosition.Horizontal>(
             tickThickness,
             maxLabelWidth,
           ),
-        minOf(bounds.top, chartBounds.top),
+        min(bounds.top, layerBounds.top),
         bounds.right +
           itemPlacer.getEndHorizontalAxisInset(
             this,
@@ -73,18 +121,16 @@ public open class HorizontalAxis<Position : AxisPosition.Horizontal>(
             tickThickness,
             maxLabelWidth,
           ),
-        maxOf(bounds.bottom, chartBounds.bottom),
+        max(bounds.bottom, layerBounds.bottom),
       )
 
-      val textY = if (position.isBottom) tickMarkBottom else tickMarkTop
+      val textY = if (position.isBottom) tickBottom else tickTop
       val baseCanvasX =
-        bounds.getStart(isLtr) - horizontalScroll +
+        bounds.getStart(isLtr) - scroll +
           horizontalDimensions.startPadding * layoutDirectionMultiplier
       val firstVisibleX =
         fullXRange.start +
-          horizontalScroll / horizontalDimensions.xSpacing *
-            chartValues.xStep *
-            layoutDirectionMultiplier
+          scroll / horizontalDimensions.xSpacing * chartValues.xStep * layoutDirectionMultiplier
       val lastVisibleX =
         firstVisibleX + bounds.width() / horizontalDimensions.xSpacing * chartValues.xStep
       val visibleXRange = firstVisibleX..lastVisibleX
@@ -94,17 +140,16 @@ public open class HorizontalAxis<Position : AxisPosition.Horizontal>(
       labelValues.forEachIndexed { index, x ->
         val canvasX =
           baseCanvasX +
-            (x - chartValues.minX) / chartValues.xStep *
+            ((x - chartValues.minX) / chartValues.xStep).toFloat() *
               horizontalDimensions.xSpacing *
               layoutDirectionMultiplier
         val previousX = labelValues.getOrNull(index - 1) ?: (fullXRange.start.doubled - x)
         val nextX = labelValues.getOrNull(index + 1) ?: (fullXRange.endInclusive.doubled - x)
         val maxWidth =
-          (min(x - previousX, nextX - x) / chartValues.xStep * horizontalDimensions.xSpacing)
-            .ceil
+          ceil(min(x - previousX, nextX - x) / chartValues.xStep * horizontalDimensions.xSpacing)
             .toInt()
 
-        label?.drawText(
+        label?.draw(
           context = context,
           text =
             valueFormatter.format(
@@ -112,19 +157,19 @@ public open class HorizontalAxis<Position : AxisPosition.Horizontal>(
               chartValues = chartValues,
               verticalAxisPosition = null,
             ),
-          textX = canvasX,
-          textY = textY,
+          x = canvasX,
+          y = textY,
           verticalPosition = position.textVerticalPosition,
-          maxTextWidth = maxWidth,
-          maxTextHeight = (bounds.height() - tickLength - axisThickness.half).toInt(),
+          maxWidth = maxWidth,
+          maxHeight = (bounds.height() - tickLength - lineThickness.half).toInt(),
           rotationDegrees = labelRotationDegrees,
         )
 
         if (lineValues == null) {
           tick?.drawVertical(
             context = this,
-            top = tickMarkTop,
-            bottom = tickMarkBottom,
+            top = tickTop,
+            bottom = tickBottom,
             centerX = canvasX + getLinesCorrectionX(x, fullXRange),
           )
         }
@@ -133,40 +178,43 @@ public open class HorizontalAxis<Position : AxisPosition.Horizontal>(
       lineValues?.forEach { x ->
         tick?.drawVertical(
           context = this,
-          top = tickMarkTop,
-          bottom = tickMarkBottom,
+          top = tickTop,
+          bottom = tickBottom,
           centerX =
             baseCanvasX +
-              (x - chartValues.minX) / chartValues.xStep *
+              ((x - chartValues.minX) / chartValues.xStep).toFloat() *
                 horizontalDimensions.xSpacing *
                 layoutDirectionMultiplier +
               getLinesCorrectionX(x, fullXRange),
         )
       }
 
-      val axisLineExtend =
-        if (itemPlacer.getShiftExtremeTicks(context)) {
+      val lineExtensionLength =
+        if (itemPlacer.getShiftExtremeLines(context)) {
           tickThickness
         } else {
           tickThickness.half
         }
 
-      axisLine?.drawHorizontal(
+      line?.drawHorizontal(
         context = context,
-        left = chartBounds.left - axisLineExtend,
-        right = chartBounds.right + axisLineExtend,
+        left = layerBounds.left - lineExtensionLength,
+        right = layerBounds.right + lineExtensionLength,
         centerY =
-          if (position.isBottom) bounds.top + axisThickness.half
-          else bounds.bottom - axisThickness.half,
+          if (position.isBottom) {
+            bounds.top + lineThickness.half
+          } else {
+            bounds.bottom - lineThickness.half
+          },
       )
 
       title?.let { title ->
-        titleComponent?.drawText(
+        titleComponent?.draw(
           context = context,
-          textX = bounds.centerX(),
-          textY = if (position.isTop) bounds.top else bounds.bottom,
+          x = bounds.centerX(),
+          y = if (position.isTop) bounds.top else bounds.bottom,
           verticalPosition = if (position.isTop) VerticalPosition.Bottom else VerticalPosition.Top,
-          maxTextWidth = bounds.width().toInt(),
+          maxWidth = bounds.width().toInt(),
           text = title,
         )
       }
@@ -175,43 +223,44 @@ public open class HorizontalAxis<Position : AxisPosition.Horizontal>(
 
       drawGuidelines(context, baseCanvasX, fullXRange, labelValues, lineValues)
     }
+  }
 
   protected open fun drawGuidelines(
     context: CartesianDrawContext,
     baseCanvasX: Float,
-    fullXRange: ClosedFloatingPointRange<Float>,
-    labelValues: List<Float>,
-    lineValues: List<Float>?,
+    fullXRange: ClosedFloatingPointRange<Double>,
+    labelValues: List<Double>,
+    lineValues: List<Double>?,
   ): Unit =
     with(context) {
       val guideline = guideline ?: return
       val clipRestoreCount = canvas.save()
-      canvas.clipRect(chartBounds)
+      canvas.clipRect(layerBounds)
 
       if (lineValues == null) {
         labelValues.forEach { x ->
           val canvasX =
             baseCanvasX +
-              (x - chartValues.minX) / chartValues.xStep *
+              ((x - chartValues.minX) / chartValues.xStep).toFloat() *
                 horizontalDimensions.xSpacing *
                 layoutDirectionMultiplier
 
           guideline
             .takeUnless { x.isBoundOf(fullXRange) }
-            ?.drawVertical(this, chartBounds.top, chartBounds.bottom, canvasX)
+            ?.drawVertical(this, layerBounds.top, layerBounds.bottom, canvasX)
         }
       } else {
         lineValues.forEach { x ->
           val canvasX =
             baseCanvasX +
-              (x - chartValues.minX) / chartValues.xStep *
+              ((x - chartValues.minX) / chartValues.xStep).toFloat() *
                 horizontalDimensions.xSpacing *
                 layoutDirectionMultiplier +
               getLinesCorrectionX(x, fullXRange)
 
           guideline
             .takeUnless { x.isBoundOf(fullXRange) }
-            ?.drawVertical(this, chartBounds.top, chartBounds.bottom, canvasX)
+            ?.drawVertical(this, layerBounds.top, layerBounds.bottom, canvasX)
         }
       }
 
@@ -219,17 +268,17 @@ public open class HorizontalAxis<Position : AxisPosition.Horizontal>(
     }
 
   protected fun CartesianDrawContext.getLinesCorrectionX(
-    entryX: Float,
-    fullXRange: ClosedFloatingPointRange<Float>,
+    entryX: Double,
+    fullXRange: ClosedFloatingPointRange<Double>,
   ): Float =
     when {
-      itemPlacer.getShiftExtremeTicks(this).not() -> 0f
+      itemPlacer.getShiftExtremeLines(this).not() -> 0f
       entryX == fullXRange.start -> -tickThickness.half
       entryX == fullXRange.endInclusive -> tickThickness.half
       else -> 0f
     } * layoutDirectionMultiplier
 
-  override fun drawAboveChart(context: CartesianDrawContext): Unit = Unit
+  override fun drawOverLayers(context: CartesianDrawContext) {}
 
   override fun updateHorizontalDimensions(
     context: CartesianMeasureContext,
@@ -248,15 +297,20 @@ public open class HorizontalAxis<Position : AxisPosition.Horizontal>(
           chartValues = chartValues,
           verticalAxisPosition = null,
         )
-      label
-        .getWidth(
-          context = context,
-          text = text,
-          rotationDegrees = labelRotationDegrees,
-          pad = true,
-        )
-        .half
-        .let { horizontalDimensions.ensureValuesAtLeast(unscalableStartPadding = it) }
+      var unscalableStartPadding =
+        label
+          .getWidth(
+            context = context,
+            text = text,
+            rotationDegrees = labelRotationDegrees,
+            pad = true,
+          )
+          .half
+      if (!context.zoomEnabled) {
+        unscalableStartPadding -=
+          (firstLabelValue - chartValues.minX).toFloat() * horizontalDimensions.xSpacing
+      }
+      horizontalDimensions.ensureValuesAtLeast(unscalableStartPadding = unscalableStartPadding)
     }
     if (lastLabelValue != null) {
       val text =
@@ -265,58 +319,62 @@ public open class HorizontalAxis<Position : AxisPosition.Horizontal>(
           chartValues = chartValues,
           verticalAxisPosition = null,
         )
-      label
-        .getWidth(
-          context = context,
-          text = text,
-          rotationDegrees = labelRotationDegrees,
-          pad = true,
-        )
-        .half
-        .let { horizontalDimensions.ensureValuesAtLeast(unscalableEndPadding = it) }
+      var unscalableEndPadding =
+        label
+          .getWidth(
+            context = context,
+            text = text,
+            rotationDegrees = labelRotationDegrees,
+            pad = true,
+          )
+          .half
+      if (!context.zoomEnabled) {
+        unscalableEndPadding -=
+          ((chartValues.maxX - lastLabelValue) * horizontalDimensions.xSpacing).toFloat()
+      }
+      horizontalDimensions.ensureValuesAtLeast(unscalableEndPadding = unscalableEndPadding)
     }
   }
 
-  override fun getInsets(
+  override fun updateInsets(
     context: CartesianMeasureContext,
-    outInsets: Insets,
     horizontalDimensions: HorizontalDimensions,
+    model: CartesianChartModel,
+    insets: Insets,
   ) {
     val maxLabelWidth =
       context.getMaxLabelWidth(horizontalDimensions, context.getFullXRange(horizontalDimensions))
-    with(outInsets) {
-      start =
-        itemPlacer.getStartHorizontalAxisInset(
-          context,
-          horizontalDimensions,
-          context.tickThickness,
-          maxLabelWidth,
-        )
-      end =
-        itemPlacer.getEndHorizontalAxisInset(
-          context,
-          horizontalDimensions,
-          context.tickThickness,
-          maxLabelWidth,
-        )
-      top =
-        if (position.isTop) getDesiredHeight(context, horizontalDimensions, maxLabelWidth) else 0f
-      bottom =
-        if (position.isBottom) getDesiredHeight(context, horizontalDimensions, maxLabelWidth)
-        else 0f
+    val height = getHeight(context, horizontalDimensions, maxLabelWidth)
+    insets.ensureValuesAtLeast(
+      itemPlacer.getStartHorizontalAxisInset(
+        context,
+        horizontalDimensions,
+        context.tickThickness,
+        maxLabelWidth,
+      ),
+      itemPlacer.getEndHorizontalAxisInset(
+        context,
+        horizontalDimensions,
+        context.tickThickness,
+        maxLabelWidth,
+      ),
+    )
+    when {
+      position.isTop -> insets.ensureValuesAtLeast(top = height)
+      position.isBottom -> insets.ensureValuesAtLeast(bottom = height)
     }
   }
 
   protected fun CartesianMeasureContext.getFullXRange(
     horizontalDimensions: HorizontalDimensions
-  ): ClosedFloatingPointRange<Float> =
+  ): ClosedFloatingPointRange<Double> =
     with(horizontalDimensions) {
       val start = chartValues.minX - startPadding / xSpacing * chartValues.xStep
       val end = chartValues.maxX + endPadding / xSpacing * chartValues.xStep
       start..end
     }
 
-  protected open fun getDesiredHeight(
+  protected open fun getHeight(
     context: CartesianMeasureContext,
     horizontalDimensions: HorizontalDimensions,
     maxLabelWidth: Float,
@@ -332,14 +390,14 @@ public open class HorizontalAxis<Position : AxisPosition.Horizontal>(
               ?.let { title ->
                 titleComponent?.getHeight(
                   context = context,
-                  width = bounds.width().toInt(),
+                  maxWidth = bounds.width().toInt(),
                   text = title,
                 )
               }
               .orZero
           (labelHeight +
               titleComponentHeight +
-              (if (position.isBottom) axisThickness else 0f) +
+              (if (position.isBottom) lineThickness else 0f) +
               tickLength)
             .coerceAtMost(maximumValue = canvasBounds.height() / MAX_HEIGHT_DIVISOR)
             .coerceIn(
@@ -362,7 +420,7 @@ public open class HorizontalAxis<Position : AxisPosition.Horizontal>(
 
   protected fun CartesianMeasureContext.getMaxLabelWidth(
     horizontalDimensions: HorizontalDimensions,
-    fullXRange: ClosedFloatingPointRange<Float>,
+    fullXRange: ClosedFloatingPointRange<Double>,
   ): Float {
     val label = label ?: return 0f
     return itemPlacer
@@ -386,7 +444,7 @@ public open class HorizontalAxis<Position : AxisPosition.Horizontal>(
 
   protected fun CartesianMeasureContext.getMaxLabelHeight(
     horizontalDimensions: HorizontalDimensions,
-    fullXRange: ClosedFloatingPointRange<Float>,
+    fullXRange: ClosedFloatingPointRange<Double>,
     maxLabelWidth: Float,
   ): Float {
     val label = label ?: return 0f
@@ -408,41 +466,176 @@ public open class HorizontalAxis<Position : AxisPosition.Horizontal>(
       }
   }
 
-  /**
-   * Creates [HorizontalAxis] instances. It’s recommended to use this via [HorizontalAxis.build].
-   */
-  public class Builder<Position : AxisPosition.Horizontal>(
-    builder: BaseAxis.Builder<Position>? = null
-  ) : BaseAxis.Builder<Position>(builder) {
+  /** Determines for what _x_ values a [HorizontalAxis] displays labels, ticks, and guidelines. */
+  public interface ItemPlacer {
     /**
-     * Determines for what _x_ values the [HorizontalAxis] is to display labels, ticks, and
-     * guidelines.
+     * Returns a boolean indicating whether to shift the lines whose _x_ values are equal to
+     * [ChartValues.minX] or [ChartValues.maxX], if such lines are present, outward. The
+     * [ChartValues.minX] lines are then positioned immediately before the start edge of the
+     * [CartesianLayer] bounds, and the [ChartValues.maxX] lines are positioned immediately after
+     * these bounds’ end edge. On either side, if a [VerticalAxis] is present, the shifted tick is
+     * aligned with it, and the shifted guideline is hidden.
      */
-    public var itemPlacer: AxisItemPlacer.Horizontal = AxisItemPlacer.Horizontal.default()
-
-    /** Creates a [HorizontalAxis] instance with the properties from this [Builder]. */
-    @Suppress("UNCHECKED_CAST")
-    public inline fun <reified T : Position> build(): HorizontalAxis<T> {
-      val position =
-        when (T::class.java) {
-          AxisPosition.Horizontal.Top::class.java -> AxisPosition.Horizontal.Top
-          AxisPosition.Horizontal.Bottom::class.java -> AxisPosition.Horizontal.Bottom
-          else ->
-            throw IllegalStateException("Got unknown AxisPosition class ${T::class.java.name}")
-        }
-          as Position
-      return setTo(HorizontalAxis(position = position)).also { it.itemPlacer = itemPlacer }
-        as HorizontalAxis<T>
+    public fun getShiftExtremeLines(context: CartesianDrawContext): Boolean = true
+
+    /**
+     * If the [HorizontalAxis] is to reserve room for the first label, returns the first label’s _x_
+     * value. Otherwise, returns `null`.
+     */
+    public fun getFirstLabelValue(context: CartesianMeasureContext, maxLabelWidth: Float): Double? =
+      null
+
+    /**
+     * If the [HorizontalAxis] is to reserve room for the last label, returns the last label’s _x_
+     * value. Otherwise, returns `null`.
+     */
+    public fun getLastLabelValue(context: CartesianMeasureContext, maxLabelWidth: Float): Double? =
+      null
+
+    /**
+     * Returns, as a list, the _x_ values for which labels are to be displayed, restricted to
+     * [visibleXRange] and with two extra values on either side (if applicable).
+     */
+    public fun getLabelValues(
+      context: CartesianDrawContext,
+      visibleXRange: ClosedFloatingPointRange<Double>,
+      fullXRange: ClosedFloatingPointRange<Double>,
+      maxLabelWidth: Float,
+    ): List<Double>
+
+    /**
+     * Returns, as a list, the _x_ values for which the [HorizontalAxis] is to create labels and
+     * measure their widths during the measuring phase. The width of the widest label is passed to
+     * other functions.
+     */
+    public fun getWidthMeasurementLabelValues(
+      context: CartesianMeasureContext,
+      horizontalDimensions: HorizontalDimensions,
+      fullXRange: ClosedFloatingPointRange<Double>,
+    ): List<Double>
+
+    /**
+     * Returns, as a list, the _x_ values for which the [HorizontalAxis] is to create labels and
+     * measure their heights during the measuring phase. This affects how much vertical space the
+     * [HorizontalAxis] requests.
+     */
+    public fun getHeightMeasurementLabelValues(
+      context: CartesianMeasureContext,
+      horizontalDimensions: HorizontalDimensions,
+      fullXRange: ClosedFloatingPointRange<Double>,
+      maxLabelWidth: Float,
+    ): List<Double>
+
+    /**
+     * Returns, as a list, the _x_ values for which ticks and guidelines are to be displayed,
+     * restricted to [visibleXRange] and with an extra value on either side (if applicable). If
+     * `null` is returned, the values returned by [getLabelValues] are used.
+     */
+    public fun getLineValues(
+      context: CartesianDrawContext,
+      visibleXRange: ClosedFloatingPointRange<Double>,
+      fullXRange: ClosedFloatingPointRange<Double>,
+      maxLabelWidth: Float,
+    ): List<Double>? = null
+
+    /** Returns the start inset required by the [HorizontalAxis]. */
+    public fun getStartHorizontalAxisInset(
+      context: CartesianMeasureContext,
+      horizontalDimensions: HorizontalDimensions,
+      tickThickness: Float,
+      maxLabelWidth: Float,
+    ): Float
+
+    /** Returns the end inset required by the [HorizontalAxis]. */
+    public fun getEndHorizontalAxisInset(
+      context: CartesianMeasureContext,
+      horizontalDimensions: HorizontalDimensions,
+      tickThickness: Float,
+      maxLabelWidth: Float,
+    ): Float
+
+    /** Houses an [ItemPlacer] factory function. */
+    public companion object {
+      /**
+       * Creates a base [ItemPlacer] implementation. [spacing] defines how often items should be
+       * drawn (relative to [ChartValues.xStep]). [offset] is the number of labels (and, for
+       * [HorizontalLayout.FullWidth], their corresponding ticks and guidelines) to skip from the
+       * start. [shiftExtremeTicks] defines whether ticks whose _x_ values are bounds of the
+       * _x_-axis value range should be shifted to the edges of the axis bounds, to be aligned with
+       * the vertical axes. [addExtremeLabelPadding] specifies whether, for
+       * [HorizontalLayout.FullWidth], padding should be added for the first and last labels,
+       * ensuring their visibility.
+       */
+      public fun default(
+        spacing: Int = 1,
+        offset: Int = 0,
+        shiftExtremeTicks: Boolean = true,
+        addExtremeLabelPadding: Boolean = false,
+      ): ItemPlacer =
+        DefaultHorizontalAxisItemPlacer(spacing, offset, shiftExtremeTicks, addExtremeLabelPadding)
     }
   }
 
-  /** Houses a [HorizontalAxis] factory function. */
+  /** Houses [HorizontalAxis] factory functions. */
   public companion object {
     private const val MAX_HEIGHT_DIVISOR = 3f
 
-    /** Creates a [HorizontalAxis] via [Builder]. */
-    public inline fun <reified P : AxisPosition.Horizontal> build(
-      block: Builder<P>.() -> Unit = {}
-    ): HorizontalAxis<P> = Builder<P>().apply(block).build()
+    /** Creates a top [HorizontalAxis]. */
+    public fun top(
+      line: LineComponent? = null,
+      label: TextComponent? = null,
+      labelRotationDegrees: Float = 0f,
+      valueFormatter: CartesianValueFormatter = CartesianValueFormatter.decimal(),
+      tick: LineComponent? = null,
+      tickLengthDp: Float = 0f,
+      guideline: LineComponent? = null,
+      itemPlacer: ItemPlacer = ItemPlacer.default(),
+      sizeConstraint: SizeConstraint = SizeConstraint.Auto(),
+      titleComponent: TextComponent? = null,
+      title: CharSequence? = null,
+    ): HorizontalAxis<AxisPosition.Horizontal.Top> =
+      HorizontalAxis(
+        AxisPosition.Horizontal.Top,
+        line,
+        label,
+        labelRotationDegrees,
+        valueFormatter,
+        tick,
+        tickLengthDp,
+        guideline,
+        itemPlacer,
+        sizeConstraint,
+        titleComponent,
+        title,
+      )
+
+    /** Creates a bottom [HorizontalAxis]. */
+    public fun bottom(
+      line: LineComponent? = null,
+      label: TextComponent? = null,
+      labelRotationDegrees: Float = 0f,
+      valueFormatter: CartesianValueFormatter = CartesianValueFormatter.decimal(),
+      tick: LineComponent? = null,
+      tickLengthDp: Float = 0f,
+      guideline: LineComponent? = null,
+      itemPlacer: ItemPlacer = ItemPlacer.default(),
+      sizeConstraint: SizeConstraint = SizeConstraint.Auto(),
+      titleComponent: TextComponent? = null,
+      title: CharSequence? = null,
+    ): HorizontalAxis<AxisPosition.Horizontal.Bottom> =
+      HorizontalAxis(
+        AxisPosition.Horizontal.Bottom,
+        line,
+        label,
+        labelRotationDegrees,
+        valueFormatter,
+        tick,
+        tickLengthDp,
+        guideline,
+        itemPlacer,
+        sizeConstraint,
+        titleComponent,
+        title,
+      )
   }
 }
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/axis/VerticalAxis.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/axis/VerticalAxis.kt
index b7af7e990..bc7348a2e 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/axis/VerticalAxis.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/axis/VerticalAxis.kt
@@ -16,6 +16,8 @@
 
 package com.patrykandpatrick.vico.core.cartesian.axis
 
+import androidx.annotation.RestrictTo
+import com.patrykandpatrick.vico.core.cartesian.CartesianChart
 import com.patrykandpatrick.vico.core.cartesian.CartesianDrawContext
 import com.patrykandpatrick.vico.core.cartesian.CartesianMeasureContext
 import com.patrykandpatrick.vico.core.cartesian.HorizontalDimensions
@@ -25,27 +27,63 @@ import com.patrykandpatrick.vico.core.cartesian.MutableHorizontalDimensions
 import com.patrykandpatrick.vico.core.cartesian.axis.VerticalAxis.HorizontalLabelPosition.Inside
 import com.patrykandpatrick.vico.core.cartesian.axis.VerticalAxis.HorizontalLabelPosition.Outside
 import com.patrykandpatrick.vico.core.cartesian.axis.VerticalAxis.VerticalLabelPosition.Center
+import com.patrykandpatrick.vico.core.cartesian.data.CartesianChartModel
+import com.patrykandpatrick.vico.core.cartesian.data.CartesianValueFormatter
+import com.patrykandpatrick.vico.core.cartesian.data.ChartValues
+import com.patrykandpatrick.vico.core.cartesian.layer.CartesianLayer
 import com.patrykandpatrick.vico.core.common.HorizontalPosition
 import com.patrykandpatrick.vico.core.common.VerticalPosition
-import com.patrykandpatrick.vico.core.common.ceil
+import com.patrykandpatrick.vico.core.common.component.LineComponent
 import com.patrykandpatrick.vico.core.common.component.TextComponent
 import com.patrykandpatrick.vico.core.common.data.ExtraStore
-import com.patrykandpatrick.vico.core.common.getEnd
-import com.patrykandpatrick.vico.core.common.getStart
 import com.patrykandpatrick.vico.core.common.half
 import com.patrykandpatrick.vico.core.common.orZero
 import com.patrykandpatrick.vico.core.common.translate
+import kotlin.math.ceil
+import kotlin.math.max
 
 private const val TITLE_ABS_ROTATION_DEGREES = 90f
 
 /**
- * An implementation of [Axis] used for vertical axes. This class extends [BaseAxis].
+ * Draws vertical axes. See the [BaseAxis] documentation for descriptions of the inherited
+ * properties.
  *
- * @see Axis
- * @see BaseAxis
+ * @property itemPlacer determines for what _y_ values the [VerticalAxis] displays labels, ticks,
+ *   and guidelines.
+ * @property horizontalLabelPosition defines the horizontal position of the labels relative to the
+ *   axis line.
+ * @property verticalLabelPosition defines the vertical positions of the labels relative to their
+ *   ticks.
  */
-public open class VerticalAxis<Position : AxisPosition.Vertical>(override val position: Position) :
-  BaseAxis<Position>() {
+public open class VerticalAxis<Position : AxisPosition.Vertical>
+protected constructor(
+  override val position: Position,
+  line: LineComponent?,
+  label: TextComponent?,
+  labelRotationDegrees: Float,
+  public var horizontalLabelPosition: HorizontalLabelPosition = Outside,
+  public var verticalLabelPosition: VerticalLabelPosition = Center,
+  valueFormatter: CartesianValueFormatter,
+  tick: LineComponent?,
+  tickLengthDp: Float,
+  guideline: LineComponent?,
+  public var itemPlacer: ItemPlacer = ItemPlacer.step(),
+  sizeConstraint: SizeConstraint,
+  titleComponent: TextComponent?,
+  title: CharSequence?,
+) :
+  BaseAxis<Position>(
+    line,
+    label,
+    labelRotationDegrees,
+    valueFormatter,
+    tick,
+    tickLengthDp,
+    guideline,
+    sizeConstraint,
+    titleComponent,
+    title,
+  ) {
   protected val areLabelsOutsideAtStartOrInsideAtEnd: Boolean
     get() =
       horizontalLabelPosition == Outside && position is AxisPosition.Vertical.Start ||
@@ -55,20 +93,33 @@ public open class VerticalAxis<Position : AxisPosition.Vertical>(override val po
     get() =
       if (areLabelsOutsideAtStartOrInsideAtEnd) HorizontalPosition.Start else HorizontalPosition.End
 
-  protected val maxLabelWidthKey: ExtraStore.Key<Float> = ExtraStore.Key()
-
-  /**
-   * Determines for what _y_ values this [VerticalAxis] is to display labels, ticks, and guidelines.
-   */
-  public var itemPlacer: AxisItemPlacer.Vertical = AxisItemPlacer.Vertical.step()
-
-  /** Defines the horizontal position of each axis label relative to the axis line. */
-  public var horizontalLabelPosition: HorizontalLabelPosition = Outside
-
-  /** Defines the vertical position of each axis label relative to its corresponding tick. */
-  public var verticalLabelPosition: VerticalLabelPosition = Center
-
-  override fun drawBehindChart(context: CartesianDrawContext): Unit =
+  protected var maxLabelWidth: Float? = null
+
+  /** @suppress */
+  @RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
+  public constructor(
+    position: Position,
+    horizontalLabelPosition: HorizontalLabelPosition,
+    verticalLabelPosition: VerticalLabelPosition,
+    itemPlacer: ItemPlacer,
+  ) : this(
+    position = position,
+    line = null,
+    label = null,
+    labelRotationDegrees = 0f,
+    horizontalLabelPosition = horizontalLabelPosition,
+    verticalLabelPosition = verticalLabelPosition,
+    valueFormatter = CartesianValueFormatter.decimal(),
+    tick = null,
+    tickLengthDp = 0f,
+    guideline = null,
+    itemPlacer = itemPlacer,
+    sizeConstraint = SizeConstraint.Auto(),
+    titleComponent = null,
+    title = null,
+  )
+
+  override fun drawUnderLayers(context: CartesianDrawContext) {
     with(context) {
       var centerY: Float
       val yRange = chartValues.getYRange(position)
@@ -79,53 +130,54 @@ public open class VerticalAxis<Position : AxisPosition.Vertical>(override val po
 
       lineValues.forEach { lineValue ->
         centerY =
-          bounds.bottom - bounds.height() * (lineValue - yRange.minY) / yRange.length +
+          bounds.bottom - bounds.height() * ((lineValue - yRange.minY) / yRange.length).toFloat() +
             getLineCanvasYCorrection(guidelineThickness, lineValue)
 
         guideline
           ?.takeIf {
             isNotInRestrictedBounds(
-              left = chartBounds.left,
+              left = layerBounds.left,
               top = centerY - guidelineThickness.half,
-              right = chartBounds.right,
+              right = layerBounds.right,
               bottom = centerY + guidelineThickness.half,
             )
           }
           ?.drawHorizontal(
             context = context,
-            left = chartBounds.left,
-            right = chartBounds.right,
+            left = layerBounds.left,
+            right = layerBounds.right,
             centerY = centerY,
           )
       }
-      val axisLineExtensionLength = if (itemPlacer.getShiftTopLines(this)) tickThickness else 0f
-      axisLine?.drawVertical(
+      val lineExtensionLength = if (itemPlacer.getShiftTopLines(this)) tickThickness else 0f
+      line?.drawVertical(
         context = context,
-        top = bounds.top - axisLineExtensionLength,
-        bottom = bounds.bottom + axisLineExtensionLength,
+        top = bounds.top - lineExtensionLength,
+        bottom = bounds.bottom + lineExtensionLength,
         centerX =
           if (position.isLeft(isLtr = isLtr)) {
-            bounds.right - axisThickness.half
+            bounds.right - lineThickness.half
           } else {
-            bounds.left + axisThickness.half
+            bounds.left + lineThickness.half
           },
       )
     }
+  }
 
-  override fun drawAboveChart(context: CartesianDrawContext): Unit =
+  override fun drawOverLayers(context: CartesianDrawContext) {
     with(context) {
       val label = label
       val labelValues =
         itemPlacer.getLabelValues(this, bounds.height(), getMaxLabelHeight(), position)
       val tickLeftX = getTickLeftX()
-      val tickRightX = tickLeftX + axisThickness + tickLength
+      val tickRightX = tickLeftX + lineThickness + tickLength
       val labelX = if (areLabelsOutsideAtStartOrInsideAtEnd == isLtr) tickLeftX else tickRightX
       var tickCenterY: Float
       val yRange = chartValues.getYRange(position)
 
       labelValues.forEach { labelValue ->
         tickCenterY =
-          bounds.bottom - bounds.height() * (labelValue - yRange.minY) / yRange.length +
+          bounds.bottom - bounds.height() * ((labelValue - yRange.minY) / yRange.length).toFloat() +
             getLineCanvasYCorrection(tickThickness, labelValue)
 
         tick?.drawHorizontal(
@@ -138,28 +190,28 @@ public open class VerticalAxis<Position : AxisPosition.Vertical>(override val po
         label ?: return@forEach
         drawLabel(
           context = this,
-          label = label,
-          labelText = valueFormatter.format(labelValue, chartValues, position),
+          labelComponent = label,
+          label = valueFormatter.format(labelValue, chartValues, position),
           labelX = labelX,
           tickCenterY = tickCenterY,
         )
       }
 
       title?.let { title ->
-        titleComponent?.drawText(
+        titleComponent?.draw(
           context = this,
           text = title,
-          textX =
-            if (position.isStart) bounds.getStart(isLtr = isLtr) else bounds.getEnd(isLtr = isLtr),
-          textY = bounds.centerY(),
+          x = if (position.isLeft(isLtr)) bounds.left else bounds.right,
+          y = bounds.centerY(),
           horizontalPosition =
             if (position.isStart) HorizontalPosition.End else HorizontalPosition.Start,
           verticalPosition = VerticalPosition.Center,
           rotationDegrees = TITLE_ABS_ROTATION_DEGREES * if (position.isStart) -1f else 1f,
-          maxTextHeight = bounds.height().toInt(),
+          maxHeight = bounds.height().toInt(),
         )
       }
     }
+  }
 
   override fun updateHorizontalDimensions(
     context: CartesianMeasureContext,
@@ -168,16 +220,16 @@ public open class VerticalAxis<Position : AxisPosition.Vertical>(override val po
 
   protected open fun drawLabel(
     context: CartesianDrawContext,
-    label: TextComponent,
-    labelText: CharSequence,
+    labelComponent: TextComponent,
+    label: CharSequence,
     labelX: Float,
     tickCenterY: Float,
   ): Unit =
     with(context) {
       val textBounds =
-        label.getTextBounds(this, labelText, rotationDegrees = labelRotationDegrees).apply {
-          translate(x = labelX, y = tickCenterY - centerY())
-        }
+        labelComponent
+          .getBounds(context = this, text = label, rotationDegrees = labelRotationDegrees)
+          .apply { translate(labelX, tickCenterY - centerY()) }
 
       if (
         horizontalLabelPosition == Outside ||
@@ -188,17 +240,15 @@ public open class VerticalAxis<Position : AxisPosition.Vertical>(override val po
             bottom = textBounds.bottom,
           )
       ) {
-        label.drawText(
+        labelComponent.draw(
           context = this,
-          text = labelText,
-          textX = labelX,
-          textY = tickCenterY,
+          text = label,
+          x = labelX,
+          y = tickCenterY,
           horizontalPosition = textHorizontalPosition,
           verticalPosition = verticalLabelPosition.textPosition,
           rotationDegrees = labelRotationDegrees,
-          maxTextWidth =
-            (extraStore.getOrNull(maxLabelWidthKey) ?: (chartBounds.width().half - tickLength))
-              .toInt(),
+          maxWidth = (maxLabelWidth ?: (layerBounds.width().half - tickLength)).toInt(),
         )
       }
     }
@@ -207,37 +257,37 @@ public open class VerticalAxis<Position : AxisPosition.Vertical>(override val po
     val onLeft = position.isLeft(isLtr = isLtr)
     val base = if (onLeft) bounds.right else bounds.left
     return when {
-      onLeft && horizontalLabelPosition == Outside -> base - axisThickness - tickLength
-      onLeft && horizontalLabelPosition == Inside -> base - axisThickness
+      onLeft && horizontalLabelPosition == Outside -> base - lineThickness - tickLength
+      onLeft && horizontalLabelPosition == Inside -> base - lineThickness
       horizontalLabelPosition == Outside -> base
       horizontalLabelPosition == Inside -> base - tickLength
       else -> error("Unexpected combination of axis position and label position")
     }
   }
 
-  override fun getHorizontalInsets(
+  override fun updateHorizontalInsets(
     context: CartesianMeasureContext,
-    availableHeight: Float,
-    outInsets: HorizontalInsets,
-  ): Unit =
-    with(context) {
-      val desiredWidth = getDesiredWidth(this, availableHeight)
-
-      outInsets.set(
-        start = if (position.isStart) desiredWidth else 0f,
-        end = if (position.isEnd) desiredWidth else 0f,
-      )
+    freeHeight: Float,
+    model: CartesianChartModel,
+    insets: HorizontalInsets,
+  ) {
+    val width = getWidth(context, freeHeight)
+    when {
+      position.isStart -> insets.ensureValuesAtLeast(start = width)
+      position.isEnd -> insets.ensureValuesAtLeast(end = width)
     }
+  }
 
-  override fun getInsets(
+  override fun updateInsets(
     context: CartesianMeasureContext,
-    outInsets: Insets,
     horizontalDimensions: HorizontalDimensions,
+    model: CartesianChartModel,
+    insets: Insets,
   ): Unit =
     with(context) {
       val maxLabelHeight = getMaxLabelHeight()
-      val maxLineThickness = maxOf(axisThickness, tickThickness)
-      outInsets.set(
+      val maxLineThickness = max(lineThickness, tickThickness)
+      insets.ensureValuesAtLeast(
         top =
           itemPlacer.getTopVerticalAxisInset(
             context,
@@ -255,11 +305,7 @@ public open class VerticalAxis<Position : AxisPosition.Vertical>(override val po
       )
     }
 
-  /**
-   * Calculates the optimal width for this [VerticalAxis], accounting for the value of
-   * [sizeConstraint].
-   */
-  protected open fun getDesiredWidth(context: CartesianMeasureContext, height: Float): Float =
+  protected open fun getWidth(context: CartesianMeasureContext, freeHeight: Float): Float =
     with(context) {
       when (val constraint = sizeConstraint) {
         is SizeConstraint.Auto -> {
@@ -270,20 +316,16 @@ public open class VerticalAxis<Position : AxisPosition.Vertical>(override val po
                   context = this,
                   text = title,
                   rotationDegrees = TITLE_ABS_ROTATION_DEGREES,
-                  height = bounds.height().toInt(),
+                  maxHeight = bounds.height().toInt(),
                 )
               }
               .orZero
           val labelSpace =
             when (horizontalLabelPosition) {
-              Outside -> {
-                val maxLabelWidth = getMaxLabelWidth(height).ceil
-                extraStore[maxLabelWidthKey] = maxLabelWidth
-                maxLabelWidth + tickLength
-              }
+              Outside -> ceil(getMaxLabelWidth(freeHeight)).also { maxLabelWidth = it } + tickLength
               Inside -> 0f
             }
-          (labelSpace + titleComponentWidth + axisThickness).coerceIn(
+          (labelSpace + titleComponentWidth + lineThickness).coerceIn(
             minimumValue = constraint.minSizeDp.pixels,
             maximumValue = constraint.maxSizeDp.pixels,
           )
@@ -297,7 +339,7 @@ public open class VerticalAxis<Position : AxisPosition.Vertical>(override val po
               text = constraint.text,
               rotationDegrees = labelRotationDegrees,
             )
-            .orZero + tickLength + axisThickness.half
+            .orZero + tickLength + lineThickness.half
       }
     }
 
@@ -329,7 +371,7 @@ public open class VerticalAxis<Position : AxisPosition.Vertical>(override val po
       }
       .orZero
 
-  protected fun CartesianDrawContext.getLineCanvasYCorrection(thickness: Float, y: Float): Float =
+  protected fun CartesianDrawContext.getLineCanvasYCorrection(thickness: Float, y: Double): Float =
     if (y == chartValues.getYRange(position).maxY && itemPlacer.getShiftTopLines(this)) {
       -thickness.half
     } else {
@@ -357,46 +399,173 @@ public open class VerticalAxis<Position : AxisPosition.Vertical>(override val po
     Bottom(VerticalPosition.Bottom),
   }
 
-  /** Creates [VerticalAxis] instances. It’s recommended to use this via [VerticalAxis.build]. */
-  public class Builder<Position : AxisPosition.Vertical>(
-    builder: BaseAxis.Builder<Position>? = null
-  ) : BaseAxis.Builder<Position>(builder) {
+  /** Determines for what _y_ values a [VerticalAxis] displays labels, ticks, and guidelines. */
+  public interface ItemPlacer {
     /**
-     * Determines for what _y_ values this [VerticalAxis] is to display labels, ticks, and
-     * guidelines.
+     * Returns a boolean indicating whether to shift the lines whose _y_ values are equal to
+     * [ChartValues.YRange.maxY], if such lines are present, such that they’re immediately above the
+     * [CartesianLayer] bounds. If the [CartesianChart] has a top axis, the shifted tick is then
+     * aligned with it, and the shifted guideline is hidden.
      */
-    public var itemPlacer: AxisItemPlacer.Vertical = AxisItemPlacer.Vertical.step()
-
-    /** Defines the horizontal position of each axis label relative to the axis line. */
-    public var horizontalLabelPosition: HorizontalLabelPosition = Outside
-
-    /** Defines the vertical position of each axis label relative to its corresponding tick. */
-    public var verticalLabelPosition: VerticalLabelPosition = Center
-
-    /** Creates a [VerticalAxis] instance with the properties from this [Builder]. */
-    @Suppress("UNCHECKED_CAST")
-    public inline fun <reified T : Position> build(): VerticalAxis<T> {
-      val position =
-        when (T::class.java) {
-          AxisPosition.Vertical.Start::class.java -> AxisPosition.Vertical.Start
-          AxisPosition.Vertical.End::class.java -> AxisPosition.Vertical.End
-          else ->
-            throw IllegalStateException("Got unknown AxisPosition class ${T::class.java.name}")
-        }
-          as Position
-      return setTo(VerticalAxis(position)).also { axis ->
-        axis.itemPlacer = itemPlacer
-        axis.horizontalLabelPosition = horizontalLabelPosition
-        axis.verticalLabelPosition = verticalLabelPosition
-      } as VerticalAxis<T>
+    public fun getShiftTopLines(context: CartesianDrawContext): Boolean = true
+
+    /** Returns, as a list, the _y_ values for which labels are to be displayed. */
+    public fun getLabelValues(
+      context: CartesianDrawContext,
+      axisHeight: Float,
+      maxLabelHeight: Float,
+      position: AxisPosition.Vertical,
+    ): List<Double>
+
+    /**
+     * Returns, as a list, the _y_ values for which the [VerticalAxis] is to create labels and
+     * measure their widths during the measuring phase. This affects how much horizontal space the
+     * [VerticalAxis] requests.
+     */
+    public fun getWidthMeasurementLabelValues(
+      context: CartesianMeasureContext,
+      axisHeight: Float,
+      maxLabelHeight: Float,
+      position: AxisPosition.Vertical,
+    ): List<Double>
+
+    /**
+     * Returns, as a list, the _y_ values for which the [VerticalAxis] is to create labels and
+     * measure their heights during the measuring phase. The height of the tallest label is passed
+     * to other functions.
+     */
+    public fun getHeightMeasurementLabelValues(
+      context: CartesianMeasureContext,
+      position: AxisPosition.Vertical,
+    ): List<Double>
+
+    /** Returns, as a list, the _y_ values for which ticks and guidelines are to be displayed. */
+    public fun getLineValues(
+      context: CartesianDrawContext,
+      axisHeight: Float,
+      maxLabelHeight: Float,
+      position: AxisPosition.Vertical,
+    ): List<Double>? = null
+
+    /** Returns the top inset required by the [VerticalAxis]. */
+    public fun getTopVerticalAxisInset(
+      context: CartesianMeasureContext,
+      verticalLabelPosition: VerticalLabelPosition,
+      maxLabelHeight: Float,
+      maxLineThickness: Float,
+    ): Float
+
+    /** Returns the bottom inset required by the [VerticalAxis]. */
+    public fun getBottomVerticalAxisInset(
+      context: CartesianMeasureContext,
+      verticalLabelPosition: VerticalLabelPosition,
+      maxLabelHeight: Float,
+      maxLineThickness: Float,
+    ): Float
+
+    /** Houses [ItemPlacer] factory functions. */
+    public companion object {
+      /**
+       * Creates a step-based [ItemPlacer] implementation. [step] returns the difference between the
+       * _y_ values of neighboring labels (and their corresponding line pairs). A multiple of this
+       * may be used for overlap prevention. If `null` is returned, the step will be determined
+       * automatically. [shiftTopLines] defines whether to shift the lines whose _y_ values are
+       * equal to [ChartValues.YRange.maxY], if such lines are present, such that they’re
+       * immediately above the [CartesianChart]’s bounds. If the chart has a top axis, the shifted
+       * tick will then be aligned with this axis, and the shifted guideline will be hidden.
+       */
+      public fun step(
+        step: (ExtraStore) -> Double? = { null },
+        shiftTopLines: Boolean = true,
+      ): ItemPlacer =
+        DefaultVerticalAxisItemPlacer(DefaultVerticalAxisItemPlacer.Mode.Step(step), shiftTopLines)
+
+      /**
+       * Creates a count-based [ItemPlacer] implementation. [count] returns the number of labels
+       * (and their corresponding line pairs) to be displayed. This may be reduced for overlap
+       * prevention. If `null` is returned, the [VerticalAxis] will display as many items as
+       * possible. [shiftTopLines] defines whether to shift the lines whose _y_ values are equal to
+       * [ChartValues.YRange.maxY], if such lines are present, such that they’re immediately above
+       * the [CartesianChart]’s bounds. If the chart has a top axis, the shifted tick will then be
+       * aligned with this axis, and the shifted guideline will be hidden.
+       */
+      public fun count(
+        count: (ExtraStore) -> Int? = { null },
+        shiftTopLines: Boolean = true,
+      ): ItemPlacer =
+        DefaultVerticalAxisItemPlacer(
+          DefaultVerticalAxisItemPlacer.Mode.Count(count),
+          shiftTopLines,
+        )
     }
   }
 
-  /** Houses a [VerticalAxis] factory function. */
+  /** Houses [VerticalAxis] factory functions. */
   public companion object {
-    /** Creates a [VerticalAxis] via [Builder]. */
-    public inline fun <reified P : AxisPosition.Vertical> build(
-      block: Builder<P>.() -> Unit = {}
-    ): VerticalAxis<P> = Builder<P>().apply(block).build()
+    /** Creates a start [VerticalAxis]. */
+    public fun start(
+      line: LineComponent? = null,
+      label: TextComponent? = null,
+      labelRotationDegrees: Float = 0f,
+      horizontalLabelPosition: HorizontalLabelPosition = Outside,
+      verticalLabelPosition: VerticalLabelPosition = Center,
+      valueFormatter: CartesianValueFormatter = CartesianValueFormatter.decimal(),
+      tick: LineComponent? = null,
+      tickLengthDp: Float = 0f,
+      guideline: LineComponent? = null,
+      itemPlacer: ItemPlacer = ItemPlacer.step(),
+      sizeConstraint: SizeConstraint = SizeConstraint.Auto(),
+      titleComponent: TextComponent? = null,
+      title: CharSequence? = null,
+    ): VerticalAxis<AxisPosition.Vertical.Start> =
+      VerticalAxis(
+        AxisPosition.Vertical.Start,
+        line,
+        label,
+        labelRotationDegrees,
+        horizontalLabelPosition,
+        verticalLabelPosition,
+        valueFormatter,
+        tick,
+        tickLengthDp,
+        guideline,
+        itemPlacer,
+        sizeConstraint,
+        titleComponent,
+        title,
+      )
+
+    /** Creates an end [VerticalAxis]. */
+    public fun end(
+      line: LineComponent? = null,
+      label: TextComponent? = null,
+      labelRotationDegrees: Float = 0f,
+      horizontalLabelPosition: HorizontalLabelPosition = Outside,
+      verticalLabelPosition: VerticalLabelPosition = Center,
+      valueFormatter: CartesianValueFormatter = CartesianValueFormatter.decimal(),
+      tick: LineComponent? = null,
+      tickLengthDp: Float = 0f,
+      guideline: LineComponent? = null,
+      itemPlacer: ItemPlacer = ItemPlacer.step(),
+      sizeConstraint: SizeConstraint = SizeConstraint.Auto(),
+      titleComponent: TextComponent? = null,
+      title: CharSequence? = null,
+    ): VerticalAxis<AxisPosition.Vertical.End> =
+      VerticalAxis(
+        AxisPosition.Vertical.End,
+        line,
+        label,
+        labelRotationDegrees,
+        horizontalLabelPosition,
+        verticalLabelPosition,
+        valueFormatter,
+        tick,
+        tickLengthDp,
+        guideline,
+        itemPlacer,
+        sizeConstraint,
+        titleComponent,
+        title,
+      )
   }
 }
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/data/AxisValueOverrider.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/data/AxisValueOverrider.kt
index eab893a32..adc80545d 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/data/AxisValueOverrider.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/data/AxisValueOverrider.kt
@@ -17,11 +17,11 @@
 package com.patrykandpatrick.vico.core.cartesian.data
 
 import com.patrykandpatrick.vico.core.cartesian.layer.CartesianLayer
-import com.patrykandpatrick.vico.core.common.ceil
 import com.patrykandpatrick.vico.core.common.data.ExtraStore
-import com.patrykandpatrick.vico.core.common.floor
-import com.patrykandpatrick.vico.core.common.round
+import com.patrykandpatrick.vico.core.common.roundedToNearest
 import kotlin.math.abs
+import kotlin.math.ceil
+import kotlin.math.floor
 import kotlin.math.log10
 import kotlin.math.max
 import kotlin.math.pow
@@ -30,62 +30,62 @@ import kotlin.math.sign
 /** Overrides a [CartesianLayer]’s _x_ and _y_ ranges. */
 public interface AxisValueOverrider {
   /** Returns the minimum _x_ value. */
-  public fun getMinX(minX: Float, maxX: Float, extraStore: ExtraStore): Float = minX
+  public fun getMinX(minX: Double, maxX: Double, extraStore: ExtraStore): Double = minX
 
   /** Returns the maximum _x_ value. */
-  public fun getMaxX(minX: Float, maxX: Float, extraStore: ExtraStore): Float = maxX
+  public fun getMaxX(minX: Double, maxX: Double, extraStore: ExtraStore): Double = maxX
 
   /** Returns the minimum _y_ value. */
-  public fun getMinY(minY: Float, maxY: Float, extraStore: ExtraStore): Float =
-    minY.coerceAtMost(0f)
+  public fun getMinY(minY: Double, maxY: Double, extraStore: ExtraStore): Double =
+    minY.coerceAtMost(0.0)
 
   /** Returns the maximum _y_ value. */
-  public fun getMaxY(minY: Float, maxY: Float, extraStore: ExtraStore): Float =
-    if (minY == 0f && maxY == 0f) 1f else maxY.coerceAtLeast(0f)
+  public fun getMaxY(minY: Double, maxY: Double, extraStore: ExtraStore): Double =
+    if (minY == 0.0 && maxY == 0.0) 1.0 else maxY.coerceAtLeast(0.0)
 
   public companion object {
     /** Uses dynamic rounding. */
     public fun auto(): AxisValueOverrider =
       object : AxisValueOverrider {
-        override fun getMinY(minY: Float, maxY: Float, extraStore: ExtraStore) =
-          if (minY == 0f && maxY == 0f || minY >= 0f) 0f else minY.round(maxY)
+        override fun getMinY(minY: Double, maxY: Double, extraStore: ExtraStore) =
+          if (minY == 0.0 && maxY == 0.0 || minY >= 0.0) 0.0 else minY.round(maxY)
 
-        override fun getMaxY(minY: Float, maxY: Float, extraStore: ExtraStore) =
+        override fun getMaxY(minY: Double, maxY: Double, extraStore: ExtraStore) =
           when {
-            minY == 0f && maxY == 0f -> 1f
-            maxY <= 0f -> 0f
+            minY == 0.0 && maxY == 0.0 -> 1.0
+            maxY <= 0.0 -> 0.0
             else -> maxY.round(minY)
           }
 
-        private fun Float.round(other: Float): Float {
+        private fun Double.round(other: Double): Double {
           val absoluteValue = abs(this)
-          val base = 10f.pow(log10(max(absoluteValue, abs(other))).floor - 1)
-          return sign * (absoluteValue / base).ceil * base
+          val base = 10.0.pow(floor(log10(max(absoluteValue, abs(other)))) - 1)
+          return sign * ceil(absoluteValue / base) * base
         }
       }
 
     /** Overrides the defaults with the provided values. */
     public fun fixed(
-      minX: Float? = null,
-      maxX: Float? = null,
-      minY: Float? = null,
-      maxY: Float? = null,
+      minX: Double? = null,
+      maxX: Double? = null,
+      minY: Double? = null,
+      maxY: Double? = null,
     ): AxisValueOverrider {
       val newMinX = minX
       val newMaxX = maxX
       val newMinY = minY
       val newMaxY = maxY
       return object : AxisValueOverrider {
-        override fun getMinX(minX: Float, maxX: Float, extraStore: ExtraStore) =
+        override fun getMinX(minX: Double, maxX: Double, extraStore: ExtraStore) =
           newMinX ?: super.getMinX(minX, maxX, extraStore)
 
-        override fun getMaxX(minX: Float, maxX: Float, extraStore: ExtraStore) =
+        override fun getMaxX(minX: Double, maxX: Double, extraStore: ExtraStore) =
           newMaxX ?: super.getMaxX(minX, maxX, extraStore)
 
-        override fun getMinY(minY: Float, maxY: Float, extraStore: ExtraStore) =
+        override fun getMinY(minY: Double, maxY: Double, extraStore: ExtraStore) =
           newMinY ?: super.getMinY(minY, maxY, extraStore)
 
-        override fun getMaxY(minY: Float, maxY: Float, extraStore: ExtraStore) =
+        override fun getMaxY(minY: Double, maxY: Double, extraStore: ExtraStore) =
           newMaxY ?: super.getMaxY(getMinY(minY, maxY, extraStore), maxY, extraStore)
       }
     }
@@ -97,19 +97,20 @@ public interface AxisValueOverrider {
      */
     public fun adaptiveYValues(yFraction: Float, round: Boolean = false): AxisValueOverrider =
       object : AxisValueOverrider {
+        private val Double.conditionallyRoundedToNearest
+          get() = if (round) roundedToNearest else this
+
         init {
           require(yFraction > 0f)
         }
 
-        override fun getMinY(minY: Float, maxY: Float, extraStore: ExtraStore): Float {
+        override fun getMinY(minY: Double, maxY: Double, extraStore: ExtraStore): Double {
           val difference = abs(getMaxY(minY, maxY, extraStore) - maxY)
-          return (minY - difference).maybeRound().coerceAtLeast(0f)
+          return (minY - difference).conditionallyRoundedToNearest.coerceAtLeast(0.0)
         }
 
-        override fun getMaxY(minY: Float, maxY: Float, extraStore: ExtraStore): Float =
-          if (minY == 0f && maxY == 0f) 1f else (yFraction * maxY).maybeRound()
-
-        private fun Float.maybeRound() = if (round) this.round else this
+        override fun getMaxY(minY: Double, maxY: Double, extraStore: ExtraStore): Double =
+          if (minY == 0.0 && maxY == 0.0) 1.0 else (yFraction * maxY).conditionallyRoundedToNearest
       }
   }
 }
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/data/CandlestickCartesianLayerDrawingModel.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/data/CandlestickCartesianLayerDrawingModel.kt
index 3888a23f3..33039307f 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/data/CandlestickCartesianLayerDrawingModel.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/data/CandlestickCartesianLayerDrawingModel.kt
@@ -25,11 +25,11 @@ import com.patrykandpatrick.vico.core.common.orZero
  * Houses drawing information for a [CandlestickCartesianLayer]. [opacity] is the columns’ opacity.
  */
 public class CandlestickCartesianLayerDrawingModel(
-  public val entries: Map<Float, CandleInfo>,
+  public val entries: Map<Double, CandleInfo>,
   public val opacity: Float = 1f,
 ) : DrawingModel<CandlestickCartesianLayerDrawingModel.CandleInfo>(listOf(entries)) {
   override fun transform(
-    drawingInfo: List<Map<Float, CandleInfo>>,
+    drawingInfo: List<Map<Double, CandleInfo>>,
     from: DrawingModel<CandleInfo>?,
     fraction: Float,
   ): DrawingModel<CandleInfo> {
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/data/CandlestickCartesianLayerModel.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/data/CandlestickCartesianLayerModel.kt
index 34698b0d6..8b5e4dcde 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/data/CandlestickCartesianLayerModel.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/data/CandlestickCartesianLayerModel.kt
@@ -27,13 +27,13 @@ public class CandlestickCartesianLayerModel : CartesianLayerModel {
 
   override val id: Int
 
-  override val minX: Float
+  override val minX: Double
 
-  override val maxX: Float
+  override val maxX: Double
 
-  override val minY: Float
+  override val minY: Double
 
-  override val maxY: Float
+  override val maxY: Double
 
   override val extraStore: ExtraStore
 
@@ -54,10 +54,10 @@ public class CandlestickCartesianLayerModel : CartesianLayerModel {
   private constructor(
     series: List<Entry>,
     id: Int,
-    minX: Float,
-    maxX: Float,
-    minY: Float,
-    maxY: Float,
+    minX: Double,
+    maxX: Double,
+    minY: Double,
+    maxY: Double,
     extraStore: ExtraStore,
   ) {
     this.series = series
@@ -69,7 +69,7 @@ public class CandlestickCartesianLayerModel : CartesianLayerModel {
     this.extraStore = extraStore
   }
 
-  override fun getXDeltaGcd(): Float = series.getXDeltaGcd()
+  override fun getXDeltaGcd(): Double = series.getXDeltaGcd()
 
   override fun copy(extraStore: ExtraStore): CartesianLayerModel =
     CandlestickCartesianLayerModel(series, id, minX, maxX, minY, maxY, extraStore)
@@ -110,11 +110,11 @@ public class CandlestickCartesianLayerModel : CartesianLayerModel {
    */
   public open class Entry
   internal constructor(
-    override val x: Float,
-    public val opening: Float,
-    public val closing: Float,
-    public val low: Float,
-    public val high: Float,
+    override val x: Double,
+    public val opening: Double,
+    public val closing: Double,
+    public val low: Double,
+    public val high: Double,
     public val absoluteChange: Change,
     public val relativeChange: Change,
   ) : CartesianLayerModel.Entry {
@@ -127,11 +127,11 @@ public class CandlestickCartesianLayerModel : CartesianLayerModel {
       absoluteChange: Change,
       relativeChange: Change,
     ) : this(
-      x.toFloat(),
-      opening.toFloat(),
-      closing.toFloat(),
-      low.toFloat(),
-      high.toFloat(),
+      x.toDouble(),
+      opening.toDouble(),
+      closing.toDouble(),
+      low.toDouble(),
+      high.toDouble(),
       absoluteChange,
       relativeChange,
     )
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/data/CartesianChartModel.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/data/CartesianChartModel.kt
index b59721585..00605e50a 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/data/CartesianChartModel.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/data/CartesianChartModel.kt
@@ -33,7 +33,7 @@ public class CartesianChartModel {
    * Expresses the size of this [CartesianChartModel] in terms of the range of the _x_ values
    * covered.
    */
-  public val width: Float
+  public val width: Double
 
   /** Stores auxiliary data, including [DrawingModel]s. */
   public val extraStore: ExtraStore
@@ -57,7 +57,7 @@ public class CartesianChartModel {
   internal constructor(
     models: List<CartesianLayerModel>,
     id: Int,
-    width: Float,
+    width: Double,
     extraStore: ExtraStore,
   ) {
     this.models = models
@@ -67,11 +67,11 @@ public class CartesianChartModel {
   }
 
   /** Returns the greatest common divisor of the _x_ values’ differences. */
-  public fun getXDeltaGcd(): Float =
-    models.fold<CartesianLayerModel, Float?>(null) { gcd, layerModel ->
+  public fun getXDeltaGcd(): Double =
+    models.fold<CartesianLayerModel, Double?>(null) { gcd, layerModel ->
       val layerModelGcd = layerModel.getXDeltaGcd()
       gcd?.gcdWith(layerModelGcd) ?: layerModelGcd
-    } ?: 1f
+    } ?: 1.0
 
   /**
    * Creates a copy of this [CartesianChartModel] with the given [ExtraStore], which is also applied
@@ -86,6 +86,6 @@ public class CartesianChartModel {
   public companion object {
     /** An empty [CartesianChartModel]. */
     public val empty: CartesianChartModel =
-      CartesianChartModel(models = emptyList(), id = 0, width = 0f, extraStore = ExtraStore.empty)
+      CartesianChartModel(models = emptyList(), id = 0, width = 0.0, extraStore = ExtraStore.empty)
   }
 }
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/data/CartesianChartModelProducer.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/data/CartesianChartModelProducer.kt
index 981ecbb31..7597b614b 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/data/CartesianChartModelProducer.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/data/CartesianChartModelProducer.kt
@@ -16,48 +16,54 @@
 
 package com.patrykandpatrick.vico.core.cartesian.data
 
-import androidx.annotation.WorkerThread
+import androidx.annotation.RestrictTo
+import com.patrykandpatrick.vico.core.cartesian.CartesianChart
 import com.patrykandpatrick.vico.core.cartesian.layer.CartesianLayer
 import com.patrykandpatrick.vico.core.common.data.ExtraStore
 import com.patrykandpatrick.vico.core.common.data.MutableExtraStore
-import kotlinx.coroutines.CompletableDeferred
+import java.util.concurrent.ConcurrentHashMap
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Deferred
 import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.async
-import kotlinx.coroutines.awaitAll
+import kotlinx.coroutines.coroutineScope
 import kotlinx.coroutines.currentCoroutineContext
 import kotlinx.coroutines.ensureActive
+import kotlinx.coroutines.joinAll
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import kotlinx.coroutines.withContext
 
 /** Creates [CartesianChartModel]s and handles difference animations. */
 public class CartesianChartModelProducer private constructor(dispatcher: CoroutineDispatcher) {
   private var partials = emptyList<CartesianLayerModel.Partial>()
   private var extraStore = MutableExtraStore()
   private var cachedModel: CartesianChartModel? = null
-  private val mutex = Mutex()
+  private val updateMutex = Mutex()
+  private val registrationMutex = Mutex()
   private val coroutineScope = CoroutineScope(dispatcher)
-  private val updateReceivers = mutableMapOf<Any, UpdateReceiver>()
+  private val updateReceivers = ConcurrentHashMap<Any, UpdateReceiver>()
+
+  /** Creates a [CartesianChartModelProducer]. */
+  public constructor() : this(Dispatchers.Default)
 
   private fun tryUpdate(
     partials: List<CartesianLayerModel.Partial>,
     extraStore: MutableExtraStore,
   ): Boolean {
-    if (!mutex.tryLock()) return false
+    if (!updateMutex.tryLock()) return false
     val immutablePartials = partials.toList()
     if (immutablePartials == this.partials && extraStore == this.extraStore) {
-      mutex.unlock()
+      updateMutex.unlock()
       return true
     }
     this.partials = immutablePartials
     this.extraStore = extraStore
     cachedModel = null
-    val deferredUpdates = updateReceivers.values.map { coroutineScope.async { it.handleUpdate() } }
+    val receiverJobs = updateReceivers.values.map { coroutineScope.launch { it.handleUpdate() } }
     coroutineScope.launch {
-      deferredUpdates.awaitAll()
-      mutex.unlock()
+      receiverJobs.joinAll()
+      updateMutex.unlock()
     }
     return true
   }
@@ -65,25 +71,28 @@ public class CartesianChartModelProducer private constructor(dispatcher: Corouti
   private suspend fun update(
     partials: List<CartesianLayerModel.Partial>,
     extraStore: MutableExtraStore,
-  ): Deferred<Unit> {
-    mutex.lock()
-    val completableDeferred = CompletableDeferred<Unit>()
-    val immutablePartials = partials.toList()
-    if (immutablePartials == this.partials && extraStore == this.extraStore) {
-      mutex.unlock()
-      completableDeferred.complete(Unit)
-      return completableDeferred
-    }
-    this.partials = partials.toList()
-    this.extraStore = extraStore
-    cachedModel = null
-    val deferredUpdates = updateReceivers.values.map { coroutineScope.async { it.handleUpdate() } }
-    coroutineScope.launch {
-      deferredUpdates.awaitAll()
-      mutex.unlock()
-      completableDeferred.complete(Unit)
+  ) {
+    withContext(Dispatchers.Default) {
+      updateMutex.lock()
+      registrationMutex.lock()
+      val immutablePartials = partials.toList()
+      if (
+        immutablePartials == this@CartesianChartModelProducer.partials &&
+          extraStore == this@CartesianChartModelProducer.extraStore
+      ) {
+        updateMutex.unlock()
+        registrationMutex.unlock()
+        return@withContext
+      }
+      this@CartesianChartModelProducer.partials = partials.toList()
+      this@CartesianChartModelProducer.extraStore = extraStore
+      cachedModel = null
+      coroutineScope {
+        updateReceivers.values.forEach { launch { it.handleUpdate() } }
+        registrationMutex.unlock()
+      }
+      updateMutex.unlock()
     }
-    return completableDeferred
   }
 
   private fun getModel(extraStore: ExtraStore) =
@@ -103,24 +112,18 @@ public class CartesianChartModelProducer private constructor(dispatcher: Corouti
     chartValues: ChartValues,
   ) {
     with(updateReceivers[key] ?: return) {
-      transform(extraStore, fraction)
-      val transformedModel =
-        model?.copy(this@CartesianChartModelProducer.extraStore + extraStore.copy())
-      currentCoroutineContext().ensureActive()
-      onModelCreated(transformedModel, chartValues)
+      withContext(Dispatchers.Default) {
+        transform(extraStore, fraction)
+        val transformedModel =
+          model?.copy(this@CartesianChartModelProducer.extraStore + extraStore.copy())
+        currentCoroutineContext().ensureActive()
+        onModelCreated(transformedModel, chartValues)
+      }
     }
   }
 
-  /**
-   * Registers an update listener associated with a [key]. [cancelAnimation] and [startAnimation]
-   * are called after a data update is requested, with [cancelAnimation] being called before the
-   * update starts being processed (at which point [transformModel] should stop being used), and
-   * [startAnimation] being called once the update has been processed (at which point it’s safe to
-   * use [transformModel]). [updateChartValues] updates the chart’s [MutableChartValues] instance
-   * and returns an immutable copy of it. [onModelCreated] is called when a new
-   * [CartesianChartModel] has been generated.
-   */
-  @WorkerThread
+  /** @suppress */
+  @RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
   public suspend fun registerForUpdates(
     key: Any,
     cancelAnimation: suspend () -> Unit,
@@ -131,51 +134,61 @@ public class CartesianChartModelProducer private constructor(dispatcher: Corouti
     updateChartValues: (CartesianChartModel?) -> ChartValues,
     onModelCreated: (CartesianChartModel?, ChartValues) -> Unit,
   ) {
-    UpdateReceiver(
-        cancelAnimation,
-        startAnimation,
-        onModelCreated,
-        extraStore,
-        prepareForTransformation,
-        transform,
-        updateChartValues,
-      )
-      .run {
-        updateReceivers[key] = this
-        handleUpdate()
+    withContext(Dispatchers.Default) {
+      val receiver =
+        UpdateReceiver(
+          cancelAnimation,
+          startAnimation,
+          onModelCreated,
+          extraStore,
+          prepareForTransformation,
+          transform,
+          updateChartValues,
+        )
+      registrationMutex.withLock {
+        updateReceivers[key] = receiver
+        receiver.handleUpdate()
       }
+    }
   }
 
-  /** Checks if an update listener with the given key is registered. */
+  /** @suppress */
+  @RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
   public fun isRegistered(key: Any): Boolean = updateReceivers.containsKey(key)
 
-  /** Unregisters the update listener associated with the given [key]. */
+  /** @suppress */
+  @RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
   public fun unregisterFromUpdates(key: Any) {
     updateReceivers.remove(key)
   }
 
   /** Creates a [Transaction] instance. */
+  @Deprecated("Use the `Transaction` constructor.", ReplaceWith("Transaction()"))
   public fun createTransaction(): Transaction = Transaction()
 
   /**
    * Creates a [Transaction], runs [block], and calls [Transaction.tryCommit], returning its output.
    * For suspending behavior, use [runTransaction].
    */
+  @Suppress("DeprecatedCallableAddReplaceWith")
+  @Deprecated(
+    "Use `runTransaction`. More information: " +
+      "https://patrykandpatrick.com/vico/releases/2.0.0-alpha.22."
+  )
   public fun tryRunTransaction(block: Transaction.() -> Unit): Boolean =
-    createTransaction().also(block).tryCommit()
+    @Suppress("DEPRECATION") Transaction().also(block).tryCommit()
 
-  /**
-   * Creates a [Transaction], runs [block], and calls [Transaction.commit], returning its output.
-   */
-  public suspend fun runTransaction(block: Transaction.() -> Unit): Deferred<Unit> =
-    createTransaction().also(block).commit()
+  /** Creates a [Transaction], runs [block], and calls [Transaction.commit]. */
+  public suspend fun runTransaction(block: Transaction.() -> Unit) {
+    Transaction().also(block).commit()
+  }
 
   /**
    * Handles data updates. An initially empty list of [CartesianLayerModel.Partial]s is created and
    * can be updated via the class’s functions. Each [CartesianLayerModel.Partial] corresponds to a
    * [CartesianLayer].
    */
-  public inner class Transaction internal constructor() {
+  public inner class Transaction {
     private val newPartials = mutableListOf<CartesianLayerModel.Partial>()
     private val newExtraStore = MutableExtraStore()
 
@@ -188,23 +201,38 @@ public class CartesianChartModelProducer private constructor(dispatcher: Corouti
      * Allows for adding auxiliary values, which can later be retrieved via
      * [CartesianChartModel.extraStore].
      */
-    public fun updateExtras(block: (MutableExtraStore) -> Unit) {
+    public fun extras(block: (MutableExtraStore) -> Unit) {
       block(newExtraStore)
     }
 
+    /**
+     * Allows for adding auxiliary values, which can later be retrieved via
+     * [CartesianChartModel.extraStore].
+     */
+    @Deprecated("Use `extras`.", ReplaceWith("extras(block)"))
+    public fun updateExtras(block: (MutableExtraStore) -> Unit) {
+      extras(block)
+    }
+
     /**
      * Requests a data update. If the update is accepted, `true` is returned. If the update is
      * rejected, which occurs when there’s already an update in progress, `false` is returned. For
      * suspending behavior, use [commit].
      */
+    @Deprecated(
+      "Use `commit`. More information: https://patrykandpatrick.com/vico/releases/2.0.0-alpha.22."
+    )
     public fun tryCommit(): Boolean = tryUpdate(newPartials, newExtraStore)
 
     /**
-     * Runs a data update. Unlike [tryCommit], this function suspends the current coroutine and
-     * waits until an update can be run, meaning the update cannot be rejected. The returned
-     * [Deferred] implementation is marked as completed once the update has been processed.
+     * Runs a data update, returning once the update is complete. If there’s already an update in
+     * progress, the current coroutine is first suspended until the ongoing update’s completion. An
+     * update is complete once a new [CartesianChartModel] has been generated, and the
+     * [CartesianChart] hosts have been notified.
      */
-    public suspend fun commit(): Deferred<Unit> = update(newPartials, newExtraStore)
+    public suspend fun commit() {
+      update(newPartials, newExtraStore)
+    }
   }
 
   private inner class UpdateReceiver(
@@ -230,12 +258,18 @@ public class CartesianChartModelProducer private constructor(dispatcher: Corouti
      * Creates a [CartesianChartModelProducer], running an initial [Transaction]. [dispatcher] is
      * the [CoroutineDispatcher] to be used for update handling.
      */
+    @Deprecated(
+      "To create a `CartesianChartModelProducer`, use the constructor. Rather than passing a " +
+        "`CoroutineDispatcher`, use `runTransaction` with a `CoroutineContext` that includes the " +
+        "`CoroutineDispatcher`. Also use `runTransaction` to run an initial `Transaction`. " +
+        "More information: https://patrykandpatrick.com/vico/releases/2.0.0-alpha.22."
+    )
     public fun build(
       dispatcher: CoroutineDispatcher = Dispatchers.Default,
       transaction: (Transaction.() -> Unit)? = null,
     ): CartesianChartModelProducer =
       CartesianChartModelProducer(dispatcher).apply {
-        if (transaction != null) tryRunTransaction(transaction)
+        if (transaction != null) @Suppress("DEPRECATION") tryRunTransaction(transaction)
       }
   }
 }
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/data/CartesianLayerModel.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/data/CartesianLayerModel.kt
index e4e3db32e..de7ac0f7b 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/data/CartesianLayerModel.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/data/CartesianLayerModel.kt
@@ -28,22 +28,22 @@ public interface CartesianLayerModel {
   public val id: Int
 
   /** The minimum _x_ value. */
-  public val minX: Float
+  public val minX: Double
 
   /** The maximum _x_ value. */
-  public val maxX: Float
+  public val maxX: Double
 
   /** The minimum _y_ value. */
-  public val minY: Float
+  public val minY: Double
 
   /** The maximum _y_ value. */
-  public val maxY: Float
+  public val maxY: Double
 
   /** Stores auxiliary data, including [DrawingModel]s. */
   public val extraStore: ExtraStore
 
   /** Returns the greatest common divisor of the _x_ values’ differences. */
-  public fun getXDeltaGcd(): Float
+  public fun getXDeltaGcd(): Double
 
   /** Creates a copy of this [CartesianLayerModel] with the given [ExtraStore]. */
   public fun copy(extraStore: ExtraStore): CartesianLayerModel
@@ -55,7 +55,7 @@ public interface CartesianLayerModel {
   /** Represents a single entity in a [CartesianLayerModel]. */
   public interface Entry {
     /** The _x_ coordinate. */
-    public val x: Float
+    public val x: Double
 
     override fun equals(other: Any?): Boolean
 
@@ -72,26 +72,26 @@ public interface CartesianLayerModel {
   }
 }
 
-internal fun List<CartesianLayerModel.Entry>.getXDeltaGcd(): Float {
-  if (isEmpty()) return 1f
+internal fun List<CartesianLayerModel.Entry>.getXDeltaGcd(): Double {
+  if (isEmpty()) return 1.0
   val iterator = iterator()
   var prevX = iterator.next().x
-  var gcd: Float? = null
+  var gcd: Double? = null
   while (iterator.hasNext()) {
     val x = iterator.next().x
     val delta = abs(x - prevX)
     prevX = x
-    if (delta != 0f) gcd = gcd?.gcdWith(delta) ?: delta
+    if (delta != 0.0) gcd = gcd?.gcdWith(delta) ?: delta
   }
   return gcd?.also {
-    require(it != 0f) {
-      "The x values are too precise. The maximum precision is two decimal places."
+    require(it != 0.0) {
+      "The x values are too precise. The maximum precision is four decimal places."
     }
-  } ?: 1f
+  } ?: 1.0
 }
 
 internal inline fun <T : CartesianLayerModel.Entry> List<T>.forEachIn(
-  range: ClosedFloatingPointRange<Float>,
+  range: ClosedFloatingPointRange<Double>,
   padding: Int = 0,
   action: (T, T?) -> Unit,
 ) {
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/data/CartesianValueFormatter.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/data/CartesianValueFormatter.kt
index e5a803e8f..51784cc38 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/data/CartesianValueFormatter.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/data/CartesianValueFormatter.kt
@@ -28,7 +28,7 @@ public fun interface CartesianValueFormatter {
    * is associated. Pass this to [ChartValues.getYRange].
    */
   public fun format(
-    value: Float,
+    value: Double,
     chartValues: ChartValues,
     verticalAxisPosition: AxisPosition.Vertical?,
   ): CharSequence
@@ -37,7 +37,7 @@ public fun interface CartesianValueFormatter {
   public companion object {
     private class Decimal(private val decimalFormat: DecimalFormat) : CartesianValueFormatter {
       override fun format(
-        value: Float,
+        value: Double,
         chartValues: ChartValues,
         verticalAxisPosition: AxisPosition.Vertical?,
       ): CharSequence = decimalFormat.format(value)
@@ -50,7 +50,7 @@ public fun interface CartesianValueFormatter {
 
     private class YPercent(private val decimalFormat: DecimalFormat) : CartesianValueFormatter {
       override fun format(
-        value: Float,
+        value: Double,
         chartValues: ChartValues,
         verticalAxisPosition: AxisPosition.Vertical?,
       ): CharSequence =
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/data/ChartValues.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/data/ChartValues.kt
index 5578ccabf..f722a9524 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/data/ChartValues.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/data/ChartValues.kt
@@ -18,20 +18,17 @@ package com.patrykandpatrick.vico.core.cartesian.data
 
 import com.patrykandpatrick.vico.core.cartesian.CartesianChart
 import com.patrykandpatrick.vico.core.cartesian.axis.AxisPosition
-import com.patrykandpatrick.vico.core.common.round
-import kotlin.math.absoluteValue
-import kotlin.math.ulp
 
 /** Houses a [CartesianChart]’s [CartesianChartModel] and _x_ and _y_ ranges. */
 public interface ChartValues {
   /** The minimum _x_ value. */
-  public val minX: Float
+  public val minX: Double
 
   /** The maximum _x_ value. */
-  public val maxX: Float
+  public val maxX: Double
 
   /** The difference between the _x_ values of neighboring major entries. */
-  public val xStep: Float
+  public val xStep: Double
 
   /** The [CartesianChart]’s [CartesianChartModel]. */
   public val model: CartesianChartModel
@@ -43,36 +40,36 @@ public interface ChartValues {
   public fun getYRange(axisPosition: AxisPosition.Vertical?): YRange
 
   /** The difference between [maxX] and [minX]. */
-  public val xLength: Float
+  public val xLength: Double
     get() = maxX - minX
 
   /** Holds information on a _y_ range. */
   public interface YRange {
     /** The minimum _y_ value. */
-    public val minY: Float
+    public val minY: Double
 
     /** The maximum _y_ value. */
-    public val maxY: Float
+    public val maxY: Double
 
     /** The difference between [maxY] and [minY]. */
-    public val length: Float
+    public val length: Double
   }
 
   /** An empty [ChartValues] implementation. */
   public object Empty : ChartValues {
     private const val ERROR_MESSAGE = "`ChartValues.Empty` shouldn’t be used."
 
-    override val minX: Float
+    override val minX: Double
       get() {
         error(ERROR_MESSAGE)
       }
 
-    override val maxX: Float
+    override val maxX: Double
       get() {
         error(ERROR_MESSAGE)
       }
 
-    override val xStep: Float
+    override val xStep: Double
       get() {
         error(ERROR_MESSAGE)
       }
@@ -84,11 +81,3 @@ public interface ChartValues {
     }
   }
 }
-
-internal fun ChartValues.getXSpacingMultiplier(entryX: Float): Float {
-  val xSpacingMultiplier = (entryX - minX) / xStep
-  check((xSpacingMultiplier - xSpacingMultiplier.round).absoluteValue <= xSpacingMultiplier.ulp) {
-    "Each entry’s x value must be a multiple of the x step."
-  }
-  return xSpacingMultiplier
-}
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/data/ColumnCartesianLayerDrawingModel.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/data/ColumnCartesianLayerDrawingModel.kt
index 4c82f2a5d..8457ced9a 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/data/ColumnCartesianLayerDrawingModel.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/data/ColumnCartesianLayerDrawingModel.kt
@@ -23,11 +23,11 @@ import com.patrykandpatrick.vico.core.common.orZero
 
 /** Houses drawing information for a [ColumnCartesianLayer]. [opacity] is the columns’ opacity. */
 public class ColumnCartesianLayerDrawingModel(
-  private val entries: List<Map<Float, ColumnInfo>>,
+  private val entries: List<Map<Double, ColumnInfo>>,
   public val opacity: Float = 1f,
 ) : DrawingModel<ColumnCartesianLayerDrawingModel.ColumnInfo>(entries) {
   override fun transform(
-    drawingInfo: List<Map<Float, ColumnInfo>>,
+    drawingInfo: List<Map<Double, ColumnInfo>>,
     from: DrawingModel<ColumnInfo>?,
     fraction: Float,
   ): DrawingModel<ColumnInfo> {
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/data/ColumnCartesianLayerModel.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/data/ColumnCartesianLayerModel.kt
index 923b1b20f..295773d3b 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/data/ColumnCartesianLayerModel.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/data/ColumnCartesianLayerModel.kt
@@ -30,19 +30,19 @@ public class ColumnCartesianLayerModel : CartesianLayerModel {
 
   override val id: Int
 
-  override val minX: Float
+  override val minX: Double
 
-  override val maxX: Float
+  override val maxX: Double
 
-  override val minY: Float
+  override val minY: Double
 
-  override val maxY: Float
+  override val maxY: Double
 
   /** The minimum sum of all _y_ values associated with a given _x_ value. */
-  public val minAggregateY: Float
+  public val minAggregateY: Double
 
   /** The maximum sum of all _y_ values associated with a given _x_ value. */
-  public val maxAggregateY: Float
+  public val maxAggregateY: Double
 
   override val extraStore: ExtraStore
 
@@ -73,12 +73,12 @@ public class ColumnCartesianLayerModel : CartesianLayerModel {
     entries: List<Entry>,
     series: List<List<Entry>>,
     id: Int,
-    minX: Float,
-    maxX: Float,
-    minY: Float,
-    maxY: Float,
-    minAggregateY: Float,
-    maxAggregateY: Float,
+    minX: Double,
+    maxX: Double,
+    minY: Double,
+    maxY: Double,
+    minAggregateY: Double,
+    maxAggregateY: Double,
     extraStore: ExtraStore,
   ) {
     this.entries = entries
@@ -93,7 +93,7 @@ public class ColumnCartesianLayerModel : CartesianLayerModel {
     this.extraStore = extraStore
   }
 
-  override fun getXDeltaGcd(): Float = entries.getXDeltaGcd()
+  override fun getXDeltaGcd(): Double = entries.getXDeltaGcd()
 
   override fun copy(extraStore: ExtraStore): CartesianLayerModel =
     ColumnCartesianLayerModel(
@@ -136,9 +136,9 @@ public class ColumnCartesianLayerModel : CartesianLayerModel {
   }
 
   /** Represents a column of height [y] at [x]. */
-  public class Entry internal constructor(override val x: Float, public val y: Float) :
+  public class Entry internal constructor(override val x: Double, public val y: Double) :
     CartesianLayerModel.Entry {
-    public constructor(x: Number, y: Number) : this(x.toFloat(), y.toFloat())
+    public constructor(x: Number, y: Number) : this(x.toDouble(), y.toDouble())
 
     override fun equals(other: Any?): Boolean =
       this === other || other is Entry && x == other.x && y == other.y
@@ -205,8 +205,8 @@ public fun CartesianChartModelProducer.Transaction.columnSeries(
 }
 
 internal fun Iterable<ColumnCartesianLayerModel.Entry>.getAggregateYRange() =
-  fold(mutableMapOf<Float, Pair<Float, Float>>()) { map, entry ->
-      val (negativeY, positiveY) = map.getOrElse(entry.x) { 0f to 0f }
+  fold(mutableMapOf<Double, Pair<Double, Double>>()) { map, entry ->
+      val (negativeY, positiveY) = map.getOrElse(entry.x) { 0.0 to 0.0 }
       map[entry.x] =
         if (entry.y < 0f) negativeY + entry.y to positiveY else negativeY to positiveY + entry.y
       map
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/data/LineCartesianLayerDrawingModel.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/data/LineCartesianLayerDrawingModel.kt
index 9c040c705..2a86727b7 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/data/LineCartesianLayerDrawingModel.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/data/LineCartesianLayerDrawingModel.kt
@@ -23,16 +23,16 @@ import com.patrykandpatrick.vico.core.common.orZero
 
 /**
  * Houses drawing information for a [LineCartesianLayer]. [opacity] is the lines’ opacity. [zeroY],
- * restricted to the interval [0, 1], specifies the position of the zero line (_y_ = 0) from the top
- * of the [LineCartesianLayer] as a fraction of the [LineCartesianLayer]’s height.
+ * restricted to the interval [[0, 1]], specifies the position of the zero line (_y_ = 0) from the
+ * top of the [LineCartesianLayer] as a fraction of the [LineCartesianLayer]’s height.
  */
 public class LineCartesianLayerDrawingModel(
-  private val pointInfo: List<Map<Float, PointInfo>>,
+  private val pointInfo: List<Map<Double, PointInfo>>,
   public val zeroY: Float,
   public val opacity: Float = 1f,
 ) : DrawingModel<LineCartesianLayerDrawingModel.PointInfo>(pointInfo) {
   override fun transform(
-    drawingInfo: List<Map<Float, PointInfo>>,
+    drawingInfo: List<Map<Double, PointInfo>>,
     from: DrawingModel<PointInfo>?,
     fraction: Float,
   ): DrawingModel<PointInfo> {
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/data/LineCartesianLayerModel.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/data/LineCartesianLayerModel.kt
index 1846519f1..18b234a5d 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/data/LineCartesianLayerModel.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/data/LineCartesianLayerModel.kt
@@ -30,13 +30,13 @@ public class LineCartesianLayerModel : CartesianLayerModel {
 
   override val id: Int
 
-  override val minX: Float
+  override val minX: Double
 
-  override val maxX: Float
+  override val maxX: Double
 
-  override val minY: Float
+  override val minY: Double
 
-  override val maxY: Float
+  override val maxY: Double
 
   override val extraStore: ExtraStore
 
@@ -64,10 +64,10 @@ public class LineCartesianLayerModel : CartesianLayerModel {
     entries: List<Entry>,
     series: List<List<Entry>>,
     id: Int,
-    minX: Float,
-    maxX: Float,
-    minY: Float,
-    maxY: Float,
+    minX: Double,
+    maxX: Double,
+    minY: Double,
+    maxY: Double,
     extraStore: ExtraStore,
   ) {
     this.entries = entries
@@ -80,7 +80,7 @@ public class LineCartesianLayerModel : CartesianLayerModel {
     this.extraStore = extraStore
   }
 
-  override fun getXDeltaGcd(): Float = entries.getXDeltaGcd()
+  override fun getXDeltaGcd(): Double = entries.getXDeltaGcd()
 
   override fun copy(extraStore: ExtraStore): CartesianLayerModel =
     LineCartesianLayerModel(entries, series, id, minX, maxX, minY, maxY, extraStore)
@@ -108,9 +108,9 @@ public class LineCartesianLayerModel : CartesianLayerModel {
   }
 
   /** Represents a line node at ([x], [y]). */
-  public class Entry internal constructor(override val x: Float, public val y: Float) :
+  public class Entry internal constructor(override val x: Double, public val y: Double) :
     CartesianLayerModel.Entry {
-    public constructor(x: Number, y: Number) : this(x.toFloat(), y.toFloat())
+    public constructor(x: Number, y: Number) : this(x.toDouble(), y.toDouble())
 
     override fun equals(other: Any?): Boolean =
       this === other || other is Entry && x == other.x && y == other.y
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/data/MutableChartValues.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/data/MutableChartValues.kt
index 9f6c5272a..5b38718f7 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/data/MutableChartValues.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/data/MutableChartValues.kt
@@ -24,22 +24,22 @@ import kotlin.math.min
 
 /** An implementation of [ChartValues] whose every property is mutable. */
 public class MutableChartValues : ChartValues {
-  private var _minX: Float? = null
+  private var _minX: Double? = null
 
-  private var _maxX: Float? = null
+  private var _maxX: Double? = null
 
-  private var _xStep: Float? = null
+  private var _xStep: Double? = null
 
   internal var yRanges: MutableMap<AxisPosition.Vertical?, MutableYRange> = mutableMapOf()
 
-  override val minX: Float
+  override val minX: Double
     get() = _minX.orZero
 
-  override val maxX: Float
+  override val maxX: Double
     get() = _maxX.orZero
 
-  override val xStep: Float
-    get() = _xStep ?: 1f
+  override val xStep: Double
+    get() = _xStep ?: 1.0
 
   override fun getYRange(axisPosition: AxisPosition.Vertical?): ChartValues.YRange =
     yRanges[axisPosition] ?: yRanges.getValue(null)
@@ -47,7 +47,7 @@ public class MutableChartValues : ChartValues {
   override var model: CartesianChartModel = CartesianChartModel.empty
 
   /** Updates [MutableChartValues.xStep] and [MutableChartValues.model]. */
-  public fun update(xStep: Float? = null, model: CartesianChartModel) {
+  public fun update(xStep: Double, model: CartesianChartModel) {
     _xStep = xStep
     this.model = model
   }
@@ -57,10 +57,10 @@ public class MutableChartValues : ChartValues {
    * only be increased.
    */
   public fun tryUpdate(
-    minX: Float,
-    maxX: Float,
-    minY: Float,
-    maxY: Float,
+    minX: Double,
+    maxX: Double,
+    minY: Double,
+    maxY: Double,
     axisPosition: AxisPosition.Vertical?,
   ) {
     _minX = _minX?.coerceAtMost(minX) ?: minX
@@ -82,16 +82,16 @@ public class MutableChartValues : ChartValues {
   }
 
   /** A mutable implementation of [ChartValues.YRange]. */
-  public class MutableYRange(override var minY: Float, override var maxY: Float) :
+  public class MutableYRange(override var minY: Double, override var maxY: Double) :
     ChartValues.YRange {
-    override val length: Float
+    override val length: Double
       get() = maxY - minY
 
     /**
      * Tries to update [MutableYRange.minY] and [MutableYRange.maxY]. [MutableYRange.minY] can only
      * be decreased. [MutableYRange.maxY] can only be increased.
      */
-    public fun tryUpdate(minY: Float, maxY: Float) {
+    public fun tryUpdate(minY: Double, maxY: Double) {
       this.minY = min(this.minY, minY)
       this.maxY = max(this.maxY, maxY)
     }
@@ -103,9 +103,9 @@ public class MutableChartValues : ChartValues {
 public fun MutableChartValues.toImmutable(): ChartValues =
   object : ChartValues {
     private val yRanges = this@toImmutable.yRanges
-    override val minX: Float = this@toImmutable.minX
-    override val maxX: Float = this@toImmutable.maxX
-    override val xStep: Float = this@toImmutable.xStep
+    override val minX: Double = this@toImmutable.minX
+    override val maxX: Double = this@toImmutable.maxX
+    override val xStep: Double = this@toImmutable.xStep
     override val model: CartesianChartModel = this@toImmutable.model.toImmutable()
 
     override fun getYRange(axisPosition: AxisPosition.Vertical?): ChartValues.YRange =
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/data/RandomCartesianModelGenerator.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/data/RandomCartesianModelGenerator.kt
index f460230ba..30f2d0982 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/data/RandomCartesianModelGenerator.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/data/RandomCartesianModelGenerator.kt
@@ -19,20 +19,22 @@ package com.patrykandpatrick.vico.core.cartesian.data
 import androidx.annotation.RestrictTo
 import com.patrykandpatrick.vico.core.common.length
 import com.patrykandpatrick.vico.core.common.random
+import kotlin.math.max
+import kotlin.math.min
 import kotlin.random.Random
 
 /** @suppress */
 @RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
 public object RandomCartesianModelGenerator {
   public val defaultX: IntProgression = 0..96
-  public val defaultY: ClosedFloatingPointRange<Float> = 2f..20f
-  public val defaultOpeningClosingRange: ClosedFloatingPointRange<Float> = 5f..15f
-  public val defaultLowHighRange: ClosedFloatingPointRange<Float> = .5f..5f
+  public val defaultY: ClosedFloatingPointRange<Double> = 2.0..20.0
+  public val defaultOpeningClosingRange: ClosedFloatingPointRange<Double> = 5.0..15.0
+  public val defaultLowHighRange: ClosedFloatingPointRange<Double> = 0.5..5.0
 
   public fun getRandomColumnLayerModelPartial(
     seriesCount: Int = 1,
     x: IntProgression = defaultX,
-    y: ClosedFloatingPointRange<Float> = defaultY,
+    y: ClosedFloatingPointRange<Double> = defaultY,
   ): ColumnCartesianLayerModel.Partial =
     ColumnCartesianLayerModel.partial {
       repeat(seriesCount) { series(x.toList(), x.map { y.random() }) }
@@ -41,7 +43,7 @@ public object RandomCartesianModelGenerator {
   public fun getRandomLineLayerModelPartial(
     seriesCount: Int = 1,
     x: IntProgression = defaultX,
-    y: ClosedFloatingPointRange<Float> = defaultY,
+    y: ClosedFloatingPointRange<Double> = defaultY,
   ): LineCartesianLayerModel.Partial =
     LineCartesianLayerModel.partial {
       repeat(seriesCount) { series(x.toList(), x.map { y.random() }) }
@@ -49,18 +51,17 @@ public object RandomCartesianModelGenerator {
 
   public fun getRandomCandlestickLayerModelPartial(
     x: IntProgression = defaultX,
-    y: ClosedFloatingPointRange<Float> = defaultY,
-    openingClosingRange: ClosedFloatingPointRange<Float> = defaultOpeningClosingRange,
-    lowHighRange: ClosedFloatingPointRange<Float> = defaultLowHighRange,
+    openingClosingRange: ClosedFloatingPointRange<Double> = defaultOpeningClosingRange,
+    lowHighRange: ClosedFloatingPointRange<Double> = defaultLowHighRange,
   ): CandlestickCartesianLayerModel.Partial {
-    var previousClosingPrice: Float? = null
-    val opening = mutableListOf<Float>()
-    val closing = mutableListOf<Float>()
-    val low = mutableListOf<Float>()
-    val high = mutableListOf<Float>()
-    val maxOpeningPriceDelta = .2f * openingClosingRange.length
-    val changeOverrideThreshold = .2f * openingClosingRange.length
-    val maxClosingPriceDelta = .8f * openingClosingRange.length
+    var previousClosingPrice: Double? = null
+    val opening = mutableListOf<Double>()
+    val closing = mutableListOf<Double>()
+    val low = mutableListOf<Double>()
+    val high = mutableListOf<Double>()
+    val maxOpeningPriceDelta = 0.2 * openingClosingRange.length
+    val changeOverrideThreshold = 0.2 * openingClosingRange.length
+    val maxClosingPriceDelta = 0.8 * openingClosingRange.length
     for (i in x) {
       val openingPrice =
         if (previousClosingPrice != null) {
@@ -94,8 +95,8 @@ public object RandomCartesianModelGenerator {
             }
       opening += openingPrice
       closing += closingPrice
-      low += minOf(openingPrice, closingPrice) - lowHighRange.random()
-      high += maxOf(openingPrice, closingPrice) + lowHighRange.random()
+      low += min(openingPrice, closingPrice) - lowHighRange.random()
+      high += max(openingPrice, closingPrice) + lowHighRange.random()
       previousClosingPrice = closingPrice
     }
     return CandlestickCartesianLayerModel.partial(x.toList(), opening, closing, low, high)
@@ -105,13 +106,13 @@ public object RandomCartesianModelGenerator {
     columnSeriesCount: Int = 1,
     lineSeriesCount: Int = 1,
     x: IntProgression = defaultX,
-    y: ClosedFloatingPointRange<Float> = defaultY,
+    y: ClosedFloatingPointRange<Double> = defaultY,
   ): CartesianChartModel =
     CartesianChartModel(
       buildList {
         add(getRandomColumnLayerModelPartial(columnSeriesCount, x, y).complete())
         add(getRandomLineLayerModelPartial(lineSeriesCount, x, y).complete())
-        add(getRandomCandlestickLayerModelPartial(x, y).complete())
+        add(getRandomCandlestickLayerModelPartial(x).complete())
       }
     )
 }
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/decoration/Decoration.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/decoration/Decoration.kt
index eea05643b..2902324f0 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/decoration/Decoration.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/decoration/Decoration.kt
@@ -16,9 +16,9 @@
 
 package com.patrykandpatrick.vico.core.cartesian.decoration
 
-import android.graphics.RectF
 import com.patrykandpatrick.vico.core.cartesian.CartesianChart
 import com.patrykandpatrick.vico.core.cartesian.CartesianDrawContext
+import com.patrykandpatrick.vico.core.cartesian.layer.CartesianLayer
 
 /**
  * A [Decoration] presents additional information on a [CartesianChart].
@@ -27,19 +27,9 @@ import com.patrykandpatrick.vico.core.cartesian.CartesianDrawContext
  * @see [HorizontalLine]
  */
 public interface Decoration {
-  /**
-   * Called before the [CartesianChart] starts drawing itself.
-   *
-   * @param [context] holds the information needed to draw the [CartesianChart].
-   * @param [bounds] the bounding box of the [CartesianChart].
-   */
-  public fun onDrawBehindChart(context: CartesianDrawContext, bounds: RectF): Unit = Unit
+  /** Draws content under the [CartesianLayer]s. */
+  public fun drawUnderLayers(context: CartesianDrawContext) {}
 
-  /**
-   * Called immediately after the [CartesianChart] finishes drawing itself.
-   *
-   * @param [context] holds the information needed to draw the [CartesianChart].
-   * @param [bounds] the bounding box of the [CartesianChart].
-   */
-  public fun onDrawAboveChart(context: CartesianDrawContext, bounds: RectF): Unit = Unit
+  /** Draws content over the [CartesianLayer]s. */
+  public fun drawOverLayers(context: CartesianDrawContext) {}
 }
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/decoration/HorizontalBox.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/decoration/HorizontalBox.kt
index f3bb9f9d1..312e7fa50 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/decoration/HorizontalBox.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/decoration/HorizontalBox.kt
@@ -16,7 +16,6 @@
 
 package com.patrykandpatrick.vico.core.cartesian.decoration
 
-import android.graphics.RectF
 import androidx.annotation.RestrictTo
 import com.patrykandpatrick.vico.core.cartesian.CartesianDrawContext
 import com.patrykandpatrick.vico.core.cartesian.axis.AxisPosition
@@ -47,7 +46,7 @@ import java.text.DecimalFormat
  *   should use when interpreting [y].
  */
 public class HorizontalBox(
-  private val y: (ExtraStore) -> ClosedFloatingPointRange<Float>,
+  private val y: (ExtraStore) -> ClosedFloatingPointRange<Double>,
   private val box: ShapeComponent,
   private val labelComponent: TextComponent? = null,
   private val label: (ExtraStore) -> CharSequence = { getLabel(y(it)) },
@@ -56,35 +55,39 @@ public class HorizontalBox(
   private val labelRotationDegrees: Float = 0f,
   private val verticalAxisPosition: AxisPosition.Vertical? = null,
 ) : Decoration {
-  override fun onDrawAboveChart(context: CartesianDrawContext, bounds: RectF) {
+  override fun drawOverLayers(context: CartesianDrawContext) {
     with(context) {
       val yRange = chartValues.getYRange(verticalAxisPosition)
       val extraStore = chartValues.model.extraStore
       val y = y(extraStore)
       val label = label(extraStore)
-      val topY = bounds.bottom - (y.endInclusive - yRange.minY) / yRange.length * bounds.height()
-      val bottomY = bounds.bottom - (y.start - yRange.minY) / yRange.length * bounds.height()
+      val topY =
+        layerBounds.bottom -
+          ((y.endInclusive - yRange.minY) / yRange.length).toFloat() * layerBounds.height()
+      val bottomY =
+        (layerBounds.bottom - (y.start - yRange.minY) / yRange.length * layerBounds.height())
+          .toFloat()
       val labelY =
         when (verticalLabelPosition) {
           VerticalPosition.Top -> topY
           VerticalPosition.Center -> (topY + bottomY).half
           VerticalPosition.Bottom -> bottomY
         }
-      box.draw(context, bounds.left, topY, bounds.right, bottomY)
-      labelComponent?.drawText(
+      box.draw(context, layerBounds.left, topY, layerBounds.right, bottomY)
+      labelComponent?.draw(
         context = context,
         text = label,
-        textX =
+        x =
           when (horizontalLabelPosition) {
-            HorizontalPosition.Start -> bounds.getStart(isLtr)
-            HorizontalPosition.Center -> bounds.centerX()
-            HorizontalPosition.End -> bounds.getEnd(isLtr)
+            HorizontalPosition.Start -> layerBounds.getStart(isLtr)
+            HorizontalPosition.Center -> layerBounds.centerX()
+            HorizontalPosition.End -> layerBounds.getEnd(isLtr)
           },
-        textY = labelY,
+        y = labelY,
         horizontalPosition = -horizontalLabelPosition,
         verticalPosition =
           verticalLabelPosition.inBounds(
-            bounds = bounds,
+            bounds = layerBounds,
             componentHeight =
               labelComponent.getHeight(
                 context = context,
@@ -93,7 +96,7 @@ public class HorizontalBox(
               ),
             y = labelY,
           ),
-        maxTextWidth = bounds.width().toInt(),
+        maxWidth = layerBounds.width().toInt(),
         rotationDegrees = labelRotationDegrees,
       )
     }
@@ -104,7 +107,7 @@ public class HorizontalBox(
   public companion object {
     private val decimalFormat = DecimalFormat("#.##;−#.##")
 
-    public fun getLabel(y: ClosedFloatingPointRange<Float>): String =
+    public fun getLabel(y: ClosedFloatingPointRange<Double>): String =
       "${decimalFormat.format(y.start)}–${decimalFormat.format(y.endInclusive)}"
   }
 }
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/decoration/HorizontalLine.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/decoration/HorizontalLine.kt
index 6f0210a21..1d4979a27 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/decoration/HorizontalLine.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/decoration/HorizontalLine.kt
@@ -16,7 +16,6 @@
 
 package com.patrykandpatrick.vico.core.cartesian.decoration
 
-import android.graphics.RectF
 import androidx.annotation.RestrictTo
 import com.patrykandpatrick.vico.core.cartesian.CartesianDrawContext
 import com.patrykandpatrick.vico.core.cartesian.axis.AxisPosition
@@ -47,7 +46,7 @@ import java.text.DecimalFormat
  *   [HorizontalLine] should use when interpreting [y].
  */
 public class HorizontalLine(
-  private val y: (ExtraStore) -> Float,
+  private val y: (ExtraStore) -> Double,
   private val line: LineComponent,
   private val labelComponent: TextComponent? = null,
   private val label: (ExtraStore) -> CharSequence = { getLabel(y(it)) },
@@ -56,18 +55,19 @@ public class HorizontalLine(
   private val labelRotationDegrees: Float = 0f,
   private val verticalAxisPosition: AxisPosition.Vertical? = null,
 ) : Decoration {
-  override fun onDrawAboveChart(context: CartesianDrawContext, bounds: RectF) {
+  override fun drawOverLayers(context: CartesianDrawContext) {
     with(context) {
       val yRange = chartValues.getYRange(verticalAxisPosition)
       val extraStore = chartValues.model.extraStore
       val y = y(extraStore)
       val label = label(extraStore)
-      val canvasY = bounds.bottom - (y - yRange.minY) / yRange.length * bounds.height()
-      line.drawHorizontal(context, bounds.left, bounds.right, canvasY)
+      val canvasY =
+        layerBounds.bottom - ((y - yRange.minY) / yRange.length).toFloat() * layerBounds.height()
+      line.drawHorizontal(context, layerBounds.left, layerBounds.right, canvasY)
       if (labelComponent == null) return
       val clippingFreeVerticalLabelPosition =
         verticalLabelPosition.inBounds(
-          bounds = bounds,
+          bounds = layerBounds,
           distanceFromPoint = line.thicknessDp.half.pixels,
           componentHeight =
             labelComponent.getHeight(
@@ -77,16 +77,16 @@ public class HorizontalLine(
             ),
           y = canvasY,
         )
-      labelComponent.drawText(
+      labelComponent.draw(
         context = context,
         text = label,
-        textX =
+        x =
           when (horizontalLabelPosition) {
-            HorizontalPosition.Start -> bounds.getStart(isLtr)
-            HorizontalPosition.Center -> bounds.centerX()
-            HorizontalPosition.End -> bounds.getEnd(isLtr)
+            HorizontalPosition.Start -> layerBounds.getStart(isLtr)
+            HorizontalPosition.Center -> layerBounds.centerX()
+            HorizontalPosition.End -> layerBounds.getEnd(isLtr)
           },
-        textY =
+        y =
           when (clippingFreeVerticalLabelPosition) {
             VerticalPosition.Top -> canvasY - line.thicknessDp.half.pixels
             VerticalPosition.Center -> canvasY
@@ -94,7 +94,7 @@ public class HorizontalLine(
           },
         horizontalPosition = -horizontalLabelPosition,
         verticalPosition = clippingFreeVerticalLabelPosition,
-        maxTextWidth = bounds.width().toInt(),
+        maxWidth = layerBounds.width().toInt(),
         rotationDegrees = labelRotationDegrees,
       )
     }
@@ -105,6 +105,6 @@ public class HorizontalLine(
   public companion object {
     private val decimalFormat: DecimalFormat = DecimalFormat("#.##;−#.##")
 
-    public fun getLabel(y: Float): String = decimalFormat.format(y)
+    public fun getLabel(y: Double): String = decimalFormat.format(y)
   }
 }
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/layer/BaseCartesianLayer.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/layer/BaseCartesianLayer.kt
index da89a0c43..22c166208 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/layer/BaseCartesianLayer.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/layer/BaseCartesianLayer.kt
@@ -16,23 +16,19 @@
 
 package com.patrykandpatrick.vico.core.cartesian.layer
 
-import android.graphics.RectF
 import com.patrykandpatrick.vico.core.cartesian.CartesianDrawContext
 import com.patrykandpatrick.vico.core.cartesian.Insets
 import com.patrykandpatrick.vico.core.cartesian.MutableHorizontalDimensions
 import com.patrykandpatrick.vico.core.cartesian.data.AxisValueOverrider
 import com.patrykandpatrick.vico.core.cartesian.data.CartesianLayerModel
 import com.patrykandpatrick.vico.core.cartesian.data.ChartValues
-import com.patrykandpatrick.vico.core.common.BoundsAware
 import com.patrykandpatrick.vico.core.common.half
 import com.patrykandpatrick.vico.core.common.inClip
 
 /** A base [CartesianLayer] implementation. */
-public abstract class BaseCartesianLayer<T : CartesianLayerModel> : CartesianLayer<T>, BoundsAware {
+public abstract class BaseCartesianLayer<T : CartesianLayerModel> : CartesianLayer<T> {
   private val insets: Insets = Insets()
 
-  override val bounds: RectF = RectF()
-
   /** Overrides the _x_ and _y_ ranges. */
   public var axisValueOverrider: AxisValueOverrider = AxisValueOverrider.auto()
 
@@ -46,19 +42,19 @@ public abstract class BaseCartesianLayer<T : CartesianLayerModel> : CartesianLay
       xSpacing = xSpacing,
       scalableStartPadding = xSpacing.half,
       scalableEndPadding =
-        ((-chartValues.xLength / chartValues.xStep - 0.5f) % 1f + 1f) % 1f * xSpacing,
+        (((-chartValues.xLength / chartValues.xStep - 0.5) % 1 + 1) % 1).toFloat() * xSpacing,
     )
   }
 
   override fun draw(context: CartesianDrawContext, model: T) {
     with(context) {
       insets.clear()
-      getInsets(this, insets, horizontalDimensions)
+      updateInsets(this, horizontalDimensions, model, insets)
       canvas.inClip(
-        left = bounds.left - insets.getLeft(isLtr),
-        top = bounds.top - insets.top,
-        right = bounds.right + insets.getRight(isLtr),
-        bottom = bounds.bottom + insets.bottom,
+        left = layerBounds.left - insets.getLeft(isLtr),
+        top = layerBounds.top - insets.top,
+        right = layerBounds.right + insets.getRight(isLtr),
+        bottom = layerBounds.bottom + insets.bottom,
       ) {
         drawInternal(context, model)
       }
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/layer/CandlestickCartesianLayer.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/layer/CandlestickCartesianLayer.kt
index cc49869ba..8e6ffbe4b 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/layer/CandlestickCartesianLayer.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/layer/CandlestickCartesianLayer.kt
@@ -16,7 +16,6 @@
 
 package com.patrykandpatrick.vico.core.cartesian.layer
 
-import android.graphics.Color
 import androidx.annotation.RestrictTo
 import com.patrykandpatrick.vico.core.cartesian.CartesianDrawContext
 import com.patrykandpatrick.vico.core.cartesian.CartesianMeasureContext
@@ -30,7 +29,6 @@ import com.patrykandpatrick.vico.core.cartesian.data.CandlestickCartesianLayerMo
 import com.patrykandpatrick.vico.core.cartesian.data.ChartValues
 import com.patrykandpatrick.vico.core.cartesian.data.MutableChartValues
 import com.patrykandpatrick.vico.core.cartesian.data.forEachIn
-import com.patrykandpatrick.vico.core.cartesian.data.getXSpacingMultiplier
 import com.patrykandpatrick.vico.core.cartesian.layer.CandlestickCartesianLayer.Candle
 import com.patrykandpatrick.vico.core.cartesian.marker.CandlestickCartesianLayerMarkerTarget
 import com.patrykandpatrick.vico.core.cartesian.marker.CartesianMarker
@@ -43,6 +41,7 @@ import com.patrykandpatrick.vico.core.common.data.MutableExtraStore
 import com.patrykandpatrick.vico.core.common.getStart
 import com.patrykandpatrick.vico.core.common.half
 import com.patrykandpatrick.vico.core.common.shape.Shape
+import kotlin.math.max
 
 /**
  * Draws the content of candlestick charts.
@@ -85,10 +84,11 @@ public open class CandlestickCartesianLayer(
       get() = maxOf(body.thicknessDp, topWick.thicknessDp, bottomWick.thicknessDp)
 
     // Empty companion object is needed for extension functions.
-    public companion object
+    /** @suppress */
+    @RestrictTo(RestrictTo.Scope.LIBRARY_GROUP) public companion object
   }
 
-  private val _markerTargets = mutableMapOf<Float, List<CandlestickCartesianLayerMarkerTarget>>()
+  private val _markerTargets = mutableMapOf<Double, List<CandlestickCartesianLayerMarkerTarget>>()
 
   /** Holds information on the [CandlestickCartesianLayer]’s horizontal dimensions. */
   protected val horizontalDimensions: MutableHorizontalDimensions = MutableHorizontalDimensions()
@@ -96,7 +96,7 @@ public open class CandlestickCartesianLayer(
   protected val drawingModelKey: ExtraStore.Key<CandlestickCartesianLayerDrawingModel> =
     ExtraStore.Key()
 
-  override val markerTargets: Map<Float, List<CartesianMarker.Target>> = _markerTargets
+  override val markerTargets: Map<Double, List<CartesianMarker.Target>> = _markerTargets
 
   override fun drawInternal(
     context: CartesianDrawContext,
@@ -120,9 +120,9 @@ public open class CandlestickCartesianLayer(
     val halfMaxCandleWidth = candles.getWidestCandle(model.extraStore).widthDp.half.pixels
 
     val drawingStart =
-      bounds.getStart(isLtr) +
+      layerBounds.getStart(isLtr) +
         (horizontalDimensions.startPadding - halfMaxCandleWidth * zoom) *
-          layoutDirectionMultiplier - horizontalScroll
+          layoutDirectionMultiplier - scroll
 
     var bodyCenterX: Float
     var candle: Candle
@@ -131,16 +131,16 @@ public open class CandlestickCartesianLayer(
     model.series.forEachIn(chartValues.minX..chartValues.maxX) { entry, _ ->
       candle = candles.getCandle(entry, model.extraStore)
       val candleInfo = drawingModel?.entries?.get(entry.x) ?: entry.toCandleInfo(yRange)
-      val xSpacingMultiplier = chartValues.getXSpacingMultiplier(entry.x)
+      val xSpacingMultiplier = ((entry.x - chartValues.minX) / chartValues.xStep).toFloat()
       bodyCenterX =
         drawingStart +
           layoutDirectionMultiplier * horizontalDimensions.xSpacing * xSpacingMultiplier +
           halfMaxCandleWidth * zoom
 
-      var bodyBottomY = bounds.bottom - candleInfo.bodyBottomY * bounds.height()
-      var bodyTopY = bounds.bottom - candleInfo.bodyTopY * bounds.height()
-      val bottomWickY = bounds.bottom - candleInfo.bottomWickY * bounds.height()
-      val topWickY = bounds.bottom - candleInfo.topWickY * bounds.height()
+      var bodyBottomY = layerBounds.bottom - candleInfo.bodyBottomY * layerBounds.height()
+      var bodyTopY = layerBounds.bottom - candleInfo.bodyTopY * layerBounds.height()
+      val bottomWickY = layerBounds.bottom - candleInfo.bottomWickY * layerBounds.height()
+      val topWickY = layerBounds.bottom - candleInfo.topWickY * layerBounds.height()
 
       if (bodyBottomY - bodyTopY < minBodyHeight) {
         bodyBottomY = (bodyBottomY + bodyTopY).half + minBodyHeight.half
@@ -153,7 +153,7 @@ public open class CandlestickCartesianLayer(
           top = bodyTopY,
           bottom = bodyBottomY,
           centerX = bodyCenterX,
-          boundingBox = bounds,
+          boundingBox = layerBounds,
           thicknessScale = zoom,
         )
       ) {
@@ -188,7 +188,7 @@ public open class CandlestickCartesianLayer(
     }
   }
 
-  protected open fun updateMarkerTargets(
+  protected open fun CartesianDrawContext.updateMarkerTargets(
     entry: CandlestickCartesianLayerModel.Entry,
     canvasX: Float,
     bodyBottomCanvasY: Float,
@@ -197,9 +197,9 @@ public open class CandlestickCartesianLayer(
     highCanvasY: Float,
     candle: Candle,
   ) {
-    if (canvasX <= bounds.left - 1 || canvasX >= bounds.right + 1) return
-    val limitedBodyBottomCanvasY = bodyBottomCanvasY.coerceIn(bounds.top, bounds.bottom)
-    val limitedBodyTopCanvasY = bodyTopCanvasY.coerceIn(bounds.top, bounds.bottom)
+    if (canvasX <= layerBounds.left - 1 || canvasX >= layerBounds.right + 1) return
+    val limitedBodyBottomCanvasY = bodyBottomCanvasY.coerceIn(layerBounds.top, layerBounds.bottom)
+    val limitedBodyTopCanvasY = bodyTopCanvasY.coerceIn(layerBounds.top, layerBounds.bottom)
     _markerTargets[entry.x] =
       listOf(
         CandlestickCartesianLayerMarkerTarget(
@@ -212,8 +212,8 @@ public open class CandlestickCartesianLayer(
           closingCanvasY =
             if (entry.absoluteChange == Change.Bullish) limitedBodyTopCanvasY
             else limitedBodyBottomCanvasY,
-          lowCanvasY = lowCanvasY.coerceIn(bounds.top, bounds.bottom),
-          highCanvasY = highCanvasY.coerceIn(bounds.top, bounds.bottom),
+          lowCanvasY = lowCanvasY.coerceIn(layerBounds.top, layerBounds.bottom),
+          highCanvasY = highCanvasY.coerceIn(layerBounds.top, layerBounds.bottom),
           openingColor = candle.body.solidOrStrokeColor,
           closingColor = candle.body.solidOrStrokeColor,
           lowColor = candle.bottomWick.solidOrStrokeColor,
@@ -278,10 +278,10 @@ public open class CandlestickCartesianLayer(
 
   private fun CandlestickCartesianLayerModel.Entry.toCandleInfo(yRange: ChartValues.YRange) =
     CandlestickCartesianLayerDrawingModel.CandleInfo(
-      bodyBottomY = (minOf(opening, closing) - yRange.minY) / yRange.length,
-      bodyTopY = (maxOf(opening, closing) - yRange.minY) / yRange.length,
-      bottomWickY = (low - yRange.minY) / yRange.length,
-      topWickY = (high - yRange.minY) / yRange.length,
+      bodyBottomY = ((minOf(opening, closing) - yRange.minY) / yRange.length).toFloat(),
+      bodyTopY = ((max(opening, closing) - yRange.minY) / yRange.length).toFloat(),
+      bottomWickY = ((low - yRange.minY) / yRange.length).toFloat(),
+      topWickY = ((high - yRange.minY) / yRange.length).toFloat(),
     )
 
   private fun CandlestickCartesianLayerModel.toDrawingModel(
@@ -382,10 +382,10 @@ public open class CandlestickCartesianLayer(
 @RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
 public fun LineComponent.asWick(): LineComponent =
   copy(
-    color = if (color == Color.TRANSPARENT) strokeColor else color,
+    color = solidOrStrokeColor,
     thicknessDp = Defaults.WICK_DEFAULT_WIDTH_DP,
-    strokeWidthDp = 0f,
     shape = Shape.Rectangle,
+    strokeThicknessDp = 0f,
   )
 
 /**
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/layer/CartesianLayer.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/layer/CartesianLayer.kt
index 707ffb389..fa217e996 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/layer/CartesianLayer.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/layer/CartesianLayer.kt
@@ -25,33 +25,32 @@ import com.patrykandpatrick.vico.core.cartesian.data.CartesianLayerModel
 import com.patrykandpatrick.vico.core.cartesian.data.ChartValues
 import com.patrykandpatrick.vico.core.cartesian.data.MutableChartValues
 import com.patrykandpatrick.vico.core.cartesian.marker.CartesianMarker
-import com.patrykandpatrick.vico.core.common.BoundsAware
 import com.patrykandpatrick.vico.core.common.data.MutableExtraStore
 
 /**
  * Visualizes data on a Cartesian plane. [CartesianLayer]s are combined and drawn by
  * [CartesianChart]s.
  */
-public interface CartesianLayer<T : CartesianLayerModel> : BoundsAware, ChartInsetter {
+public interface CartesianLayer<M : CartesianLayerModel> : ChartInsetter<M> {
   /** Links _x_ values to [CartesianMarker.Target]s. */
-  public val markerTargets: Map<Float, List<CartesianMarker.Target>>
+  public val markerTargets: Map<Double, List<CartesianMarker.Target>>
 
   /** Draws the [CartesianLayer]. */
-  public fun draw(context: CartesianDrawContext, model: T)
+  public fun draw(context: CartesianDrawContext, model: M)
 
   /** Updates [horizontalDimensions] to match this [CartesianLayer]’s dimensions. */
   public fun updateHorizontalDimensions(
     context: CartesianMeasureContext,
     horizontalDimensions: MutableHorizontalDimensions,
-    model: T,
+    model: M,
   )
 
   /** Updates [chartValues] in accordance with [model]. */
-  public fun updateChartValues(chartValues: MutableChartValues, model: T)
+  public fun updateChartValues(chartValues: MutableChartValues, model: M)
 
   /** Prepares the [CartesianLayer] for a difference animation. */
   public fun prepareForTransformation(
-    model: T?,
+    model: M?,
     extraStore: MutableExtraStore,
     chartValues: ChartValues,
   )
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/layer/ColumnCartesianLayer.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/layer/ColumnCartesianLayer.kt
index 542e2b9d1..e7a72501c 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/layer/ColumnCartesianLayer.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/layer/ColumnCartesianLayer.kt
@@ -16,6 +16,7 @@
 
 package com.patrykandpatrick.vico.core.cartesian.layer
 
+import androidx.compose.runtime.Immutable
 import com.patrykandpatrick.vico.core.cartesian.CartesianDrawContext
 import com.patrykandpatrick.vico.core.cartesian.CartesianMeasureContext
 import com.patrykandpatrick.vico.core.cartesian.HorizontalLayout
@@ -28,7 +29,6 @@ import com.patrykandpatrick.vico.core.cartesian.data.ColumnCartesianLayerDrawing
 import com.patrykandpatrick.vico.core.cartesian.data.ColumnCartesianLayerModel
 import com.patrykandpatrick.vico.core.cartesian.data.MutableChartValues
 import com.patrykandpatrick.vico.core.cartesian.data.forEachIn
-import com.patrykandpatrick.vico.core.cartesian.data.getXSpacingMultiplier
 import com.patrykandpatrick.vico.core.cartesian.marker.CartesianMarker
 import com.patrykandpatrick.vico.core.cartesian.marker.ColumnCartesianLayerMarkerTarget
 import com.patrykandpatrick.vico.core.cartesian.marker.MutableColumnCartesianLayerMarkerTarget
@@ -47,13 +47,13 @@ import com.patrykandpatrick.vico.core.common.half
 import com.patrykandpatrick.vico.core.common.inBounds
 import com.patrykandpatrick.vico.core.common.unaryMinus
 import kotlin.math.abs
+import kotlin.math.min
 
 /**
  * Displays data as vertical bars.
  *
  * @property columnProvider provides the column [LineComponent]s.
- * @property spacingDp the spacing between neighboring column collections.
- * @property innerSpacingDp the spacing between neighboring grouped columns.
+ * @property columnCollectionSpacingDp the spacing between neighboring column collections (in dp).
  * @property mergeMode defines how columns should be drawn in column collections.
  * @property verticalAxisPosition the position of the [VerticalAxis] with which the
  *   [ColumnCartesianLayer] should be associated. Use this for independent [CartesianLayer] scaling.
@@ -67,9 +67,8 @@ import kotlin.math.abs
  */
 public open class ColumnCartesianLayer(
   public var columnProvider: ColumnProvider,
-  public var spacingDp: Float = Defaults.COLUMN_OUTSIDE_SPACING,
-  public var innerSpacingDp: Float = Defaults.COLUMN_INSIDE_SPACING,
-  public var mergeMode: (ExtraStore) -> MergeMode = { MergeMode.Grouped },
+  public var columnCollectionSpacingDp: Float = Defaults.COLUMN_COLLECTION_SPACING,
+  public var mergeMode: (ExtraStore) -> MergeMode = { MergeMode.Grouped() },
   public var verticalAxisPosition: AxisPosition.Vertical? = null,
   public var dataLabel: TextComponent? = null,
   public var dataLabelVerticalPosition: VerticalPosition = VerticalPosition.Top,
@@ -83,16 +82,16 @@ public open class ColumnCartesianLayer(
     DefaultDrawingModelInterpolator(),
 ) : BaseCartesianLayer<ColumnCartesianLayerModel>() {
   private val _markerTargets =
-    mutableMapOf<Float, MutableList<MutableColumnCartesianLayerMarkerTarget>>()
+    mutableMapOf<Double, MutableList<MutableColumnCartesianLayerMarkerTarget>>()
 
-  protected val stackInfo: MutableMap<Float, StackInfo> = mutableMapOf()
+  protected val stackInfo: MutableMap<Double, StackInfo> = mutableMapOf()
 
   /** Holds information on the [ColumnCartesianLayer]’s horizontal dimensions. */
   protected val horizontalDimensions: MutableHorizontalDimensions = MutableHorizontalDimensions()
 
   protected val drawingModelKey: ExtraStore.Key<ColumnCartesianLayerDrawingModel> = ExtraStore.Key()
 
-  override val markerTargets: Map<Float, List<CartesianMarker.Target>> = _markerTargets
+  override val markerTargets: Map<Double, List<CartesianMarker.Target>> = _markerTargets
 
   override fun drawInternal(context: CartesianDrawContext, model: ColumnCartesianLayerModel): Unit =
     with(context) {
@@ -111,23 +110,25 @@ public open class ColumnCartesianLayer(
     drawingModel: ColumnCartesianLayerDrawingModel?,
   ) {
     val yRange = chartValues.getYRange(verticalAxisPosition)
-    val heightMultiplier = bounds.height() / yRange.length
+    val heightMultiplier = layerBounds.height() / yRange.length.toFloat()
 
     var drawingStart: Float
     var height: Float
     var columnCenterX: Float
     var columnTop: Float
     var columnBottom: Float
-    val zeroLinePosition = bounds.bottom + yRange.minY / yRange.length * bounds.height()
+    val zeroLinePosition =
+      layerBounds.bottom + (yRange.minY / yRange.length).toFloat() * layerBounds.height()
     val mergeMode = mergeMode(model.extraStore)
 
     model.series.forEachIndexed { index, entryCollection ->
-      drawingStart = getDrawingStart(index, model.series.size, mergeMode) - horizontalScroll
+      drawingStart = getDrawingStart(index, model.series.size, mergeMode) - scroll
 
       entryCollection.forEachIn(chartValues.minX..chartValues.maxX) { entry, _ ->
         val columnInfo = drawingModel?.getOrNull(index)?.get(entry.x)
-        height = (columnInfo?.height ?: (abs(entry.y) / yRange.length)) * bounds.height()
-        val xSpacingMultiplier = chartValues.getXSpacingMultiplier(entry.x)
+        height =
+          (columnInfo?.height ?: (abs(entry.y) / yRange.length)).toFloat() * layerBounds.height()
+        val xSpacingMultiplier = ((entry.x - chartValues.minX) / chartValues.xStep).toFloat()
         val column = columnProvider.getColumn(entry, index, model.extraStore)
         columnCenterX =
           drawingStart +
@@ -142,7 +143,7 @@ public open class ColumnCartesianLayer(
           MergeMode.Stacked -> {
             val stackInfo = stackInfo.getOrPut(entry.x) { StackInfo() }
             columnBottom =
-              if (entry.y >= 0f) {
+              if (entry.y >= 0) {
                 zeroLinePosition - stackInfo.topHeight
               } else {
                 zeroLinePosition + stackInfo.bottomHeight + height
@@ -150,7 +151,7 @@ public open class ColumnCartesianLayer(
             columnTop = (columnBottom - height).coerceAtMost(columnBottom)
             stackInfo.update(entry.y, height)
           }
-          MergeMode.Grouped -> {
+          is MergeMode.Grouped -> {
             columnBottom = zeroLinePosition + if (entry.y < 0f) height else 0f
             columnTop = columnBottom - height
           }
@@ -164,7 +165,7 @@ public open class ColumnCartesianLayer(
             top = columnTop,
             bottom = columnBottom,
             centerX = columnCenterX,
-            boundingBox = bounds,
+            boundingBox = layerBounds,
             thicknessScale = zoom,
           )
         ) {
@@ -179,7 +180,7 @@ public open class ColumnCartesianLayer(
           )
         }
 
-        if (mergeMode == MergeMode.Grouped) {
+        if (mergeMode is MergeMode.Grouped) {
           drawDataLabel(
             modelEntriesSize = model.series.size,
             columnThicknessDp = column.thicknessDp,
@@ -247,7 +248,7 @@ public open class ColumnCartesianLayer(
   protected open fun CartesianDrawContext.drawDataLabel(
     modelEntriesSize: Int,
     columnThicknessDp: Float,
-    dataLabelValue: Float,
+    dataLabelValue: Double,
     x: Float,
     y: Float,
     isFirst: Boolean,
@@ -256,12 +257,13 @@ public open class ColumnCartesianLayer(
   ) {
     dataLabel?.let { textComponent ->
       val canUseXSpacing =
-        mergeMode == MergeMode.Stacked || mergeMode == MergeMode.Grouped && modelEntriesSize == 1
+        mergeMode == MergeMode.Stacked || mergeMode is MergeMode.Grouped && modelEntriesSize == 1
       var maxWidth =
         when {
           canUseXSpacing -> horizontalDimensions.xSpacing
-          mergeMode == MergeMode.Grouped ->
-            (columnThicknessDp + minOf(spacingDp, innerSpacingDp).half).pixels * zoom
+          mergeMode is MergeMode.Grouped ->
+            (columnThicknessDp + min(columnCollectionSpacingDp, mergeMode.columnSpacingDp).half)
+              .pixels * zoom
           else -> error(message = "Encountered an unexpected `MergeMode`.")
         }
       if (isFirst && horizontalLayout is HorizontalLayout.FullWidth) {
@@ -281,7 +283,11 @@ public open class ColumnCartesianLayer(
           .getWidth(context = this, text = text, rotationDegrees = dataLabelRotationDegrees)
           .coerceAtMost(maximumValue = maxWidth)
 
-      if (x - dataLabelWidth.half > bounds.right || x + dataLabelWidth.half < bounds.left) return
+      if (
+        x - dataLabelWidth.half > layerBounds.right || x + dataLabelWidth.half < layerBounds.left
+      ) {
+        return
+      }
 
       val labelVerticalPosition =
         if (dataLabelValue < 0f) -dataLabelVerticalPosition else dataLabelVerticalPosition
@@ -289,43 +295,43 @@ public open class ColumnCartesianLayer(
       val verticalPosition =
         labelVerticalPosition.inBounds(
           y = y,
-          bounds = bounds,
+          bounds = layerBounds,
           componentHeight =
             textComponent.getHeight(
               context = this,
               text = text,
-              width = maxWidth.toInt(),
+              maxWidth = maxWidth.toInt(),
               rotationDegrees = dataLabelRotationDegrees,
             ),
         )
-      textComponent.drawText(
+      textComponent.draw(
         context = this,
         text = text,
-        textX = x,
-        textY = y,
+        x = x,
+        y = y,
         verticalPosition = verticalPosition,
-        maxTextWidth = maxWidth.toInt(),
+        maxWidth = maxWidth.toInt(),
         rotationDegrees = dataLabelRotationDegrees,
       )
     }
   }
 
-  protected open fun updateMarkerTargets(
+  protected open fun CartesianDrawContext.updateMarkerTargets(
     entry: ColumnCartesianLayerModel.Entry,
     canvasX: Float,
     canvasY: Float,
     column: LineComponent,
     mergeMode: MergeMode,
   ) {
-    if (canvasX <= bounds.left - 1 || canvasX >= bounds.right + 1) return
+    if (canvasX <= layerBounds.left - 1 || canvasX >= layerBounds.right + 1) return
     val targetColumn =
       ColumnCartesianLayerMarkerTarget.Column(
         entry,
-        canvasY.coerceIn(bounds.top, bounds.bottom),
+        canvasY.coerceIn(layerBounds.top, layerBounds.bottom),
         column.solidOrStrokeColor,
       )
     when (mergeMode) {
-      MergeMode.Grouped ->
+      is MergeMode.Grouped ->
         _markerTargets.getOrPut(entry.x) { mutableListOf() } +=
           MutableColumnCartesianLayerMarkerTarget(entry.x, canvasX, mutableListOf(targetColumn))
       MergeMode.Stacked ->
@@ -337,7 +343,7 @@ public open class ColumnCartesianLayer(
           .columns +=
           ColumnCartesianLayerMarkerTarget.Column(
             entry,
-            canvasY.coerceIn(bounds.top, bounds.bottom),
+            canvasY.coerceIn(layerBounds.top, layerBounds.bottom),
             column.solidOrStrokeColor,
           )
     }
@@ -370,7 +376,7 @@ public open class ColumnCartesianLayer(
           if (model.series.isNotEmpty()) model.series.size else 1,
           mergeMode(model.extraStore),
         )
-      val xSpacing = columnCollectionWidth + spacingDp.pixels
+      val xSpacing = columnCollectionWidth + columnCollectionSpacingDp.pixels
       when (val horizontalLayout = horizontalLayout) {
         is HorizontalLayout.Segmented ->
           horizontalDimensions.ensureSegmentedValues(xSpacing, chartValues)
@@ -394,7 +400,7 @@ public open class ColumnCartesianLayer(
     mergeMode: MergeMode,
   ): Float =
     when (mergeMode) {
-      MergeMode.Stacked ->
+      is MergeMode.Stacked ->
         (0..<entryCollectionSize)
           .maxOf { seriesIndex ->
             columnProvider
@@ -402,9 +408,9 @@ public open class ColumnCartesianLayer(
               .thicknessDp
           }
           .pixels
-      MergeMode.Grouped ->
+      is MergeMode.Grouped ->
         getCumulatedThickness(entryCollectionSize) +
-          innerSpacingDp.pixels * (entryCollectionSize - 1)
+          mergeMode.columnSpacingDp.pixels * (entryCollectionSize - 1)
     }
 
   protected open fun CartesianDrawContext.getDrawingStart(
@@ -414,11 +420,12 @@ public open class ColumnCartesianLayer(
   ): Float {
     val mergeModeComponent =
       when (mergeMode) {
-        MergeMode.Grouped ->
-          getCumulatedThickness(entryCollectionIndex) + innerSpacingDp.pixels * entryCollectionIndex
+        is MergeMode.Grouped ->
+          getCumulatedThickness(entryCollectionIndex) +
+            mergeMode.columnSpacingDp.pixels * entryCollectionIndex
         MergeMode.Stacked -> 0f
       }
-    return bounds.getStart(isLtr) +
+    return layerBounds.getStart(isLtr) +
       (horizontalDimensions.startPadding +
         (mergeModeComponent - getColumnCollectionWidth(entryCollectionCount, mergeMode).half) *
           zoom) * layoutDirectionMultiplier
@@ -434,26 +441,39 @@ public open class ColumnCartesianLayer(
   }
 
   /** Defines how a [ColumnCartesianLayer] should draw columns in column collections. */
-  public enum class MergeMode {
-    /** Columns with the same x-axis values will be placed next to each other in groups. */
-    Grouped,
-
-    /** Columns with the same x-axis values will be placed on top of each other. */
-    Stacked;
-
-    /** Returns the minimum y-axis value, taking into account the current [MergeMode]. */
-    public fun getMinY(model: ColumnCartesianLayerModel): Float =
-      when (this) {
-        Grouped -> model.minY
-        Stacked -> model.minAggregateY
-      }
+  @Immutable
+  public sealed interface MergeMode {
+    /** Returns the minimum _y_ value. */
+    public fun getMinY(model: ColumnCartesianLayerModel): Double
 
-    /** Returns the maximum y-axis value, taking into account the current [MergeMode]. */
-    public fun getMaxY(model: ColumnCartesianLayerModel): Float =
-      when (this) {
-        Grouped -> model.maxY
-        Stacked -> model.maxAggregateY
-      }
+    /** Returns the maximum _y_ value. */
+    public fun getMaxY(model: ColumnCartesianLayerModel): Double
+
+    /**
+     * Groups columns with matching _x_ values horizontally, positioning them [columnSpacingDp] dp
+     * apart.
+     */
+    public class Grouped(internal val columnSpacingDp: Float = Defaults.GROUPED_COLUMN_SPACING) :
+      MergeMode {
+      override fun getMinY(model: ColumnCartesianLayerModel): Double = model.minY
+
+      override fun getMaxY(model: ColumnCartesianLayerModel): Double = model.maxY
+
+      override fun equals(other: Any?): Boolean =
+        this === other || other is Grouped && columnSpacingDp == other.columnSpacingDp
+
+      override fun hashCode(): Int = columnSpacingDp.hashCode()
+    }
+
+    /** Stacks columns with matching _x_ values. */
+    public data object Stacked : MergeMode {
+      override fun getMinY(model: ColumnCartesianLayerModel): Double = model.minAggregateY
+
+      override fun getMaxY(model: ColumnCartesianLayerModel): Double = model.maxAggregateY
+    }
+
+    /** Provides access to [MergeMode] factory functions. */
+    public companion object
   }
 
   override fun prepareForTransformation(
@@ -478,19 +498,19 @@ public open class ColumnCartesianLayer(
         series.associate { entry ->
           entry.x to
             ColumnCartesianLayerDrawingModel.ColumnInfo(
-              height = abs(entry.y) / chartValues.getYRange(verticalAxisPosition).length
+              height = (abs(entry.y) / chartValues.getYRange(verticalAxisPosition).length).toFloat()
             )
         }
       }
       .let(::ColumnCartesianLayerDrawingModel)
 
   protected data class StackInfo(
-    var topY: Float = 0f,
-    var bottomY: Float = 0f,
+    var topY: Double = 0.0,
+    var bottomY: Double = 0.0,
     var topHeight: Float = 0f,
     var bottomHeight: Float = 0f,
   ) {
-    public fun update(y: Float, height: Float) {
+    public fun update(y: Double, height: Float) {
       if (y >= 0f) {
         topY += y
         topHeight += height
@@ -515,30 +535,28 @@ public open class ColumnCartesianLayer(
 
     /** Houses [ColumnProvider] factory functions. */
     public companion object {
-      internal data class Series(val columns: List<LineComponent>) : ColumnProvider {
+      private data class Series(private val columns: List<LineComponent>) : ColumnProvider {
         override fun getColumn(
           entry: ColumnCartesianLayerModel.Entry,
           seriesIndex: Int,
           extraStore: ExtraStore,
-        ): LineComponent = columns.getRepeating(seriesIndex)
+        ) = columns.getRepeating(seriesIndex)
 
-        override fun getWidestSeriesColumn(
-          seriesIndex: Int,
-          extraStore: ExtraStore,
-        ): LineComponent = columns.getRepeating(seriesIndex)
+        override fun getWidestSeriesColumn(seriesIndex: Int, extraStore: ExtraStore) =
+          columns.getRepeating(seriesIndex)
       }
 
       /**
-       * Uses one [LineComponent] per series. The [LineComponent]s ([columns]) and series are
-       * associated by index. If there are more series than [LineComponent]s, [columns] is iterated
-       * multiple times.
+       * Uses one [LineComponent] per series. The [LineComponent]s and series are associated by
+       * index. If there are more series than [LineComponent]s, [columns] is iterated multiple
+       * times.
        */
       public fun series(columns: List<LineComponent>): ColumnProvider = Series(columns)
 
       /**
-       * Uses one [LineComponent] per series. The [LineComponent]s ([columns]) and series are
-       * associated by index. If there are more series than [LineComponent]s, the [LineComponent]
-       * list is iterated multiple times.
+       * Uses one [LineComponent] per series. The [LineComponent]s and series are associated by
+       * index. If there are more series than [LineComponent]s, the [LineComponent] list is iterated
+       * multiple times.
        */
       public fun series(vararg columns: LineComponent): ColumnProvider = series(columns.toList())
     }
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/layer/LineCartesianLayer.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/layer/LineCartesianLayer.kt
index f3d42f85b..4fa7e2c86 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/layer/LineCartesianLayer.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/layer/LineCartesianLayer.kt
@@ -21,7 +21,7 @@ import android.graphics.Path
 import android.graphics.RectF
 import com.patrykandpatrick.vico.core.cartesian.CartesianDrawContext
 import com.patrykandpatrick.vico.core.cartesian.CartesianMeasureContext
-import com.patrykandpatrick.vico.core.cartesian.DefaultPointConnector
+import com.patrykandpatrick.vico.core.cartesian.CubicPointConnector
 import com.patrykandpatrick.vico.core.cartesian.HorizontalDimensions
 import com.patrykandpatrick.vico.core.cartesian.HorizontalLayout
 import com.patrykandpatrick.vico.core.cartesian.Insets
@@ -34,8 +34,7 @@ import com.patrykandpatrick.vico.core.cartesian.data.LineCartesianLayerDrawingMo
 import com.patrykandpatrick.vico.core.cartesian.data.LineCartesianLayerModel
 import com.patrykandpatrick.vico.core.cartesian.data.MutableChartValues
 import com.patrykandpatrick.vico.core.cartesian.data.forEachIn
-import com.patrykandpatrick.vico.core.cartesian.layer.LineCartesianLayer.LineSpec
-import com.patrykandpatrick.vico.core.cartesian.layer.LineCartesianLayer.LineSpec.PointConnector
+import com.patrykandpatrick.vico.core.cartesian.layer.LineCartesianLayer.Line
 import com.patrykandpatrick.vico.core.cartesian.marker.CartesianMarker
 import com.patrykandpatrick.vico.core.cartesian.marker.LineCartesianLayerMarkerTarget
 import com.patrykandpatrick.vico.core.cartesian.marker.MutableLineCartesianLayerMarkerTarget
@@ -55,6 +54,7 @@ import com.patrykandpatrick.vico.core.common.getRepeating
 import com.patrykandpatrick.vico.core.common.getStart
 import com.patrykandpatrick.vico.core.common.half
 import com.patrykandpatrick.vico.core.common.inBounds
+import com.patrykandpatrick.vico.core.common.orZero
 import com.patrykandpatrick.vico.core.common.shader.DynamicShader
 import com.patrykandpatrick.vico.core.common.shader.TopBottomShader
 import com.patrykandpatrick.vico.core.common.withOpacity
@@ -64,16 +64,16 @@ import kotlin.math.min
 /**
  * [LineCartesianLayer] displays data as a continuous line.
  *
- * @param lines a [List] of [LineSpec]s defining the style of each line.
- * @param spacingDp the spacing between each [LineSpec.point] (in dp).
+ * @param lineProvider provides the [Line]s.
+ * @param pointSpacingDp the point spacing (in dp).
  * @param verticalAxisPosition the position of the [VerticalAxis] with which the
  *   [LineCartesianLayer] should be associated. Use this for independent [CartesianLayer] scaling.
  * @param drawingModelInterpolator interpolates the [LineCartesianLayer]’s
  *   [LineCartesianLayerDrawingModel]s.
  */
 public open class LineCartesianLayer(
-  public var lines: List<LineSpec>,
-  public var spacingDp: Float = Defaults.POINT_SPACING,
+  public var lineProvider: LineProvider,
+  public var pointSpacingDp: Float = Defaults.POINT_SPACING,
   public var verticalAxisPosition: AxisPosition.Vertical? = null,
   public var drawingModelInterpolator:
     DrawingModelInterpolator<
@@ -82,20 +82,6 @@ public open class LineCartesianLayer(
     > =
     DefaultDrawingModelInterpolator(),
 ) : BaseCartesianLayer<LineCartesianLayerModel>() {
-  /**
-   * Creates a [LineCartesianLayer] with a common style for all lines.
-   *
-   * @param line a [LineSpec] defining the style of each line.
-   * @param spacingDp the spacing between each [LineSpec.point] (in dp).
-   * @param verticalAxisPosition the position of the [VerticalAxis] with which the
-   *   [LineCartesianLayer] should be associated. Use this for independent [CartesianLayer] scaling.
-   */
-  public constructor(
-    line: LineSpec,
-    spacingDp: Float,
-    verticalAxisPosition: AxisPosition.Vertical? = null,
-  ) : this(listOf(line), spacingDp, verticalAxisPosition)
-
   /**
    * Defines the appearance of a line in a line chart.
    *
@@ -104,29 +90,27 @@ public open class LineCartesianLayer(
    * @param backgroundShader an optional [DynamicShader] to use for the areas bounded by the
    *   [LineCartesianLayer] line and the zero line (_y_ = 0).
    * @param cap the stroke cap for the line.
-   * @param point an optional [Component] that can be drawn at a given point on the line.
-   * @param pointSizeDp the size of the [point] (in dp).
+   * @param pointProvider provides the [Point]s.
    * @param dataLabel an optional [TextComponent] to use for data labels.
    * @param dataLabelVerticalPosition the vertical position of data labels relative to the line.
    * @param dataLabelValueFormatter the [CartesianValueFormatter] to use for data labels.
    * @param dataLabelRotationDegrees the rotation of data labels (in degrees).
    * @param pointConnector the [PointConnector] for the line.
    */
-  public open class LineSpec(
+  public open class Line(
     public var shader: DynamicShader,
     public var thicknessDp: Float = Defaults.LINE_SPEC_THICKNESS_DP,
     public var backgroundShader: DynamicShader? = null,
-    public var cap: Paint.Cap = Paint.Cap.ROUND,
-    public var point: Component? = null,
-    public var pointSizeDp: Float = Defaults.POINT_SIZE,
+    cap: Paint.Cap = Paint.Cap.ROUND,
+    public var pointProvider: PointProvider? = null,
+    public var pointConnector: PointConnector = PointConnector.cubic(),
     public var dataLabel: TextComponent? = null,
     public var dataLabelVerticalPosition: VerticalPosition = VerticalPosition.Top,
     public var dataLabelValueFormatter: CartesianValueFormatter = CartesianValueFormatter.decimal(),
     public var dataLabelRotationDegrees: Float = 0f,
-    public var pointConnector: PointConnector = DefaultPointConnector(),
   ) {
     /** Returns `true` if the [backgroundShader] is not null, and `false` otherwise. */
-    public val hasLineBackgroundShader: Boolean
+    public val hasBackgroundShader: Boolean
       get() = backgroundShader != null
 
     protected val linePaint: Paint =
@@ -144,15 +128,7 @@ public open class LineCartesianLayer(
     protected val pathBounds: RectF = RectF()
 
     /** The stroke cap for the line. */
-    public var lineStrokeCap: Paint.Cap by linePaint::strokeCap
-
-    /**
-     * Draws a [point] at the given [x] and [y] coordinates, using the provided [context].
-     *
-     * @see Component
-     */
-    public fun drawPoint(context: CartesianDrawContext, x: Float, y: Float): Unit =
-      with(context) { point?.drawPoint(context, x, y, pointSizeDp.pixels.half) }
+    public var cap: Paint.Cap by linePaint::strokeCap
 
     /** Draws the line. */
     public fun drawLine(
@@ -171,7 +147,7 @@ public open class LineCartesianLayer(
     }
 
     /** Draws the line background. */
-    public open fun drawBackgroundLine(
+    public open fun drawBackground(
       context: DrawContext,
       bounds: RectF,
       zeroLineYFraction: Float,
@@ -220,40 +196,118 @@ public open class LineCartesianLayer(
       (shader as? TopBottomShader)?.splitY = splitY
       (backgroundShader as? TopBottomShader)?.splitY = splitY
     }
+  }
 
-    /**
-     * Defines the shape of a line in a line chart by specifying how points are to be connected.
-     *
-     * @see DefaultPointConnector
-     */
-    public interface PointConnector {
-      /** Draws a line between two points. */
-      public fun connect(
-        path: Path,
-        prevX: Float,
-        prevY: Float,
-        x: Float,
-        y: Float,
-        horizontalDimensions: HorizontalDimensions,
-        bounds: RectF,
-      )
+  /** Connects a [LineCartesianLayer] line’s points, thus defining its shape. */
+  public fun interface PointConnector {
+    /** Connects ([x1], [y2]) and ([x2], [y2]). */
+    public fun connect(
+      context: CartesianDrawContext,
+      path: Path,
+      x1: Float,
+      y1: Float,
+      x2: Float,
+      y2: Float,
+    )
+
+    /** Houses a [PointConnector] factory function. */
+    public companion object {
+      /**
+       * Uses cubic Bézier curves. [curvature], which must be in the interval [[0, 1]], defines
+       * their strength.
+       */
+      public fun cubic(curvature: Float = Defaults.LINE_CURVATURE): PointConnector =
+        CubicPointConnector(curvature)
     }
   }
 
-  private val _markerTargets = mutableMapOf<Float, List<MutableLineCartesianLayerMarkerTarget>>()
+  /** Provides [Line]s to [LineCartesianLayer]s. */
+  public fun interface LineProvider {
+    /** Returns the [Line] for the specified series. */
+    public fun getLine(seriesIndex: Int, extraStore: ExtraStore): Line
 
-  /** The [Path] used to draw the lines, each of which corresponds to a [LineSpec]. */
-  protected val linePath: Path = Path()
+    /** Houses [LineProvider] factory functions. */
+    public companion object {
+      private data class Series(private val lines: List<Line>) : LineProvider {
+        override fun getLine(seriesIndex: Int, extraStore: ExtraStore) =
+          lines.getRepeating(seriesIndex)
+      }
+
+      /**
+       * Uses the provided [Line]s. The [Line]s and series are associated by index. If there are
+       * more series than [Line]s, [lines] is iterated multiple times.
+       */
+      public fun series(lines: List<Line>): LineProvider = Series(lines)
+
+      /**
+       * Uses the provided [Line]s. The [Line]s and series are associated by index. If there are
+       * more series than [Line]s, the [Line] list is iterated multiple times.
+       */
+      public fun series(vararg lines: Line): LineProvider = series(lines.toList())
+    }
+  }
 
   /**
-   * The [Path] used to draw the backgrounds of the lines, each of which corresponds to a
-   * [LineSpec].
+   * Defines a point style.
+   *
+   * @param component the point [Component].
+   * @property sizeDp the point size (in dp).
    */
+  public data class Point(
+    private val component: Component,
+    public val sizeDp: Float = Defaults.POINT_SIZE,
+  ) {
+    /** Draws a point at ([x], [y]). */
+    public fun draw(context: CartesianDrawContext, x: Float, y: Float) {
+      val halfSize = context.run { sizeDp.half.pixels }
+      component.draw(
+        context = context,
+        left = x - halfSize,
+        top = y - halfSize,
+        right = x + halfSize,
+        bottom = y + halfSize,
+      )
+    }
+  }
+
+  /** Provides [Point]s to [LineCartesianLayer]s. */
+  public interface PointProvider {
+    /** Returns the [Point] for the point with the given properties. */
+    public fun getPoint(
+      entry: LineCartesianLayerModel.Entry,
+      seriesIndex: Int,
+      extraStore: ExtraStore,
+    ): Point?
+
+    /** Returns the largest [Point]. */
+    public fun getLargestPoint(extraStore: ExtraStore): Point?
+
+    /** Houses a [PointProvider] factory function. */
+    public companion object {
+      private data class Single(private val point: Point) : PointProvider {
+        override fun getPoint(
+          entry: LineCartesianLayerModel.Entry,
+          seriesIndex: Int,
+          extraStore: ExtraStore,
+        ) = point
+
+        override fun getLargestPoint(extraStore: ExtraStore) = point
+      }
+
+      /** Uses [point] for each point. */
+      public fun single(point: Point): PointProvider = Single(point)
+    }
+  }
+
+  private val _markerTargets = mutableMapOf<Double, List<MutableLineCartesianLayerMarkerTarget>>()
+
+  protected val linePath: Path = Path()
+
   protected val lineBackgroundPath: Path = Path()
 
   protected val drawingModelKey: ExtraStore.Key<LineCartesianLayerDrawingModel> = ExtraStore.Key()
 
-  override val markerTargets: Map<Float, List<CartesianMarker.Target>> = _markerTargets
+  override val markerTargets: Map<Double, List<CartesianMarker.Target>> = _markerTargets
 
   override fun drawInternal(context: CartesianDrawContext, model: LineCartesianLayerModel): Unit =
     with(context) {
@@ -262,74 +316,60 @@ public open class LineCartesianLayer(
       val drawingModel = model.extraStore.getOrNull(drawingModelKey)
       val yRange = chartValues.getYRange(verticalAxisPosition)
       val zeroLineYFraction =
-        drawingModel?.zeroY ?: (yRange.minY / yRange.length + 1f).coerceIn(0f..1f)
+        drawingModel?.zeroY ?: (yRange.maxY / yRange.length).coerceIn(0.0..1.0).toFloat()
 
-      model.series.forEachIndexed { entryListIndex, entries ->
-        val pointInfoMap = drawingModel?.getOrNull(entryListIndex)
+      model.series.forEachIndexed { seriesIndex, series ->
+        val pointInfoMap = drawingModel?.getOrNull(seriesIndex)
 
         linePath.rewind()
         lineBackgroundPath.rewind()
-        val component = lines.getRepeating(entryListIndex).apply { setSplitY(zeroLineYFraction) }
+        val line =
+          lineProvider.getLine(seriesIndex, chartValues.model.extraStore).apply {
+            setSplitY(zeroLineYFraction)
+          }
 
-        var prevX = bounds.getStart(isLtr = isLtr)
-        var prevY = bounds.bottom
+        var prevX = layerBounds.getStart(isLtr = isLtr)
+        var prevY = layerBounds.bottom
 
         val drawingStartAlignmentCorrection =
           layoutDirectionMultiplier * horizontalDimensions.startPadding
 
         val drawingStart =
-          bounds.getStart(isLtr = isLtr) + drawingStartAlignmentCorrection - horizontalScroll
+          layerBounds.getStart(isLtr = isLtr) + drawingStartAlignmentCorrection - scroll
 
-        forEachPointInBounds(
-          series = entries,
-          drawingStart = drawingStart,
-          pointInfoMap = pointInfoMap,
-        ) { entry, x, y, _, _ ->
+        forEachPointInBounds(series, drawingStart, pointInfoMap) { entry, x, y, _, _ ->
           if (linePath.isEmpty) {
             linePath.moveTo(x, y)
           } else {
-            component.pointConnector.connect(
-              path = linePath,
-              prevX = prevX,
-              prevY = prevY,
-              x = x,
-              y = y,
-              horizontalDimensions = horizontalDimensions,
-              bounds = bounds,
-            )
+            line.pointConnector.connect(this, linePath, prevX, prevY, x, y)
           }
           prevX = x
           prevY = y
 
-          updateMarkerTargets(entry, x, y, component)
+          updateMarkerTargets(entry, x, y, line)
         }
 
-        if (component.hasLineBackgroundShader) {
+        if (line.hasBackgroundShader) {
           lineBackgroundPath.addPath(linePath)
-          lineBackgroundPath.lineTo(prevX, bounds.bottom)
-          component.drawBackgroundLine(
+          lineBackgroundPath.lineTo(prevX, layerBounds.bottom)
+          line.drawBackground(
             context,
-            bounds,
+            layerBounds,
             zeroLineYFraction,
             lineBackgroundPath,
             drawingModel?.opacity ?: 1f,
           )
         }
 
-        component.drawLine(
+        line.drawLine(
           context,
-          bounds,
+          layerBounds,
           zeroLineYFraction,
           linePath,
           drawingModel?.opacity ?: 1f,
         )
 
-        drawPointsAndDataLabels(
-          lineSpec = component,
-          series = entries,
-          drawingStart = drawingStart,
-          pointInfoMap = pointInfoMap,
-        )
+        drawPointsAndDataLabels(line, series, seriesIndex, drawingStart, pointInfoMap)
       }
     }
 
@@ -337,10 +377,10 @@ public open class LineCartesianLayer(
     entry: LineCartesianLayerModel.Entry,
     canvasX: Float,
     canvasY: Float,
-    lineSpec: LineSpec,
+    line: Line,
   ) {
-    if (canvasX <= bounds.left - 1 || canvasX >= bounds.right + 1) return
-    val limitedCanvasY = canvasY.coerceIn(bounds.top, bounds.bottom)
+    if (canvasX <= layerBounds.left - 1 || canvasX >= layerBounds.right + 1) return
+    val limitedCanvasY = canvasY.coerceIn(layerBounds.top, layerBounds.bottom)
     _markerTargets
       .getOrPut(entry.x) { listOf(MutableLineCartesianLayerMarkerTarget(entry.x, canvasX)) }
       .first()
@@ -348,30 +388,27 @@ public open class LineCartesianLayer(
       LineCartesianLayerMarkerTarget.Point(
         entry,
         limitedCanvasY,
-        lineSpec.shader.getColorAt(Point(canvasX, limitedCanvasY), this, bounds),
+        line.shader.getColorAt(Point(canvasX, limitedCanvasY), this, layerBounds),
       )
   }
 
-  /**
-   * Draws a line’s points ([LineSpec.point]) and their corresponding data labels
-   * ([LineSpec.dataLabel]).
-   */
   protected open fun CartesianDrawContext.drawPointsAndDataLabels(
-    lineSpec: LineSpec,
+    line: Line,
     series: List<LineCartesianLayerModel.Entry>,
+    seriesIndex: Int,
     drawingStart: Float,
-    pointInfoMap: Map<Float, LineCartesianLayerDrawingModel.PointInfo>?,
+    pointInfoMap: Map<Double, LineCartesianLayerDrawingModel.PointInfo>?,
   ) {
-    if (lineSpec.point == null && lineSpec.dataLabel == null) return
-
     forEachPointInBounds(
       series = series,
       drawingStart = drawingStart,
       pointInfoMap = pointInfoMap,
     ) { chartEntry, x, y, previousX, nextX ->
-      if (lineSpec.point != null) lineSpec.drawPoint(context = this, x = x, y = y)
+      val point =
+        line.pointProvider?.getPoint(chartEntry, seriesIndex, chartValues.model.extraStore)
+      point?.draw(this, x, y)
 
-      lineSpec.dataLabel
+      line.dataLabel
         .takeIf {
           horizontalLayout is HorizontalLayout.Segmented ||
             chartEntry.x != chartValues.minX && chartEntry.x != chartValues.maxX ||
@@ -379,26 +416,25 @@ public open class LineCartesianLayer(
             chartEntry.x == chartValues.maxX && horizontalDimensions.endPadding > 0
         }
         ?.let { textComponent ->
-          val distanceFromLine =
-            maxOf(a = lineSpec.thicknessDp, b = lineSpec.pointSizeDpOrZero).half.pixels
+          val distanceFromLine = max(line.thicknessDp, point?.sizeDp.orZero).half.pixels
 
           val text =
-            lineSpec.dataLabelValueFormatter.format(
+            line.dataLabelValueFormatter.format(
               value = chartEntry.y,
               chartValues = chartValues,
               verticalAxisPosition = verticalAxisPosition,
             )
           val maxWidth = getMaxDataLabelWidth(chartEntry, x, previousX, nextX)
           val verticalPosition =
-            lineSpec.dataLabelVerticalPosition.inBounds(
-              bounds = bounds,
+            line.dataLabelVerticalPosition.inBounds(
+              bounds = layerBounds,
               distanceFromPoint = distanceFromLine,
               componentHeight =
                 textComponent.getHeight(
                   context = this,
                   text = text,
-                  width = maxWidth,
-                  rotationDegrees = lineSpec.dataLabelRotationDegrees,
+                  maxWidth = maxWidth,
+                  rotationDegrees = line.dataLabelRotationDegrees,
                 ),
               y = y,
             )
@@ -409,14 +445,14 @@ public open class LineCartesianLayer(
                 VerticalPosition.Center -> 0f
                 VerticalPosition.Bottom -> distanceFromLine
               }
-          textComponent.drawText(
+          textComponent.draw(
             context = this,
-            textX = x,
-            textY = dataLabelY,
+            x = x,
+            y = dataLabelY,
             text = text,
             verticalPosition = verticalPosition,
-            maxTextWidth = maxWidth,
-            rotationDegrees = lineSpec.dataLabelRotationDegrees,
+            maxWidth = maxWidth,
+            rotationDegrees = line.dataLabelRotationDegrees,
           )
         }
     }
@@ -441,6 +477,7 @@ public open class LineCartesianLayer(
         ((entry.x - chartValues.minX) / chartValues.xStep * horizontalDimensions.xSpacing +
             extraSpace)
           .doubled
+          .toFloat()
           .coerceAtMost(nextX - x)
       }
       else -> {
@@ -452,11 +489,11 @@ public open class LineCartesianLayer(
         ((chartValues.maxX - entry.x) / chartValues.xStep * horizontalDimensions.xSpacing +
             extraSpace)
           .doubled
+          .toFloat()
           .coerceAtMost(x - previousX!!)
       }
     }.toInt()
 
-  /** Clears the temporary data saved during a single [drawInternal] run. */
   protected fun resetTempData() {
     _markerTargets.clear()
     linePath.rewind()
@@ -466,7 +503,7 @@ public open class LineCartesianLayer(
   protected open fun CartesianDrawContext.forEachPointInBounds(
     series: List<LineCartesianLayerModel.Entry>,
     drawingStart: Float,
-    pointInfoMap: Map<Float, LineCartesianLayerDrawingModel.PointInfo>?,
+    pointInfoMap: Map<Double, LineCartesianLayerDrawingModel.PointInfo>?,
     action:
       (
         entry: LineCartesianLayerModel.Entry, x: Float, y: Float, previousX: Float?, nextX: Float?,
@@ -479,18 +516,20 @@ public open class LineCartesianLayer(
     var x: Float? = null
     var nextX: Float? = null
 
-    val boundsStart = bounds.getStart(isLtr = isLtr)
-    val boundsEnd = boundsStart + layoutDirectionMultiplier * bounds.width()
+    val boundsStart = layerBounds.getStart(isLtr = isLtr)
+    val boundsEnd = boundsStart + layoutDirectionMultiplier * layerBounds.width()
 
     fun getDrawX(entry: LineCartesianLayerModel.Entry): Float =
       drawingStart +
-        layoutDirectionMultiplier * horizontalDimensions.xSpacing * (entry.x - minX) / xStep
+        layoutDirectionMultiplier *
+          horizontalDimensions.xSpacing *
+          ((entry.x - minX) / xStep).toFloat()
 
     fun getDrawY(entry: LineCartesianLayerModel.Entry): Float {
       val yRange = chartValues.getYRange(verticalAxisPosition)
-      return bounds.bottom -
-        (pointInfoMap?.get(entry.x)?.y ?: ((entry.y - yRange.minY) / yRange.length)) *
-          bounds.height()
+      return layerBounds.bottom -
+        (pointInfoMap?.get(entry.x)?.y ?: ((entry.y - yRange.minY) / yRange.length).toFloat()) *
+          layerBounds.height()
     }
 
     series.forEachIn(range = minX..maxX, padding = 1) { entry, next ->
@@ -517,8 +556,18 @@ public open class LineCartesianLayer(
     model: LineCartesianLayerModel,
   ) {
     with(context) {
-      val maxPointSize = lines.maxOf { it.pointSizeDpOrZero }.pixels
-      val xSpacing = maxPointSize + spacingDp.pixels
+      val maxPointSize =
+        (0..<model.series.size)
+          .maxOf {
+            lineProvider
+              .getLine(it, model.extraStore)
+              .pointProvider
+              ?.getLargestPoint(model.extraStore)
+              ?.sizeDp
+              .orZero
+          }
+          .pixels
+      val xSpacing = maxPointSize + pointSpacingDp.pixels
       when (val horizontalLayout = horizontalLayout) {
         is HorizontalLayout.Segmented ->
           horizontalDimensions.ensureSegmentedValues(xSpacing, chartValues)
@@ -547,18 +596,24 @@ public open class LineCartesianLayer(
     )
   }
 
-  override fun getInsets(
+  override fun updateInsets(
     context: CartesianMeasureContext,
-    outInsets: Insets,
     horizontalDimensions: HorizontalDimensions,
-  ): Unit =
+    model: LineCartesianLayerModel,
+    insets: Insets,
+  ) {
     with(context) {
-      outInsets.setVertical(
-        lines
-          .maxOf { if (it.point != null) max(it.thicknessDp, it.pointSizeDp) else it.thicknessDp }
+      val verticalInset =
+        (0..<model.series.size)
+          .mapNotNull { lineProvider.getLine(it, model.extraStore) }
+          .maxOf {
+            max(it.thicknessDp, it.pointProvider?.getLargestPoint(model.extraStore)?.sizeDp.orZero)
+          }
+          .half
           .pixels
-      )
+      insets.ensureValuesAtLeast(top = verticalInset, bottom = verticalInset)
     }
+  }
 
   override fun prepareForTransformation(
     model: LineCartesianLayerModel?,
@@ -584,60 +639,16 @@ public open class LineCartesianLayer(
       .map { series ->
         series.associate { entry ->
           entry.x to
-            LineCartesianLayerDrawingModel.PointInfo((entry.y - yRange.minY) / yRange.length)
+            LineCartesianLayerDrawingModel.PointInfo(
+              ((entry.y - yRange.minY) / yRange.length).toFloat()
+            )
         }
       }
       .let { pointInfo ->
         LineCartesianLayerDrawingModel(
           pointInfo,
-          (yRange.minY / yRange.length + 1f).coerceIn(0f..1f),
+          (yRange.maxY / yRange.length).coerceIn(0.0..1.0).toFloat(),
         )
       }
   }
 }
-
-/** Creates a new [LineCartesianLayer.LineSpec] based on this one, updating select properties. */
-public fun LineSpec.copy(
-  shader: DynamicShader = this.shader,
-  thicknessDp: Float = this.thicknessDp,
-  backgroundShader: DynamicShader? = this.backgroundShader,
-  cap: Paint.Cap = this.cap,
-  point: Component? = this.point,
-  pointSizeDp: Float = this.pointSizeDp,
-  dataLabel: TextComponent? = this.dataLabel,
-  dataLabelVerticalPosition: VerticalPosition = this.dataLabelVerticalPosition,
-  dataLabelValueFormatter: CartesianValueFormatter = this.dataLabelValueFormatter,
-  dataLabelRotationDegrees: Float = this.dataLabelRotationDegrees,
-  pointConnector: PointConnector = this.pointConnector,
-): LineSpec =
-  LineSpec(
-    shader = shader,
-    thicknessDp = thicknessDp,
-    backgroundShader = backgroundShader,
-    cap = cap,
-    point = point,
-    pointSizeDp = pointSizeDp,
-    dataLabel = dataLabel,
-    dataLabelVerticalPosition = dataLabelVerticalPosition,
-    dataLabelValueFormatter = dataLabelValueFormatter,
-    dataLabelRotationDegrees = dataLabelRotationDegrees,
-    pointConnector = pointConnector,
-  )
-
-internal fun Component.drawPoint(
-  context: CartesianDrawContext,
-  x: Float,
-  y: Float,
-  halfPointSize: Float,
-) {
-  draw(
-    context = context,
-    left = x - halfPointSize,
-    top = y - halfPointSize,
-    right = x + halfPointSize,
-    bottom = y + halfPointSize,
-  )
-}
-
-internal inline val LineSpec.pointSizeDpOrZero: Float
-  get() = if (point != null) pointSizeDp else 0f
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/layer/spec/SplitLineSpec.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/layer/spec/SplitLine.kt
similarity index 71%
rename from vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/layer/spec/SplitLineSpec.kt
rename to vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/layer/spec/SplitLine.kt
index b19b989a2..71edf1eb3 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/layer/spec/SplitLineSpec.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/layer/spec/SplitLine.kt
@@ -20,50 +20,42 @@ import android.graphics.Paint
 import android.graphics.Path
 import android.graphics.RectF
 import androidx.annotation.FloatRange
-import com.patrykandpatrick.vico.core.cartesian.DefaultPointConnector
 import com.patrykandpatrick.vico.core.cartesian.data.CartesianValueFormatter
 import com.patrykandpatrick.vico.core.cartesian.layer.LineCartesianLayer
+import com.patrykandpatrick.vico.core.cartesian.layer.LineCartesianLayer.PointProvider
 import com.patrykandpatrick.vico.core.common.Defaults
 import com.patrykandpatrick.vico.core.common.DrawContext
 import com.patrykandpatrick.vico.core.common.VerticalPosition
-import com.patrykandpatrick.vico.core.common.component.Component
 import com.patrykandpatrick.vico.core.common.component.TextComponent
-import com.patrykandpatrick.vico.core.common.copy
 import com.patrykandpatrick.vico.core.common.shader.DynamicShader
-import com.patrykandpatrick.vico.core.common.updateBounds
 
-/**
- * TODO
- */
-public class SplitLineSpec(
+public class SplitLine(
   shader: DynamicShader,
   thicknessDp: Float = Defaults.LINE_SPEC_THICKNESS_DP,
   public val backgroundShaderFirst: DynamicShader? = null,
   public val backgroundShaderSecond: DynamicShader? = null,
   cap: Paint.Cap = Paint.Cap.ROUND,
-  point: Component? = null,
-  pointSizeDp: Float = Defaults.POINT_SIZE,
   dataLabel: TextComponent? = null,
+  pointProvider: PointProvider? = null,
   dataLabelVerticalPosition: VerticalPosition = VerticalPosition.Top,
   dataLabelValueFormatter: CartesianValueFormatter = CartesianValueFormatter.decimal(),
   dataLabelRotationDegrees: Float = 0f,
-  pointConnector: PointConnector = DefaultPointConnector(),
+  pointConnector: LineCartesianLayer.PointConnector = LineCartesianLayer.PointConnector.cubic(),
   @FloatRange(from = 0.0, to = 1.0) public val xSplitFraction: Float = 1f,
-) : LineCartesianLayer.LineSpec(
+) : LineCartesianLayer.Line(
   shader = shader,
   thicknessDp = thicknessDp,
   backgroundShader = backgroundShaderFirst,
   cap = cap,
-  point = point,
-  pointSizeDp = pointSizeDp,
   dataLabel = dataLabel,
   dataLabelVerticalPosition = dataLabelVerticalPosition,
   dataLabelValueFormatter = dataLabelValueFormatter,
   dataLabelRotationDegrees = dataLabelRotationDegrees,
   pointConnector = pointConnector,
+  pointProvider = pointProvider
 ) {
 
-  override fun drawBackgroundLine(
+  override fun drawBackground(
     context: DrawContext,
     bounds: RectF,
     zeroLineYFraction: Float,
@@ -72,16 +64,17 @@ public class SplitLineSpec(
   ) {
     backgroundShader = backgroundShaderFirst
     when {
-        xSplitFraction <= 0f -> {
-          backgroundShader = backgroundShaderSecond
-          super.drawBackgroundLine(context, bounds, zeroLineYFraction, path, opacity)
-          backgroundShader = backgroundShaderFirst
-          return
-        }
-        xSplitFraction >= 1 -> {
-          super.drawBackgroundLine(context, bounds, zeroLineYFraction, path, opacity)
-          return
-        }
+      xSplitFraction <= 0f -> {
+        backgroundShader = backgroundShaderSecond
+        super.drawBackground(context, bounds, zeroLineYFraction, path, opacity)
+        backgroundShader = backgroundShaderFirst
+        return
+      }
+
+      xSplitFraction >= 1 -> {
+        super.drawBackground(context, bounds, zeroLineYFraction, path, opacity)
+        return
+      }
     }
 
     val firstBounds = RectF(
@@ -96,9 +89,9 @@ public class SplitLineSpec(
       /* right = */ bounds.right,
       /* bottom = */ bounds.bottom,
     )
-    super.drawBackgroundLine(context, firstBounds, zeroLineYFraction, path, opacity)
+    super.drawBackground(context, firstBounds, zeroLineYFraction, path, opacity)
     backgroundShader = backgroundShaderSecond
-    super.drawBackgroundLine(context, secondBounds, zeroLineYFraction, path, opacity)
+    super.drawBackground(context, secondBounds, zeroLineYFraction, path, opacity)
     backgroundShader = backgroundShaderFirst
   }
 }
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/marker/CandlestickCartesianLayerMarkerTarget.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/marker/CandlestickCartesianLayerMarkerTarget.kt
index c189ca28c..85224cb98 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/marker/CandlestickCartesianLayerMarkerTarget.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/marker/CandlestickCartesianLayerMarkerTarget.kt
@@ -37,7 +37,7 @@ import com.patrykandpatrick.vico.core.cartesian.layer.CandlestickCartesianLayer
  * @property highColor the color of [CandlestickCartesianLayer.Candle.topWick].
  */
 public data class CandlestickCartesianLayerMarkerTarget(
-  override val x: Float,
+  override val x: Double,
   override val canvasX: Float,
   public val entry: CandlestickCartesianLayerModel.Entry,
   public val openingCanvasY: Float,
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/marker/CartesianMarker.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/marker/CartesianMarker.kt
index a7a45bdd0..2940992b7 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/marker/CartesianMarker.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/marker/CartesianMarker.kt
@@ -19,16 +19,17 @@ package com.patrykandpatrick.vico.core.cartesian.marker
 import com.patrykandpatrick.vico.core.cartesian.CartesianChart
 import com.patrykandpatrick.vico.core.cartesian.CartesianDrawContext
 import com.patrykandpatrick.vico.core.cartesian.ChartInsetter
+import com.patrykandpatrick.vico.core.cartesian.data.CartesianChartModel
 
 /** Marks [CartesianChart] objects. */
-public interface CartesianMarker : ChartInsetter {
+public interface CartesianMarker : ChartInsetter<CartesianChartModel> {
   /** Draws the [CartesianMarker] for the specified [Target]s. */
   public fun draw(context: CartesianDrawContext, targets: List<Target>)
 
   /** Houses information on an object to be marked. */
   public interface Target {
     /** The _x_ value. */
-    public val x: Float
+    public val x: Double
 
     /** The pixel _x_ coordinate. */
     public val canvasX: Float
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/marker/ColumnCartesianLayerMarkerTarget.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/marker/ColumnCartesianLayerMarkerTarget.kt
index ef77a5fc2..4aad150f5 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/marker/ColumnCartesianLayerMarkerTarget.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/marker/ColumnCartesianLayerMarkerTarget.kt
@@ -44,7 +44,7 @@ public interface ColumnCartesianLayerMarkerTarget : CartesianMarker.Target {
 }
 
 internal data class MutableColumnCartesianLayerMarkerTarget(
-  override val x: Float,
+  override val x: Double,
   override val canvasX: Float,
   override val columns: MutableList<ColumnCartesianLayerMarkerTarget.Column> = mutableListOf(),
 ) : ColumnCartesianLayerMarkerTarget
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/marker/DefaultCartesianMarker.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/marker/DefaultCartesianMarker.kt
index 133a16543..ebafb914e 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/marker/DefaultCartesianMarker.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/marker/DefaultCartesianMarker.kt
@@ -22,42 +22,54 @@ import com.patrykandpatrick.vico.core.cartesian.CartesianDrawContext
 import com.patrykandpatrick.vico.core.cartesian.CartesianMeasureContext
 import com.patrykandpatrick.vico.core.cartesian.HorizontalDimensions
 import com.patrykandpatrick.vico.core.cartesian.Insets
+import com.patrykandpatrick.vico.core.cartesian.data.CartesianChartModel
 import com.patrykandpatrick.vico.core.common.Defaults
 import com.patrykandpatrick.vico.core.common.VerticalPosition
 import com.patrykandpatrick.vico.core.common.averageOf
-import com.patrykandpatrick.vico.core.common.ceil
 import com.patrykandpatrick.vico.core.common.component.Component
 import com.patrykandpatrick.vico.core.common.component.LineComponent
 import com.patrykandpatrick.vico.core.common.component.ShapeComponent
 import com.patrykandpatrick.vico.core.common.component.TextComponent
+import com.patrykandpatrick.vico.core.common.data.CacheStore
 import com.patrykandpatrick.vico.core.common.doubled
 import com.patrykandpatrick.vico.core.common.half
 import com.patrykandpatrick.vico.core.common.orZero
 import com.patrykandpatrick.vico.core.common.shape.MarkerCorneredShape
+import kotlin.math.ceil
+import kotlin.math.min
 
 /**
  * The default [CartesianMarker] implementation.
  *
- * @param label the [TextComponent] for the label.
- * @param valueFormatter formats the values.
- * @param labelPosition specifies the position of the label.
- * @param indicator drawn at the marked points.
- * @param indicatorSizeDp the indicator size (in dp).
- * @param setIndicatorColor sets the indicator color for each marked point.
- * @param guideline drawn vertically through the marked points.
+ * @property label the [TextComponent] for the label.
+ * @property valueFormatter formats the values.
+ * @property labelPosition specifies the position of the label.
+ * @property indicator returns a [Component] to be drawn at points with the given color.
+ * @property indicatorSizeDp the indicator size (in dp).
+ * @property guideline drawn vertically through the marked points.
  */
 public open class DefaultCartesianMarker(
   protected val label: TextComponent,
   protected val valueFormatter: CartesianMarkerValueFormatter =
     DefaultCartesianMarkerValueFormatter(),
   protected val labelPosition: LabelPosition = LabelPosition.Top,
-  protected val indicator: Component? = null,
+  protected val indicator: ((Int) -> Component)? = null,
   protected val indicatorSizeDp: Float = Defaults.MARKER_INDICATOR_SIZE,
-  protected val setIndicatorColor: ((Int) -> Unit)? = null,
   protected val guideline: LineComponent? = null,
 ) : CartesianMarker {
   protected val tempBounds: RectF = RectF()
 
+  protected val markerCorneredShape: MarkerCorneredShape? =
+    (label.background as? ShapeComponent)?.shape as? MarkerCorneredShape
+
+  protected val tickSizeDp: Float = markerCorneredShape?.tickSizeDp.orZero
+
+  @Suppress("DeprecatedCallableAddReplaceWith")
+  @Deprecated(
+    "Replace `label.tickSizeDp` with `tickSizeDp`. If using `TextComponent.tickSizeDp` with " +
+      "another `TextComponent`, check the property’s definition, and add equivalent logic to " +
+      "your code."
+  )
   protected val TextComponent.tickSizeDp: Float
     get() = ((background as? ShapeComponent)?.shape as? MarkerCorneredShape)?.tickSizeDp.orZero
 
@@ -105,15 +117,16 @@ public open class DefaultCartesianMarker(
     color: Int,
     halfIndicatorSize: Float,
   ) {
-    if (indicator == null) return
-    setIndicatorColor?.invoke(color)
-    indicator.draw(
-      this,
-      x - halfIndicatorSize,
-      y - halfIndicatorSize,
-      x + halfIndicatorSize,
-      y + halfIndicatorSize,
-    )
+    val indicator = indicator ?: return
+    cacheStore
+      .getOrSet(keyNamespace, indicator, color) { indicator.invoke(color) }
+      .draw(
+        this,
+        x - halfIndicatorSize,
+        y - halfIndicatorSize,
+        x + halfIndicatorSize,
+        y + halfIndicatorSize,
+      )
   }
 
   protected fun drawLabel(
@@ -124,27 +137,27 @@ public open class DefaultCartesianMarker(
       val text = valueFormatter.format(context, targets)
       val targetX = targets.averageOf { it.canvasX }
       val labelBounds =
-        label.getTextBounds(
+        label.getBounds(
           context = context,
           text = text,
-          width = chartBounds.width().toInt(),
+          maxWidth = layerBounds.width().toInt(),
           outRect = tempBounds,
         )
       val halfOfTextWidth = labelBounds.width().half
-      val x = overrideXPositionToFit(targetX, chartBounds, halfOfTextWidth)
-      extraStore[MarkerCorneredShape.tickXKey] = targetX
+      val x = overrideXPositionToFit(targetX, layerBounds, halfOfTextWidth)
+      markerCorneredShape?.tickX = targetX
       val tickPosition: MarkerCorneredShape.TickPosition
       val y: Float
       val verticalPosition: VerticalPosition
       when (labelPosition) {
         LabelPosition.Top -> {
           tickPosition = MarkerCorneredShape.TickPosition.Bottom
-          y = context.chartBounds.top - label.tickSizeDp.pixels
+          y = context.layerBounds.top - tickSizeDp.pixels
           verticalPosition = VerticalPosition.Top
         }
         LabelPosition.Bottom -> {
           tickPosition = MarkerCorneredShape.TickPosition.Top
-          y = context.chartBounds.bottom + label.tickSizeDp.pixels
+          y = context.layerBounds.bottom + tickSizeDp.pixels
           verticalPosition = VerticalPosition.Bottom
         }
         LabelPosition.AroundPoint,
@@ -162,23 +175,23 @@ public open class DefaultCartesianMarker(
             }
           val flip =
             labelPosition == LabelPosition.AroundPoint &&
-              topPointY - labelBounds.height() - label.tickSizeDp.pixels < context.chartBounds.top
+              topPointY - labelBounds.height() - tickSizeDp.pixels < context.layerBounds.top
           tickPosition =
             if (flip) MarkerCorneredShape.TickPosition.Top
             else MarkerCorneredShape.TickPosition.Bottom
-          y = topPointY + (if (flip) 1 else -1) * label.tickSizeDp.pixels
+          y = topPointY + (if (flip) 1 else -1) * tickSizeDp.pixels
           verticalPosition = if (flip) VerticalPosition.Bottom else VerticalPosition.Top
         }
       }
-      extraStore[MarkerCorneredShape.tickPositionKey] = tickPosition
+      markerCorneredShape?.tickPosition = tickPosition
 
-      label.drawText(
+      label.draw(
         context = context,
         text = text,
-        textX = x,
-        textY = y,
+        x = x,
+        y = y,
         verticalPosition = verticalPosition,
-        maxTextWidth = minOf(chartBounds.right - x, x - chartBounds.left).doubled.ceil.toInt(),
+        maxWidth = ceil(min(layerBounds.right - x, x - layerBounds.left).doubled).toInt(),
       )
     }
 
@@ -197,21 +210,22 @@ public open class DefaultCartesianMarker(
     targets
       .map { it.canvasX }
       .toSet()
-      .forEach { x -> guideline?.drawVertical(this, chartBounds.top, chartBounds.bottom, x) }
+      .forEach { x -> guideline?.drawVertical(this, layerBounds.top, layerBounds.bottom, x) }
   }
 
-  override fun getInsets(
+  override fun updateInsets(
     context: CartesianMeasureContext,
-    outInsets: Insets,
     horizontalDimensions: HorizontalDimensions,
+    model: CartesianChartModel,
+    insets: Insets,
   ) {
     with(context) {
       when (labelPosition) {
         LabelPosition.Top,
         LabelPosition.AbovePoint ->
-          outInsets.top = label.getHeight(context) + label.tickSizeDp.pixels
+          insets.ensureValuesAtLeast(top = label.getHeight(context) + tickSizeDp.pixels)
         LabelPosition.Bottom ->
-          outInsets.bottom = label.getHeight(context) + label.tickSizeDp.pixels
+          insets.ensureValuesAtLeast(bottom = label.getHeight(context) + tickSizeDp.pixels)
         LabelPosition.AroundPoint -> Unit // Will be inside the chart
       }
     }
@@ -236,4 +250,8 @@ public open class DefaultCartesianMarker(
      */
     AbovePoint,
   }
+
+  protected companion object {
+    public val keyNamespace: CacheStore.KeyNamespace = CacheStore.KeyNamespace()
+  }
 }
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/marker/DefaultCartesianMarkerValueFormatter.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/marker/DefaultCartesianMarkerValueFormatter.kt
index 355923b78..790aad52a 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/marker/DefaultCartesianMarkerValueFormatter.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/marker/DefaultCartesianMarkerValueFormatter.kt
@@ -22,7 +22,6 @@ import android.text.style.ForegroundColorSpan
 import com.patrykandpatrick.vico.core.cartesian.CartesianDrawContext
 import com.patrykandpatrick.vico.core.cartesian.data.CartesianLayerModel
 import com.patrykandpatrick.vico.core.common.appendCompat
-import com.patrykandpatrick.vico.core.common.sumOf
 import java.text.DecimalFormat
 
 /**
@@ -34,7 +33,7 @@ public open class DefaultCartesianMarkerValueFormatter(
   private val decimalFormat: DecimalFormat = DecimalFormat("#.##;−#.##"),
   private val colorCode: Boolean = true,
 ) : CartesianMarkerValueFormatter {
-  protected open fun SpannableStringBuilder.append(y: Float, color: Int? = null) {
+  protected open fun SpannableStringBuilder.append(y: Double, color: Int? = null) {
     if (colorCode && color != null) {
       appendCompat(
         decimalFormat.format(y),
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/marker/LineCartesianLayerMarkerTarget.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/marker/LineCartesianLayerMarkerTarget.kt
index 6f601bcc5..ab5ca6cf5 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/marker/LineCartesianLayerMarkerTarget.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/cartesian/marker/LineCartesianLayerMarkerTarget.kt
@@ -29,7 +29,7 @@ public interface LineCartesianLayerMarkerTarget : CartesianMarker.Target {
    *
    * @param entry the [LineCartesianLayerModel.Entry].
    * @param canvasY the point’s pixel _y_ coordinate.
-   * @param color the [LineCartesianLayer.LineSpec]’s color for the point.
+   * @param color the [LineCartesianLayer.Line]’s color for the point.
    */
   public data class Point(
     val entry: LineCartesianLayerModel.Entry,
@@ -39,7 +39,7 @@ public interface LineCartesianLayerMarkerTarget : CartesianMarker.Target {
 }
 
 internal data class MutableLineCartesianLayerMarkerTarget(
-  override val x: Float,
+  override val x: Double,
   override val canvasX: Float,
   override val points: MutableList<LineCartesianLayerMarkerTarget.Point> = mutableListOf(),
 ) : LineCartesianLayerMarkerTarget
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/BoundsAware.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/Bounded.kt
similarity index 90%
rename from vico/core/src/main/java/com/patrykandpatrick/vico/core/common/BoundsAware.kt
rename to vico/core/src/main/java/com/patrykandpatrick/vico/core/common/Bounded.kt
index 58b73063d..c3a53f8bf 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/BoundsAware.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/Bounded.kt
@@ -19,7 +19,7 @@ package com.patrykandpatrick.vico.core.common
 import android.graphics.RectF
 
 /** Defines an abstract component that has some physical bounds. */
-public interface BoundsAware {
+public interface Bounded {
   /** The bounds of the abstract component. */
   public val bounds: RectF
 
@@ -33,3 +33,6 @@ public interface BoundsAware {
     this.bounds.set(bounds)
   }
 }
+
+@Deprecated("Use `Bounded`.", ReplaceWith("Bounded"))
+public typealias BoundsAware = Bounded
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/Collections.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/Collections.kt
index d516f30af..02c549663 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/Collections.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/Collections.kt
@@ -38,14 +38,6 @@ internal fun <K, V> MutableMap<K, V>.setAll(other: Map<K, V>) {
 internal fun <T> Collection<T>.averageOf(selector: (T) -> Float): Float =
   fold(0f) { sum, element -> sum + selector(element) } / size
 
-internal inline fun <T> Iterable<T>.sumOf(selector: (T) -> Float): Float {
-  var sum = 0f
-  for (element in this) {
-    sum += selector(element)
-  }
-  return sum
-}
-
 internal fun <T> mutableListOf(sourceCollection: Collection<T>): MutableList<T> =
   ArrayList<T>(sourceCollection.size).apply { addAll(sourceCollection) }
 
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/Color.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/Color.kt
index 4a39c1699..331867f38 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/Color.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/Color.kt
@@ -16,7 +16,6 @@
 
 package com.patrykandpatrick.vico.core.common
 
-import android.graphics.Color
 import androidx.annotation.RestrictTo
 
 private const val ALPHA_BIT_SHIFT = 24
@@ -24,7 +23,6 @@ private const val RED_BIT_SHIFT = 16
 private const val GREEN_BIT_SHIFT = 8
 private const val BLUE_BIT_SHIFT = 0
 private const val COLOR_MASK = 0xff
-private const val BYTE_MAX_VALUE: Int = 0xFF
 internal const val MAX_HEX_VALUE = 255f
 
 /** @suppress */
@@ -62,66 +60,8 @@ internal val Int.alpha: Int
 internal val Int.alphaFloat: Float
   get() = alpha / MAX_HEX_VALUE
 
-internal val Int.isNotTransparent: Boolean
-  get() = this != Color.TRANSPARENT
-
-internal val Int.isTransparent: Boolean
-  get() = this == Color.TRANSPARENT
-
 private fun Int.extractColorChannel(bitShift: Int): Int = this shr bitShift and COLOR_MASK
 
-private fun getElevationOverlayColorWithCorrectAlpha(
-  elevationOverlayColor: Long,
-  elevationDp: Float,
-): Int {
-  val overlayPercentage =
-    when {
-      elevationDp < 1f -> 0.00f
-      elevationDp < 2f -> 0.05f
-      elevationDp < 3f -> 0.07f
-      elevationDp < 4f -> 0.08f
-      elevationDp < 6f -> 0.09f
-      elevationDp < 8f -> 0.11f
-      elevationDp < 12f -> 0.12f
-      elevationDp < 16f -> 0.14f
-      elevationDp < 24f -> 0.15f
-      else -> 0.16f
-    }
-  return if (elevationOverlayColor.alpha == 0f) {
-    Color.TRANSPARENT
-  } else {
-    elevationOverlayColor.toInt().copyColor(alpha = overlayPercentage)
-  }
-}
-
-internal fun DrawContext.applyElevationOverlayToColor(color: Int, elevationDp: Float): Int =
-  color.overlayColor(
-    getElevationOverlayColorWithCorrectAlpha(
-      elevationOverlayColor = elevationOverlayColor,
-      elevationDp = elevationDp,
-    )
-  )
-
 internal val Long.alpha: Float
   get() =
     if (this and 0x3fL == 0L) (this shr 56 and 0xff) / 255.0f else (this shr 6 and 0x3ff) / 1023.0f
-
-internal fun Int.overlayColor(overlayingColor: Int): Int {
-  val bgAlpha = Color.alpha(this)
-  val fgAlpha = Color.alpha(overlayingColor)
-  val alpha = compositeAlpha(fgAlpha, bgAlpha)
-  val red = compositeComponent(Color.red(overlayingColor), fgAlpha, Color.red(this), bgAlpha, alpha)
-  val green =
-    compositeComponent(Color.green(overlayingColor), fgAlpha, Color.green(this), bgAlpha, alpha)
-  val blue =
-    compositeComponent(Color.blue(overlayingColor), fgAlpha, Color.blue(this), bgAlpha, alpha)
-  return Color.argb(alpha, red, green, blue)
-}
-
-private fun compositeAlpha(foregroundAlpha: Int, backgroundAlpha: Int): Int =
-  BYTE_MAX_VALUE -
-    (BYTE_MAX_VALUE - backgroundAlpha) * (BYTE_MAX_VALUE - foregroundAlpha) / BYTE_MAX_VALUE
-
-private fun compositeComponent(fgC: Int, fgA: Int, bgC: Int, bgA: Int, a: Int): Int =
-  if (a == 0) 0
-  else (BYTE_MAX_VALUE * fgC * fgA + bgC * bgA * (BYTE_MAX_VALUE - fgA)) / (a * BYTE_MAX_VALUE)
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/Constants.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/Constants.kt
index de7a63722..dafbe400b 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/Constants.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/Constants.kt
@@ -16,13 +16,15 @@
 
 package com.patrykandpatrick.vico.core.common
 
-internal const val FULL_DEGREES: Float = 360f
+import androidx.annotation.RestrictTo
 
 internal const val ERR_REPEATING_COLLECTION_EMPTY =
   "Cannot get repeated item from empty collection."
 
-internal const val ELLIPSIS: String = "…"
+internal const val ELLIPSIS = "…"
 
+/** @suppress */
+@RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
 public const val NEW_PRODUCER_ERROR_MESSAGE: String =
-  "A new `CartesianChartModelProducer` was provided. Run data " +
-    "updates via `tryRunTransaction` or `runTransaction`, not by creating new `CartesianChartModelProducer`s."
+  "A new `CartesianChartModelProducer` was provided. Run data updates via `tryRunTransaction` or " +
+    "`runTransaction`, not by creating new `CartesianChartModelProducer`s."
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/Defaults.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/Defaults.kt
index db390dd07..e48c1a77b 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/Defaults.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/Defaults.kt
@@ -40,20 +40,20 @@ public object Defaults {
   public const val AXIS_LINE_WIDTH: Float = 1f
   public const val AXIS_TICK_LENGTH: Float = 4f
   public const val COLUMN_WIDTH: Float = 8f
-  public const val COLUMN_INSIDE_SPACING: Float = 8f
-  public const val COLUMN_OUTSIDE_SPACING: Float = 32f
+  public const val GROUPED_COLUMN_SPACING: Float = 8f
+  public const val COLUMN_COLLECTION_SPACING: Float = 32f
   public const val COLUMN_ROUNDNESS_PERCENT: Int = 40
   public const val CANDLE_BODY_WIDTH_DP: Float = 8f
   public const val MIN_CANDLE_BODY_HEIGHT_DP: Float = 1f
   public const val WICK_DEFAULT_WIDTH_DP: Float = 1f
-  public const val HOLLOW_CANDLE_STROKE_WIDTH_DP: Float = 1f
+  public const val HOLLOW_CANDLE_STROKE_THICKNESS_DP: Float = 1f
   public const val CANDLE_SPACING_DP: Float = 4f
-  public const val CUBIC_STRENGTH: Float = 1f
+  public const val LINE_CURVATURE: Float = 0.5f
   public const val DASH_LENGTH: Float = 4f
   public const val DASH_GAP: Float = 2f
   public const val FADING_EDGE_VISIBILITY_THRESHOLD_DP: Float = 16f
   public const val FADING_EDGE_WIDTH_DP: Float = 32f
-  public const val LABEL_LINE_COUNT: Int = 1
+  public const val TEXT_COMPONENT_LINE_COUNT: Int = 1
   public const val LINE_COMPONENT_THICKNESS_DP: Float = 1f
   public const val LINE_SPEC_THICKNESS_DP: Float = 2f
   public const val MARKER_INDICATOR_SIZE: Float = 16f
@@ -76,7 +76,6 @@ public class DefaultColors(
   public val neutralCandleColor: Long,
   public val bearishCandleColor: Long,
   public val cartesianLayerColors: List<Long>,
-  public val elevationOverlayColor: Long,
   public val lineColor: Long,
   public val textColor: Long,
 ) {
@@ -87,7 +86,6 @@ public class DefaultColors(
         neutralCandleColor = 0xff212121,
         bearishCandleColor = 0xffea284b,
         cartesianLayerColors = listOf(0xff787878, 0xff5a5a5a, 0xff383838),
-        elevationOverlayColor = 0x00000000,
         lineColor = 0x47000000,
         textColor = 0xde000000,
       )
@@ -98,7 +96,6 @@ public class DefaultColors(
         neutralCandleColor = 0xff8a8a8a,
         bearishCandleColor = 0xffea284b,
         cartesianLayerColors = listOf(0xffcacaca, 0xffa8a8a8, 0xff888888),
-        elevationOverlayColor = 0xffffffff,
         lineColor = 0xff555555,
         textColor = 0xffffffff,
       )
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/Dimensions.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/Dimensions.kt
index 014a6fd9c..0df5fbce6 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/Dimensions.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/Dimensions.kt
@@ -16,6 +16,8 @@
 
 package com.patrykandpatrick.vico.core.common
 
+import androidx.compose.runtime.Immutable
+
 /**
  * Defines the size of each edge of a rectangle. Used to store measurements such as padding or
  * margin values.
@@ -25,6 +27,7 @@ package com.patrykandpatrick.vico.core.common
  * @param endDp the value for the end edge in the dp unit.
  * @param bottomDp the value for the bottom edge in the dp unit.
  */
+@Immutable
 public data class Dimensions(
   public val startDp: Float,
   public val topDp: Float,
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/DrawContext.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/DrawContext.kt
index 4244ae695..4570a560a 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/DrawContext.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/DrawContext.kt
@@ -19,7 +19,7 @@ package com.patrykandpatrick.vico.core.common
 import android.graphics.Canvas
 import android.graphics.RectF
 import androidx.annotation.RestrictTo
-import com.patrykandpatrick.vico.core.common.component.ShapeComponent
+import com.patrykandpatrick.vico.core.common.data.CacheStore
 import com.patrykandpatrick.vico.core.common.data.MutableExtraStore
 
 /**
@@ -27,9 +27,6 @@ import com.patrykandpatrick.vico.core.common.data.MutableExtraStore
  * also defines helpful drawing functions.
  */
 public interface DrawContext : MeasureContext {
-  /** The elevation overlay color, applied to [ShapeComponent]s that cast shadows. */
-  public val elevationOverlayColor: Long
-
   /** The canvas to draw the chart on. */
   public val canvas: Canvas
 
@@ -98,18 +95,26 @@ public fun drawContext(
   canvas: Canvas,
   density: Float = 1f,
   isLtr: Boolean = true,
-  elevationOverlayColor: Long = DefaultColors.Light.elevationOverlayColor,
   canvasBounds: RectF = RectF(0f, 0f, canvas.width.toFloat(), canvas.height.toFloat()),
   spToPx: (Float) -> Float = { it },
 ): DrawContext =
   object : DrawContext {
     override val canvasBounds: RectF = canvasBounds
-    override val elevationOverlayColor: Long = elevationOverlayColor
+
     override var canvas: Canvas = canvas
+
     override val density: Float = density
+
     override val isLtr: Boolean = isLtr
+
+    @Deprecated(
+      "To cache drawing data, use `cacheStore`. If using `extraStore` for communication between " +
+        "functions or classes, switch to a suitable alternative."
+    )
     override val extraStore: MutableExtraStore = MutableExtraStore()
 
+    override val cacheStore: CacheStore = CacheStore()
+
     override fun withOtherCanvas(canvas: Canvas, block: (DrawContext) -> Unit) {
       val originalCanvas = this.canvas
       this.canvas = canvas
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/HorizontalLegend.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/HorizontalLegend.kt
index 95b717ba6..296dd7bbd 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/HorizontalLegend.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/HorizontalLegend.kt
@@ -17,6 +17,7 @@
 package com.patrykandpatrick.vico.core.common
 
 import android.graphics.RectF
+import kotlin.math.max
 
 /**
  * [HorizontalLegend] displays legend items beside one another in lines.
@@ -30,12 +31,12 @@ import android.graphics.RectF
  * @param padding defines the padding of the content.
  */
 public open class HorizontalLegend<M : MeasureContext, D : DrawContext>(
-  public var items: Collection<LegendItem>,
-  public var iconSizeDp: Float,
-  public var iconPaddingDp: Float,
-  public var lineSpacingDp: Float = 0f,
-  public var spacingDp: Float = 0f,
-  public val padding: Dimensions = Dimensions.Empty,
+  protected val items: Collection<LegendItem>,
+  protected val iconSizeDp: Float,
+  protected val iconPaddingDp: Float,
+  protected val lineSpacingDp: Float = 0f,
+  protected val spacingDp: Float = 0f,
+  protected val padding: Dimensions = Dimensions.Empty,
 ) : Legend<M, D> {
   private val heights = mutableListOf<Float>()
 
@@ -43,40 +44,37 @@ public open class HorizontalLegend<M : MeasureContext, D : DrawContext>(
 
   override val bounds: RectF = RectF()
 
-  override fun getHeight(context: M, availableWidth: Float): Float =
+  override fun getHeight(context: M, maxWidth: Float): Float =
     with(context) {
       if (items.isEmpty()) return@with 0f
       lines.clear()
       lines.add(mutableListOf())
       var height =
-        maxOf(
-          items.first().getLabelHeight(context, availableWidth, iconPaddingDp, iconSizeDp),
+        max(
+          items.first().getLabelHeight(context, maxWidth, iconPaddingDp, iconSizeDp),
           iconSizeDp.pixels,
         )
       heights.add(height)
-      buildLines(context, availableWidth) {
+      buildLines(context, maxWidth) {
         val currentHeight =
-          maxOf(
-            it.getLabelHeight(context, availableWidth, iconPaddingDp, iconSizeDp),
-            iconSizeDp.pixels,
-          )
+          max(it.getLabelHeight(context, maxWidth, iconPaddingDp, iconSizeDp), iconSizeDp.pixels)
         heights.add(currentHeight)
         height += currentHeight
       }
       height + (lines.size - 1) * lineSpacingDp.pixels + padding.verticalDp.pixels
     }
 
-  override fun draw(context: D, chartBounds: RectF): Unit =
+  override fun draw(context: D) {
     with(context) {
       var currentTop = bounds.top + padding.topDp.pixels
       // isLtr? startX means the line starts at X from left : it starts at X from right
       val startX =
         if (isLtr) {
-          chartBounds.left + padding.startDp.pixels
+          bounds.left + padding.startDp.pixels
         } else {
-          chartBounds.right - padding.startDp.pixels - iconSizeDp.pixels
+          bounds.right - padding.startDp.pixels - iconSizeDp.pixels
         }
-      val availableWidth = chartBounds.width()
+      val availableWidth = bounds.width()
       if (lines.isEmpty()) {
         buildLines(context, availableWidth)
       }
@@ -103,16 +101,15 @@ public open class HorizontalLegend<M : MeasureContext, D : DrawContext>(
             } else {
               -iconPaddingDp.pixels
             }
-          it.label.drawText(
+          it.labelComponent.draw(
             context = context,
-            text = it.labelText,
-            textX = startX + currentStart,
-            textY = centerY,
+            text = it.label,
+            x = startX + currentStart,
+            y = centerY,
             horizontalPosition = HorizontalPosition.End,
             verticalPosition = VerticalPosition.Center,
-            maxTextWidth =
-              (chartBounds.width() - (iconSizeDp + iconPaddingDp + padding.horizontalDp).pixels)
-                .toInt(),
+            maxWidth =
+              (bounds.width() - (iconSizeDp + iconPaddingDp + padding.horizontalDp).pixels).toInt(),
           )
           currentStart +=
             if (isLtr) {
@@ -127,6 +124,7 @@ public open class HorizontalLegend<M : MeasureContext, D : DrawContext>(
         currentTop += currentLineHeight + lineSpacingDp.pixels
       }
     }
+  }
 
   protected fun buildLines(
     context: MeasureContext,
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/Iterable.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/Iterable.kt
index 06df28508..7d6617abf 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/Iterable.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/Iterable.kt
@@ -16,29 +16,32 @@
 
 package com.patrykandpatrick.vico.core.common
 
+import kotlin.math.max
+import kotlin.math.min
+
 internal inline fun <T> Iterable<T>.rangeOf(
-  selector: (T) -> Float
-): ClosedFloatingPointRange<Float> {
+  selector: (T) -> Double
+): ClosedFloatingPointRange<Double> {
   val iterator = iterator()
   var minValue = selector(iterator.next())
   var maxValue = minValue
   while (iterator.hasNext()) {
     val v = selector(iterator.next())
-    minValue = minOf(minValue, v)
-    maxValue = maxOf(maxValue, v)
+    minValue = min(minValue, v)
+    maxValue = max(maxValue, v)
   }
   return minValue..maxValue
 }
 
 internal inline fun <T> Iterable<T>.rangeOfPair(
-  selector: (T) -> Pair<Float, Float>
-): ClosedFloatingPointRange<Float> {
+  selector: (T) -> Pair<Double, Double>
+): ClosedFloatingPointRange<Double> {
   val iterator = iterator()
   var (minValue, maxValue) = selector(iterator.next())
   while (iterator.hasNext()) {
     val (negValue, posValue) = selector(iterator.next())
-    minValue = minOf(minValue, negValue)
-    maxValue = maxOf(maxValue, posValue)
+    minValue = min(minValue, negValue)
+    maxValue = max(maxValue, posValue)
   }
   return minValue..maxValue
 }
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/LayeredComponent.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/LayeredComponent.kt
index b69374e3c..a28113a09 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/LayeredComponent.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/LayeredComponent.kt
@@ -23,10 +23,10 @@ import com.patrykandpatrick.vico.core.common.component.Component
  * between them.
  */
 public open class LayeredComponent(
-  public val rear: Component,
-  public val front: Component,
-  public val padding: Dimensions = Dimensions.Empty,
-  override val margins: Dimensions = Dimensions.Empty,
+  protected val rear: Component,
+  protected val front: Component,
+  protected val padding: Dimensions = Dimensions.Empty,
+  protected val margins: Dimensions = Dimensions.Empty,
 ) : Component {
   override fun draw(
     context: DrawContext,
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/Legend.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/Legend.kt
index 39fdc9241..a8658be9d 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/Legend.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/Legend.kt
@@ -16,13 +16,11 @@
 
 package com.patrykandpatrick.vico.core.common
 
-import android.graphics.RectF
-
 /** Defines the functions required by the library to draw a chart legend. */
-public interface Legend<M : MeasureContext, D : DrawContext> : BoundsAware {
+public interface Legend<M : MeasureContext, D : DrawContext> : Bounded {
   /** Returns the height of the legend. */
-  public fun getHeight(context: M, availableWidth: Float): Float
+  public fun getHeight(context: M, maxWidth: Float): Float
 
   /** Draws the legend. */
-  public fun draw(context: D, chartBounds: RectF)
+  public fun draw(context: D)
 }
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/LegendItem.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/LegendItem.kt
index d8cdcce09..b658066f3 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/LegendItem.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/LegendItem.kt
@@ -22,34 +22,34 @@ import com.patrykandpatrick.vico.core.common.component.TextComponent
 /**
  * Defines the appearance of an item of a [Legend].
  *
- * @param icon the [Component] used as the item’s icon.
- * @param label the [TextComponent] used for the label.
- * @param labelText the text content of the label.
+ * @param icon used as the icon.
+ * @param labelComponent the label [TextComponent].
+ * @param label the label text.
  */
 public open class LegendItem(
   public open val icon: Component,
-  public open val label: TextComponent,
-  public open val labelText: CharSequence,
+  public open val labelComponent: TextComponent,
+  public open val label: CharSequence,
 ) {
   /**
    * Measures the height of the label.
    *
    * @param context the [MeasureContext] used to measure the height.
-   * @param availableWidth the available width for the item.
+   * @param maxWidth the maximum width.
    * @param iconPaddingDp the padding between the icon and the label.
    * @param iconSizeDp the size of the icon.
    */
   public fun getLabelHeight(
     context: MeasureContext,
-    availableWidth: Float,
+    maxWidth: Float,
     iconPaddingDp: Float,
     iconSizeDp: Float,
   ): Float =
     with(context) {
-      label.getHeight(
+      labelComponent.getHeight(
         context = context,
-        text = labelText,
-        width = (availableWidth - iconSizeDp.pixels - iconPaddingDp.pixels).toInt(),
+        text = label,
+        maxWidth = (maxWidth - iconSizeDp.pixels - iconPaddingDp.pixels).toInt(),
       )
     }
 
@@ -57,21 +57,21 @@ public open class LegendItem(
    * Measures the width of the label.
    *
    * @param context the [MeasureContext] used to measure the height.
-   * @param availableWidth the available width for the item.
+   * @param maxWidth the maximum width.
    * @param iconPaddingDp the padding between the icon and the label.
    * @param iconSizeDp the size of the icon.
    */
   public fun getLabelWidth(
     context: MeasureContext,
-    availableWidth: Float,
+    maxWidth: Float,
     iconPaddingDp: Float,
     iconSizeDp: Float,
   ): Float =
     with(context) {
-      label.getWidth(
+      labelComponent.getWidth(
         context = context,
-        text = labelText,
-        width = (availableWidth - iconSizeDp.pixels - iconPaddingDp.pixels).toInt(),
+        text = label,
+        maxWidth = (maxWidth - iconSizeDp.pixels - iconPaddingDp.pixels).toInt(),
       )
     }
 
@@ -79,18 +79,18 @@ public open class LegendItem(
    * Measures the width of this [LegendItem].
    *
    * @param context the [MeasureContext] used to measure the height.
-   * @param availableWidth the available width for the item.
+   * @param maxWidth the maximum width.
    * @param iconPaddingDp the padding between the icon and the label.
    * @param iconSizeDp the size of the icon.
    */
   public fun getWidth(
     context: MeasureContext,
-    availableWidth: Float,
+    maxWidth: Float,
     iconPaddingDp: Float,
     iconSizeDp: Float,
   ): Float =
     with(context) {
-      getLabelWidth(context, availableWidth, iconPaddingDp, iconSizeDp) +
+      getLabelWidth(context, maxWidth, iconPaddingDp, iconSizeDp) +
         (iconSizeDp + iconPaddingDp).pixels
     }
 }
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/Math.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/Math.kt
index 768bc1c27..9551706e8 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/Math.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/Math.kt
@@ -18,7 +18,6 @@ package com.patrykandpatrick.vico.core.common
 
 import androidx.annotation.RestrictTo
 import kotlin.math.abs
-import kotlin.math.ceil
 import kotlin.math.floor
 import kotlin.math.pow
 import kotlin.math.roundToInt
@@ -27,31 +26,31 @@ import kotlin.random.Random
 
 internal const val PI_RAD: Float = 180f
 
-internal const val FLOAT_GCD_DECIMALS = 2
+internal const val DOUBLE_GCD_DECIMALS = 4
 
-private fun Float.round(decimals: Int): Float {
-  val multiplier = 10f.pow(n = decimals)
-  return (this * multiplier).round / multiplier
+private fun Double.roundToNearest(decimals: Int): Double {
+  val multiplier = 10f.pow(decimals)
+  return (this * multiplier).roundedToNearest / multiplier
 }
 
-private fun Float.gcdWithImpl(other: Float, threshold: Float): Float =
+private fun Double.gcdWithImpl(other: Double, threshold: Double): Double =
   when {
-    this < other -> other.gcdWithImpl(other = this, threshold = threshold)
-    abs(x = other) < threshold -> this
-    else -> other.gcdWithImpl(other = this - (this / other).floor * other, threshold = threshold)
+    this < other -> other.gcdWithImpl(this, threshold)
+    abs(other) < threshold -> this
+    else -> other.gcdWithImpl(this - floor(this / other) * other, threshold)
   }
 
-internal fun Float.gcdWith(other: Float): Float =
-  gcdWithImpl(other = other, threshold = 10f.pow(n = -FLOAT_GCD_DECIMALS - 1))
-    .round(decimals = FLOAT_GCD_DECIMALS)
+internal fun Double.gcdWith(other: Double) =
+  gcdWithImpl(other = other, threshold = 10.0.pow(-DOUBLE_GCD_DECIMALS - 1))
+    .roundToNearest(DOUBLE_GCD_DECIMALS)
 
 internal fun <T : Comparable<T>> T.isBoundOf(range: ClosedFloatingPointRange<T>) =
   this == range.start || this == range.endInclusive
 
-internal val ClosedFloatingPointRange<Float>.length
+internal val ClosedFloatingPointRange<Double>.length
   get() = endInclusive - start
 
-internal fun ClosedFloatingPointRange<Float>.random() = start + Random.nextFloat() * length
+internal fun ClosedFloatingPointRange<Double>.random() = start + Random.nextDouble() * length
 
 internal fun Int.getDivisors(includeDividend: Boolean = true) = buildList {
   add(1)
@@ -77,30 +76,27 @@ internal inline val Double.half: Double
   get() = this / 2
 
 internal inline val Float.doubled: Float
-  get() = this * 2
+  get() = 2 * this
+
+internal inline val Double.doubled: Double
+  get() = 2 * this
 
 /** @suppress */
 public inline val Float?.orZero: Float
   @RestrictTo(RestrictTo.Scope.LIBRARY) get() = this ?: 0f
 
+internal val Double?.orZero: Double
+  get() = this ?: 0.0
+
 internal inline val Int?.orZero: Int
   get() = this ?: 0
 
-internal inline val Float.round: Float
-  get() = roundToInt().toFloat()
+internal inline val Double.roundedToNearest: Double
+  get() = roundToInt().toDouble()
 
 internal inline val Float.piRad: Float
   get() = this * PI_RAD
 
-internal inline val Float.floor: Float
-  get() = floor(this)
-
-internal inline val Float.ceil: Float
-  get() = ceil(this)
-
-internal inline val ClosedFloatingPointRange<Float>.median: Float
-  get() = (endInclusive + start) / 2
-
 /** @suppress */
 @RestrictTo(RestrictTo.Scope.LIBRARY)
 public fun Int.hasFlag(flag: Int): Boolean = this and flag == flag
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/MeasureContext.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/MeasureContext.kt
index e00af7e4d..9276ae109 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/MeasureContext.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/MeasureContext.kt
@@ -18,6 +18,7 @@ package com.patrykandpatrick.vico.core.common
 
 import android.graphics.Canvas
 import android.graphics.RectF
+import com.patrykandpatrick.vico.core.common.data.CacheStore
 import com.patrykandpatrick.vico.core.common.data.MutableExtraStore
 
 /** Holds data used for measuring and drawing. */
@@ -49,14 +50,22 @@ public interface MeasureContext {
   public val isLtr: Boolean
 
   /** Stores temporary auxiliary data. */
+  @Deprecated(
+    "To cache drawing data, use `cacheStore`. If using `extraStore` for communication between " +
+      "functions or classes, switch to a suitable alternative."
+  )
   public val extraStore: MutableExtraStore
 
+  /** Caches drawing data. */
+  public val cacheStore: CacheStore
+
   /** `1f` if [isLtr] is `true`, and `-1f` otherwise. */
   public val layoutDirectionMultiplier: Float
     get() = if (isLtr) 1f else -1f
 
   /** Removes all temporary data. */
   public fun reset() {
-    extraStore.clear()
+    @Suppress("DEPRECATION") extraStore.clear()
+    cacheStore.purge()
   }
 }
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/MutableMeasureContext.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/MutableMeasureContext.kt
index 7900eab8f..55d43e369 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/MutableMeasureContext.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/MutableMeasureContext.kt
@@ -18,6 +18,7 @@ package com.patrykandpatrick.vico.core.common
 
 import android.graphics.RectF
 import androidx.annotation.RestrictTo
+import com.patrykandpatrick.vico.core.common.data.CacheStore
 import com.patrykandpatrick.vico.core.common.data.MutableExtraStore
 
 /** A [MeasureContext] implementation that facilitates the mutation of some of its properties. */
@@ -27,7 +28,13 @@ public open class MutableMeasureContext(
   override var isLtr: Boolean,
   @get:RestrictTo(RestrictTo.Scope.LIBRARY_GROUP) public var spToPx: (Float) -> Float,
 ) : MeasureContext {
+  @Deprecated(
+    "To cache drawing data, use `cacheStore`. If using `extraStore` for communication between " +
+      "functions or classes, switch to a suitable alternative."
+  )
   override val extraStore: MutableExtraStore = MutableExtraStore()
 
+  override val cacheStore: CacheStore = CacheStore()
+
   override fun spToPx(sp: Float): Float = spToPx.invoke(sp)
 }
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/VerticalLegend.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/VerticalLegend.kt
index 05e5a33e2..b12fab711 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/VerticalLegend.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/VerticalLegend.kt
@@ -17,6 +17,7 @@
 package com.patrykandpatrick.vico.core.common
 
 import android.graphics.RectF
+import kotlin.math.max
 
 /**
  * [VerticalLegend] displays legend items in a vertical list.
@@ -29,43 +30,40 @@ import android.graphics.RectF
  * @param padding defines the padding of the content.
  */
 public open class VerticalLegend<M : MeasureContext, D : DrawContext>(
-  public var items: Collection<LegendItem>,
-  public var iconSizeDp: Float,
-  public var iconPaddingDp: Float,
-  public var spacingDp: Float = 0f,
-  public val padding: Dimensions = Dimensions.Empty,
+  protected val items: Collection<LegendItem>,
+  protected val iconSizeDp: Float,
+  protected val iconPaddingDp: Float,
+  protected val spacingDp: Float = 0f,
+  protected val padding: Dimensions = Dimensions.Empty,
 ) : Legend<M, D> {
   private val heights: HashMap<LegendItem, Float> = HashMap()
 
   override val bounds: RectF = RectF()
 
-  override fun getHeight(context: M, availableWidth: Float): Float =
+  override fun getHeight(context: M, maxWidth: Float): Float =
     with(context) {
       items.fold(0f) { sum, item ->
         sum +
-          maxOf(
-              iconSizeDp.pixels,
-              item.getLabelHeight(context, availableWidth, iconPaddingDp, iconSizeDp),
-            )
+          max(iconSizeDp.pixels, item.getLabelHeight(context, maxWidth, iconPaddingDp, iconSizeDp))
             .also { height -> heights[item] = height }
       } + (padding.verticalDp + spacingDp * (items.size - 1)).pixels
     }
 
-  override fun draw(context: D, chartBounds: RectF): Unit =
+  override fun draw(context: D) {
     with(context) {
       var currentTop = bounds.top + padding.topDp.pixels
 
       items.forEach { item ->
         val height =
           heights.getOrPut(item) {
-            item.getLabelHeight(this, chartBounds.width(), iconPaddingDp, iconSizeDp)
+            item.getLabelHeight(this, bounds.width(), iconPaddingDp, iconSizeDp)
           }
         val centerY = currentTop + height.half
         var startX =
           if (isLtr) {
-            chartBounds.left + padding.startDp.pixels
+            bounds.left + padding.startDp.pixels
           } else {
-            chartBounds.right - padding.startDp.pixels - iconSizeDp.pixels
+            bounds.right - padding.startDp.pixels - iconSizeDp.pixels
           }
 
         item.icon.draw(
@@ -83,18 +81,18 @@ public open class VerticalLegend<M : MeasureContext, D : DrawContext>(
             -iconPaddingDp.pixels
           }
 
-        item.label.drawText(
+        item.labelComponent.draw(
           context = context,
-          text = item.labelText,
-          textX = startX,
-          textY = centerY,
+          text = item.label,
+          x = startX,
+          y = centerY,
           horizontalPosition = HorizontalPosition.End,
-          maxTextWidth =
-            (chartBounds.width() - (iconSizeDp + iconPaddingDp + padding.horizontalDp).pixels)
-              .toInt(),
+          maxWidth =
+            (bounds.width() - (iconSizeDp + iconPaddingDp + padding.horizontalDp).pixels).toInt(),
         )
 
         currentTop += height + spacingDp.pixels
       }
     }
+  }
 }
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/component/Component.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/component/Component.kt
index a690e030d..8aa2b040c 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/component/Component.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/component/Component.kt
@@ -16,7 +16,6 @@
 
 package com.patrykandpatrick.vico.core.common.component
 
-import com.patrykandpatrick.vico.core.common.Dimensions
 import com.patrykandpatrick.vico.core.common.DrawContext
 
 /**
@@ -24,9 +23,6 @@ import com.patrykandpatrick.vico.core.common.DrawContext
  * coordinates. Its subclasses are used throughout the library.
  */
 public interface Component {
-  /** The margins. */
-  public val margins: Dimensions
-
   /** Instructs the [Component] to draw itself at the given coordinates. */
   public fun draw(
     context: DrawContext,
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/component/ComponentShadow.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/component/ComponentShadow.kt
deleted file mode 100644
index 5d39ea107..000000000
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/component/ComponentShadow.kt
+++ /dev/null
@@ -1,99 +0,0 @@
-/*
- * Copyright 2024 by Patryk Goworowski and Patrick Michalik.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.patrykandpatrick.vico.core.common.component
-
-import android.graphics.Paint
-import com.patrykandpatrick.vico.core.common.DrawContext
-import com.patrykandpatrick.vico.core.common.alphaFloat
-import com.patrykandpatrick.vico.core.common.applyElevationOverlayToColor
-import com.patrykandpatrick.vico.core.common.copyColor
-
-/**
- * A class that stores shadow properties.
- *
- * @property radius the blur radius.
- * @property dx the horizontal offset.
- * @property dy the vertical offset.
- * @property color the shadow color.
- * @property applyElevationOverlay whether to apply an elevation overlay to the component casting
- *   the shadow.
- */
-public data class ComponentShadow(
-  var radius: Float = 0f,
-  var dx: Float = 0f,
-  var dy: Float = 0f,
-  var color: Int = 0,
-  var applyElevationOverlay: Boolean = false,
-) {
-  private var laRadius: Float = 0f
-  private var laDx: Float = 0f
-  private var laDy: Float = 0f
-  private var laColor: Int = 0
-  private var laDensity: Float = 0f
-
-  /** Checks whether the applied shadow layer needs to be updated. */
-  public fun maybeUpdateShadowLayer(
-    context: DrawContext,
-    paint: Paint,
-    backgroundColor: Int,
-    opacity: Float = 1f,
-  ): Unit =
-    with(context) {
-      if (shouldUpdateShadowLayer(opacity)) {
-        updateShadowLayer(paint, backgroundColor, opacity)
-      }
-    }
-
-  private fun DrawContext.updateShadowLayer(paint: Paint, backgroundColor: Int, opacity: Float) {
-    if (color == 0 || radius == 0f && dx == 0f && dy == 0f) {
-      paint.clearShadowLayer()
-    } else {
-      paint.color =
-        if (applyElevationOverlay) {
-          applyElevationOverlayToColor(color = backgroundColor, elevationDp = radius * opacity)
-        } else {
-          backgroundColor
-        }
-      paint.setShadowLayer(
-        radius.pixels,
-        dx.pixels,
-        dy.pixels,
-        color.copyColor(color.alphaFloat * opacity),
-      )
-    }
-  }
-
-  private fun DrawContext.shouldUpdateShadowLayer(opacity: Float): Boolean {
-    val adjustedColor = color.copyColor(color.alphaFloat * opacity)
-    return if (
-      radius != laRadius ||
-        dx != laDx ||
-        dy != laDy ||
-        adjustedColor != laColor ||
-        density != laDensity
-    ) {
-      laRadius = radius
-      laDx = dx
-      laDy = dy
-      laColor = adjustedColor
-      laDensity = density
-      true
-    } else {
-      false
-    }
-  }
-}
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/component/LineComponent.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/component/LineComponent.kt
index 120930e02..ec5d289e2 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/component/LineComponent.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/component/LineComponent.kt
@@ -24,28 +24,29 @@ import com.patrykandpatrick.vico.core.common.DrawContext
 import com.patrykandpatrick.vico.core.common.MeasureContext
 import com.patrykandpatrick.vico.core.common.shader.DynamicShader
 import com.patrykandpatrick.vico.core.common.shape.Shape
-import com.patrykandpatrick.vico.core.common.shape.Shape.Companion.Rectangle
 
 /**
- * Draws a line.
+ * Draws lines.
  *
- * @property color the background color.
- * @property thicknessDp the thickness of the line.
- * @property shape the [Shape] to use for the line.
- * @property dynamicShader an optional [DynamicShader] to apply to the line.
- * @property margins the margins of the line.
- * @property strokeWidthDp the stroke width.
- * @property strokeColor the stroke color.
+ * @param color the fill color.
+ * @param shape the [Shape].
+ * @param margins the margins.
+ * @param strokeColor the stroke color.
+ * @param strokeThicknessDp the stroke thickness (in dp).
+ * @param shader applied to the fill.
+ * @param shadow stores the shadow properties.
+ * @property thicknessDp the line thickness (in dp).
  */
 public open class LineComponent(
   color: Int,
-  public var thicknessDp: Float = Defaults.LINE_COMPONENT_THICKNESS_DP,
-  shape: Shape = Rectangle,
-  dynamicShader: DynamicShader? = null,
+  public val thicknessDp: Float = Defaults.LINE_COMPONENT_THICKNESS_DP,
+  shape: Shape = Shape.Rectangle,
   margins: Dimensions = Dimensions.Empty,
-  strokeWidthDp: Float = 0f,
   strokeColor: Int = Color.TRANSPARENT,
-) : ShapeComponent(shape, color, dynamicShader, margins, strokeWidthDp, strokeColor) {
+  strokeThicknessDp: Float = 0f,
+  shader: DynamicShader? = null,
+  shadow: Shadow? = null,
+) : ShapeComponent(color, shape, margins, strokeColor, strokeThicknessDp, shader, shadow) {
   private val MeasureContext.thickness: Float
     get() = thicknessDp.pixels
 
@@ -153,23 +154,46 @@ public open class LineComponent(
       boundingBox.left < right && left < boundingBox.right
     }
 
+  /** Creates a new [LineComponent] based on this one. */
+  override fun copy(
+    color: Int,
+    shape: Shape,
+    margins: Dimensions,
+    strokeColor: Int,
+    strokeThicknessDp: Float,
+    shader: DynamicShader?,
+    shadow: Shadow?,
+  ): LineComponent =
+    LineComponent(
+      color,
+      thicknessDp,
+      shape,
+      margins,
+      strokeColor,
+      strokeThicknessDp,
+      shader,
+      shadow,
+    )
+
   /** Creates a new [LineComponent] based on this one. */
   public open fun copy(
     color: Int = this.color,
     thicknessDp: Float = this.thicknessDp,
     shape: Shape = this.shape,
-    dynamicShader: DynamicShader? = this.dynamicShader,
     margins: Dimensions = this.margins,
-    strokeWidthDp: Float = this.strokeWidthDp,
     strokeColor: Int = this.strokeColor,
+    strokeThicknessDp: Float = this.strokeThicknessDp,
+    shader: DynamicShader? = this.shader,
+    shadow: Shadow? = this.shadow,
   ): LineComponent =
     LineComponent(
-      color = color,
-      thicknessDp = thicknessDp,
-      shape = shape,
-      dynamicShader = dynamicShader,
-      margins = margins,
-      strokeWidthDp = strokeWidthDp,
-      strokeColor = strokeColor,
+      color,
+      thicknessDp,
+      shape,
+      margins,
+      strokeColor,
+      strokeThicknessDp,
+      shader,
+      shadow,
     )
 }
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/component/PaintComponent.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/component/PaintComponent.kt
deleted file mode 100644
index 168ea99b9..000000000
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/component/PaintComponent.kt
+++ /dev/null
@@ -1,80 +0,0 @@
-/*
- * Copyright 2024 by Patryk Goworowski and Patrick Michalik.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.patrykandpatrick.vico.core.common.component
-
-import android.graphics.Paint
-import com.patrykandpatrick.vico.core.common.Defaults
-import com.patrykandpatrick.vico.core.common.DrawContext
-
-/** A base class for components that use [android.graphics.Paint] to draw themselves. */
-@Suppress("UNCHECKED_CAST")
-public open class PaintComponent<C> protected constructor() {
-  protected val componentShadow: ComponentShadow = ComponentShadow()
-
-  /** Checks whether the applied shadow layer needs to be updated. */
-  protected fun maybeUpdateShadowLayer(
-    context: DrawContext,
-    paint: Paint,
-    backgroundColor: Int,
-    opacity: Float = 1f,
-  ): Unit =
-    componentShadow.maybeUpdateShadowLayer(
-      context = context,
-      paint = paint,
-      backgroundColor = backgroundColor,
-      opacity = opacity,
-    )
-
-  /**
-   * Applies a drop shadow.
-   *
-   * @param radius the blur radius.
-   * @param dx the horizontal offset.
-   * @param dy the vertical offset.
-   * @param color the shadow color.
-   * @param applyElevationOverlay whether to apply an elevation overlay to the shape.
-   */
-  public fun setShadow(
-    radius: Float,
-    dx: Float = 0f,
-    dy: Float = 0f,
-    color: Int = Defaults.SHADOW_COLOR,
-    applyElevationOverlay: Boolean = false,
-  ): C =
-    apply {
-      componentShadow.apply {
-        this.radius = radius
-        this.dx = dx
-        this.dy = dy
-        this.color = color
-        this.applyElevationOverlay = applyElevationOverlay
-      }
-    }
-      as C
-
-  /** Removes this [ShapeComponent]’s drop shadow. */
-  public fun clearShadow(): C =
-    apply {
-      componentShadow.apply {
-        this.radius = 0f
-        this.dx = 0f
-        this.dy = 0f
-        this.color = 0
-      }
-    }
-      as C
-}
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/component/Shadow.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/component/Shadow.kt
new file mode 100644
index 000000000..1c54bb016
--- /dev/null
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/component/Shadow.kt
@@ -0,0 +1,52 @@
+/*
+ * Copyright 2024 by Patryk Goworowski and Patrick Michalik.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.patrykandpatrick.vico.core.common.component
+
+import android.graphics.Paint
+import androidx.compose.runtime.Immutable
+import com.patrykandpatrick.vico.core.common.Defaults
+import com.patrykandpatrick.vico.core.common.MeasureContext
+import com.patrykandpatrick.vico.core.common.alphaFloat
+import com.patrykandpatrick.vico.core.common.copyColor
+
+/**
+ * Stores shadow properties.
+ *
+ * @param radiusDp the blur radius (in dp).
+ * @param dxDp the horizontal offset (in dp).
+ * @param dyDp the vertical offset (in dp).
+ * @param color the color.
+ */
+@Immutable
+public data class Shadow(
+  private val radiusDp: Float,
+  private val dxDp: Float = 0f,
+  private val dyDp: Float = 0f,
+  private val color: Int = Defaults.SHADOW_COLOR,
+) {
+  /** Updates [paint]’s shadow layer. */
+  public fun updateShadowLayer(context: MeasureContext, paint: Paint, opacity: Float) {
+    with(context) {
+      paint.setShadowLayer(
+        radiusDp.pixels,
+        dxDp.pixels,
+        dyDp.pixels,
+        color.copyColor(opacity * color.alphaFloat),
+      )
+    }
+  }
+}
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/component/ShapeComponent.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/component/ShapeComponent.kt
index 891e3abf9..cfe7665a8 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/component/ShapeComponent.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/component/ShapeComponent.kt
@@ -19,115 +19,100 @@ package com.patrykandpatrick.vico.core.common.component
 import android.graphics.Color
 import android.graphics.Paint
 import android.graphics.Path
-import android.graphics.Shader
 import com.patrykandpatrick.vico.core.common.Dimensions
 import com.patrykandpatrick.vico.core.common.DrawContext
 import com.patrykandpatrick.vico.core.common.alpha
 import com.patrykandpatrick.vico.core.common.half
-import com.patrykandpatrick.vico.core.common.round
 import com.patrykandpatrick.vico.core.common.shader.DynamicShader
 import com.patrykandpatrick.vico.core.common.shape.Shape
 import com.patrykandpatrick.vico.core.common.withOpacity
-import kotlin.properties.Delegates
 
 /**
- * [ShapeComponent] is a [Component] that draws a shape.
+ * Draws [Shape]s.
  *
- * @param shape the [Shape] that will be drawn.
- * @param color the color of the shape.
- * @param dynamicShader an optional [Shader] provider used as the shape’s background.
- * @param margins the [Component]’s margins.
- * @param strokeWidthDp the width of the shape’s stroke (in dp).
- * @param strokeColor the color of the stroke.
+ * @property color the fill color.
+ * @property shape the [Shape].
+ * @property margins the margins.
+ * @property strokeColor the stroke color.
+ * @property strokeThicknessDp the stroke thickness (in dp).
+ * @property shader applied to the fill.
+ * @property shadow stores the shadow properties.
  */
 public open class ShapeComponent(
+  public val color: Int = Color.BLACK,
   public val shape: Shape = Shape.Rectangle,
-  color: Int = Color.BLACK,
-  public val dynamicShader: DynamicShader? = null,
-  override val margins: Dimensions = Dimensions.Empty,
-  public val strokeWidthDp: Float = 0f,
-  strokeColor: Int = Color.TRANSPARENT,
-) : PaintComponent<ShapeComponent>(), Component {
-  private val paint: Paint = Paint(Paint.ANTI_ALIAS_FLAG)
-  private val strokePaint: Paint = Paint(Paint.ANTI_ALIAS_FLAG)
+  protected val margins: Dimensions = Dimensions.Empty,
+  public val strokeColor: Int = Color.TRANSPARENT,
+  protected val strokeThicknessDp: Float = 0f,
+  protected val shader: DynamicShader? = null,
+  protected val shadow: Shadow? = null,
+) : Component {
+  private val paint = Paint(Paint.ANTI_ALIAS_FLAG).apply { color = this@ShapeComponent.color }
+  private val strokePaint =
+    Paint(Paint.ANTI_ALIAS_FLAG).apply {
+      this.color = strokeColor
+      style = Paint.Style.STROKE
+    }
 
   protected val path: Path = Path()
 
-  /** The color of the shape. */
-  public var color: Int by Delegates.observable(color) { _, _, value -> paint.color = value }
-
-  /** The color of the stroke. */
-  public var strokeColor: Int by
-    Delegates.observable(strokeColor) { _, _, value -> strokePaint.color = value }
-
   init {
-    paint.color = color
-
-    with(strokePaint) {
-      this.color = strokeColor
-      style = Paint.Style.STROKE
-    }
+    require(strokeThicknessDp >= 0) { "`strokeThicknessDp` must be nonnegative." }
   }
 
-  override fun draw(
+  protected fun applyShader(
     context: DrawContext,
     left: Float,
     top: Float,
     right: Float,
     bottom: Float,
-    opacity: Float,
-  ): Unit =
-    with(context) {
-      if (left == right || top == bottom) return // Skip drawing shape that will be invisible.
-      path.rewind()
-      applyShader(context, left, top, right, bottom)
-      val centerX = (left + right).half
-      val centerY = (top + bottom).half
-      componentShadow.maybeUpdateShadowLayer(
-        context = this,
-        paint = paint,
-        backgroundColor = color,
-        opacity = opacity,
-      )
-
-      val strokeWidth = strokeWidthDp.pixels
-      strokePaint.strokeWidth = strokeWidth
-
-      fun drawShape(paint: Paint, isStroke: Boolean) {
-        val strokeCompensation = if (isStroke) strokeWidth.half else 0f
-
-        shape.drawShape(
-          context = context,
-          paint = paint,
-          path = path,
-          left =
-            minOf(left + margins.startDp.pixels + strokeWidth.half, centerX - strokeCompensation)
-              .round,
-          top =
-            minOf(top + margins.topDp.pixels + strokeWidth.half, centerY - strokeCompensation)
-              .round,
-          right =
-            maxOf(right - margins.endDp.pixels - strokeWidth.half, centerX + strokeCompensation)
-              .round,
-          bottom =
-            maxOf(bottom - margins.bottomDp.pixels - strokeWidth.half, centerY + strokeCompensation)
-              .round,
-        )
-      }
-
-      paint.withOpacity(opacity) { paint -> drawShape(paint = paint, isStroke = false) }
-      if (strokeWidth > 0f && strokeColor.alpha > 0) drawShape(paint = strokePaint, isStroke = true)
-    }
+  ) {
+    shader?.provideShader(context, left, top, right, bottom)?.let(paint::setShader)
+  }
 
-  protected fun applyShader(
+  override fun draw(
     context: DrawContext,
     left: Float,
     top: Float,
     right: Float,
     bottom: Float,
+    opacity: Float,
   ) {
-    dynamicShader?.provideShader(context, left, top, right, bottom)?.let { shader ->
-      paint.shader = shader
+    with(context) {
+      var adjustedLeft = left + margins.getLeftDp(isLtr).pixels
+      var adjustedTop = top + margins.topDp.pixels
+      var adjustedRight = right - margins.getRightDp(isLtr).pixels
+      var adjustedBottom = bottom - margins.bottomDp.pixels
+      if (adjustedLeft >= adjustedRight || adjustedTop >= adjustedBottom) return
+      val strokeThickness = strokeThicknessDp.pixels
+      if (strokeThickness != 0f) {
+        adjustedLeft += strokeThickness.half
+        adjustedTop += strokeThickness.half
+        adjustedRight -= strokeThickness.half
+        adjustedBottom -= strokeThickness.half
+        if (adjustedLeft > adjustedRight || adjustedTop > adjustedBottom) return
+      }
+      path.rewind()
+      applyShader(this, left, top, right, bottom)
+      shadow?.updateShadowLayer(this, paint, opacity)
+      paint.withOpacity(opacity) { paint ->
+        shape.draw(this, paint, path, adjustedLeft, adjustedTop, adjustedRight, adjustedBottom)
+      }
+      if (strokeThickness == 0f || strokeColor.alpha == 0) return
+      strokePaint.strokeWidth = strokeThickness
+      shape.draw(this, strokePaint, path, adjustedLeft, adjustedTop, adjustedRight, adjustedBottom)
     }
   }
+
+  /** Creates a new [ShapeComponent] based on this one. */
+  public open fun copy(
+    color: Int = this.color,
+    shape: Shape = this.shape,
+    margins: Dimensions = this.margins,
+    strokeColor: Int = this.strokeColor,
+    strokeThicknessDp: Float = this.strokeThicknessDp,
+    shader: DynamicShader? = this.shader,
+    shadow: Shadow? = this.shadow,
+  ): ShapeComponent =
+    ShapeComponent(color, shape, margins, strokeColor, strokeThicknessDp, shader, shadow)
 }
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/component/TextComponent.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/component/TextComponent.kt
index afc20f805..3076ee146 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/component/TextComponent.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/component/TextComponent.kt
@@ -27,16 +27,16 @@ import android.text.Spanned
 import android.text.StaticLayout
 import android.text.TextPaint
 import android.text.TextUtils
-import com.patrykandpatrick.vico.core.common.Defaults.LABEL_LINE_COUNT
-import com.patrykandpatrick.vico.core.common.Defaults.TEXT_COMPONENT_TEXT_SIZE
+import androidx.compose.runtime.Immutable
+import com.patrykandpatrick.vico.core.common.Defaults
+import com.patrykandpatrick.vico.core.common.Defaults.TEXT_COMPONENT_LINE_COUNT
 import com.patrykandpatrick.vico.core.common.Dimensions
 import com.patrykandpatrick.vico.core.common.DrawContext
 import com.patrykandpatrick.vico.core.common.HorizontalPosition
 import com.patrykandpatrick.vico.core.common.MeasureContext
 import com.patrykandpatrick.vico.core.common.VerticalPosition
 import com.patrykandpatrick.vico.core.common.copy
-import com.patrykandpatrick.vico.core.common.data.ExtraStore
-import com.patrykandpatrick.vico.core.common.data.getOrSetCached
+import com.patrykandpatrick.vico.core.common.data.CacheStore
 import com.patrykandpatrick.vico.core.common.getBounds
 import com.patrykandpatrick.vico.core.common.half
 import com.patrykandpatrick.vico.core.common.piRad
@@ -49,7 +49,6 @@ import kotlin.math.cos
 import kotlin.math.min
 import kotlin.math.sin
 
-private const val LAYOUT_KEY_PREFIX = "layout_"
 private const val DEF_LAYOUT_SIZE = 100000
 
 /**
@@ -61,96 +60,69 @@ private const val DEF_LAYOUT_SIZE = 100000
  * - text backgrounds (any [Component])
  * - margins and padding
  *
- * It’s recommended to create instances via [TextComponent.build].
+ * @property color the text color.
+ * @property typeface the [Typeface].
+ * @property textSizeSp the text size (in sp).
+ * @property textAlignment the text alignment.
+ * @property lineCount the line count.
+ * @property truncateAt the truncation type.
+ * @property padding the padding.
+ * @property margins the margins.
+ * @property background drawn behind the text.
+ * @property minWidth defines the minimum width.
  */
-public open class TextComponent protected constructor() {
-  private val textPaint: TextPaint = TextPaint(Paint.ANTI_ALIAS_FLAG)
-  private val tempMeasureBounds = RectF()
-  private val layoutCacheKey: ExtraStore.Key<Pair<String, StaticLayout>> = ExtraStore.Key()
-
-  /** The text’s color. */
-  public var color: Int by textPaint::color
-
-  /** The [Typeface] for the text. */
-  public var typeface: Typeface? by textPaint::typeface
-
-  /** The font size (in sp). */
-  public var textSizeSp: Float = 0f
-
-  /**
-   * The type of text truncation to be used when the text’s width exceeds the amount of available
-   * space. By default, text is truncated at the end, and an ellipsis (…) is used.
-   */
-  public var ellipsize: TextUtils.TruncateAt? = TextUtils.TruncateAt.END
-
-  /**
-   * The maximum number of lines for the text. For performance reasons, during the measurement
-   * phase, it is presumed that the actual number of lines is equal to this value.
-   */
-  public var lineCount: Int = LABEL_LINE_COUNT
-
-  /**
-   * The text’s background. Use [padding] to set the padding between the text and the background.
-   *
-   * @see [padding]
-   */
-  public var background: Component? = null
-
-  /** The text alignment. */
-  public var textAlignment: Layout.Alignment = Layout.Alignment.ALIGN_NORMAL
-
-  /** Defines the minimum width. */
-  public var minWidth: MinWidth = MinWidth.fixed()
-
-  /**
-   * The padding between the text and the background. This is applied even if [background] is null.
-   *
-   * @see [background]
-   */
-  public var padding: Dimensions = Dimensions.Empty
-
-  /**
-   * The margins around the background. This is applied even if [background] is null.
-   *
-   * @see [background]
-   */
-  public var margins: Dimensions = Dimensions.Empty
-
+public open class TextComponent(
+  protected val color: Int = Color.BLACK,
+  protected val typeface: Typeface = Typeface.DEFAULT,
+  protected val textSizeSp: Float = Defaults.TEXT_COMPONENT_TEXT_SIZE,
+  protected val textAlignment: Layout.Alignment = Layout.Alignment.ALIGN_NORMAL,
+  protected val lineCount: Int = TEXT_COMPONENT_LINE_COUNT,
+  protected val truncateAt: TextUtils.TruncateAt? = TextUtils.TruncateAt.END,
+  protected val margins: Dimensions = Dimensions.Empty,
+  protected val padding: Dimensions = Dimensions.Empty,
+  public val background: Component? = null,
+  protected val minWidth: MinWidth = MinWidth.fixed(),
+) {
+  private val textPaint =
+    TextPaint(Paint.ANTI_ALIAS_FLAG).also { textPaint ->
+      textPaint.color = color
+      textPaint.typeface = typeface
+    }
   private var layout: Layout = staticLayout("", textPaint, 0)
+  private val tempMeasureBounds = RectF()
 
   /**
    * Uses [Canvas] to draw this [TextComponent].
    *
    * @param context holds environment data.
    * @param text the text to be drawn.
-   * @param textX the _x_ coordinate for the text.
-   * @param textY the _y_ coordinate for the text.
-   * @param horizontalPosition the horizontal position of the text, relative to [textX].
-   * @param verticalPosition the vertical position of the text, relative to [textY].
-   * @param maxTextWidth the maximum width available for the text (in pixels).
-   * @param maxTextHeight the maximum height available for the text (in pixels).
+   * @param x the _x_ coordinate for the text.
+   * @param y the _y_ coordinate for the text.
+   * @param horizontalPosition the horizontal position of the text, relative to [x].
+   * @param verticalPosition the vertical position of the text, relative to [y].
+   * @param maxWidth the maximum width available for the text (in pixels).
+   * @param maxHeight the maximum height available for the text (in pixels).
    * @param rotationDegrees the rotation of the text (in degrees).
    */
-  public fun drawText(
+  public fun draw(
     context: DrawContext,
     text: CharSequence,
-    textX: Float,
-    textY: Float,
+    x: Float,
+    y: Float,
     horizontalPosition: HorizontalPosition = HorizontalPosition.Center,
     verticalPosition: VerticalPosition = VerticalPosition.Center,
-    maxTextWidth: Int = DEF_LAYOUT_SIZE,
-    maxTextHeight: Int = DEF_LAYOUT_SIZE,
+    maxWidth: Int = DEF_LAYOUT_SIZE,
+    maxHeight: Int = DEF_LAYOUT_SIZE,
     rotationDegrees: Float = 0f,
-  ): Unit =
+  ) {
     with(context) {
       if (text.isBlank()) return
-      layout = getLayout(this, text, maxTextWidth, maxTextHeight, rotationDegrees)
+      layout = getLayout(this, text, maxWidth, maxHeight, rotationDegrees)
 
       val shouldRotate = rotationDegrees % 2f.piRad != 0f
       val textStartPosition =
-        horizontalPosition.getTextStartPosition(context, textX, layout.widestLineWidth)
-      val textTopPosition =
-        verticalPosition.getTextTopPosition(context, textY, layout.height.toFloat())
+        horizontalPosition.getTextStartPosition(context, x, layout.widestLineWidth)
+      val textTopPosition = verticalPosition.getTextTopPosition(context, y, layout.height.toFloat())
 
       context.withSavedCanvas {
         val bounds = layout.getBounds(tempMeasureBounds)
@@ -160,13 +132,8 @@ public open class TextComponent protected constructor() {
 
         with(receiver = bounds) {
           val minWidth =
-            minWidth.getValue(
-              context,
-              this@TextComponent,
-              maxTextWidth,
-              maxTextHeight,
-              rotationDegrees,
-            ) - padding.horizontalDp.pixels
+            minWidth.getValue(context, this@TextComponent, maxWidth, maxHeight, rotationDegrees) -
+              padding.horizontalDp.pixels
           val minWidthCorrection =
             (minWidth.coerceAtMost(layout.width.toFloat()) - width()).coerceAtLeast(0f)
           left -= minWidthCorrection.half
@@ -222,6 +189,7 @@ public open class TextComponent protected constructor() {
         layout.draw(this)
       }
     }
+  }
 
   private fun HorizontalPosition.getTextStartPosition(
     context: MeasureContext,
@@ -280,61 +248,59 @@ public open class TextComponent protected constructor() {
     }
 
   /**
-   * Returns the width of this [TextComponent] for the given [text] and the available [width] and
-   * [height]. [pad] defines whether to extend [text] by such a number of blank lines that it has
-   * [lineCount] lines.
+   * Returns the width of this [TextComponent] for the given text and maximum dimensions. [pad]
+   * defines whether to extend [text] by such a number of blank lines that it has [lineCount] lines.
    */
   public fun getWidth(
     context: MeasureContext,
     text: CharSequence? = null,
-    width: Int = DEF_LAYOUT_SIZE,
-    height: Int = DEF_LAYOUT_SIZE,
+    maxWidth: Int = DEF_LAYOUT_SIZE,
+    maxHeight: Int = DEF_LAYOUT_SIZE,
     rotationDegrees: Float = 0f,
     pad: Boolean = text == null,
   ): Float =
-    getTextBounds(
+    getBounds(
         context = context,
         text = text,
-        width = width,
-        height = height,
+        maxWidth = maxWidth,
+        maxHeight = maxHeight,
         rotationDegrees = rotationDegrees,
         pad = pad,
       )
       .width()
 
   /**
-   * Returns the height of this [TextComponent] for the given [text] and the available [width] and
-   * [height]. [pad] defines whether to extend [text] by such a number of blank lines that it has
-   * [lineCount] lines.
+   * Returns the height of this [TextComponent] for the given text and maximum dimensions. [pad]
+   * defines whether to extend [text] by such a number of blank lines that it has [lineCount] lines.
    */
   public fun getHeight(
     context: MeasureContext,
     text: CharSequence? = null,
-    width: Int = DEF_LAYOUT_SIZE,
-    height: Int = DEF_LAYOUT_SIZE,
+    maxWidth: Int = DEF_LAYOUT_SIZE,
+    maxHeight: Int = DEF_LAYOUT_SIZE,
     rotationDegrees: Float = 0f,
     pad: Boolean = text == null,
   ): Float =
-    getTextBounds(
+    getBounds(
         context = context,
         text = text,
-        width = width,
-        height = height,
+        maxWidth = maxWidth,
+        maxHeight = maxHeight,
         rotationDegrees = rotationDegrees,
         pad = pad,
       )
       .height()
 
   /**
-   * Returns the bounds ([RectF]) of this [TextComponent] for the given [text] and the available
-   * [width] and [height]. [pad] defines whether to extend [text] by such a number of blank lines
-   * that it has [lineCount] lines.
+   * Returns the bounds ([RectF]) of this [TextComponent] for the given [text] and maximum
+   * dimensions. [pad] defines whether to extend [text] by such a number of blank lines that it has
+   * [lineCount] lines.
    */
-  public fun getTextBounds(
+  public fun getBounds(
     context: MeasureContext,
     text: CharSequence? = null,
-    width: Int = DEF_LAYOUT_SIZE,
-    height: Int = DEF_LAYOUT_SIZE,
+    maxWidth: Int = DEF_LAYOUT_SIZE,
+    maxHeight: Int = DEF_LAYOUT_SIZE,
     outRect: RectF = tempMeasureBounds,
     includePaddingAndMargins: Boolean = true,
     rotationDegrees: Float = 0f,
@@ -346,12 +312,12 @@ public open class TextComponent protected constructor() {
         repeat((lineCount - measuredText.lines().size).coerceAtLeast(0)) {
           measuredText.append('\n')
         }
-      val layout = getLayout(this, measuredText, width, height, rotationDegrees)
+      val layout = getLayout(this, measuredText, maxWidth, maxHeight, rotationDegrees)
       layout
         .getBounds(outRect)
         .apply {
           val minWidth =
-            minWidth.getValue(context, this@TextComponent, width, height, rotationDegrees) -
+            minWidth.getValue(context, this@TextComponent, maxWidth, maxHeight, rotationDegrees) -
               padding.horizontalDp.pixels
           right = right.coerceAtLeast(minWidth).coerceAtMost(layout.width.toFloat())
           if (includePaddingAndMargins) {
@@ -368,6 +334,32 @@ public open class TextComponent protected constructor() {
         }
     }
 
+  /** Creates a new [TextComponent] based on this one. */
+  public open fun copy(
+    color: Int = this.color,
+    typeface: Typeface = this.typeface,
+    textSizeSp: Float = this.textSizeSp,
+    textAlignment: Layout.Alignment = this.textAlignment,
+    lineCount: Int = this.lineCount,
+    truncateAt: TextUtils.TruncateAt? = this.truncateAt,
+    margins: Dimensions = this.margins,
+    padding: Dimensions = this.padding,
+    background: Component? = this.background,
+    minWidth: MinWidth = this.minWidth,
+  ): TextComponent =
+    TextComponent(
+      color,
+      typeface,
+      textSizeSp,
+      textAlignment,
+      lineCount,
+      truncateAt,
+      margins,
+      padding,
+      background,
+      minWidth,
+    )
+
   private fun getLayout(
     context: MeasureContext,
     text: CharSequence,
@@ -382,7 +374,7 @@ public open class TextComponent protected constructor() {
       val correctedWidth =
         (when {
             rotationDegrees % 1f.piRad == 0f -> widthWithoutMargins
-            rotationDegrees % .5f.piRad == 0f -> heightWithoutMargins
+            rotationDegrees % 0.5f.piRad == 0f -> heightWithoutMargins
             else -> {
               val cumulatedHeight =
                 lineCount * textPaint.lineHeight + padding.verticalDp.wholePixels
@@ -397,14 +389,15 @@ public open class TextComponent protected constructor() {
           } - padding.horizontalDp.wholePixels)
           .coerceAtLeast(0)
 
-      extraStore.getOrSetCached(
-        cacheKey = layoutCacheKey,
-        valueKey =
-          LAYOUT_KEY_PREFIX +
-            text.hashCode() +
-            correctedWidth +
-            rotationDegrees +
-            textPaint.hashCode(),
+      cacheStore.getOrSet(
+        cacheKeyNamespace,
+        text.hashCode(),
+        textPaint.hashCode(),
+        textSizeSp,
+        correctedWidth,
+        lineCount,
+        truncateAt,
+        textAlignment,
       ) {
         textPaint.textSize = spToPx(textSizeSp)
         staticLayout(
@@ -412,7 +405,7 @@ public open class TextComponent protected constructor() {
           paint = textPaint,
           width = correctedWidth,
           maxLines = lineCount,
-          ellipsize = ellipsize,
+          ellipsize = truncateAt,
           align = textAlignment,
         )
       }
@@ -424,55 +417,8 @@ public open class TextComponent protected constructor() {
     canvas.restore()
   }
 
-  /** Creates [TextComponent]s. It’s recommended to use this via [TextComponent.build]. */
-  public class Builder {
-    /** @see [TextComponent.color] */
-    public var color: Int = Color.BLACK
-
-    /** @see [TextComponent.textSizeSp] */
-    public var textSizeSp: Float = TEXT_COMPONENT_TEXT_SIZE
-
-    /** @see [TextComponent.typeface] */
-    public var typeface: Typeface? = null
-
-    /** @see [TextComponent.ellipsize] */
-    public var ellipsize: TextUtils.TruncateAt = TextUtils.TruncateAt.END
-
-    /** @see [TextComponent.lineCount] */
-    public var lineCount: Int = LABEL_LINE_COUNT
-
-    /** @see [TextComponent.background] */
-    public var background: Component? = null
-
-    /** @see TextComponent.textAlignment */
-    public var textAlignment: Layout.Alignment = Layout.Alignment.ALIGN_NORMAL
-
-    /** Defines the minimum width. */
-    public var minWidth: MinWidth = MinWidth.fixed()
-
-    /** @see [TextComponent.padding] */
-    public var padding: Dimensions = Dimensions.Empty
-
-    /** @see [TextComponent.margins] */
-    public var margins: Dimensions = Dimensions.Empty
-
-    /** Creates a new instance of [TextComponent] with the supplied properties. */
-    public fun build(): TextComponent =
-      TextComponent().apply {
-        color = this@Builder.color
-        textSizeSp = this@Builder.textSizeSp
-        typeface = this@Builder.typeface
-        ellipsize = this@Builder.ellipsize
-        lineCount = this@Builder.lineCount
-        background = this@Builder.background
-        textAlignment = this@Builder.textAlignment
-        minWidth = this@Builder.minWidth
-        padding = this@Builder.padding
-        margins = this@Builder.margins
-      }
-  }
-
   /** Defines a [TextComponent]’s minimum width. */
+  @Immutable
   public fun interface MinWidth {
     /** Returns the minimum width. */
     public fun getValue(
@@ -530,20 +476,8 @@ public open class TextComponent protected constructor() {
     }
   }
 
-  /** Houses a [TextComponent] factory function. */
-  public companion object {
-    /**
-     * Creates a [TextComponent] via [Builder]. Sample usage:
-     * ```
-     * TextComponent.build {
-     *     color = Color.BLACK
-     *     textSizeSp = 12f
-     *     typeface = Typeface.MONOSPACE
-     * }
-     * ```
-     */
-    public inline fun build(block: Builder.() -> Unit = {}): TextComponent =
-      Builder().apply(block).build()
+  protected companion object {
+    public val cacheKeyNamespace: CacheStore.KeyNamespace = CacheStore.KeyNamespace()
   }
 }
 
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/component/UnboundedLineComponent.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/component/UnboundedLineComponent.kt
index 32c842baf..27f7cdb87 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/component/UnboundedLineComponent.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/component/UnboundedLineComponent.kt
@@ -27,29 +27,14 @@ import com.patrykandpatrick.vico.core.common.shape.Shape
  * This class represents an unbounded line component. It extends the LineComponent class and
  * provides additional functionality for drawing vertical and horizontal lines with additional
  * drawing space.
- *
- * @property color the background color.
- * @property thicknessDp the thickness of the line.
- * @property shape the [Shape] to use for the line.
- * @property dynamicShader an optional [DynamicShader] to apply to the line.
- * @property margins the margins of the line.
- * @property strokeWidthDp the stroke width.
- * @property strokeColor the stroke color.
- * @param verticalAddDrawSpaceDp Additional vertical drawing space for the line component in density-independent pixels (dp).
- * @param horizontalAddDrawSpaceDp Additional horizontal drawing space for the line component in density-independent pixels (dp).
- *
- * @see LineComponent
- * @see Shape
- * @see DynamicShader
- * @see Dimensions
  */
 public class UnboundedLineComponent(
   color: Int,
   thicknessDp: Float = Defaults.LINE_COMPONENT_THICKNESS_DP,
   shape: Shape = Shape.Rectangle,
-  dynamicShader: DynamicShader? = null,
+  shader: DynamicShader? = null,
   margins: Dimensions = Dimensions.Empty,
-  strokeWidthDp: Float = 0f,
+  strokeThicknessDp: Float = 0f,
   strokeColor: Int = Color.TRANSPARENT,
   protected val verticalAddDrawSpaceDp: Float = 0f,
   protected val horizontalAddDrawSpaceDp: Float = 0f,
@@ -57,9 +42,9 @@ public class UnboundedLineComponent(
   color = color,
   thicknessDp = thicknessDp,
   shape = shape,
-  dynamicShader = dynamicShader,
+  shader = shader,
   margins = margins,
-  strokeWidthDp = strokeWidthDp,
+  strokeThicknessDp = strokeThicknessDp,
   strokeColor = strokeColor,
 ) {
 
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/data/CacheStore.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/data/CacheStore.kt
new file mode 100644
index 000000000..19e39ed90
--- /dev/null
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/data/CacheStore.kt
@@ -0,0 +1,57 @@
+/*
+ * Copyright 2024 by Patryk Goworowski and Patrick Michalik.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.patrykandpatrick.vico.core.common.data
+
+/** Caches data. */
+public class CacheStore {
+  private var map = mutableMapOf<String, Any>()
+  private var purgedMap = mutableMapOf<String, Any>()
+
+  /**
+   * Retrieves the value associated with the key belonging to the specified namespace and matching
+   * the given components. If there’s no such value, [value] is called, and its result is cached and
+   * returned.
+   */
+  public fun <T : Any> getOrSet(
+    keyNamespace: KeyNamespace,
+    vararg keyComponents: Any?,
+    value: () -> T,
+  ): T {
+    val key = keyNamespace.getKey(*keyComponents)
+    return (@Suppress("UNCHECKED_CAST") (map[key]?.also { purgedMap[key] = it } as T?))
+      ?: value().also { newValue ->
+        map[key] = newValue
+        purgedMap[key] = newValue
+      }
+  }
+
+  /**
+   * Removes all values that were added before the last call to this function and haven’t been read
+   * since the last call. When called for the first time on a given [CacheStore], this function
+   * doesn’t remove any values.
+   */
+  public fun purge() {
+    map = purgedMap
+    purgedMap = mutableMapOf()
+  }
+
+  /** Identifies a key namespace. These namespaces help prevent interscope key collisions. */
+  public class KeyNamespace {
+    internal fun getKey(vararg components: Any?) =
+      components.joinToString(prefix = "${hashCode()}, ")
+  }
+}
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/data/DefaultDrawingModelInterpolator.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/data/DefaultDrawingModelInterpolator.kt
index 03188eb2f..2ef54a761 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/data/DefaultDrawingModelInterpolator.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/data/DefaultDrawingModelInterpolator.kt
@@ -25,7 +25,7 @@ import kotlinx.coroutines.ensureActive
 @Suppress("UNCHECKED_CAST")
 public class DefaultDrawingModelInterpolator<T : DrawingModel.DrawingInfo, R : DrawingModel<T>> :
   DrawingModelInterpolator<T, R> {
-  private var transformationMaps = emptyList<Map<Float, TransformationModel<T>>>()
+  private var transformationMaps = emptyList<Map<Double, TransformationModel<T>>>()
   private var oldDrawingModel: R? = null
   private var newDrawingModel: R? = null
 
@@ -56,7 +56,7 @@ public class DefaultDrawingModelInterpolator<T : DrawingModel.DrawingInfo, R : D
   private fun updateTransformationMap() {
     transformationMaps = buildList {
       repeat(max(oldDrawingModel?.size.orZero, newDrawingModel?.size.orZero)) { index ->
-        val map = mutableMapOf<Float, TransformationModel<T>>()
+        val map = mutableMapOf<Double, TransformationModel<T>>()
         oldDrawingModel?.getOrNull(index)?.forEach { (x, drawingInfo) ->
           map[x] = TransformationModel(drawingInfo)
         }
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/data/DrawingModel.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/data/DrawingModel.kt
index 975d0bf8f..c878dfaac 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/data/DrawingModel.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/data/DrawingModel.kt
@@ -20,8 +20,8 @@ import com.patrykandpatrick.vico.core.cartesian.layer.CartesianLayer
 
 /** Houses drawing information for a [CartesianLayer]. */
 public abstract class DrawingModel<T : DrawingModel.DrawingInfo>(
-  private val drawingInfo: List<Map<Float, T>>
-) : List<Map<Float, T>> by drawingInfo {
+  private val drawingInfo: List<Map<Double, T>>
+) : List<Map<Double, T>> by drawingInfo {
   /**
    * Returns an intermediate [DrawingModel] between this one and [from]. The returned drawing model
    * includes the provided [DrawingInfo] list. [fraction] is the balance between [from] and this
@@ -30,7 +30,7 @@ public abstract class DrawingModel<T : DrawingModel.DrawingInfo>(
    * belongs.
    */
   public abstract fun transform(
-    drawingInfo: List<Map<Float, T>>,
+    drawingInfo: List<Map<Double, T>>,
     from: DrawingModel<T>?,
     fraction: Float,
   ): DrawingModel<T>
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/data/ExtraStore.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/data/ExtraStore.kt
index 2eccb1dd2..b494e328c 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/data/ExtraStore.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/data/ExtraStore.kt
@@ -89,16 +89,3 @@ public class MutableExtraStore internal constructor(mapDelegate: Map<Key<*>, Any
       }
     )
 }
-
-internal fun <T : Any> MutableExtraStore.getOrSet(key: ExtraStore.Key<T>, block: () -> T): T =
-  getOrNull(key) ?: block().also { this[key] = it }
-
-internal fun <K : Any, V> MutableExtraStore.getOrSetCached(
-  cacheKey: ExtraStore.Key<Pair<K, V>>,
-  valueKey: K,
-  block: () -> V,
-): V {
-  val cache = getOrNull(cacheKey)
-  return if (cache?.first == valueKey) cache.second
-  else block().also { this[cacheKey] = valueKey to it }
-}
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/shader/BaseDynamicShader.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/shader/BaseDynamicShader.kt
index 546074140..961cf88d0 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/shader/BaseDynamicShader.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/shader/BaseDynamicShader.kt
@@ -22,17 +22,16 @@ import android.graphics.Paint
 import android.graphics.RectF
 import com.patrykandpatrick.vico.core.common.DrawContext
 import com.patrykandpatrick.vico.core.common.Point
-import com.patrykandpatrick.vico.core.common.data.ExtraStore
-import com.patrykandpatrick.vico.core.common.data.getOrSet
+import com.patrykandpatrick.vico.core.common.data.CacheStore
 import kotlin.math.roundToInt
 
 /** A base [DynamicShader] implementation. This overrides [getColorAt]. */
 public abstract class BaseDynamicShader : DynamicShader {
-  private val bitmapKey: ExtraStore.Key<Bitmap> = ExtraStore.Key()
+  private val cacheKeyNamespace = CacheStore.KeyNamespace()
 
   override fun getColorAt(point: Point, context: DrawContext, bounds: RectF): Int =
-    context.extraStore
-      .getOrSet(bitmapKey) { toBitmap(context, bounds) }
+    context.cacheStore
+      .getOrSet(cacheKeyNamespace) { toBitmap(context, bounds) }
       .getPixel(
         (point.x - bounds.left).toInt().coerceIn(0, bounds.width().toInt() - 1),
         (point.y - bounds.top).toInt().coerceIn(0, bounds.height().toInt() - 1),
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/shape/CorneredShape.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/shape/CorneredShape.kt
index 754a8de31..09fb2806d 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/shape/CorneredShape.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/shape/CorneredShape.kt
@@ -60,7 +60,7 @@ public open class CorneredShape(
     )
   }
 
-  override fun drawShape(
+  override fun draw(
     context: DrawContext,
     paint: Paint,
     path: Path,
@@ -73,6 +73,22 @@ public open class CorneredShape(
     context.canvas.drawPath(path, paint)
   }
 
+  @Deprecated(
+    "Use `draw`.",
+    replaceWith = ReplaceWith("draw(context, paint, path, left, top, right, bottom)"),
+  )
+  override fun drawShape(
+    context: DrawContext,
+    paint: Paint,
+    path: Path,
+    left: Float,
+    top: Float,
+    right: Float,
+    bottom: Float,
+  ) {
+    draw(context, paint, path, left, top, right, bottom)
+  }
+
   protected open fun createPath(
     context: DrawContext,
     path: Path,
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/shape/DashedShape.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/shape/DashedShape.kt
index aeba88ec5..7cbb6e6ef 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/shape/DashedShape.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/shape/DashedShape.kt
@@ -20,7 +20,7 @@ import android.graphics.Paint
 import android.graphics.Path
 import com.patrykandpatrick.vico.core.common.Defaults
 import com.patrykandpatrick.vico.core.common.DrawContext
-import com.patrykandpatrick.vico.core.common.ceil
+import kotlin.math.ceil
 
 /**
  * [DashedShape] draws a dashed line by interchangeably drawing the provided [shape] and leaving a
@@ -40,7 +40,7 @@ public class DashedShape(
   private var drawDashLength = dashLengthDp
   private var drawGapLength = gapLengthDp
 
-  override fun drawShape(
+  override fun draw(
     context: DrawContext,
     paint: Paint,
     path: Path,
@@ -56,6 +56,22 @@ public class DashedShape(
     }
   }
 
+  @Deprecated(
+    "Use `draw`.",
+    replaceWith = ReplaceWith("draw(context, paint, path, left, top, right, bottom)"),
+  )
+  override fun drawShape(
+    context: DrawContext,
+    paint: Paint,
+    path: Path,
+    left: Float,
+    top: Float,
+    right: Float,
+    bottom: Float,
+  ) {
+    draw(context, paint, path, left, top, right, bottom)
+  }
+
   private fun drawHorizontalDashes(
     context: DrawContext,
     paint: Paint,
@@ -73,7 +89,7 @@ public class DashedShape(
       drawnLength +=
         if (index % 2 == 0) {
           path.reset()
-          shape.drawShape(
+          shape.draw(
             context = context,
             paint = paint,
             path = path,
@@ -107,7 +123,7 @@ public class DashedShape(
       drawnLength +=
         if (index % 2 == 0) {
           path.reset()
-          shape.drawShape(
+          shape.draw(
             context = context,
             paint = paint,
             path = path,
@@ -141,7 +157,7 @@ public class DashedShape(
           }
           else -> {
             val gapAndDashLength = gapLength + dashLength
-            val ratio = length / (dashLength + (length / gapAndDashLength).ceil * gapAndDashLength)
+            val ratio = length / (dashLength + ceil(length / gapAndDashLength) * gapAndDashLength)
             drawDashLength = dashLength * ratio
             drawGapLength = gapLength * ratio
           }
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/shape/MarkerCorneredShape.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/shape/MarkerCorneredShape.kt
index addd109b6..c5a1662d0 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/shape/MarkerCorneredShape.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/shape/MarkerCorneredShape.kt
@@ -41,6 +41,18 @@ public open class MarkerCorneredShape(
   bottomLeft: Corner,
   public val tickSizeDp: Float = MARKER_TICK_SIZE,
 ) : CorneredShape(topLeft, topRight, bottomRight, bottomLeft) {
+  /** The tick’s _x_ coordinate. If this is null, the tick isn’t drawn. */
+  public var tickX: Float? = null
+
+  /** Specifies the tick position. */
+  public var tickPosition: TickPosition = TickPosition.Bottom
+    set(value) {
+      field = value
+      tickPositionSet = true
+    }
+
+  private var tickPositionSet = false
+
   public constructor(
     all: Corner,
     tickSizeDp: Float = MARKER_TICK_SIZE,
@@ -57,7 +69,7 @@ public open class MarkerCorneredShape(
     tickSizeDp = tickSizeDp,
   )
 
-  override fun drawShape(
+  override fun draw(
     context: DrawContext,
     paint: Paint,
     path: Path,
@@ -65,12 +77,16 @@ public open class MarkerCorneredShape(
     top: Float,
     right: Float,
     bottom: Float,
-  ): Unit =
+  ) {
     with(context) {
-      val tickX: Float? = context.extraStore.getOrNull(tickXKey)
+      val tickX = tickX ?: @Suppress("DEPRECATION") context.extraStore.getOrNull(tickXKey)
       if (tickX != null) {
-        val tickPosition: TickPosition =
-          context.extraStore.getOrNull(tickPositionKey) ?: TickPosition.Bottom
+        val tickPosition =
+          if (tickPositionSet) {
+            tickPosition
+          } else {
+            (@Suppress("DEPRECATION") context.extraStore.getOrNull(tickPositionKey)) ?: tickPosition
+          }
         createPath(
           context = context,
           path = path,
@@ -110,9 +126,26 @@ public open class MarkerCorneredShape(
         path.close()
         context.canvas.drawPath(path, paint)
       } else {
-        super.drawShape(context, paint, path, left, top, right, bottom)
+        super.draw(context, paint, path, left, top, right, bottom)
       }
     }
+  }
+
+  @Deprecated(
+    "Use `draw`.",
+    replaceWith = ReplaceWith("draw(context, paint, path, left, top, right, bottom)"),
+  )
+  override fun drawShape(
+    context: DrawContext,
+    paint: Paint,
+    path: Path,
+    left: Float,
+    top: Float,
+    right: Float,
+    bottom: Float,
+  ) {
+    draw(context, paint, path, left, top, right, bottom)
+  }
 
   /** Specifies the position of a [MarkerCorneredShape]’s tick. */
   public enum class TickPosition {
@@ -125,9 +158,11 @@ public open class MarkerCorneredShape(
 
   public companion object {
     /** Used to store and retrieve the _x_ coordinate of a [MarkerCorneredShape]’s tick. */
+    @Deprecated("Use the `tickX` instance property.")
     public val tickXKey: ExtraStore.Key<Float> = ExtraStore.Key()
 
     /** Used to store and retrieve a [MarkerCorneredShape]’s [TickPosition]. */
+    @Deprecated("Use the `tickPosition` instance property.")
     public val tickPositionKey: ExtraStore.Key<TickPosition> = ExtraStore.Key()
   }
 }
diff --git a/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/shape/Shape.kt b/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/shape/Shape.kt
index 3d5b8140d..3478b60f0 100644
--- a/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/shape/Shape.kt
+++ b/vico/core/src/main/java/com/patrykandpatrick/vico/core/common/shape/Shape.kt
@@ -40,6 +40,37 @@ public interface Shape {
    * @param bottom the _y_ coordinate of the bottom edge of the bounds in which the shape should be
    *   drawn.
    */
+  @Suppress("DEPRECATION")
+  public fun draw(
+    context: DrawContext,
+    paint: Paint,
+    path: Path,
+    left: Float,
+    top: Float,
+    right: Float,
+    bottom: Float,
+  ) {
+    drawShape(context, paint, path, left, top, right, bottom)
+  }
+
+  /**
+   * Draws the [Shape] on the canvas.
+   *
+   * @param context holds environment data.
+   * @param paint the [Paint] used to draw the shape.
+   * @param path the [Path] defining the shape.
+   * @param left the _x_ coordinate of the left edge of the bounds in which the shape should be
+   *   drawn.
+   * @param top the _y_ coordinate of the top edge of the bounds in which the shape should be drawn.
+   * @param right the _x_ coordinate of the right edge of the bounds in which the shape should be
+   *   drawn.
+   * @param bottom the _y_ coordinate of the bottom edge of the bounds in which the shape should be
+   *   drawn.
+   */
+  @Deprecated(
+    message = "Use `draw`.",
+    replaceWith = ReplaceWith("draw(context, paint, path, left, top, right, bottom)"),
+  )
   public fun drawShape(
     context: DrawContext,
     paint: Paint,
@@ -54,7 +85,7 @@ public interface Shape {
     /** A rectangle with sharp corners. */
     public val Rectangle: Shape =
       object : Shape {
-        override fun drawShape(
+        override fun draw(
           context: DrawContext,
           paint: Paint,
           path: Path,
@@ -70,6 +101,22 @@ public interface Shape {
           path.close()
           context.canvas.drawPath(path, paint)
         }
+
+        @Deprecated(
+          "Use `draw`.",
+          replaceWith = ReplaceWith("draw(context, paint, path, left, top, right, bottom)"),
+        )
+        override fun drawShape(
+          context: DrawContext,
+          paint: Paint,
+          path: Path,
+          left: Float,
+          top: Float,
+          right: Float,
+          bottom: Float,
+        ) {
+          draw(context, paint, path, left, top, right, bottom)
+        }
       }
 
     /** A shape whose each corner is fully rounded. */
@@ -187,7 +234,7 @@ public interface Shape {
           drawable.intrinsicWidth.coerceAtLeast(1) /
             drawable.intrinsicHeight.coerceAtLeast(1).toFloat()
 
-        override fun drawShape(
+        override fun draw(
           context: DrawContext,
           paint: Paint,
           path: Path,
@@ -233,7 +280,7 @@ public interface Shape {
           otherShape ?: return
 
           if (bottom - otherComponentTop > 0 && right - otherComponentLeft > 0) {
-            otherShape.drawShape(
+            otherShape.draw(
               context = context,
               paint = paint,
               path = path,
@@ -244,6 +291,22 @@ public interface Shape {
             )
           }
         }
+
+        @Deprecated(
+          "Use `draw`.",
+          replaceWith = ReplaceWith("draw(context, paint, path, left, top, right, bottom)"),
+        )
+        override fun drawShape(
+          context: DrawContext,
+          paint: Paint,
+          path: Path,
+          left: Float,
+          top: Float,
+          right: Float,
+          bottom: Float,
+        ) {
+          draw(context, paint, path, left, top, right, bottom)
+        }
       }
   }
 }
diff --git a/vico/core/src/test/java/com/patrykandpatrick/vico/core/data/XSpacingMultiplierTest.kt b/vico/core/src/test/java/com/patrykandpatrick/vico/core/data/XSpacingMultiplierTest.kt
deleted file mode 100644
index 0257eba76..000000000
--- a/vico/core/src/test/java/com/patrykandpatrick/vico/core/data/XSpacingMultiplierTest.kt
+++ /dev/null
@@ -1,82 +0,0 @@
-/*
- * Copyright 2024 by Patryk Goworowski and Patrick Michalik.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.patrykandpatrick.vico.core.data
-
-import com.patrykandpatrick.vico.core.cartesian.data.CartesianChartModel
-import com.patrykandpatrick.vico.core.cartesian.data.ColumnCartesianLayerModel
-import com.patrykandpatrick.vico.core.cartesian.data.MutableChartValues
-import com.patrykandpatrick.vico.core.cartesian.data.getXSpacingMultiplier
-import java.util.stream.Stream
-import org.junit.jupiter.api.assertThrows
-import org.junit.jupiter.params.ParameterizedTest
-import org.junit.jupiter.params.provider.Arguments
-import org.junit.jupiter.params.provider.MethodSource
-
-public class XSpacingMultiplierTest {
-
-  @ParameterizedTest
-  @MethodSource("getXWithValidXStep")
-  public fun `Valid xStep produces the correct xStepMultiplier`(x: List<Number>, xStep: Float) {
-    checkXSpacingMultiplier(x, xStep)
-  }
-
-  @ParameterizedTest()
-  @MethodSource("getXWithInvalidXStep")
-  public fun `Invalid xStep throws an exception on xStepMultiplier calculation`(
-    x: List<Number>,
-    xStep: Float,
-  ) {
-    assertThrows<IllegalStateException> { checkXSpacingMultiplier(x, xStep) }
-  }
-
-  private fun checkXSpacingMultiplier(xCollection: List<Number>, xStep: Float) {
-    val chartValues = MutableChartValues()
-    val columnCartesianModel =
-      ColumnCartesianLayerModel.build { series(xCollection, xCollection.map { 1f }) }
-    val model = CartesianChartModel(columnCartesianModel)
-    chartValues.update(xStep, model)
-
-    chartValues.tryUpdate(
-      columnCartesianModel.minX,
-      columnCartesianModel.maxX,
-      columnCartesianModel.minY,
-      columnCartesianModel.maxY,
-      null,
-    )
-    xCollection.forEach { chartValues.getXSpacingMultiplier(it.toFloat()) }
-  }
-
-  private companion object {
-    @JvmStatic
-    private fun getXWithValidXStep(): Stream<Arguments> =
-      Stream.of(
-        Arguments.of(listOf(1.35, 1.9, 2.59), 0.01f),
-        Arguments.of(listOf(0.1, 0.2), 0.1f),
-        Arguments.of(listOf(0.000001f, 0.000002f), 0.000001f),
-        Arguments.of(listOf(1000f, 0.000002f), 1000f),
-      )
-
-    @JvmStatic
-    private fun getXWithInvalidXStep(): Stream<Arguments> =
-      Stream.of(
-        Arguments.of(listOf(1.35, 1.9, 2.59), 0.1f),
-        Arguments.of(listOf(0.1, 0.2), 1f),
-        Arguments.of(listOf(0.000001f, 0.000002f), 10f),
-        Arguments.of(listOf(1000f, 0.000002f), 10000f),
-      )
-  }
-}
diff --git a/vico/core/src/test/java/com/patrykandpatrick/vico/core/model/XDeltaGcdTest.kt b/vico/core/src/test/java/com/patrykandpatrick/vico/core/model/XDeltaGcdTest.kt
index ce70b09f0..28b545ee3 100644
--- a/vico/core/src/test/java/com/patrykandpatrick/vico/core/model/XDeltaGcdTest.kt
+++ b/vico/core/src/test/java/com/patrykandpatrick/vico/core/model/XDeltaGcdTest.kt
@@ -26,36 +26,36 @@ import org.junit.Test
 public class XDeltaGcdTest {
   private fun getEntries(vararg x: Number) =
     x.map { value ->
-      mockk<CartesianLayerModel.Entry> { every { this@mockk.x } returns value.toFloat() }
+      mockk<CartesianLayerModel.Entry> { every { this@mockk.x } returns value.toDouble() }
     }
 
   @Test
   public fun `Ensure 1 is returned for empty collection`() {
-    assertEquals(1f, getEntries().getXDeltaGcd())
+    assertEquals(1.0, getEntries().getXDeltaGcd())
   }
 
   @Test
   public fun `Ensure 1 is returned for single number`() {
-    assertEquals(1f, getEntries(4).getXDeltaGcd())
+    assertEquals(1.0, getEntries(4).getXDeltaGcd())
   }
 
   @Test
   public fun `Ensure 2 is returned for multiples of 2`() {
-    assertEquals(2f, getEntries(0, 2, 4, 6).getXDeltaGcd())
+    assertEquals(2.0, getEntries(0, 2, 4, 6).getXDeltaGcd())
   }
 
   @Test
   public fun `Ensure 1 is returned for primes`() {
-    assertEquals(1f, getEntries(2, 3, 5, 7).getXDeltaGcd())
+    assertEquals(1.0, getEntries(2, 3, 5, 7).getXDeltaGcd())
   }
 
   @Test
   public fun `Ensure one half is returned for multiples of one half`() {
-    assertEquals(.5f, getEntries(0, .5, 1, 1.5).getXDeltaGcd())
+    assertEquals(0.5, getEntries(0, 0.5, 1, 1.5).getXDeltaGcd())
   }
 
   @Test
   public fun `Ensure 3 is returned for shuffled multiples of 3`() {
-    assertEquals(3f, getEntries(12, 3, 6, 21).getXDeltaGcd())
+    assertEquals(3.0, getEntries(12, 3, 6, 21).getXDeltaGcd())
   }
 }
diff --git a/vico/views/src/main/java/com/patrykandpatrick/vico/views/cartesian/Candle.kt b/vico/views/src/main/java/com/patrykandpatrick/vico/views/cartesian/Candle.kt
index e53635694..f3cc12fde 100644
--- a/vico/views/src/main/java/com/patrykandpatrick/vico/views/cartesian/Candle.kt
+++ b/vico/views/src/main/java/com/patrykandpatrick/vico/views/cartesian/Candle.kt
@@ -38,14 +38,14 @@ internal fun Candle.Companion.sharpFilledCandle(
 internal fun Candle.Companion.sharpHollowCandle(
   color: Int,
   thicknessDp: Float = Defaults.CANDLE_BODY_WIDTH_DP,
-  strokeWidthDp: Float = Defaults.HOLLOW_CANDLE_STROKE_WIDTH_DP,
+  strokeThicknessDp: Float = Defaults.HOLLOW_CANDLE_STROKE_THICKNESS_DP,
 ): Candle {
   val hollowBody =
     LineComponent(
       color = Color.TRANSPARENT,
       thicknessDp = thicknessDp,
-      strokeWidthDp = strokeWidthDp,
       strokeColor = color,
+      strokeThicknessDp = strokeThicknessDp,
     )
 
   return Candle(body = hollowBody)
diff --git a/vico/views/src/main/java/com/patrykandpatrick/vico/views/cartesian/CartesianChartView.kt b/vico/views/src/main/java/com/patrykandpatrick/vico/views/cartesian/CartesianChartView.kt
index 7e4cfb854..03225fefe 100644
--- a/vico/views/src/main/java/com/patrykandpatrick/vico/views/cartesian/CartesianChartView.kt
+++ b/vico/views/src/main/java/com/patrykandpatrick/vico/views/cartesian/CartesianChartView.kt
@@ -23,7 +23,6 @@ import android.view.MotionEvent
 import android.view.ScaleGestureDetector
 import android.view.View
 import android.widget.OverScroller
-import androidx.core.view.ViewCompat
 import com.patrykandpatrick.vico.core.cartesian.CartesianChart
 import com.patrykandpatrick.vico.core.cartesian.CartesianDrawContext
 import com.patrykandpatrick.vico.core.cartesian.HorizontalLayout
@@ -36,9 +35,6 @@ import com.patrykandpatrick.vico.core.cartesian.data.ChartValues
 import com.patrykandpatrick.vico.core.cartesian.data.MutableChartValues
 import com.patrykandpatrick.vico.core.cartesian.data.RandomCartesianModelGenerator
 import com.patrykandpatrick.vico.core.cartesian.data.toImmutable
-import com.patrykandpatrick.vico.core.cartesian.drawMarker
-import com.patrykandpatrick.vico.core.cartesian.marker.CartesianMarker
-import com.patrykandpatrick.vico.core.cartesian.marker.CartesianMarkerVisibilityListener
 import com.patrykandpatrick.vico.core.common.Defaults
 import com.patrykandpatrick.vico.core.common.NEW_PRODUCER_ERROR_MESSAGE
 import com.patrykandpatrick.vico.core.common.Point
@@ -63,35 +59,35 @@ public open class CartesianChartView
 @JvmOverloads
 constructor(context: Context, attrs: AttributeSet? = null, defStyleAttr: Int = 0) :
   BaseChartView<CartesianChartModel>(context, attrs, defStyleAttr) {
+  private val themeHandler: ThemeHandler = ThemeHandler(context, attrs)
+
   private val scroller = OverScroller(context)
 
   private val mutableChartValues = MutableChartValues()
 
   override val measureContext: MutableCartesianMeasureContext =
     MutableCartesianMeasureContext(
-      canvasBounds = contentBounds,
+      canvasBounds = canvasBounds,
       density = context.density,
       isLtr = context.isLtr,
       scrollEnabled = false,
-      spToPx = context::spToPx,
+      zoomEnabled = false,
+      horizontalLayout = themeHandler.chart?.horizontalLayout ?: HorizontalLayout.Segmented,
       chartValues = ChartValues.Empty,
+      spToPx = context::spToPx,
     )
 
   private val scaleGestureListener: ScaleGestureDetector.OnScaleGestureListener =
-    ChartScaleGestureListener(getChartBounds = { chart?.bounds }, onZoom = ::handleZoom)
+    ChartScaleGestureListener(getLayerBounds = { chart?.layerBounds }, onZoom = ::handleZoom)
 
   private val scaleGestureDetector = ScaleGestureDetector(context, scaleGestureListener)
 
   private var markerTouchPoint: Point? = null
 
-  private var previousMarkerTargetHashCode: Int? = null
-
   private var scrollDirectionResolved = false
 
   private var horizontalDimensions = MutableHorizontalDimensions()
 
-  private val themeHandler: ThemeHandler = ThemeHandler(context, attrs)
-
   /**
    * Houses information on the [CartesianChart]’s scroll value. Allows for scroll customization and
    * programmatic scrolling.
@@ -102,13 +98,16 @@ constructor(context: Context, attrs: AttributeSet? = null, defStyleAttr: Int = 0
       newValue.postInvalidate = ::postInvalidate
       newValue.postInvalidateOnAnimation = ::postInvalidateOnAnimation
       measureContext.scrollEnabled = newValue.scrollEnabled
+      measureContext.zoomEnabled = measureContext.zoomEnabled && newValue.scrollEnabled
     }
 
   /** Houses information on the [CartesianChart]’s zoom factor. Allows for zoom customization. */
   public var zoomHandler: ZoomHandler by
     invalidatingObservable(
       ZoomHandler.default(themeHandler.isChartZoomEnabled, scrollHandler.scrollEnabled)
-    )
+    ) { _, newValue ->
+      measureContext.zoomEnabled = newValue.zoomEnabled && measureContext.scrollEnabled
+    }
 
   private val motionEventHandler =
     MotionEventHandler(
@@ -118,22 +117,11 @@ constructor(context: Context, attrs: AttributeSet? = null, defStyleAttr: Int = 0
       requestInvalidate = ::invalidate,
     )
 
-  /** Defines how the chart’s content is positioned horizontally. */
-  public var horizontalLayout: HorizontalLayout by
-    invalidatingObservable(themeHandler.horizontalLayout) { _, newValue ->
-      measureContext.horizontalLayout = newValue
-    }
-
-  /**
-   * Overrides the _x_ step (the difference between the _x_ values of neighboring major entries). If
-   * this is null, the output of [CartesianChartModel.getXDeltaGcd] is used.
-   */
-  public var getXStep: ((CartesianChartModel) -> Float)? by invalidatingObservable(null)
-
   /** The [CartesianChart] displayed by this [View]. */
   public var chart: CartesianChart? by
-    observable(themeHandler.chart) { _, _, _ ->
-      tryInvalidate(chart = chart, model = model, updateChartValues = true)
+    observable(themeHandler.chart) { _, _, newValue ->
+      if (newValue != null) measureContext.horizontalLayout = newValue.horizontalLayout
+      tryInvalidate(chart = newValue, model = model, updateChartValues = true)
     }
 
   /** Creates and updates the [CartesianChartModel]. */
@@ -146,7 +134,7 @@ constructor(context: Context, attrs: AttributeSet? = null, defStyleAttr: Int = 0
     }
 
   private fun registerForUpdates() {
-    coroutineScope?.launch(dispatcher) {
+    coroutineScope?.launch {
       modelProducer?.registerForUpdates(
         key = this@CartesianChartView,
         cancelAnimation = {
@@ -165,7 +153,7 @@ constructor(context: Context, attrs: AttributeSet? = null, defStyleAttr: Int = 0
         updateChartValues = { model ->
           mutableChartValues.reset()
           if (model != null) {
-            chart?.updateChartValues(mutableChartValues, model, getXStep?.invoke(model))
+            chart?.updateChartValues(mutableChartValues, model)
             mutableChartValues.toImmutable()
           } else {
             ChartValues.Empty
@@ -192,12 +180,6 @@ constructor(context: Context, attrs: AttributeSet? = null, defStyleAttr: Int = 0
     scrollHandler.clearUpdated()
   }
 
-  /** The [CartesianMarker] for this chart. */
-  public var marker: CartesianMarker? = null
-
-  /** Allows for listening to [marker] visibility changes. */
-  public var markerVisibilityListener: CartesianMarkerVisibilityListener? = null
-
   init {
     if (isInEditMode && attrs != null) {
       context.obtainStyledAttributes(attrs, R.styleable.CartesianChartView, defStyleAttr, 0).use {
@@ -213,15 +195,17 @@ constructor(context: Context, attrs: AttributeSet? = null, defStyleAttr: Int = 0
             RandomCartesianModelGenerator.defaultX.last,
           )
         val minY =
-          typedArray.getFloat(
-            R.styleable.CartesianChartView_previewMinY,
-            RandomCartesianModelGenerator.defaultY.start,
-          )
+          if (typedArray.hasValue(R.styleable.CartesianChartView_previewMinY)) {
+            typedArray.getFloat(R.styleable.CartesianChartView_previewMinY, 0f).toDouble()
+          } else {
+            RandomCartesianModelGenerator.defaultY.start
+          }
         val maxY =
-          typedArray.getFloat(
-            R.styleable.CartesianChartView_previewMaxY,
-            RandomCartesianModelGenerator.defaultY.endInclusive,
-          )
+          if (typedArray.hasValue(R.styleable.CartesianChartView_previewMaxY)) {
+            typedArray.getFloat(R.styleable.CartesianChartView_previewMaxY, 0f).toDouble()
+          } else {
+            RandomCartesianModelGenerator.defaultY.endInclusive
+          }
         setModel(
           RandomCartesianModelGenerator.getRandomModel(
             typedArray.getInt(R.styleable.CartesianChartView_previewColumnSeriesCount, 1),
@@ -259,7 +243,7 @@ constructor(context: Context, attrs: AttributeSet? = null, defStyleAttr: Int = 0
     if (chart == null || model == null) return
     if (updateChartValues) {
       mutableChartValues.reset()
-      chart.updateChartValues(mutableChartValues, model, getXStep?.invoke(model))
+      chart.updateChartValues(mutableChartValues, model)
       measureContext.chartValues = mutableChartValues.toImmutable()
     }
     if (isAttachedToWindowCompat) invalidate()
@@ -303,7 +287,9 @@ constructor(context: Context, attrs: AttributeSet? = null, defStyleAttr: Int = 0
 
   private fun handleZoom(focusX: Float, zoomChange: Float) {
     val chart = chart ?: return
-    scrollHandler.scroll(zoomHandler.zoom(zoomChange, focusX, scrollHandler.value, chart.bounds))
+    scrollHandler.scroll(
+      zoomHandler.zoom(zoomChange, focusX, scrollHandler.value, chart.layerBounds)
+    )
     handleTouchEvent(null)
     invalidate()
   }
@@ -318,43 +304,31 @@ constructor(context: Context, attrs: AttributeSet? = null, defStyleAttr: Int = 0
     withChartAndModel { chart, model ->
       measureContext.reset()
       horizontalDimensions.clear()
-      chart.prepare(measureContext, model, horizontalDimensions, contentBounds, marker)
+      chart.prepare(measureContext, model, horizontalDimensions, canvasBounds)
 
-      if (chart.bounds.isEmpty) return@withChartAndModel
+      if (chart.layerBounds.isEmpty) return@withChartAndModel
 
       motionEventHandler.scrollEnabled = scrollHandler.scrollEnabled
       if (scroller.computeScrollOffset()) {
         scrollHandler.scroll(Scroll.Absolute.pixels(scroller.currX.toFloat()))
-        ViewCompat.postInvalidateOnAnimation(this)
+        postInvalidateOnAnimation()
       }
 
-      zoomHandler.update(measureContext, horizontalDimensions, chart.bounds)
-      scrollHandler.update(measureContext, chart.bounds, horizontalDimensions)
+      zoomHandler.update(measureContext, horizontalDimensions, chart.layerBounds)
+      scrollHandler.update(measureContext, chart.layerBounds, horizontalDimensions)
 
       val cartesianDrawContext =
         CartesianDrawContext(
           canvas = canvas,
-          elevationOverlayColor = elevationOverlayColor,
           measureContext = measureContext,
           markerTouchPoint = markerTouchPoint,
           horizontalDimensions = horizontalDimensions,
-          chartBounds = chart.bounds,
-          horizontalScroll = scrollHandler.value,
+          layerBounds = chart.layerBounds,
+          scroll = scrollHandler.value,
           zoom = zoomHandler.value,
         )
 
-      chart.draw(cartesianDrawContext, model)
-
-      marker?.also { marker ->
-        previousMarkerTargetHashCode =
-          cartesianDrawContext.drawMarker(
-            marker,
-            markerTouchPoint,
-            chart,
-            markerVisibilityListener,
-            previousMarkerTargetHashCode,
-          )
-      }
+      chart.draw(cartesianDrawContext, model, markerTouchPoint)
       measureContext.reset()
     }
   }
diff --git a/vico/views/src/main/java/com/patrykandpatrick/vico/views/cartesian/ScrollHandler.kt b/vico/views/src/main/java/com/patrykandpatrick/vico/views/cartesian/ScrollHandler.kt
index b07749a06..4792b0648 100644
--- a/vico/views/src/main/java/com/patrykandpatrick/vico/views/cartesian/ScrollHandler.kt
+++ b/vico/views/src/main/java/com/patrykandpatrick/vico/views/cartesian/ScrollHandler.kt
@@ -36,7 +36,7 @@ import com.patrykandpatrick.vico.core.common.rangeWith
  * Houses information on a [CartesianChart]’s scroll value. Allows for scroll customization and
  * programmatic scrolling.
  *
- * @property scrollEnabled whether scrolling is enabled.
+ * @property scrollEnabled whether scroll is enabled.
  * @property initialScroll represents the initial scroll value.
  * @property autoScroll represents the scroll value or delta for automatic scrolling.
  * @property autoScrollCondition defines when an automatic scroll should be performed.
diff --git a/vico/views/src/main/java/com/patrykandpatrick/vico/views/cartesian/ZoomHandler.kt b/vico/views/src/main/java/com/patrykandpatrick/vico/views/cartesian/ZoomHandler.kt
index 1b1607807..7c3ef7c35 100644
--- a/vico/views/src/main/java/com/patrykandpatrick/vico/views/cartesian/ZoomHandler.kt
+++ b/vico/views/src/main/java/com/patrykandpatrick/vico/views/cartesian/ZoomHandler.kt
@@ -29,7 +29,7 @@ import com.patrykandpatrick.vico.core.common.Defaults
 /**
  * Houses information on a [CartesianChart]’s zoom factor. Allows for zoom customization.
  *
- * @param zoomEnabled whether zooming is enabled.
+ * @param zoomEnabled whether zoom is enabled.
  * @param initialZoom represents the initial zoom factor.
  * @param minZoom represents the minimum zoom factor.
  * @param maxZoom represents the maximum zoom factor.
diff --git a/vico/views/src/main/java/com/patrykandpatrick/vico/views/common/BaseChartView.kt b/vico/views/src/main/java/com/patrykandpatrick/vico/views/common/BaseChartView.kt
index f5f513dbf..a8b4ce764 100644
--- a/vico/views/src/main/java/com/patrykandpatrick/vico/views/common/BaseChartView.kt
+++ b/vico/views/src/main/java/com/patrykandpatrick/vico/views/common/BaseChartView.kt
@@ -26,21 +26,18 @@ import android.view.View
 import android.view.ViewGroup
 import android.view.animation.Interpolator
 import android.widget.FrameLayout
-import androidx.core.view.ViewCompat
 import androidx.core.view.isVisible
 import androidx.interpolator.view.animation.FastOutSlowInInterpolator
 import com.patrykandpatrick.vico.core.cartesian.CartesianChart
 import com.patrykandpatrick.vico.core.common.Animation
 import com.patrykandpatrick.vico.core.common.MutableMeasureContext
-import com.patrykandpatrick.vico.core.common.component.ShapeComponent
 import com.patrykandpatrick.vico.core.common.data.MutableExtraStore
 import com.patrykandpatrick.vico.core.common.set
 import com.patrykandpatrick.vico.core.common.spToPx
-import kotlinx.coroutines.CoroutineDispatcher
+import kotlin.coroutines.EmptyCoroutineContext
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
-import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.cancel
 import kotlinx.coroutines.cancelAndJoin
 import kotlinx.coroutines.launch
@@ -50,11 +47,11 @@ public abstract class BaseChartView<Model>
 @JvmOverloads
 constructor(context: Context, attrs: AttributeSet? = null, defStyleAttr: Int = 0) :
   FrameLayout(context, attrs, defStyleAttr) {
-  protected val contentBounds: RectF = RectF()
+  protected val canvasBounds: RectF = RectF()
 
   protected open val measureContext: MutableMeasureContext =
     MutableMeasureContext(
-      canvasBounds = contentBounds,
+      canvasBounds = canvasBounds,
       density = context.density,
       isLtr = context.isLtr,
       spToPx = context::spToPx,
@@ -90,12 +87,9 @@ constructor(context: Context, attrs: AttributeSet? = null, defStyleAttr: Int = 0
    */
   public var runInitialAnimation: Boolean = true
 
-  /** Used for handling [model] updates. */
-  public var dispatcher: CoroutineDispatcher = Dispatchers.Default
-
   override fun onAttachedToWindow() {
     super.onAttachedToWindow()
-    coroutineScope = CoroutineScope(Dispatchers.Main.immediate + SupervisorJob())
+    coroutineScope = CoroutineScope(EmptyCoroutineContext)
   }
 
   override fun onDetachedFromWindow() {
@@ -106,9 +100,6 @@ constructor(context: Context, attrs: AttributeSet? = null, defStyleAttr: Int = 0
     isAnimationRunning = false
   }
 
-  /** The color of elevation overlays, which are applied to [ShapeComponent]s that cast shadows. */
-  public var elevationOverlayColor: Int = context.defaultColors.elevationOverlayColor.toInt()
-
   override fun addView(child: View, index: Int, params: ViewGroup.LayoutParams?) {
     check(childCount == 0) { "Only one placeholder can be added." }
     super.addView(child, index, params)
@@ -151,7 +142,7 @@ constructor(context: Context, attrs: AttributeSet? = null, defStyleAttr: Int = 0
       MeasureSpec.makeMeasureSpec(width, MeasureSpec.EXACTLY),
       MeasureSpec.makeMeasureSpec(height, MeasureSpec.EXACTLY),
     )
-    contentBounds.set(
+    canvasBounds.set(
       left = paddingLeft,
       top = paddingTop,
       right = width - paddingRight,
@@ -169,14 +160,14 @@ constructor(context: Context, attrs: AttributeSet? = null, defStyleAttr: Int = 0
             !isAnimationFrameGenerationRunning -> {
               isAnimationFrameGenerationRunning = true
               animationFrameJob =
-                coroutineScope?.launch(dispatcher) {
+                coroutineScope?.launch {
                   transformModel(this@BaseChartView, fraction)
                   isAnimationFrameGenerationRunning = false
                 }
             }
             fraction == 1f -> {
               finalAnimationFrameJob =
-                coroutineScope?.launch(dispatcher) {
+                coroutineScope?.launch(Dispatchers.Default) {
                   animationFrameJob?.cancelAndJoin()
                   transformModel(this@BaseChartView, fraction)
                   isAnimationFrameGenerationRunning = false
@@ -187,21 +178,19 @@ constructor(context: Context, attrs: AttributeSet? = null, defStyleAttr: Int = 0
       }
     } else {
       finalAnimationFrameJob =
-        coroutineScope?.launch(dispatcher) {
-          transformModel(this@BaseChartView, Animation.range.endInclusive)
-        }
+        coroutineScope?.launch { transformModel(this@BaseChartView, Animation.range.endInclusive) }
     }
   }
 
   protected abstract fun getChartDesiredHeight(widthMeasureSpec: Int, heightMeasureSpec: Int): Int
 
   /** Sets the duration (in milliseconds) of difference animations. */
-  public fun setDiffAnimationDuration(durationMillis: Long) {
+  public fun setAnimationDuration(durationMillis: Long) {
     animator.duration = durationMillis
   }
 
   /** Sets the [Interpolator] for difference animations. */
-  public fun setDiffAnimationInterpolator(interpolator: Interpolator) {
+  public fun setAnimationInterpolator(interpolator: Interpolator) {
     animator.interpolator = interpolator
   }
 
@@ -212,7 +201,7 @@ constructor(context: Context, attrs: AttributeSet? = null, defStyleAttr: Int = 0
     // In this case, we can ignore this callback, as the layout direction will be determined when
     // the
     // MeasureContext instance is created.
-    measureContext?.isLtr = layoutDirection == ViewCompat.LAYOUT_DIRECTION_LTR
+    measureContext?.isLtr = layoutDirection == View.LAYOUT_DIRECTION_LTR
   }
 }
 
diff --git a/vico/views/src/main/java/com/patrykandpatrick/vico/views/common/Context.kt b/vico/views/src/main/java/com/patrykandpatrick/vico/views/common/Context.kt
index 02b1645f2..4fff1440c 100644
--- a/vico/views/src/main/java/com/patrykandpatrick/vico/views/common/Context.kt
+++ b/vico/views/src/main/java/com/patrykandpatrick/vico/views/common/Context.kt
@@ -18,20 +18,14 @@ package com.patrykandpatrick.vico.views.common
 
 import android.content.Context
 import android.content.res.Configuration
-import android.os.Build
-import androidx.core.view.ViewCompat
+import android.view.View.LAYOUT_DIRECTION_LTR
 import com.patrykandpatrick.vico.core.common.DefaultColors
 
 internal val Context.density: Float
   get() = resources.displayMetrics.density
 
 internal val Context.isLtr: Boolean
-  get() =
-    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
-      resources.configuration.layoutDirection == ViewCompat.LAYOUT_DIRECTION_LTR
-    } else {
-      true
-    }
+  get() = resources.configuration.layoutDirection == LAYOUT_DIRECTION_LTR
 
 internal val Context.isDarkMode: Boolean
   get() =
diff --git a/vico/views/src/main/java/com/patrykandpatrick/vico/views/common/gesture/ChartScaleGestureListener.kt b/vico/views/src/main/java/com/patrykandpatrick/vico/views/common/gesture/ChartScaleGestureListener.kt
index d4e5e5e39..1db6ca8bf 100644
--- a/vico/views/src/main/java/com/patrykandpatrick/vico/views/common/gesture/ChartScaleGestureListener.kt
+++ b/vico/views/src/main/java/com/patrykandpatrick/vico/views/common/gesture/ChartScaleGestureListener.kt
@@ -20,7 +20,7 @@ import android.graphics.RectF
 import android.view.ScaleGestureDetector
 
 internal class ChartScaleGestureListener(
-  private val getChartBounds: () -> RectF?,
+  private val getLayerBounds: () -> RectF?,
   private val onZoom: (focusX: Float, zoomChange: Float) -> Unit,
 ) : ScaleGestureDetector.OnScaleGestureListener {
   override fun onScale(detector: ScaleGestureDetector): Boolean {
@@ -29,7 +29,7 @@ internal class ChartScaleGestureListener(
   }
 
   override fun onScaleBegin(detector: ScaleGestureDetector): Boolean =
-    getChartBounds()?.contains(detector.focusX, detector.focusY) == true
+    getLayerBounds()?.contains(detector.focusX, detector.focusY) == true
 
   override fun onScaleEnd(detector: ScaleGestureDetector) = Unit
 }
diff --git a/vico/views/src/main/java/com/patrykandpatrick/vico/views/common/shape/ShapeDrawable.kt b/vico/views/src/main/java/com/patrykandpatrick/vico/views/common/shape/ShapeDrawable.kt
index 93a6f97e9..4d4b71dc6 100644
--- a/vico/views/src/main/java/com/patrykandpatrick/vico/views/common/shape/ShapeDrawable.kt
+++ b/vico/views/src/main/java/com/patrykandpatrick/vico/views/common/shape/ShapeDrawable.kt
@@ -32,109 +32,80 @@ import com.patrykandpatrick.vico.core.common.shape.Shape
 import com.patrykandpatrick.vico.views.common.density
 import com.patrykandpatrick.vico.views.common.isLtr
 
-/**
- * Creates a [Drawable] out of the provided [shape].
- *
- * @param shape the [Shape] used as a [Drawable].
- * @param isLtr whether the device layout is left-to-right.
- * @param density the pixel density of the device screen.
- * @param width the width of the [Drawable].
- * @param height the height of the [Drawable].
- */
-public class ShapeDrawable(
-  private val shape: Shape,
-  private val isLtr: Boolean,
-  private val density: Float,
-  private val width: Int = 0,
-  private val height: Int = 0,
-) : Drawable() {
-  public constructor(
-    context: Context,
-    shape: Shape,
-    width: Int = 0,
-    height: Int = 0,
-  ) : this(
-    shape = shape,
-    density = context.density,
-    isLtr = context.isLtr,
-    width = width,
-    height = height,
-  )
-
-  private val path: Path = Path()
-
-  private var tintList: ColorStateList? = null
-
-  /** The [Paint] used to draw the shape. */
-  public val paint: Paint = Paint(Paint.ANTI_ALIAS_FLAG).apply { color = DEF_COLOR }
-
-  init {
-    setBounds(0, 0, width, height)
-  }
+private const val DEFAULT_COLOR = Color.BLACK
 
-  override fun draw(canvas: Canvas) {
-    shape.drawShape(
-      drawContext(canvas = canvas, density = density, isLtr = isLtr()),
-      paint = paint,
-      path = path,
-      left = bounds.left.toFloat(),
-      top = bounds.top.toFloat(),
-      right = bounds.right.toFloat(),
-      bottom = bounds.bottom.toFloat(),
-    )
-    path.reset()
-  }
-
-  private fun isLtr(): Boolean =
-    if (Build.VERSION.SDK_INT == Build.VERSION_CODES.M) {
-      layoutDirection == LayoutDirection.LTR
-    } else {
-      isLtr
+/** Converts this [Shape] to a [Drawable]. */
+public fun Shape.toDrawable(
+  context: Context,
+  intrinsicWidth: Int = -1,
+  intrinsicHeight: Int = -1,
+): Drawable {
+  val density = context.density
+  val isLtr = context.isLtr
+  return object : Drawable() {
+    val paint = Paint(Paint.ANTI_ALIAS_FLAG).apply { color = DEFAULT_COLOR }
+    val path = Path()
+
+    var tintList: ColorStateList? = null
+      @JvmName("setShapeDrawableTintList")
+      set(value) {
+        field = value
+        applyTint()
+      }
+
+    init {
+      setBounds(0, 0, intrinsicWidth, intrinsicHeight)
     }
 
-  override fun setAlpha(alpha: Int) {
-    paint.alpha = alpha
-  }
+    fun applyTint() {
+      paint.color = tintList?.getColorForState(state, DEFAULT_COLOR) ?: DEFAULT_COLOR
+    }
 
-  override fun setColorFilter(colorFilter: ColorFilter?) {
-    paint.colorFilter = colorFilter
-  }
+    override fun draw(canvas: Canvas) {
+      draw(
+        drawContext(
+          canvas = canvas,
+          density = density,
+          isLtr =
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+              layoutDirection == LayoutDirection.LTR
+            } else {
+              isLtr
+            },
+        ),
+        paint,
+        path,
+        bounds.left.toFloat(),
+        bounds.top.toFloat(),
+        bounds.right.toFloat(),
+        bounds.bottom.toFloat(),
+      )
+      path.rewind()
+    }
 
-  override fun setTintList(tint: ColorStateList?) {
-    tintList = tint
-    updateColor()
-  }
+    override fun setAlpha(alpha: Int) {
+      paint.alpha = alpha
+    }
 
-  override fun setState(stateSet: IntArray): Boolean {
-    val result = super.setState(stateSet)
-    updateColor()
-    return result
-  }
+    override fun setColorFilter(colorFilter: ColorFilter?) {
+      paint.colorFilter = colorFilter
+    }
 
-  private fun updateColor() {
-    paint.color = tintList?.getColorForState(state, DEF_COLOR) ?: DEF_COLOR
-  }
+    override fun setTintList(tint: ColorStateList?) {
+      tintList = tint
+    }
 
-  @Deprecated("`Drawable#getOpacity` is deprecated.")
-  override fun getOpacity(): Int = PixelFormat.TRANSLUCENT
+    override fun setState(stateSet: IntArray): Boolean {
+      val result = super.setState(stateSet)
+      applyTint()
+      return result
+    }
 
-  override fun getIntrinsicWidth(): Int = width
+    @Deprecated("`Drawable#getOpacity` is deprecated.")
+    override fun getOpacity() = PixelFormat.TRANSLUCENT
 
-  override fun getIntrinsicHeight(): Int = height
+    override fun getIntrinsicWidth() = intrinsicWidth
 
-  private companion object {
-    const val DEF_COLOR = Color.BLACK
+    override fun getIntrinsicHeight() = intrinsicHeight
   }
 }
-
-/**
- * Converts this [Shape] to a [Drawable].
- *
- * @param intrinsicWidth the width of the [Drawable].
- * @param intrinsicHeight the height of the [Drawable].
- */
-public fun Shape.toDrawable(
-  context: Context,
-  intrinsicWidth: Int = 0,
-  intrinsicHeight: Int = 0,
-): Drawable = ShapeDrawable(context, this, intrinsicWidth, intrinsicHeight)
diff --git a/vico/views/src/main/java/com/patrykandpatrick/vico/views/common/theme/ChartStyle.kt b/vico/views/src/main/java/com/patrykandpatrick/vico/views/common/theme/ChartStyle.kt
index 3324af53b..d828067a4 100644
--- a/vico/views/src/main/java/com/patrykandpatrick/vico/views/common/theme/ChartStyle.kt
+++ b/vico/views/src/main/java/com/patrykandpatrick/vico/views/common/theme/ChartStyle.kt
@@ -43,15 +43,25 @@ internal fun TypedArray.getColumnCartesianLayer(
   getNestedTypedArray(context, resourceId, styleableResourceId).run {
     val defaultShape = Shape.rounded(allPercent = Defaults.COLUMN_ROUNDNESS_PERCENT)
     val mergeMode =
-      getInteger(R.styleable.ColumnCartesianLayerStyle_mergeMode, 0)
-        .let(ColumnCartesianLayer.MergeMode.entries::get)
+      when (getInteger(R.styleable.ColumnCartesianLayerStyle_mergeMode, 0)) {
+        0 ->
+          ColumnCartesianLayer.MergeMode.Grouped(
+            getRawDimension(
+              context,
+              R.styleable.ColumnCartesianLayerStyle_groupedColumnSpacing,
+              Defaults.GROUPED_COLUMN_SPACING,
+            )
+          )
+        1 -> ColumnCartesianLayer.MergeMode.Stacked
+        else -> throw IllegalArgumentException("Unexpected `mergeMode` value.")
+      }
     ColumnCartesianLayer(
       columnProvider =
         ColumnCartesianLayer.ColumnProvider.series(
           getNestedTypedArray(
               context = context,
-              resourceId = R.styleable.ColumnCartesianLayerStyle_column1,
-              styleableResourceId = R.styleable.LineComponent,
+              resourceId = R.styleable.ColumnCartesianLayerStyle_column1Style,
+              styleableResourceId = R.styleable.LineComponentStyle,
             )
             .getLineComponent(
               context = context,
@@ -61,8 +71,8 @@ internal fun TypedArray.getColumnCartesianLayer(
             ),
           getNestedTypedArray(
               context = context,
-              resourceId = R.styleable.ColumnCartesianLayerStyle_column2,
-              styleableResourceId = R.styleable.LineComponent,
+              resourceId = R.styleable.ColumnCartesianLayerStyle_column2Style,
+              styleableResourceId = R.styleable.LineComponentStyle,
             )
             .getLineComponent(
               context = context,
@@ -72,8 +82,8 @@ internal fun TypedArray.getColumnCartesianLayer(
             ),
           getNestedTypedArray(
               context = context,
-              resourceId = R.styleable.ColumnCartesianLayerStyle_column3,
-              styleableResourceId = R.styleable.LineComponent,
+              resourceId = R.styleable.ColumnCartesianLayerStyle_column3Style,
+              styleableResourceId = R.styleable.LineComponentStyle,
             )
             .getLineComponent(
               context = context,
@@ -82,17 +92,11 @@ internal fun TypedArray.getColumnCartesianLayer(
               defaultShape = defaultShape,
             ),
         ),
-      spacingDp =
+      columnCollectionSpacingDp =
         getRawDimension(
           context = context,
-          index = R.styleable.ColumnCartesianLayerStyle_columnOuterSpacing,
-          defaultValue = Defaults.COLUMN_OUTSIDE_SPACING,
-        ),
-      innerSpacingDp =
-        getRawDimension(
-          context = context,
-          index = R.styleable.ColumnCartesianLayerStyle_columnInnerSpacing,
-          defaultValue = Defaults.COLUMN_INSIDE_SPACING,
+          index = R.styleable.ColumnCartesianLayerStyle_columnCollectionSpacing,
+          defaultValue = Defaults.COLUMN_COLLECTION_SPACING,
         ),
       mergeMode = { mergeMode },
       dataLabel =
@@ -107,11 +111,8 @@ internal fun TypedArray.getColumnCartesianLayer(
           null
         },
       dataLabelVerticalPosition =
-        getInteger(R.styleable.ColumnCartesianLayerStyle_dataLabelVerticalPosition, 0).let { value
-          ->
-          val values = VerticalPosition.entries
-          values[value % values.size]
-        },
+        VerticalPosition.entries[
+            getInteger(R.styleable.ColumnCartesianLayerStyle_dataLabelVerticalPosition, 0)],
       dataLabelRotationDegrees =
         getFloat(R.styleable.ColumnCartesianLayerStyle_dataLabelRotationDegrees, 0f),
     )
@@ -124,40 +125,40 @@ internal fun TypedArray.getLineCartesianLayer(
 ): LineCartesianLayer =
   getNestedTypedArray(context, resourceId, styleableResourceId).run {
     LineCartesianLayer(
-      lines =
-        listOf(
+      lineProvider =
+        LineCartesianLayer.LineProvider.series(
           getNestedTypedArray(
               context = context,
-              resourceId = R.styleable.LineCartesianLayerStyle_line1Spec,
-              styleableResourceId = R.styleable.LineSpec,
+              resourceId = R.styleable.LineCartesianLayerStyle_line1Style,
+              styleableResourceId = R.styleable.LineStyle,
             )
-            .getLineSpec(
+            .getLine(
               context = context,
               defaultColor = context.defaultColors.cartesianLayerColors[0].toInt(),
             ),
           getNestedTypedArray(
               context = context,
-              resourceId = R.styleable.LineCartesianLayerStyle_line2Spec,
-              styleableResourceId = R.styleable.LineSpec,
+              resourceId = R.styleable.LineCartesianLayerStyle_line2Style,
+              styleableResourceId = R.styleable.LineStyle,
             )
-            .getLineSpec(
+            .getLine(
               context = context,
               defaultColor = context.defaultColors.cartesianLayerColors.getRepeating(1).toInt(),
             ),
           getNestedTypedArray(
               context = context,
-              resourceId = R.styleable.LineCartesianLayerStyle_line3Spec,
-              styleableResourceId = R.styleable.LineSpec,
+              resourceId = R.styleable.LineCartesianLayerStyle_line3Style,
+              styleableResourceId = R.styleable.LineStyle,
             )
-            .getLineSpec(
+            .getLine(
               context = context,
               defaultColor = context.defaultColors.cartesianLayerColors.getRepeating(2).toInt(),
             ),
         ),
-      spacingDp =
+      pointSpacingDp =
         getRawDimension(
           context = context,
-          index = R.styleable.LineCartesianLayerStyle_spacing,
+          index = R.styleable.LineCartesianLayerStyle_pointSpacing,
           defaultValue = Defaults.POINT_SPACING,
         ),
     )
@@ -170,45 +171,55 @@ internal fun TypedArray.getCandlestickCartesianLayer(context: Context): Candlest
   return getNestedTypedArray(
       context,
       R.styleable.CartesianChartView_candlestickLayerStyle,
-      R.styleable.CandlestickLayerStyle,
+      R.styleable.CandlestickCartesianLayerStyle,
     )
     .use { typedArray ->
       val candleProvider =
-        when (typedArray.getInteger(R.styleable.CandlestickLayerStyle_candleStyle, 0)) {
+        when (typedArray.getInteger(R.styleable.CandlestickCartesianLayerStyle_candleStyle, 0)) {
           0 -> {
             val bullish =
-              typedArray.getCandle(context, R.styleable.CandlestickLayerStyle_bullishCandleStyle)
-                ?: CandlestickCartesianLayer.Candle.sharpFilledCandle(bullishColor)
+              typedArray.getCandle(
+                context,
+                R.styleable.CandlestickCartesianLayerStyle_bullishCandleStyle,
+              ) ?: CandlestickCartesianLayer.Candle.sharpFilledCandle(bullishColor)
             CandlestickCartesianLayer.CandleProvider.absolute(
               bullish = bullish,
               neutral =
-                typedArray.getCandle(context, R.styleable.CandlestickLayerStyle_neutralCandleStyle)
-                  ?: bullish.copyWithColor(neutralColor),
+                typedArray.getCandle(
+                  context,
+                  R.styleable.CandlestickCartesianLayerStyle_neutralCandleStyle,
+                ) ?: bullish.copyWithColor(neutralColor),
               bearish =
-                typedArray.getCandle(context, R.styleable.CandlestickLayerStyle_bearishCandleStyle)
-                  ?: bullish.copyWithColor(bearishColor),
+                typedArray.getCandle(
+                  context,
+                  R.styleable.CandlestickCartesianLayerStyle_bearishCandleStyle,
+                ) ?: bullish.copyWithColor(bearishColor),
             )
           }
           1 -> {
             val absolutelyBullishRelativelyBullish =
               typedArray.getCandle(
                 context,
-                R.styleable.CandlestickLayerStyle_absolutelyBullishRelativelyBullishCandleStyle,
+                R.styleable
+                  .CandlestickCartesianLayerStyle_absolutelyBullishRelativelyBullishCandleStyle,
               ) ?: CandlestickCartesianLayer.Candle.sharpHollowCandle(bullishColor)
             val absolutelyBullishRelativelyNeutral =
               typedArray.getCandle(
                 context,
-                R.styleable.CandlestickLayerStyle_absolutelyBullishRelativelyNeutralCandleStyle,
+                R.styleable
+                  .CandlestickCartesianLayerStyle_absolutelyBullishRelativelyNeutralCandleStyle,
               ) ?: absolutelyBullishRelativelyBullish.copyWithColor(neutralColor)
             val absolutelyBullishRelativelyBearish =
               typedArray.getCandle(
                 context,
-                R.styleable.CandlestickLayerStyle_absolutelyBullishRelativelyBearishCandleStyle,
+                R.styleable
+                  .CandlestickCartesianLayerStyle_absolutelyBullishRelativelyBearishCandleStyle,
               ) ?: absolutelyBullishRelativelyBullish.copyWithColor(bearishColor)
             val absolutelyBearishRelativelyBullish =
               typedArray.getCandle(
                 context,
-                R.styleable.CandlestickLayerStyle_absolutelyBearishRelativelyBullishCandleStyle,
+                R.styleable
+                  .CandlestickCartesianLayerStyle_absolutelyBearishRelativelyBullishCandleStyle,
               ) ?: CandlestickCartesianLayer.Candle.sharpFilledCandle(bullishColor)
             CandlestickCartesianLayer.CandleProvider.absoluteRelative(
               absolutelyBullishRelativelyBullish = absolutelyBullishRelativelyBullish,
@@ -217,49 +228,54 @@ internal fun TypedArray.getCandlestickCartesianLayer(context: Context): Candlest
               absolutelyNeutralRelativelyBullish =
                 typedArray.getCandle(
                   context,
-                  R.styleable.CandlestickLayerStyle_absolutelyNeutralRelativelyBullishCandleStyle,
+                  R.styleable
+                    .CandlestickCartesianLayerStyle_absolutelyNeutralRelativelyBullishCandleStyle,
                 ) ?: absolutelyBullishRelativelyBullish,
               absolutelyNeutralRelativelyNeutral =
                 typedArray.getCandle(
                   context,
-                  R.styleable.CandlestickLayerStyle_absolutelyNeutralRelativelyNeutralCandleStyle,
+                  R.styleable
+                    .CandlestickCartesianLayerStyle_absolutelyNeutralRelativelyNeutralCandleStyle,
                 ) ?: absolutelyBullishRelativelyNeutral,
               absolutelyNeutralRelativelyBearish =
                 typedArray.getCandle(
                   context,
-                  R.styleable.CandlestickLayerStyle_absolutelyNeutralRelativelyBearishCandleStyle,
+                  R.styleable
+                    .CandlestickCartesianLayerStyle_absolutelyNeutralRelativelyBearishCandleStyle,
                 ) ?: absolutelyBullishRelativelyBearish,
               absolutelyBearishRelativelyBullish = absolutelyBearishRelativelyBullish,
               absolutelyBearishRelativelyNeutral =
                 typedArray.getCandle(
                   context,
-                  R.styleable.CandlestickLayerStyle_absolutelyBearishRelativelyNeutralCandleStyle,
+                  R.styleable
+                    .CandlestickCartesianLayerStyle_absolutelyBearishRelativelyNeutralCandleStyle,
                 ) ?: absolutelyBearishRelativelyBullish.copyWithColor(neutralColor),
               absolutelyBearishRelativelyBearish =
                 typedArray.getCandle(
                   context,
-                  R.styleable.CandlestickLayerStyle_absolutelyBearishRelativelyBearishCandleStyle,
+                  R.styleable
+                    .CandlestickCartesianLayerStyle_absolutelyBearishRelativelyBearishCandleStyle,
                 ) ?: absolutelyBearishRelativelyBullish.copyWithColor(bearishColor),
             )
           }
-          else -> error("Unexpected `candleStyle` value.")
+          else -> throw IllegalArgumentException("Unexpected `candleStyle` value.")
         }
       CandlestickCartesianLayer(
         candles = candleProvider,
         minCandleBodyHeightDp =
           typedArray.getRawDimension(
             context,
-            R.styleable.CandlestickLayerStyle_minCandleBodyHeight,
+            R.styleable.CandlestickCartesianLayerStyle_minCandleBodyHeight,
             Defaults.MIN_CANDLE_BODY_HEIGHT_DP,
           ),
         candleSpacingDp =
           typedArray.getRawDimension(
             context,
-            R.styleable.CandlestickLayerStyle_candleSpacing,
+            R.styleable.CandlestickCartesianLayerStyle_candleSpacing,
             Defaults.CANDLE_SPACING_DP,
           ),
         scaleCandleWicks =
-          typedArray.getBoolean(R.styleable.CandlestickLayerStyle_scaleCandleWicks, false),
+          typedArray.getBoolean(R.styleable.CandlestickCartesianLayerStyle_scaleCandleWicks, false),
       )
     }
 }
@@ -275,7 +291,7 @@ private fun TypedArray.getCandle(
           .getNestedTypedArray(
             context,
             R.styleable.CandleStyle_bodyStyle,
-            R.styleable.LineComponent,
+            R.styleable.LineComponentStyle,
           )
           .getLineComponent(context = context, defaultThickness = Defaults.CANDLE_BODY_WIDTH_DP)
       val topWick =
@@ -284,7 +300,7 @@ private fun TypedArray.getCandle(
             .getNestedTypedArray(
               context,
               R.styleable.CandleStyle_topWickStyle,
-              R.styleable.LineComponent,
+              R.styleable.LineComponentStyle,
             )
             .getLineComponent(context)
         } else {
@@ -296,7 +312,7 @@ private fun TypedArray.getCandle(
             .getNestedTypedArray(
               context,
               R.styleable.CandleStyle_bottomWickStyle,
-              R.styleable.LineComponent,
+              R.styleable.LineComponentStyle,
             )
             .getLineComponent(context)
         } else {
diff --git a/vico/views/src/main/java/com/patrykandpatrick/vico/views/common/theme/ComponentStyle.kt b/vico/views/src/main/java/com/patrykandpatrick/vico/views/common/theme/ComponentStyle.kt
index 915ae8dd4..e43bd83b0 100644
--- a/vico/views/src/main/java/com/patrykandpatrick/vico/views/common/theme/ComponentStyle.kt
+++ b/vico/views/src/main/java/com/patrykandpatrick/vico/views/common/theme/ComponentStyle.kt
@@ -19,7 +19,6 @@ package com.patrykandpatrick.vico.views.common.theme
 import android.content.Context
 import android.content.res.TypedArray
 import android.graphics.Color
-import com.patrykandpatrick.vico.core.cartesian.DefaultPointConnector
 import com.patrykandpatrick.vico.core.cartesian.layer.LineCartesianLayer
 import com.patrykandpatrick.vico.core.common.DefaultAlpha
 import com.patrykandpatrick.vico.core.common.Defaults
@@ -44,36 +43,24 @@ internal fun TypedArray.getLineComponent(
   defaultShape: Shape = Shape.Rectangle,
 ): LineComponent = use { array ->
   LineComponent(
-    color =
-      array.getColorExtended(index = R.styleable.LineComponent_color, defaultColor = defaultColor),
+    color = array.getColorExtended(R.styleable.LineComponentStyle_color, defaultColor),
     thicknessDp =
-      array.getRawDimension(
-        context = context,
-        index = R.styleable.LineComponent_thickness,
-        defaultValue = defaultThickness,
-      ),
+      array.getRawDimension(context, R.styleable.LineComponentStyle_thickness, defaultThickness),
     shape =
-      if (hasValue(R.styleable.LineComponent_shapeStyle)) {
+      if (hasValue(R.styleable.LineComponentStyle_shapeStyle)) {
         getNestedTypedArray(
-            context = context,
-            resourceId = R.styleable.LineComponent_shapeStyle,
-            styleableResourceId = R.styleable.Shape,
+            context,
+            R.styleable.LineComponentStyle_shapeStyle,
+            R.styleable.ShapeStyle,
           )
-          .getShape(context = context)
+          .getShape(context)
       } else {
         defaultShape
       },
     strokeColor =
-      array.getColorExtended(
-        index = R.styleable.LineComponent_strokeColor,
-        defaultColor = Color.TRANSPARENT,
-      ),
-    strokeWidthDp =
-      array.getRawDimension(
-        context = context,
-        index = R.styleable.LineComponent_strokeWidth,
-        defaultValue = 0f,
-      ),
+      array.getColorExtended(R.styleable.LineComponentStyle_strokeColor, Color.TRANSPARENT),
+    strokeThicknessDp =
+      array.getRawDimension(context, R.styleable.LineComponentStyle_strokeThickness, 0f),
   )
 }
 
@@ -103,25 +90,14 @@ internal fun TypedArray.getComponent(context: Context): Component? = use { array
 
   val baseComponent =
     ShapeComponent(
-      color = array.getColorExtended(index = R.styleable.ComponentStyle_color),
+      color = array.getColorExtended(R.styleable.ComponentStyle_color),
       shape =
-        getNestedTypedArray(
-            context = context,
-            resourceId = R.styleable.ComponentStyle_shapeStyle,
-            styleableResourceId = R.styleable.Shape,
-          )
+        getNestedTypedArray(context, R.styleable.ComponentStyle_shapeStyle, R.styleable.ShapeStyle)
           .getShape(context),
       strokeColor =
-        array.getColorExtended(
-          index = R.styleable.ComponentStyle_strokeColor,
-          defaultColor = Color.TRANSPARENT,
-        ),
-      strokeWidthDp =
-        array.getRawDimension(
-          context = context,
-          index = R.styleable.ComponentStyle_strokeWidth,
-          defaultValue = 0f,
-        ),
+        array.getColorExtended(R.styleable.ComponentStyle_strokeColor, Color.TRANSPARENT),
+      strokeThicknessDp =
+        array.getRawDimension(context, R.styleable.ComponentStyle_strokeThickness, 0f),
     )
 
   if (layeredComponent != null) {
@@ -148,107 +124,97 @@ internal fun TypedArray.getComponent(context: Context): Component? = use { array
   }
 }
 
-internal fun TypedArray.getLineSpec(
-  context: Context,
-  defaultColor: Int,
-): LineCartesianLayer.LineSpec {
+internal fun TypedArray.getLine(context: Context, defaultColor: Int): LineCartesianLayer.Line {
   val positiveLineColor =
-    getColor(R.styleable.LineSpec_positiveColor, getColor(R.styleable.LineSpec_color, defaultColor))
+    getColor(
+      R.styleable.LineStyle_positiveColor,
+      getColor(R.styleable.LineStyle_color, defaultColor),
+    )
 
   val negativeLineColor =
-    getColor(R.styleable.LineSpec_negativeColor, getColor(R.styleable.LineSpec_color, defaultColor))
+    getColor(
+      R.styleable.LineStyle_negativeColor,
+      getColor(R.styleable.LineStyle_color, defaultColor),
+    )
 
   val positiveGradientTopColor =
     getColor(
-      R.styleable.LineSpec_positiveGradientTopColor,
+      R.styleable.LineStyle_positiveGradientTopColor,
       getColor(
-        R.styleable.LineSpec_gradientTopColor,
+        R.styleable.LineStyle_gradientTopColor,
         positiveLineColor.copyColor(alpha = DefaultAlpha.LINE_BACKGROUND_SHADER_START),
       ),
     )
 
   val positiveGradientBottomColor =
     getColor(
-      R.styleable.LineSpec_positiveGradientBottomColor,
+      R.styleable.LineStyle_positiveGradientBottomColor,
       getColor(
-        R.styleable.LineSpec_gradientBottomColor,
+        R.styleable.LineStyle_gradientBottomColor,
         positiveLineColor.copyColor(alpha = DefaultAlpha.LINE_BACKGROUND_SHADER_END),
       ),
     )
 
   val negativeGradientTopColor =
     getColor(
-      R.styleable.LineSpec_negativeGradientTopColor,
+      R.styleable.LineStyle_negativeGradientTopColor,
       getColor(
-        R.styleable.LineSpec_gradientBottomColor,
+        R.styleable.LineStyle_gradientBottomColor,
         negativeLineColor.copyColor(alpha = DefaultAlpha.LINE_BACKGROUND_SHADER_END),
       ),
     )
 
   val negativeGradientBottomColor =
     getColor(
-      R.styleable.LineSpec_negativeGradientBottomColor,
+      R.styleable.LineStyle_negativeGradientBottomColor,
       getColor(
-        R.styleable.LineSpec_gradientTopColor,
+        R.styleable.LineStyle_gradientTopColor,
         negativeLineColor.copyColor(alpha = DefaultAlpha.LINE_BACKGROUND_SHADER_START),
       ),
     )
 
-  return LineCartesianLayer.LineSpec(
+  return LineCartesianLayer.Line(
     shader =
       if (positiveLineColor != negativeLineColor) {
         TopBottomShader(ColorShader(positiveLineColor), ColorShader(negativeLineColor))
       } else {
         ColorShader(positiveLineColor)
       },
-    point =
-      getNestedTypedArray(
-          context = context,
-          resourceId = R.styleable.LineSpec_pointStyle,
-          styleableResourceId = R.styleable.ComponentStyle,
-        )
-        .getComponent(context),
-    pointSizeDp =
-      getRawDimension(
-        context = context,
-        index = R.styleable.LineSpec_pointSize,
-        defaultValue = Defaults.POINT_SIZE,
-      ),
     thicknessDp =
-      getRawDimension(
-        context = context,
-        index = R.styleable.LineSpec_lineThickness,
-        defaultValue = Defaults.LINE_SPEC_THICKNESS_DP,
-      ),
+      getRawDimension(context, R.styleable.LineStyle_thickness, Defaults.LINE_SPEC_THICKNESS_DP),
     backgroundShader =
       TopBottomShader(
         DynamicShader.verticalGradient(positiveGradientTopColor, positiveGradientBottomColor),
         DynamicShader.verticalGradient(negativeGradientTopColor, negativeGradientBottomColor),
       ),
+    pointProvider =
+      getNestedTypedArray(context, R.styleable.LineStyle_pointStyle, R.styleable.ComponentStyle)
+        .getComponent(context)
+        ?.let { component ->
+          LineCartesianLayer.PointProvider.single(
+            LineCartesianLayer.Point(
+              component,
+              getRawDimension(context, R.styleable.LineStyle_pointSize, Defaults.POINT_SIZE),
+            )
+          )
+        },
+    pointConnector =
+      LineCartesianLayer.PointConnector.cubic(
+        getFraction(R.styleable.LineStyle_curvature, Defaults.LINE_CURVATURE)
+      ),
     dataLabel =
-      if (getBoolean(R.styleable.LineSpec_showDataLabels, false)) {
+      if (getBoolean(R.styleable.LineStyle_showDataLabels, false)) {
         getNestedTypedArray(
-            context = context,
-            resourceId = R.styleable.LineSpec_dataLabelStyle,
-            styleableResourceId = R.styleable.TextComponentStyle,
+            context,
+            R.styleable.LineStyle_dataLabelStyle,
+            R.styleable.TextComponentStyle,
           )
-          .getTextComponent(context = context)
+          .getTextComponent(context)
       } else {
         null
       },
     dataLabelVerticalPosition =
-      getInteger(R.styleable.LineSpec_dataLabelVerticalPosition, 0).let { value ->
-        val values = VerticalPosition.entries
-        values[value % values.size]
-      },
-    dataLabelRotationDegrees = getFloat(R.styleable.LineSpec_dataLabelRotationDegrees, 0f),
-    pointConnector =
-      DefaultPointConnector(
-        cubicStrength =
-          getFraction(
-            index = R.styleable.LineSpec_cubicStrength,
-            defaultValue = Defaults.CUBIC_STRENGTH,
-          )
-      ),
+      VerticalPosition.entries[getInteger(R.styleable.LineStyle_dataLabelVerticalPosition, 0)],
+    dataLabelRotationDegrees = getFloat(R.styleable.LineStyle_dataLabelRotationDegrees, 0f),
   )
 }
diff --git a/vico/views/src/main/java/com/patrykandpatrick/vico/views/common/theme/ShapeStyle.kt b/vico/views/src/main/java/com/patrykandpatrick/vico/views/common/theme/ShapeStyle.kt
index b9fc224c1..6eaac6372 100644
--- a/vico/views/src/main/java/com/patrykandpatrick/vico/views/common/theme/ShapeStyle.kt
+++ b/vico/views/src/main/java/com/patrykandpatrick/vico/views/common/theme/ShapeStyle.kt
@@ -37,38 +37,45 @@ internal fun TypedArray.getShape(context: Context): Shape {
       topLeft =
         getCorner(
           context = context,
-          sizeIndex = R.styleable.Shape_topStartCornerSize,
-          treatmentIndex = R.styleable.Shape_topStartCornerTreatment,
+          sizeIndex = R.styleable.ShapeStyle_topStartCornerSize,
+          treatmentIndex = R.styleable.ShapeStyle_topStartCornerTreatment,
         ),
       topRight =
         getCorner(
           context = context,
-          sizeIndex = R.styleable.Shape_topEndCornerSize,
-          treatmentIndex = R.styleable.Shape_topEndCornerTreatment,
+          sizeIndex = R.styleable.ShapeStyle_topEndCornerSize,
+          treatmentIndex = R.styleable.ShapeStyle_topEndCornerTreatment,
         ),
       bottomLeft =
         getCorner(
           context = context,
-          sizeIndex = R.styleable.Shape_bottomStartCornerSize,
-          treatmentIndex = R.styleable.Shape_bottomStartCornerTreatment,
+          sizeIndex = R.styleable.ShapeStyle_bottomStartCornerSize,
+          treatmentIndex = R.styleable.ShapeStyle_bottomStartCornerTreatment,
         ),
       bottomRight =
         getCorner(
           context = context,
-          sizeIndex = R.styleable.Shape_bottomEndCornerSize,
-          treatmentIndex = R.styleable.Shape_bottomEndCornerTreatment,
+          sizeIndex = R.styleable.ShapeStyle_bottomEndCornerSize,
+          treatmentIndex = R.styleable.ShapeStyle_bottomEndCornerTreatment,
         ),
     )
 
-  val dashLength =
-    getRawDimension(context = context, index = R.styleable.Shape_dashLength, defaultValue = 0f)
-  val dashGapLength =
-    getRawDimension(context = context, index = R.styleable.Shape_dashGapLength, defaultValue = 0f)
+  val dashLengthDp =
+    getRawDimension(context = context, index = R.styleable.ShapeStyle_dashLength, defaultValue = 0f)
 
-  return if (dashLength == 0f) {
+  return if (dashLengthDp == 0f) {
     shape
   } else {
-    DashedShape(shape = shape, dashLengthDp = dashLength, gapLengthDp = dashGapLength)
+    DashedShape(
+      shape = shape,
+      dashLengthDp = dashLengthDp,
+      gapLengthDp =
+        getRawDimension(
+          context,
+          R.styleable.ShapeStyle_gapLength,
+          getRawDimension(context, R.styleable.ShapeStyle_dashGapLength, 0f),
+        ),
+    )
   }
 }
 
@@ -82,7 +89,7 @@ private fun TypedArray.getCorner(
     !hasValue(sizeIndex) && handleNullSizeIndex -> {
       getCorner(
         context = context,
-        sizeIndex = R.styleable.Shape_cornerSize,
+        sizeIndex = R.styleable.ShapeStyle_cornerSize,
         treatmentIndex = treatmentIndex,
         handleNullSizeIndex = false,
       )
@@ -118,7 +125,7 @@ private fun TypedArray.getCornerTreatment(
   defaultValue: Int = -1,
 ): CornerTreatment =
   when (getInt(index, defaultValue)) {
-    -1 -> getCornerTreatment(R.styleable.Shape_cornerTreatment, defaultValue = 0)
+    -1 -> getCornerTreatment(R.styleable.ShapeStyle_cornerTreatment, defaultValue = 0)
     0 -> RoundedCornerTreatment
     else -> CutCornerTreatment
   }
diff --git a/vico/views/src/main/java/com/patrykandpatrick/vico/views/common/theme/TextComponentStyle.kt b/vico/views/src/main/java/com/patrykandpatrick/vico/views/common/theme/TextComponentStyle.kt
index e5acf3aea..29565b344 100644
--- a/vico/views/src/main/java/com/patrykandpatrick/vico/views/common/theme/TextComponentStyle.kt
+++ b/vico/views/src/main/java/com/patrykandpatrick/vico/views/common/theme/TextComponentStyle.kt
@@ -26,7 +26,7 @@ import androidx.annotation.StyleableRes
 import androidx.core.content.res.ResourcesCompat
 import com.patrykandpatrick.vico.core.common.Defaults.AXIS_LABEL_HORIZONTAL_PADDING
 import com.patrykandpatrick.vico.core.common.Defaults.AXIS_LABEL_VERTICAL_PADDING
-import com.patrykandpatrick.vico.core.common.Defaults.LABEL_LINE_COUNT
+import com.patrykandpatrick.vico.core.common.Defaults.TEXT_COMPONENT_LINE_COUNT
 import com.patrykandpatrick.vico.core.common.Defaults.TEXT_COMPONENT_TEXT_SIZE
 import com.patrykandpatrick.vico.core.common.Dimensions
 import com.patrykandpatrick.vico.core.common.component.TextComponent
@@ -38,32 +38,33 @@ import com.patrykandpatrick.vico.views.common.defaultColors
 private const val FONT_WEIGHT_NORMAL = 400
 
 internal fun TypedArray.getTextComponent(context: Context): TextComponent = use {
-  val color =
-    getColor(R.styleable.TextComponentStyle_labelColor, context.defaultColors.textColor.toInt())
-  val background =
-    getNestedTypedArray(
-        context = context,
-        resourceId = R.styleable.TextComponentStyle_backgroundStyle,
-        styleableResourceId = R.styleable.ComponentStyle,
-      )
-      .getComponent(context)
-
-  TextComponent.build {
-    this.color = color
-    this.background = background
-    this.padding = getPadding(context)
-    this.margins = getMargins(context)
-    this.textSizeSp =
+  TextComponent(
+    color =
+      getColor(
+        R.styleable.TextComponentStyle_android_color,
+        getColor(R.styleable.TextComponentStyle_labelColor, context.defaultColors.textColor.toInt()),
+      ),
+    typeface = getTypeface(context) ?: Typeface.DEFAULT,
+    textSizeSp =
       getRawDimension(
         context = context,
         index = R.styleable.TextComponentStyle_android_textSize,
         defaultValue = TEXT_COMPONENT_TEXT_SIZE,
-      )
-    this.lineCount = getInteger(R.styleable.TextComponentStyle_android_maxLines, LABEL_LINE_COUNT)
-    this.ellipsize = getTruncateAt()
-    getTypeface(context)?.let { this.typeface = it }
-    this.textAlignment = getTextAlignment()
-  }
+      ),
+    textAlignment = getTextAlignment(),
+    lineCount =
+      getInteger(R.styleable.TextComponentStyle_android_maxLines, TEXT_COMPONENT_LINE_COUNT),
+    truncateAt = getTruncateAt(),
+    margins = getMargins(context),
+    padding = getPadding(context),
+    background =
+      getNestedTypedArray(
+          context = context,
+          resourceId = R.styleable.TextComponentStyle_backgroundStyle,
+          styleableResourceId = R.styleable.ComponentStyle,
+        )
+        .getComponent(context),
+  )
 }
 
 private fun TypedArray.getTruncateAt(): TextUtils.TruncateAt {
@@ -99,7 +100,7 @@ private fun TypedArray.getTypeface(context: Context): Typeface? {
     if (fontResId > 0) {
       ResourcesCompat.getFont(context, fontResId)
     } else {
-      when (getInteger(R.styleable.TextComponentStyle_typeface, 3)) {
+      when (getInteger(R.styleable.TextComponentStyle_typeface, 0)) {
         0 -> Typeface.DEFAULT
         1 -> Typeface.SANS_SERIF
         2 -> Typeface.SERIF
diff --git a/vico/views/src/main/java/com/patrykandpatrick/vico/views/common/theme/ThemeHandler.kt b/vico/views/src/main/java/com/patrykandpatrick/vico/views/common/theme/ThemeHandler.kt
index 67d4368ce..de4971069 100644
--- a/vico/views/src/main/java/com/patrykandpatrick/vico/views/common/theme/ThemeHandler.kt
+++ b/vico/views/src/main/java/com/patrykandpatrick/vico/views/common/theme/ThemeHandler.kt
@@ -22,22 +22,17 @@ import android.content.res.TypedArray
 import android.util.AttributeSet
 import android.util.Log
 import android.view.animation.AccelerateInterpolator
-import androidx.annotation.StyleableRes
 import com.patrykandpatrick.vico.core.cartesian.CartesianChart
 import com.patrykandpatrick.vico.core.cartesian.FadingEdges
 import com.patrykandpatrick.vico.core.cartesian.HorizontalLayout
 import com.patrykandpatrick.vico.core.cartesian.axis.Axis
-import com.patrykandpatrick.vico.core.cartesian.axis.AxisItemPlacer
 import com.patrykandpatrick.vico.core.cartesian.axis.AxisPosition
-import com.patrykandpatrick.vico.core.cartesian.axis.BaseAxis
 import com.patrykandpatrick.vico.core.cartesian.axis.HorizontalAxis
 import com.patrykandpatrick.vico.core.cartesian.axis.VerticalAxis
 import com.patrykandpatrick.vico.core.common.Defaults
 import com.patrykandpatrick.vico.core.common.Defaults.FADING_EDGE_VISIBILITY_THRESHOLD_DP
-import com.patrykandpatrick.vico.core.common.component.LineComponent
 import com.patrykandpatrick.vico.core.common.hasFlag
 import com.patrykandpatrick.vico.core.common.shape.DashedShape
-import com.patrykandpatrick.vico.core.common.shape.Shape
 import com.patrykandpatrick.vico.views.R
 
 internal class ThemeHandler(private val context: Context, attrs: AttributeSet?) {
@@ -50,16 +45,21 @@ internal class ThemeHandler(private val context: Context, attrs: AttributeSet?)
   var chart: CartesianChart? = null
     private set
 
-  lateinit var horizontalLayout: HorizontalLayout
-    private set
-
   init {
     context.obtainStyledAttributes(attrs, R.styleable.CartesianChartView).use { typedArray ->
       scrollEnabled =
-        typedArray.getBoolean(R.styleable.CartesianChartView_chartHorizontalScrollingEnabled, true)
+        typedArray.getBoolean(
+          R.styleable.CartesianChartView_scrollEnabled,
+          typedArray.getBoolean(
+            R.styleable.CartesianChartView_chartHorizontalScrollingEnabled,
+            true,
+          ),
+        )
       isChartZoomEnabled =
-        typedArray.getBoolean(R.styleable.CartesianChartView_chartZoomEnabled, true)
-      horizontalLayout = typedArray.getHorizontalLayout()
+        typedArray.getBoolean(
+          R.styleable.CartesianChartView_zoomEnabled,
+          typedArray.getBoolean(R.styleable.CartesianChartView_chartZoomEnabled, true),
+        )
 
       context.obtainStyledAttributes(attrs, R.styleable.CartesianChartView).use {
         chart = getChart(it, typedArray)
@@ -67,111 +67,120 @@ internal class ThemeHandler(private val context: Context, attrs: AttributeSet?)
     }
   }
 
-  private fun <Position : AxisPosition, Builder : BaseAxis.Builder<Position>> TypedArray
-    .getAxisBuilder(styleAttrId: Int, builder: Builder): Builder {
-    fun TypedArray.getLineComponent(
-      @StyleableRes resourceId: Int,
-      @StyleableRes styleableResourceId: IntArray,
-      defaultShape: Shape = Shape.Rectangle,
-    ): LineComponent =
-      getNestedTypedArray(
-          context = context,
-          resourceId = resourceId,
-          styleableResourceId = styleableResourceId,
-        )
-        .getLineComponent(context = context, defaultShape = defaultShape)
-
-    val axisStyle =
-      getNestedTypedArray(
-        context = context,
-        resourceId =
-          if (hasValue(styleAttrId)) styleAttrId else R.styleable.CartesianChartView_axisStyle,
-        styleableResourceId = R.styleable.Axis,
-      )
-
-    return builder
-      .apply {
-        axis =
+  private fun <P : AxisPosition> TypedArray.getAxis(position: P): Axis<P>? {
+    val visibilityAttributeIndex: Int
+    var styleAttributeIndex: Int
+    when {
+      position.isStart -> {
+        visibilityAttributeIndex = R.styleable.CartesianChartView_showStartAxis
+        styleAttributeIndex = R.styleable.CartesianChartView_startAxisStyle
+      }
+      position.isTop -> {
+        visibilityAttributeIndex = R.styleable.CartesianChartView_showTopAxis
+        styleAttributeIndex = R.styleable.CartesianChartView_topAxisStyle
+      }
+      position.isEnd -> {
+        visibilityAttributeIndex = R.styleable.CartesianChartView_showEndAxis
+        styleAttributeIndex = R.styleable.CartesianChartView_endAxisStyle
+      }
+      position.isBottom -> {
+        visibilityAttributeIndex = R.styleable.CartesianChartView_showBottomAxis
+        styleAttributeIndex = R.styleable.CartesianChartView_bottomAxisStyle
+      }
+      else -> throw IllegalArgumentException("Unexpected `AxisPosition` subclass.")
+    }
+    if (!getBoolean(visibilityAttributeIndex, false)) return null
+    if (!hasValue(styleAttributeIndex)) {
+      styleAttributeIndex = R.styleable.CartesianChartView_axisStyle
+    }
+    return getNestedTypedArray(context, styleAttributeIndex, R.styleable.AxisStyle).use { axisStyle
+      ->
+      @Suppress("UNCHECKED_CAST")
+      when (position) {
+        is AxisPosition.Horizontal ->
+          HorizontalAxis(position, axisStyle.getHorizontalAxisItemPlacer())
+        is AxisPosition.Vertical ->
+          VerticalAxis(
+            position = position,
+            horizontalLabelPosition =
+              VerticalAxis.HorizontalLabelPosition.entries[
+                  axisStyle.getInteger(
+                    R.styleable.AxisStyle_verticalAxisHorizontalLabelPosition,
+                    0,
+                  )],
+            verticalLabelPosition =
+              VerticalAxis.VerticalLabelPosition.entries[
+                  axisStyle.getInteger(R.styleable.AxisStyle_verticalAxisVerticalLabelPosition, 0)],
+            itemPlacer = axisStyle.getVerticalAxisItemPlacer(),
+          )
+        else -> throw IllegalArgumentException("Unexpected `AxisPosition` subclass.")
+      }.apply {
+        line =
+          if (axisStyle.getBoolean(R.styleable.AxisStyle_showLine, true)) {
+            axisStyle
+              .getNestedTypedArray(
+                context,
+                R.styleable.AxisStyle_lineStyle,
+                R.styleable.LineComponentStyle,
+              )
+              .getLineComponent(context)
+          } else {
+            null
+          }
+        label =
           axisStyle
-            .takeIf { it.getBoolean(R.styleable.Axis_showAxisLine, true) }
-            ?.getLineComponent(
-              resourceId = R.styleable.Axis_axisLineStyle,
-              styleableResourceId = R.styleable.LineComponent,
+            .getNestedTypedArray(
+              context,
+              R.styleable.AxisStyle_labelStyle,
+              R.styleable.TextComponentStyle,
             )
+            .getTextComponent(context)
+        labelRotationDegrees = axisStyle.getFloat(R.styleable.AxisStyle_labelRotationDegrees, 0f)
         tick =
-          axisStyle
-            .takeIf { it.getBoolean(R.styleable.Axis_showTick, true) }
-            ?.getLineComponent(
-              resourceId = R.styleable.Axis_axisTickStyle,
-              styleableResourceId = R.styleable.LineComponent,
-            )
+          if (axisStyle.getBoolean(R.styleable.AxisStyle_showTicks, true)) {
+            axisStyle
+              .getNestedTypedArray(
+                context,
+                R.styleable.AxisStyle_tickStyle,
+                R.styleable.LineComponentStyle,
+              )
+              .getLineComponent(context)
+          } else {
+            null
+          }
         tickLengthDp =
           axisStyle.getRawDimension(
-            context = context,
-            R.styleable.Axis_axisTickLength,
-            defaultValue = Defaults.AXIS_TICK_LENGTH,
+            context,
+            R.styleable.AxisStyle_tickLength,
+            Defaults.AXIS_TICK_LENGTH,
           )
         guideline =
-          axisStyle
-            .takeIf { it.getBoolean(R.styleable.Axis_showGuideline, true) }
-            ?.getLineComponent(
-              resourceId = R.styleable.Axis_axisGuidelineStyle,
-              styleableResourceId = R.styleable.LineComponent,
-              defaultShape = DashedShape(),
-            )
-        labelRotationDegrees = axisStyle.getFloat(R.styleable.Axis_labelRotationDegrees, 0f)
-        label =
-          axisStyle
-            .getNestedTypedArray(
-              context = context,
-              resourceId = R.styleable.Axis_axisLabelStyle,
-              styleableResourceId = R.styleable.TextComponentStyle,
-            )
-            .getTextComponent(context = context)
-        titleComponent =
-          if (axisStyle.getBoolean(R.styleable.Axis_showTitle, false)) {
+          if (axisStyle.getBoolean(R.styleable.AxisStyle_showGuidelines, true)) {
             axisStyle
               .getNestedTypedArray(
-                context = context,
-                resourceId = R.styleable.Axis_titleStyle,
-                styleableResourceId = R.styleable.TextComponentStyle,
+                context,
+                R.styleable.AxisStyle_guidelineStyle,
+                R.styleable.LineComponentStyle,
               )
-              .getTextComponent(context = context)
+              .getLineComponent(context = context, defaultShape = DashedShape())
           } else {
             null
           }
-        title = axisStyle.getString(R.styleable.Axis_title)
-
-        when (this) {
-          is VerticalAxis.Builder<*> -> {
-            horizontalLabelPosition =
-              axisStyle.getInteger(R.styleable.Axis_verticalAxisHorizontalLabelPosition, 0).let {
-                value ->
-                val values = VerticalAxis.HorizontalLabelPosition.entries
-                values[value % values.size]
-              }
-
-            verticalLabelPosition =
-              axisStyle.getInteger(R.styleable.Axis_verticalAxisVerticalLabelPosition, 0).let {
-                value ->
-                val values = VerticalAxis.VerticalLabelPosition.entries
-                values[value % values.size]
-              }
-
-            itemPlacer = axisStyle.getVerticalAxisItemPlacer()
-          }
-          is HorizontalAxis.Builder<*> -> {
-            itemPlacer =
-              AxisItemPlacer.Horizontal.default(
-                axisStyle.getInteger(R.styleable.Axis_horizontalAxisLabelSpacing, 1),
-                axisStyle.getInteger(R.styleable.Axis_horizontalAxisLabelOffset, 0),
-                axisStyle.getBoolean(R.styleable.Axis_shiftExtremeHorizontalAxisTicks, true),
-                axisStyle.getBoolean(R.styleable.Axis_addExtremeHorizontalAxisLabelPadding, false),
+        titleComponent =
+          if (axisStyle.getBoolean(R.styleable.AxisStyle_showTitle, false)) {
+            axisStyle
+              .getNestedTypedArray(
+                context,
+                R.styleable.AxisStyle_titleStyle,
+                R.styleable.TextComponentStyle,
               )
+              .getTextComponent(context)
+          } else {
+            null
           }
-        }
-      }
-      .also { axisStyle.recycle() }
+        title = axisStyle.getString(R.styleable.AxisStyle_title)
+      } as Axis<P>
+    }
   }
 
   private fun TypedArray.getHorizontalLayout(): HorizontalLayout =
@@ -207,20 +216,20 @@ internal class ThemeHandler(private val context: Context, attrs: AttributeSet?)
       else null
 
     return CartesianChart(
-        layers =
-          buildList {
+      layers =
+        buildList {
             if (columnLayer != null) add(columnLayer)
             if (lineLayer != null) add(lineLayer)
             if (candlestickLayer != null) add(candlestickLayer)
-          },
-        fadingEdges = baseTypedArray.getFadingEdges(),
-      )
-      .apply {
-        startAxis = baseTypedArray.getStartAxis()
-        topAxis = baseTypedArray.getTopAxis()
-        endAxis = baseTypedArray.getEndAxis()
-        bottomAxis = baseTypedArray.getBottomAxis()
-      }
+          }
+          .toTypedArray(),
+      startAxis = baseTypedArray.getAxis(AxisPosition.Vertical.Start),
+      topAxis = baseTypedArray.getAxis(AxisPosition.Horizontal.Top),
+      endAxis = baseTypedArray.getAxis(AxisPosition.Vertical.End),
+      bottomAxis = baseTypedArray.getAxis(AxisPosition.Horizontal.Bottom),
+      fadingEdges = baseTypedArray.getFadingEdges(),
+      horizontalLayout = baseTypedArray.getHorizontalLayout(),
+    )
   }
 
   private fun TypedArray.getFadingEdges(): FadingEdges? {
@@ -270,55 +279,31 @@ internal class ThemeHandler(private val context: Context, attrs: AttributeSet?)
     }
   }
 
-  private fun TypedArray.getVerticalAxisItemPlacer(): AxisItemPlacer.Vertical {
-    val shiftTopLines = getBoolean(R.styleable.Axis_shiftTopVerticalAxisLines, true)
+  private fun TypedArray.getHorizontalAxisItemPlacer(): HorizontalAxis.ItemPlacer =
+    HorizontalAxis.ItemPlacer.default(
+      getInteger(R.styleable.AxisStyle_horizontalAxisLabelSpacing, 1),
+      getInteger(R.styleable.AxisStyle_horizontalAxisLabelOffset, 0),
+      getBoolean(R.styleable.AxisStyle_shiftExtremeHorizontalAxisTicks, true),
+      getBoolean(R.styleable.AxisStyle_addExtremeHorizontalAxisLabelPadding, false),
+    )
+
+  private fun TypedArray.getVerticalAxisItemPlacer(): VerticalAxis.ItemPlacer {
+    val shiftTopLines = getBoolean(R.styleable.AxisStyle_shiftTopVerticalAxisLines, true)
     return if (
-      hasValue(R.styleable.Axis_verticalAxisItemCount) ||
-        hasValue(R.styleable.Axis_maxVerticalAxisItemCount)
+      hasValue(R.styleable.AxisStyle_verticalAxisItemCount) ||
+        hasValue(R.styleable.AxisStyle_maxVerticalAxisItemCount)
     ) {
       val itemCount =
         getInteger(
-          R.styleable.Axis_verticalAxisItemCount,
-          getInteger(R.styleable.Axis_maxVerticalAxisItemCount, -1),
+          R.styleable.AxisStyle_verticalAxisItemCount,
+          getInteger(R.styleable.AxisStyle_maxVerticalAxisItemCount, -1),
         )
-      AxisItemPlacer.Vertical.count({ itemCount }, shiftTopLines)
+      VerticalAxis.ItemPlacer.count({ itemCount }, shiftTopLines)
     } else {
-      AxisItemPlacer.Vertical.step(shiftTopLines = shiftTopLines)
+      VerticalAxis.ItemPlacer.step(shiftTopLines = shiftTopLines)
     }
   }
 
-  private fun TypedArray.getStartAxis(): Axis<AxisPosition.Vertical.Start>? =
-    if (getBoolean(R.styleable.CartesianChartView_showStartAxis, false)) {
-      getAxisBuilder(R.styleable.CartesianChartView_startAxisStyle, VerticalAxis.Builder())
-        .build<AxisPosition.Vertical.Start>()
-    } else {
-      null
-    }
-
-  private fun TypedArray.getTopAxis(): Axis<AxisPosition.Horizontal.Top>? =
-    if (getBoolean(R.styleable.CartesianChartView_showTopAxis, false)) {
-      getAxisBuilder(R.styleable.CartesianChartView_topAxisStyle, HorizontalAxis.Builder())
-        .build<AxisPosition.Horizontal.Top>()
-    } else {
-      null
-    }
-
-  private fun TypedArray.getEndAxis(): Axis<AxisPosition.Vertical.End>? =
-    if (getBoolean(R.styleable.CartesianChartView_showEndAxis, false)) {
-      getAxisBuilder(R.styleable.CartesianChartView_endAxisStyle, VerticalAxis.Builder())
-        .build<AxisPosition.Vertical.End>()
-    } else {
-      null
-    }
-
-  private fun TypedArray.getBottomAxis(): Axis<AxisPosition.Horizontal.Bottom>? =
-    if (getBoolean(R.styleable.CartesianChartView_showBottomAxis, false)) {
-      getAxisBuilder(R.styleable.CartesianChartView_bottomAxisStyle, HorizontalAxis.Builder())
-        .build<AxisPosition.Horizontal.Bottom>()
-    } else {
-      null
-    }
-
   private companion object {
     const val COLUMN_LAYER = 1
     const val LINE_LAYER = 2
diff --git a/vico/views/src/main/res/values/attrs.xml b/vico/views/src/main/res/values/attrs.xml
index dd5171cf2..bd7a35561 100644
--- a/vico/views/src/main/res/values/attrs.xml
+++ b/vico/views/src/main/res/values/attrs.xml
@@ -20,10 +20,11 @@
     <attr name="negativeColor" format="color" />
     <attr name="shapeStyle" format="reference" />
     <attr name="strokeColor" format="color" />
-    <attr name="strokeWidth" format="dimension" />
+    <attr name="strokeThickness" format="dimension" />
     <attr name="dataLabelRotationDegrees" format="float" />
     <attr name="showDataLabels" format="boolean" />
     <attr name="dataLabelStyle" format="reference" />
+    <attr name="thickness" format="dimension" />
 
     <attr name="dataLabelVerticalPosition" format="enum">
         <enum name="top" value="0" />
@@ -49,7 +50,11 @@
         <attr name="showTopAxis" format="boolean" />
         <attr name="showEndAxis" format="boolean" />
         <attr name="showBottomAxis" format="boolean" />
+        <attr name="scrollEnabled" format="boolean" />
+        <!-- Deprecated. Use `scrollEnabled`. -->
         <attr name="chartHorizontalScrollingEnabled" format="boolean" />
+        <attr name="zoomEnabled" format="boolean" />
+        <!-- Deprecated. Use `zoomEnabled`. -->
         <attr name="chartZoomEnabled" format="boolean" />
         <attr name="fadingEdgeWidth" format="dimension" />
         <attr name="startFadingEdgeWidth" format="dimension" />
@@ -73,16 +78,16 @@
     </declare-styleable>
 
     <!-- Defines the appearance of chart axes. -->
-    <declare-styleable name="Axis">
-        <attr name="showAxisLine" format="boolean" />
-        <attr name="axisLineStyle" format="reference" />
-        <attr name="showGuideline" format="boolean" />
-        <attr name="axisGuidelineStyle" format="reference" />
-        <attr name="showTick" format="boolean" />
-        <attr name="axisTickStyle" format="reference" />
-        <attr name="axisLabelStyle" format="reference" />
-        <attr name="axisTickLength" format="dimension" />
-        <attr name="axisLabelBackground" format="color|reference" />
+    <declare-styleable name="AxisStyle">
+        <attr name="showLine" format="boolean" />
+        <attr name="lineStyle" format="reference" />
+        <attr name="showGuidelines" format="boolean" />
+        <attr name="guidelineStyle" format="reference" />
+        <attr name="showTicks" format="boolean" />
+        <attr name="tickStyle" format="reference" />
+        <attr name="labelStyle" format="reference" />
+        <attr name="tickLength" format="dimension" />
+        <attr name="labelBackground" format="color|reference" />
         <attr name="verticalAxisHorizontalLabelPosition" format="enum">
             <enum name="outside" value="0" />
             <enum name="inside" value="1" />
@@ -106,15 +111,17 @@
         <attr name="verticalAxisItemCount" format="integer" />
     </declare-styleable>
 
-    <declare-styleable name="LineComponent">
+    <declare-styleable name="LineComponentStyle">
         <attr name="color" />
-        <attr name="thickness" format="dimension" />
+        <attr name="thickness" />
         <attr name="shapeStyle" />
         <attr name="strokeColor" />
-        <attr name="strokeWidth" />
+        <attr name="strokeThickness" />
     </declare-styleable>
 
     <declare-styleable name="TextComponentStyle">
+        <attr name="android:color" />
+        <!-- Deprecated. Use `android:color`. -->
         <attr name="labelColor" format="color" />
         <attr name="backgroundStyle" format="reference" />
         <attr name="android:padding" />
@@ -152,7 +159,7 @@
         </attr>
     </declare-styleable>
 
-    <declare-styleable name="Shape">
+    <declare-styleable name="ShapeStyle">
         <attr name="cornerSize" format="dimension|fraction" />
         <attr name="cornerTreatment" format="enum">
             <enum name="rounded" value="0" />
@@ -184,6 +191,8 @@
         </attr>
 
         <attr name="dashLength" format="dimension" />
+        <attr name="gapLength" format="dimension" />
+        <!-- Deprecated. Use `gapLength`. -->
         <attr name="dashGapLength" format="dimension" />
     </declare-styleable>
 </resources>
diff --git a/vico/views/src/main/res/values/candlestick_chart_attrs.xml b/vico/views/src/main/res/values/candlestick_chart_attrs.xml
index bb2107971..f5b5f17d6 100644
--- a/vico/views/src/main/res/values/candlestick_chart_attrs.xml
+++ b/vico/views/src/main/res/values/candlestick_chart_attrs.xml
@@ -17,7 +17,7 @@
 <resources>
     <attr name="candlestickLayerStyle" format="reference" />
 
-    <declare-styleable name="CandlestickLayerStyle">
+    <declare-styleable name="CandlestickCartesianLayerStyle">
         <attr name="candleStyle" format="enum">
             <enum name="absolute" value="0" />
             <enum name="absoluteRelative" value="1" />
diff --git a/vico/views/src/main/res/values/column_chart_attrs.xml b/vico/views/src/main/res/values/column_chart_attrs.xml
index 8404ecfa7..95c76cd5a 100644
--- a/vico/views/src/main/res/values/column_chart_attrs.xml
+++ b/vico/views/src/main/res/values/column_chart_attrs.xml
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?><!--
-  ~ Copyright 2023 by Patryk Goworowski and Patrick Michalik.
+  ~ Copyright 2024 by Patryk Goworowski and Patrick Michalik.
   ~
   ~ Licensed under the Apache License, Version 2.0 (the "License");
   ~ you may not use this file except in compliance with the License.
@@ -18,11 +18,11 @@
     <attr name="columnLayerStyle" format="reference" />
 
     <declare-styleable name="ColumnCartesianLayerStyle">
-        <attr name="column1" format="reference" />
-        <attr name="column2" format="reference" />
-        <attr name="column3" format="reference" />
-        <attr name="columnOuterSpacing" format="dimension" />
-        <attr name="columnInnerSpacing" format="dimension" />
+        <attr name="column1Style" format="reference" />
+        <attr name="column2Style" format="reference" />
+        <attr name="column3Style" format="reference" />
+        <attr name="columnCollectionSpacing" format="dimension" />
+        <attr name="groupedColumnSpacing" format="dimension" />
         <attr name="showDataLabels" />
         <attr name="dataLabelStyle" />
         <attr name="dataLabelVerticalPosition" />
diff --git a/vico/views/src/main/res/values/line_chart_attrs.xml b/vico/views/src/main/res/values/line_chart_attrs.xml
index 7f50f29e8..a3741b50d 100644
--- a/vico/views/src/main/res/values/line_chart_attrs.xml
+++ b/vico/views/src/main/res/values/line_chart_attrs.xml
@@ -16,18 +16,18 @@
 
 <resources>
     <attr name="lineLayerStyle" format="reference" />
-    <attr name="line1Spec" format="reference" />
-    <attr name="line2Spec" format="reference" />
-    <attr name="line3Spec" format="reference" />
+    <attr name="line1Style" format="reference" />
+    <attr name="line2Style" format="reference" />
+    <attr name="line3Style" format="reference" />
 
     <declare-styleable name="LineCartesianLayerStyle">
-        <attr name="line1Spec" />
-        <attr name="line2Spec" />
-        <attr name="line3Spec" />
-        <attr name="spacing" format="dimension" />
+        <attr name="line1Style" />
+        <attr name="line2Style" />
+        <attr name="line3Style" />
+        <attr name="pointSpacing" format="dimension" />
     </declare-styleable>
 
-    <declare-styleable name="LineSpec">
+    <declare-styleable name="LineStyle">
         <attr name="color" />
         <attr name="positiveColor" />
         <attr name="negativeColor" />
@@ -38,9 +38,9 @@
         <attr name="negativeGradientTopColor" format="color" />
         <attr name="negativeGradientBottomColor" format="color" />
         <attr name="pointSize" format="dimension" />
-        <attr name="lineThickness" format="dimension" />
+        <attr name="thickness" />
         <attr name="pointStyle" format="reference" />
-        <attr name="cubicStrength" format="fraction" />
+        <attr name="curvature" format="fraction" />
         <attr name="showDataLabels" />
         <attr name="dataLabelStyle" />
         <attr name="dataLabelVerticalPosition" />
@@ -51,7 +51,7 @@
         <attr name="color" />
         <attr name="shapeStyle" />
         <attr name="strokeColor" />
-        <attr name="strokeWidth" />
+        <attr name="strokeThickness" />
         <attr name="overlayingComponentStyle" format="reference"/>
         <attr name="layeredComponentStyle" format="reference" />
         <attr name="overlayingComponentPadding" format="dimension"/>