diff --git a/compose/material/material/src/androidAndroidTest/kotlin/androidx/compose/material/swipeable/SwipeableV2AnchorTest.kt b/compose/material/material/src/androidAndroidTest/kotlin/androidx/compose/material/swipeable/SwipeableV2AnchorTest.kt
index 546a345..c7f0a55 100644
--- a/compose/material/material/src/androidAndroidTest/kotlin/androidx/compose/material/swipeable/SwipeableV2AnchorTest.kt
+++ b/compose/material/material/src/androidAndroidTest/kotlin/androidx/compose/material/swipeable/SwipeableV2AnchorTest.kt
@@ -53,9 +53,10 @@
         rule.mainClock.autoAdvance = false
 
         var compositionCounter = 0
-        val state = SwipeableV2State(initialState = A)
+        lateinit var state: SwipeableV2State<TestState>
 
         rule.setContent {
+            state = rememberSwipeableV2State(initialState = A)
             compositionCounter++
             Box(
                 Modifier
@@ -82,7 +83,7 @@
 
     @Test
     fun swipeable_swipeAnchors_calculatedCorrectlyFromLayoutSize() {
-        val state = SwipeableV2State(initialState = A)
+        lateinit var state: SwipeableV2State<TestState>
 
         fun anchorA() = 0f
         fun anchorB(layoutHeight: Float) = layoutHeight / 2
@@ -91,6 +92,7 @@
         val swipeableSize = 200.dp
 
         rule.setContent {
+            state = rememberSwipeableV2State(initialState = A)
             Box(
                 Modifier
                     .requiredHeight(swipeableSize)
diff --git a/compose/material/material/src/androidAndroidTest/kotlin/androidx/compose/material/swipeable/SwipeableV2GestureTest.kt b/compose/material/material/src/androidAndroidTest/kotlin/androidx/compose/material/swipeable/SwipeableV2GestureTest.kt
index 15409f5..551c9bc 100644
--- a/compose/material/material/src/androidAndroidTest/kotlin/androidx/compose/material/swipeable/SwipeableV2GestureTest.kt
+++ b/compose/material/material/src/androidAndroidTest/kotlin/androidx/compose/material/swipeable/SwipeableV2GestureTest.kt
@@ -17,11 +17,15 @@
 package androidx.compose.material.swipeable
 
 import androidx.compose.foundation.gestures.Orientation
+import androidx.compose.material.AutoTestFrameClock
 import androidx.compose.material.ExperimentalMaterialApi
 import androidx.compose.material.SwipeableV2State
+import androidx.compose.material.fixedPositionalThreshold
+import androidx.compose.material.fractionalPositionalThreshold
 import androidx.compose.material.swipeable.TestState.A
 import androidx.compose.material.swipeable.TestState.B
 import androidx.compose.material.swipeable.TestState.C
+import androidx.compose.ui.geometry.Offset
 import androidx.compose.ui.test.TouchInjectionScope
 import androidx.compose.ui.test.junit4.createComposeRule
 import androidx.compose.ui.test.onNodeWithTag
@@ -30,9 +34,15 @@
 import androidx.compose.ui.test.swipeLeft
 import androidx.compose.ui.test.swipeRight
 import androidx.compose.ui.test.swipeUp
+import androidx.compose.ui.test.swipeWithVelocity
+import androidx.compose.ui.unit.Density
+import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.dp
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import androidx.test.filters.LargeTest
 import com.google.common.truth.Truth.assertThat
+import kotlin.math.abs
+import kotlinx.coroutines.runBlocking
 import org.junit.Rule
 import org.junit.Test
 import org.junit.runner.RunWith
@@ -47,21 +57,21 @@
 
     @Test
     fun swipeable_swipe_horizontal() = directionalSwipeTest(
-        SwipeableV2State(initialState = A),
+        SwipeableTestState(initialState = A),
         orientation = Orientation.Horizontal,
         verify = verifyOffsetMatchesAnchor()
     )
 
     @Test
     fun swipeable_swipe_vertical() = directionalSwipeTest(
-        SwipeableV2State(initialState = A),
+        SwipeableTestState(initialState = A),
         orientation = Orientation.Vertical,
         verify = verifyOffsetMatchesAnchor()
     )
 
     @Test
     fun swipeable_swipe_disabled_horizontal() = directionalSwipeTest(
-        SwipeableV2State(initialState = A),
+        SwipeableTestState(initialState = A),
         orientation = Orientation.Horizontal,
         enabled = false,
         verify = verifyOffset0(),
@@ -69,7 +79,7 @@
 
     @Test
     fun swipeable_swipe_disabled_vertical(): Unit = directionalSwipeTest(
-        SwipeableV2State(initialState = A),
+        SwipeableTestState(initialState = A),
         orientation = Orientation.Vertical,
         enabled = false,
         verify = verifyOffset0(),
@@ -77,7 +87,7 @@
 
     @Test
     fun swipeable_swipe_reverse_direction_horizontal() = directionalSwipeTest(
-        SwipeableV2State(initialState = A),
+        SwipeableTestState(initialState = A),
         orientation = Orientation.Horizontal,
         verify = verifyOffsetMatchesAnchor()
     )
@@ -136,6 +146,214 @@
         verify(state, A)
     }
 
+    @Test
+    fun swipeable_positionalThresholds_fractional_targetState() = fractionalThresholdsTest(0.5f)
+
+    @Test
+    fun swipeable_positionalThresholds_fractional_negativeThreshold_targetState() =
+        fractionalThresholdsTest(-0.5f)
+
+    private fun fractionalThresholdsTest(positionalThreshold: Float) {
+        val absThreshold = abs(positionalThreshold)
+        val state = SwipeableTestState(
+            initialState = A,
+            positionalThreshold = fractionalPositionalThreshold(positionalThreshold)
+        )
+        rule.setContent { SwipeableBox(state) }
+
+        val positionOfA = state.anchors.getValue(A)
+        val positionOfB = state.anchors.getValue(B)
+        val distance = abs(positionOfA - positionOfB)
+        state.dispatchRawDelta(positionOfA + distance * (absThreshold * 0.9f))
+        rule.waitForIdle()
+
+        assertThat(state.currentState).isEqualTo(A)
+        assertThat(state.targetState).isEqualTo(A)
+
+        state.dispatchRawDelta(distance * 0.2f)
+        rule.waitForIdle()
+
+        assertThat(state.currentState).isEqualTo(A)
+        assertThat(state.targetState).isEqualTo(B)
+
+        runBlocking(AutoTestFrameClock()) { state.settle(velocity = 0f) }
+
+        assertThat(state.currentState).isEqualTo(B)
+        assertThat(state.targetState).isEqualTo(B)
+
+        state.dispatchRawDelta(-distance * (absThreshold * 0.9f))
+        rule.waitForIdle()
+
+        assertThat(state.currentState).isEqualTo(B)
+        assertThat(state.targetState).isEqualTo(B)
+
+        state.dispatchRawDelta(-distance * 0.2f)
+        rule.waitForIdle()
+
+        assertThat(state.currentState).isEqualTo(B)
+        assertThat(state.targetState).isEqualTo(A)
+
+        runBlocking(AutoTestFrameClock()) { state.settle(velocity = 0f) }
+
+        assertThat(state.currentState).isEqualTo(A)
+        assertThat(state.targetState).isEqualTo(A)
+    }
+
+    @Test
+    fun swipeable_positionalThresholds_fixed_targetState() = fixedThresholdsTest(56.dp)
+
+    @Test
+    fun swipeable_positionalThresholds_fixed_negativeThreshold_targetState() =
+        fixedThresholdsTest((-56).dp)
+
+    private fun fixedThresholdsTest(positionalThreshold: Dp) {
+        val absThreshold = with(rule.density) { abs(positionalThreshold.toPx()) }
+        val state = SwipeableTestState(
+            initialState = A,
+            positionalThreshold = fixedPositionalThreshold(positionalThreshold)
+        )
+        rule.setContent { SwipeableBox(state) }
+
+        val initialOffset = state.requireOffset()
+
+        // Swipe towards B, close before threshold
+        state.dispatchRawDelta(initialOffset + (absThreshold * 0.9f))
+        rule.waitForIdle()
+
+        assertThat(state.currentState).isEqualTo(A)
+        assertThat(state.targetState).isEqualTo(A)
+
+        // Swipe towards B, close after threshold
+        state.dispatchRawDelta(absThreshold * 0.2f)
+        rule.waitForIdle()
+
+        assertThat(state.currentState).isEqualTo(A)
+        assertThat(state.targetState).isEqualTo(B)
+
+        runBlocking(AutoTestFrameClock()) { state.settle(velocity = 0f) }
+
+        assertThat(state.currentState).isEqualTo(B)
+        assertThat(state.targetState).isEqualTo(B)
+
+        // Swipe towards A, close before threshold
+        state.dispatchRawDelta(-(absThreshold * 0.9f))
+        rule.waitForIdle()
+
+        assertThat(state.currentState).isEqualTo(B)
+        assertThat(state.targetState).isEqualTo(B)
+
+        // Swipe towards A, close after threshold
+        state.dispatchRawDelta(-(absThreshold * 0.2f))
+        rule.waitForIdle()
+
+        assertThat(state.currentState).isEqualTo(B)
+        assertThat(state.targetState).isEqualTo(A)
+
+        runBlocking(AutoTestFrameClock()) { state.settle(velocity = 0f) }
+
+        assertThat(state.currentState).isEqualTo(A)
+        assertThat(state.targetState).isEqualTo(A)
+    }
+
+    @Test
+    fun swipeable_velocityThreshold_settle_velocityHigherThanThreshold_advances() =
+        runBlocking(AutoTestFrameClock()) {
+            val velocity = 100.dp
+            val velocityPx = with(rule.density) { velocity.toPx() }
+            val state = with(rule) {
+                SwipeableTestState(
+                    initialState = A,
+                    anchors = mapOf(
+                        A to 0f,
+                        B to 100f,
+                        C to 200f
+                    ),
+                    velocityThreshold = velocity / 2
+                )
+            }
+            state.dispatchRawDelta(60f)
+            state.settle(velocityPx)
+            assertThat(state.currentState).isEqualTo(B)
+        }
+
+    @Test
+    fun swipeable_velocityThreshold_settle_velocityLowerThanThreshold_doesntAdvance() =
+        runBlocking(AutoTestFrameClock()) {
+            val velocity = 100.dp
+            val velocityPx = with(rule.density) { velocity.toPx() }
+            val state = SwipeableTestState(
+                initialState = A,
+                anchors = mapOf(
+                    A to 0f,
+                    B to 100f,
+                    C to 200f
+                ),
+                velocityThreshold = velocity,
+                positionalThreshold = { Float.POSITIVE_INFINITY }
+            )
+            state.dispatchRawDelta(60f)
+            state.settle(velocityPx / 2)
+            assertThat(state.currentState).isEqualTo(A)
+        }
+
+    @Test
+    fun swipeable_velocityThreshold_swipe_velocityHigherThanThreshold_advances() {
+        val velocityThreshold = 100.dp
+        val state = SwipeableTestState(
+            initialState = A,
+            velocityThreshold = velocityThreshold
+        )
+        rule.setContent { SwipeableBox(state) }
+
+        rule.onNodeWithTag(swipeableTestTag)
+            .performTouchInput {
+                swipeWithVelocity(
+                    start = Offset(left, 0f),
+                    end = Offset(right / 2, 0f),
+                    endVelocity = with(rule.density) { velocityThreshold.toPx() } * 1.1f
+                )
+            }
+
+        rule.waitForIdle()
+        assertThat(state.currentState).isEqualTo(B)
+    }
+
+    @Test
+    fun swipeable_velocityThreshold_swipe_velocityLowerThanThreshold_doesntAdvance() {
+        val velocityThreshold = 100.dp
+        val state = SwipeableTestState(
+            initialState = A,
+            velocityThreshold = velocityThreshold,
+            positionalThreshold = { Float.POSITIVE_INFINITY }
+        )
+        rule.setContent { SwipeableBox(state) }
+
+        rule.onNodeWithTag(swipeableTestTag)
+            .performTouchInput {
+                swipeWithVelocity(
+                    start = Offset(left, 0f),
+                    end = Offset(right / 2, 0f),
+                    endVelocity = with(rule.density) { velocityThreshold.toPx() } * 0.9f
+                )
+            }
+
+        rule.waitForIdle()
+        assertThat(state.currentState).isEqualTo(A)
+    }
+
+    private fun SwipeableTestState(
+        initialState: TestState,
+        density: Density = rule.density,
+        positionalThreshold: Density.(distance: Float) -> Float = { 56f },
+        velocityThreshold: Dp = 125.dp,
+        anchors: Map<TestState, Float>? = null
+    ) = SwipeableV2State(
+        initialState = initialState,
+        positionalThreshold = positionalThreshold,
+        velocityThreshold = velocityThreshold,
+        density = density
+    ).apply { if (anchors != null) updateAnchors(anchors) }
+
     private fun TouchInjectionScope.endEdge(orientation: Orientation) =
         if (orientation == Orientation.Horizontal) right else bottom
 
diff --git a/compose/material/material/src/androidAndroidTest/kotlin/androidx/compose/material/swipeable/SwipeableV2StateTest.kt b/compose/material/material/src/androidAndroidTest/kotlin/androidx/compose/material/swipeable/SwipeableV2StateTest.kt
index 888ce82..d7433e2 100644
--- a/compose/material/material/src/androidAndroidTest/kotlin/androidx/compose/material/swipeable/SwipeableV2StateTest.kt
+++ b/compose/material/material/src/androidAndroidTest/kotlin/androidx/compose/material/swipeable/SwipeableV2StateTest.kt
@@ -56,8 +56,9 @@
 
     @Test
     fun swipeable_state_canSkipStateByFling() {
-        val state = SwipeableV2State(A)
+        lateinit var state: SwipeableV2State<TestState>
         rule.setContent {
+            state = rememberSwipeableV2State(initialState = A)
             SwipeableBox(
                 swipeableState = state,
                 orientation = Orientation.Vertical,
@@ -75,8 +76,9 @@
 
     @Test
     fun swipeable_targetState_updatedOnSwipe() {
-        val state = SwipeableV2State(A)
+        lateinit var state: SwipeableV2State<TestState>
         rule.setContent {
+            state = rememberSwipeableV2State(initialState = A)
             SwipeableBox(
                 swipeableState = state,
                 orientation = Orientation.Vertical,
@@ -104,12 +106,13 @@
     fun swipeable_targetState_updatedWithAnimation() {
         rule.mainClock.autoAdvance = false
         val animationDuration = 300
-        val state = SwipeableV2State(
-            initialState = A,
-            animationSpec = tween(animationDuration, easing = LinearEasing)
-        )
+        lateinit var state: SwipeableV2State<TestState>
         lateinit var scope: CoroutineScope
         rule.setContent {
+            state = rememberSwipeableV2State(
+                initialState = A,
+                animationSpec = tween(animationDuration, easing = LinearEasing)
+            )
             scope = rememberCoroutineScope()
             SwipeableBox(
                 swipeableState = state,
@@ -142,8 +145,9 @@
 
     @Test
     fun swipeable_progress_matchesSwipePosition() {
-        val state = SwipeableV2State(A)
+        lateinit var state: SwipeableV2State<TestState>
         rule.setContent {
+            state = rememberSwipeableV2State(initialState = A)
             WithTouchSlop(touchSlop = 0f) {
                 SwipeableBox(
                     swipeableState = state,
@@ -175,8 +179,9 @@
 
     @Test
     fun swipeable_snapTo_updatesImmediately() = runBlocking {
-        val state = SwipeableV2State(A)
+        lateinit var state: SwipeableV2State<TestState>
         rule.setContent {
+            state = rememberSwipeableV2State(initialState = A)
             SwipeableBox(
                 swipeableState = state,
                 orientation = Orientation.Vertical
@@ -247,15 +252,22 @@
     }
 
     @Test
+    @Ignore("Todo: Fix differences between tests and real code - this shouldn't work :)")
     fun swipeable_requireOffset_accessedInInitialComposition_throws() {
         var exception: Throwable? = null
+        lateinit var state: SwipeableV2State<TestState>
+        var offset: Float? = null
         rule.setContent {
-            val state = rememberSwipeableV2State(initialState = B)
-            exception = runCatching { state.requireOffset() }.exceptionOrNull()
+            state = rememberSwipeableV2State(initialState = B)
+            SwipeableBox(state)
+            exception = runCatching { offset = state.requireOffset() }.exceptionOrNull()
         }
 
+        assertThat(state.anchors).isNotEmpty()
+        assertThat(offset).isNull()
         assertThat(exception).isNotNull()
         assertThat(exception).isInstanceOf(IllegalStateException::class.java)
+        assertThat(exception).hasMessageThat().contains("offset")
     }
 
     @Test
diff --git a/compose/material/material/src/commonMain/kotlin/androidx/compose/material/SwipeableV2.kt b/compose/material/material/src/commonMain/kotlin/androidx/compose/material/SwipeableV2.kt
index 03a7fc4..b21f1bc 100644
--- a/compose/material/material/src/commonMain/kotlin/androidx/compose/material/SwipeableV2.kt
+++ b/compose/material/material/src/commonMain/kotlin/androidx/compose/material/SwipeableV2.kt
@@ -17,6 +17,7 @@
 package androidx.compose.material
 
 import androidx.compose.animation.core.AnimationSpec
+import androidx.compose.animation.core.SpringSpec
 import androidx.compose.animation.core.animate
 import androidx.compose.foundation.gestures.DraggableState
 import androidx.compose.foundation.gestures.Orientation
@@ -33,7 +34,11 @@
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.layout.onSizeChanged
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.unit.Density
+import androidx.compose.ui.unit.Dp
 import androidx.compose.ui.unit.IntSize
+import androidx.compose.ui.unit.dp
 import kotlin.math.abs
 import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.launch
@@ -115,32 +120,49 @@
  *
  * This contains necessary information about any ongoing swipe or animation and provides methods
  * to change the state either immediately or by starting an animation. To create and remember a
- * [SwipeableState] use [rememberSwipeableState].
+ * [SwipeableV2State] use [rememberSwipeableV2State].
  *
  * @param initialState The initial value of the state.
+ * @param density The density used to convert thresholds from px to dp.
  * @param animationSpec The default animation that will be used to animate to a new state.
  * @param confirmStateChange Optional callback invoked to confirm or veto a pending state change.
+ * @param positionalThreshold The positional threshold to be used when calculating the target state
+ * while a swipe is in progress and when settling after the swipe ends. This is the distance from
+ * the start of a transition. It will be, depending on the direction of the interaction, added or
+ * subtracted from/to the origin offset. It should always be a positive value. See the
+ * [fractionalPositionalThreshold] and [fixedPositionalThreshold] methods.
+ * @param velocityThreshold The velocity threshold (in dp per second) that the end velocity has to
+ * exceed in order to animate to the next state, even if the [positionalThreshold] has not been
+ * reached.
  */
 @Stable
 @ExperimentalMaterialApi
 internal class SwipeableV2State<T>(
     initialState: T,
-    val animationSpec: AnimationSpec<Float> = SwipeableDefaults.AnimationSpec,
-    val confirmStateChange: (newValue: T) -> Boolean = { true },
+    internal val density: Density,
+    internal val animationSpec: AnimationSpec<Float> = SwipeableV2Defaults.AnimationSpec,
+    internal val confirmStateChange: (newValue: T) -> Boolean = { true },
+    internal val positionalThreshold: Density.(totalDistance: Float) -> Float =
+        SwipeableV2Defaults.PositionalThreshold,
+    internal val velocityThreshold: Dp = SwipeableV2Defaults.VelocityThreshold,
 ) {
 
     /**
-     * The current state of the [SwipeableState].
+     * The current state of the [SwipeableV2State].
      */
     var currentState: T by mutableStateOf(initialState)
         private set
 
     /**
      * The target state. This is the closest state to the current offset (taking into account
-     * positional thresholds). If no animation is in progress, this will be the current state.
+     * positional thresholds). If no interactions like animations or drags are in progress, this
+     * will be the current state.
      */
     val targetState: T by derivedStateOf {
-        if (offset != null) anchors.closestState(offset!!) else currentState
+        val currentOffset = offset
+        if (currentOffset != null) {
+            computeTarget(currentOffset, currentState, velocity = 0f)
+        } else currentState
     }
 
     /**
@@ -205,11 +227,7 @@
     private val minBound by derivedStateOf { anchors.minOrNull() ?: Float.NEGATIVE_INFINITY }
     private val maxBound by derivedStateOf { anchors.maxOrNull() ?: Float.POSITIVE_INFINITY }
 
-    private var positionalThresholds: (lower: T, upper: T) -> Float by mutableStateOf(
-        { _, _ -> 0f } // TODO
-    )
-
-    private var velocityThreshold by mutableStateOf(0f)
+    private val velocityThresholdPx = with(density) { velocityThreshold.toPx() }
 
     internal val draggableState = DraggableState {
         dragPosition = (dragPosition ?: 0f) + it
@@ -276,8 +294,10 @@
             }
             lastVelocity = 0f
         } finally {
-            val endOffset = requireNotNull(dragPosition) { "The drag position was in an " +
-                "invalid state. Please report this issue." }
+            val endOffset = requireNotNull(dragPosition) {
+                "The drag position was in an " +
+                    "invalid state. Please report this issue."
+            }
             val endState = anchors
                 .entries
                 .firstOrNull { (_, anchorOffset) -> abs(anchorOffset - endOffset) < 0.5f }
@@ -294,9 +314,7 @@
         val targetState = computeTarget(
             offset = requireOffset(),
             currentState = previousState,
-            thresholds = positionalThresholds,
-            velocity = velocity,
-            velocityThreshold = velocityThreshold
+            velocity = velocity
         )
         if (confirmStateChange(targetState)) {
             animateTo(targetState, velocity)
@@ -325,28 +343,31 @@
     private fun computeTarget(
         offset: Float,
         currentState: T,
-        thresholds: (lower: T, upper: T) -> Float,
-        velocity: Float,
-        velocityThreshold: Float
+        velocity: Float
     ): T {
         val currentAnchors = anchors
-        return if (currentAnchors.requireAnchor(currentState) <= offset) {
+        val currentAnchor = currentAnchors.requireAnchor(currentState)
+        return if (currentAnchor <= offset) {
             // Swiping from lower to upper (positive).
-            if (velocity >= velocityThreshold) {
+            if (velocity >= velocityThresholdPx) {
                 currentAnchors.closestState(offset, true)
             } else {
                 val upper = currentAnchors.closestState(offset, true)
-                val threshold = thresholds(currentState, upper)
-                if (offset < threshold) currentState else upper
+                val distance = abs(currentAnchors.getValue(upper) - currentAnchor)
+                val relativeThreshold = abs(positionalThreshold(density, distance))
+                val absoluteThreshold = abs(currentAnchor + relativeThreshold)
+                if (offset < absoluteThreshold) currentState else upper
             }
         } else {
             // Swiping from upper to lower (negative).
-            if (velocity <= -velocityThreshold) {
+            if (velocity <= -velocityThresholdPx) {
                 currentAnchors.closestState(offset, false)
             } else {
                 val lower = currentAnchors.closestState(offset, false)
-                val threshold = thresholds(currentState, lower)
-                if (offset > threshold) currentState else lower
+                val distance = abs(currentAnchor - currentAnchors.getValue(lower))
+                val relativeThreshold = abs(positionalThreshold(density, distance))
+                val absoluteThreshold = abs(currentAnchor - relativeThreshold)
+                if (offset > absoluteThreshold) currentState else lower
             }
         }
     }
@@ -355,9 +376,13 @@
         /**
          * The default [Saver] implementation for [SwipeableV2State].
          */
+        @ExperimentalMaterialApi
         fun <T : Any> Saver(
             animationSpec: AnimationSpec<Float>,
             confirmStateChange: (T) -> Boolean,
+            positionalThreshold: Density.(distance: Float) -> Float,
+            velocityThreshold: Dp,
+            density: Density
         ) = Saver<SwipeableV2State<T>, T>(
             save = { it.currentState },
             restore = {
@@ -365,6 +390,9 @@
                     initialState = it,
                     animationSpec = animationSpec,
                     confirmStateChange = confirmStateChange,
+                    positionalThreshold = positionalThreshold,
+                    velocityThreshold = velocityThreshold,
+                    density = density
                 )
             }
         )
@@ -382,28 +410,78 @@
 @ExperimentalMaterialApi
 internal fun <T : Any> rememberSwipeableV2State(
     initialState: T,
-    animationSpec: AnimationSpec<Float> = SwipeableDefaults.AnimationSpec,
-    confirmStateChange: (newValue: T) -> Boolean = { true },
+    animationSpec: AnimationSpec<Float> = SwipeableV2Defaults.AnimationSpec,
+    confirmStateChange: (newValue: T) -> Boolean = { true }
 ): SwipeableV2State<T> {
+    val density = LocalDensity.current
     return rememberSaveable(
+        initialState, animationSpec, confirmStateChange, density,
         saver = SwipeableV2State.Saver(
             animationSpec = animationSpec,
-            confirmStateChange = confirmStateChange
-        )
+            confirmStateChange = confirmStateChange,
+            positionalThreshold = SwipeableV2Defaults.PositionalThreshold,
+            velocityThreshold = SwipeableV2Defaults.VelocityThreshold,
+            density = density
+        ),
     ) {
         SwipeableV2State(
             initialState = initialState,
             animationSpec = animationSpec,
-            confirmStateChange = confirmStateChange
+            confirmStateChange = confirmStateChange,
+            positionalThreshold = SwipeableV2Defaults.PositionalThreshold,
+            velocityThreshold = SwipeableV2Defaults.VelocityThreshold,
+            density = density
         )
     }
 }
 
-private fun <T> Map<T, Float>.closestState(offset: Float = 0f): T {
-    require(isNotEmpty()) { "The anchors were empty when trying to find the closest state" }
-    return minBy { (_, anchor) ->
-        abs(anchor - offset)
-    }.key
+/**
+ * Expresses a fixed positional threshold of [threshold] dp. This will be the distance from an
+ * anchor that needs to be reached for [SwipeableV2State] to settle to the next closest anchor.
+ *
+ * @see [fractionalPositionalThreshold] for a fractional positional threshold
+ */
+@ExperimentalMaterialApi
+internal fun fixedPositionalThreshold(threshold: Dp): Density.(distance: Float) -> Float = {
+    threshold.toPx()
+}
+
+/**
+ * Expresses a relative positional threshold of the [fraction] of the distance to the closest anchor
+ * in the current direction. This will be the distance from an anchor that needs to be reached for
+ * [SwipeableV2State] to settle to the next closest anchor.
+ *
+ * @see [fixedPositionalThreshold] for a fixed positional threshold
+ */
+@ExperimentalMaterialApi
+internal fun fractionalPositionalThreshold(
+    fraction: Float
+): Density.(distance: Float) -> Float = { distance -> distance * fraction }
+
+/**
+ * Contains useful defaults for [swipeableV2] and [SwipeableV2State].
+ */
+@Stable
+@ExperimentalMaterialApi
+internal object SwipeableV2Defaults {
+    /**
+     * The default animation used by [SwipeableV2State].
+     */
+    @ExperimentalMaterialApi
+    val AnimationSpec = SpringSpec<Float>()
+
+    /**
+     * The default velocity threshold (1.8 dp per millisecond) used by [rememberSwipeableV2State].
+     */
+    @ExperimentalMaterialApi
+    val VelocityThreshold: Dp = 125.dp
+
+    /**
+     * The default positional threshold (56 dp) used by [rememberSwipeableV2State]
+     */
+    @ExperimentalMaterialApi
+    val PositionalThreshold: Density.(totalDistance: Float) -> Float =
+        fixedPositionalThreshold(56.dp)
 }
 
 private fun <T> Map<T, Float>.closestState(