diff --git a/CHANGELOG.md b/CHANGELOG.md
index e1931091c67..6c881195508 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -20,6 +20,7 @@ Mapbox welcomes participation and contributions from everyone.
   - `ViewOptionsCustomization.showEndNavigationButton` can be used to show/hide info panel's end navigation button. The default is `true`. [#6506](https://github.com/mapbox/mapbox-navigation-android/pull/6506)
 - Introduced `ViewOptionsCustomization.showPoiName` and `ViewOptionsCustomization.showArrivalText` that allows showing/hiding of the POI and arrival text view. [#6515](https://github.com/mapbox/mapbox-navigation-android/pull/6515)
 - Introduced `ViewBinderCustomization.infoPanelPoiNameBinder` and `ViewBinderCustomization.infoPanelArrivalTextBinder` that allows injection of custom Info Panel POI and arrival text view into `NavigationView`. [#6515](https://github.com/mapbox/mapbox-navigation-android/pull/6515)
+- Added experimental routes preview state, see `MapboxNavigaton#setRoutesPreview`, `MapboxNavigaton#changeRoutesPreviewPrimaryRoute`, `MapboxNavigaton#registerRoutesPreviewObserver`, `MapboxNavigaton#getRoutesPreview`. [#6495](https://github.com/mapbox/mapbox-navigation-android/pull/6495)
 #### Bug fixes and improvements
 - :warning: Removed `MapboxMapScalebarParams` and replaced `ViewStyleCustomization.mapScalebarParams` by `ViewOptionsCustomization.showMapScalebar` [#6523](https://github.com/mapbox/mapbox-navigation-android/pull/6523)
 - Refactored `ScalebarComponent` to use `ViewOptionsCustomization.distanceFormatterOptions` to change between imperial and metric based unit. [#6523](https://github.com/mapbox/mapbox-navigation-android/pull/6523)
diff --git a/examples/src/main/java/com/mapbox/navigation/examples/core/MapboxNavigationActivity.kt b/examples/src/main/java/com/mapbox/navigation/examples/core/MapboxNavigationActivity.kt
index 84ea81b9275..80cc3fd7fb1 100644
--- a/examples/src/main/java/com/mapbox/navigation/examples/core/MapboxNavigationActivity.kt
+++ b/examples/src/main/java/com/mapbox/navigation/examples/core/MapboxNavigationActivity.kt
@@ -5,6 +5,7 @@ import android.content.res.Configuration
 import android.content.res.Resources
 import android.location.Location
 import android.os.Bundle
+import android.view.View
 import android.view.View.INVISIBLE
 import android.view.View.VISIBLE
 import android.widget.Toast
@@ -19,8 +20,10 @@ import com.mapbox.maps.MapboxMap
 import com.mapbox.maps.Style.Companion.MAPBOX_STREETS
 import com.mapbox.maps.plugin.LocationPuck2D
 import com.mapbox.maps.plugin.animation.camera
+import com.mapbox.maps.plugin.gestures.OnMapClickListener
 import com.mapbox.maps.plugin.gestures.gestures
 import com.mapbox.maps.plugin.locationcomponent.location
+import com.mapbox.navigation.base.ExperimentalPreviewMapboxNavigationAPI
 import com.mapbox.navigation.base.TimeFormat
 import com.mapbox.navigation.base.extensions.applyDefaultNavigationOptions
 import com.mapbox.navigation.base.extensions.applyLanguageAndVoiceUnitOptions
@@ -35,6 +38,7 @@ import com.mapbox.navigation.core.MapboxNavigation
 import com.mapbox.navigation.core.MapboxNavigationProvider
 import com.mapbox.navigation.core.directions.session.RoutesObserver
 import com.mapbox.navigation.core.formatter.MapboxDistanceFormatter
+import com.mapbox.navigation.core.preview.RoutesPreviewObserver
 import com.mapbox.navigation.core.trip.session.LocationMatcherResult
 import com.mapbox.navigation.core.trip.session.LocationObserver
 import com.mapbox.navigation.core.trip.session.NavigationSessionStateObserver
@@ -52,11 +56,10 @@ import com.mapbox.navigation.ui.maps.location.NavigationLocationProvider
 import com.mapbox.navigation.ui.maps.route.arrow.api.MapboxRouteArrowApi
 import com.mapbox.navigation.ui.maps.route.arrow.api.MapboxRouteArrowView
 import com.mapbox.navigation.ui.maps.route.arrow.model.RouteArrowOptions
-import com.mapbox.navigation.ui.maps.route.line.MapboxRouteLineApiExtensions.setRoutes
+import com.mapbox.navigation.ui.maps.route.line.MapboxRouteLineApiExtensions.findClosestRoute
 import com.mapbox.navigation.ui.maps.route.line.api.MapboxRouteLineApi
 import com.mapbox.navigation.ui.maps.route.line.api.MapboxRouteLineView
 import com.mapbox.navigation.ui.maps.route.line.model.MapboxRouteLineOptions
-import com.mapbox.navigation.ui.maps.route.line.model.RouteLine
 import com.mapbox.navigation.ui.tripprogress.api.MapboxTripProgressApi
 import com.mapbox.navigation.ui.tripprogress.model.DistanceRemainingFormatter
 import com.mapbox.navigation.ui.tripprogress.model.EstimatedTimeToArrivalFormatter
@@ -75,6 +78,7 @@ import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 import java.util.Locale
 
+@OptIn(ExperimentalPreviewMapboxNavigationAPI::class)
 class MapboxNavigationActivity : AppCompatActivity() {
 
     /* ----- Layout binding reference ----- */
@@ -89,6 +93,8 @@ class MapboxNavigationActivity : AppCompatActivity() {
     // location puck integration
     private val navigationLocationProvider = NavigationLocationProvider()
 
+    private val waypoints = mutableListOf<Point>()
+
     // camera
     private lateinit var navigationCamera: NavigationCamera
     private lateinit var viewportDataSource: MapboxNavigationViewportDataSource
@@ -229,18 +235,17 @@ class MapboxNavigationActivity : AppCompatActivity() {
         }
 
     private val routesObserver = RoutesObserver { result ->
-        if (result.routes.isNotEmpty()) {
+        if (result.navigationRoutes.isNotEmpty()) {
             // generate route geometries asynchronously and render them
-            CoroutineScope(Dispatchers.Main).launch {
-                val result = routeLineAPI.setRoutes(
-                    listOf(RouteLine(result.routes.first(), null))
-                )
+            routeLineAPI.setNavigationRoutes(
+                result.navigationRoutes,
+                mapboxNavigation.getAlternativeMetadataFor(result.navigationRoutes)
+            ) {
                 val style = mapboxMap.getStyle()
                 if (style != null) {
-                    routeLineView.renderRouteDrawData(style, result)
+                    routeLineView.renderRouteDrawData(style, it)
                 }
             }
-
             // update the camera position to account for the new route
             viewportDataSource.onRouteChanged(result.routes.first())
             viewportDataSource.evaluate()
@@ -263,11 +268,52 @@ class MapboxNavigationActivity : AppCompatActivity() {
         }
     }
 
+    private val routesPreviewObserver = RoutesPreviewObserver { update ->
+        val routePreview = update.routesPreview
+        if (routePreview != null) {
+            routeLineAPI.setNavigationRoutes(
+                routePreview.routesList,
+                routePreview.alternativesMetadata
+            ) {
+                val style = mapboxMap.getStyle()
+                if (style != null) {
+                    routeLineView.renderRouteDrawData(style, it)
+                }
+            }
+            // update the camera position to account for the new route
+            viewportDataSource.onRouteChanged(routePreview.primaryRoute)
+            viewportDataSource.evaluate()
+
+            binding.mapView.gestures.removeOnMapClickListener(previewMapClickListener)
+            binding.mapView.gestures.addOnMapClickListener(previewMapClickListener)
+        } else {
+            binding.mapView.gestures.removeOnMapClickListener(previewMapClickListener)
+        }
+    }
+
     private val navigationSessionStateObserver = NavigationSessionStateObserver {
         logD("NavigationSessionState=$it", LOG_CATEGORY)
         logD("sessionId=${mapboxNavigation.getNavigationSessionState().sessionId}", LOG_CATEGORY)
     }
 
+    private val routeClickPadding = com.mapbox.android.gestures.Utils.dpToPx(30f)
+
+    private val previewMapClickListener = OnMapClickListener {
+        CoroutineScope(Dispatchers.Main).launch {
+            val result = routeLineAPI.findClosestRoute(
+                it,
+                binding.mapView.getMapboxMap(),
+                routeClickPadding
+            )
+
+            val routeFound = result.value?.navigationRoute
+            if (routeFound != null && routeFound != routeLineAPI.getPrimaryNavigationRoute()) {
+                mapboxNavigation.changeRoutesPreviewPrimaryRoute(routeFound)
+            }
+        }
+        false
+    }
+
     @SuppressLint("MissingPermission")
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
@@ -438,6 +484,7 @@ class MapboxNavigationActivity : AppCompatActivity() {
         mapboxNavigation.registerRouteProgressObserver(routeProgressObserver)
         mapboxNavigation.registerLocationObserver(locationObserver)
         mapboxNavigation.registerVoiceInstructionsObserver(voiceInstructionsObserver)
+        mapboxNavigation.registerRoutesPreviewObserver(routesPreviewObserver)
     }
 
     override fun onStop() {
@@ -447,6 +494,7 @@ class MapboxNavigationActivity : AppCompatActivity() {
         mapboxNavigation.unregisterRouteProgressObserver(routeProgressObserver)
         mapboxNavigation.unregisterLocationObserver(locationObserver)
         mapboxNavigation.unregisterVoiceInstructionsObserver(voiceInstructionsObserver)
+        mapboxNavigation.unregisterRoutesPreviewObserver(routesPreviewObserver)
     }
 
     override fun onDestroy() {
@@ -464,19 +512,23 @@ class MapboxNavigationActivity : AppCompatActivity() {
             Point.fromLngLat(it.longitude, it.latitude)
         } ?: return
 
+        waypoints.add(destination)
+        val coordinates = listOf(origin) + waypoints
+        val layersList = listOf(mapboxNavigation.getZLevel()) + waypoints.map { null }
         mapboxNavigation.requestRoutes(
             RouteOptions.builder()
                 .applyDefaultNavigationOptions()
                 .applyLanguageAndVoiceUnitOptions(this)
-                .coordinatesList(listOf(origin, destination))
-                .layersList(listOf(mapboxNavigation.getZLevel(), null))
+                .alternatives(true)
+                .coordinatesList(coordinates)
+                .layersList(layersList)
                 .build(),
             object : NavigationRouterCallback {
                 override fun onRoutesReady(
                     routes: List<NavigationRoute>,
                     routerOrigin: RouterOrigin
                 ) {
-                    setRouteAndStartNavigation(routes)
+                    setRoutesPreview(routes)
                 }
 
                 override fun onFailure(
@@ -493,6 +545,19 @@ class MapboxNavigationActivity : AppCompatActivity() {
         )
     }
 
+    private fun setRoutesPreview(routes: List<NavigationRoute>) {
+        binding.navigateButton.apply {
+            visibility = View.VISIBLE
+            setOnClickListener {
+                visibility = View.GONE
+                setRouteAndStartNavigation(mapboxNavigation.getRoutesPreview()!!.routesList)
+                mapboxNavigation.setRoutesPreview(emptyList())
+                waypoints.clear()
+            }
+        }
+        mapboxNavigation.setRoutesPreview(routes)
+    }
+
     private fun setRouteAndStartNavigation(route: List<NavigationRoute>) {
         // set route
         mapboxNavigation.setNavigationRoutes(route)
diff --git a/examples/src/main/res/layout/layout_activity_navigation.xml b/examples/src/main/res/layout/layout_activity_navigation.xml
index 1a6f38c5d9e..85d34baa5bf 100644
--- a/examples/src/main/res/layout/layout_activity_navigation.xml
+++ b/examples/src/main/res/layout/layout_activity_navigation.xml
@@ -2,7 +2,9 @@
 <androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:app="http://schemas.android.com/apk/res-auto"
     android:layout_width="match_parent"
-    android:layout_height="match_parent">
+    android:layout_height="match_parent"
+    xmlns:tools="http://schemas.android.com/tools"
+    >
 
     <com.mapbox.maps.MapView
         android:id="@+id/mapView"
@@ -77,4 +79,15 @@
         app:layout_constraintEnd_toEndOf="parent"
         app:layout_constraintTop_toBottomOf="@id/routeOverview" />
 
+    <Button
+        android:id="@+id/navigateButton"
+        android:layout_width="0dp"
+        android:layout_height="wrap_content"
+        app:layout_constraintEnd_toEndOf="parent"
+        app:layout_constraintStart_toStartOf="parent"
+        app:layout_constraintBottom_toBottomOf="parent"
+        android:visibility="gone"
+        tools:visibility="visible"
+        android:text="Navigate"/>
+
 </androidx.constraintlayout.widget.ConstraintLayout>
diff --git a/instrumentation-tests/src/androidTest/java/com/mapbox/navigation/instrumentation_tests/core/RoutesPreviewTest.kt b/instrumentation-tests/src/androidTest/java/com/mapbox/navigation/instrumentation_tests/core/RoutesPreviewTest.kt
new file mode 100644
index 00000000000..79c93bf9b41
--- /dev/null
+++ b/instrumentation-tests/src/androidTest/java/com/mapbox/navigation/instrumentation_tests/core/RoutesPreviewTest.kt
@@ -0,0 +1,139 @@
+package com.mapbox.navigation.instrumentation_tests.core
+
+import android.location.Location
+import com.mapbox.navigation.base.ExperimentalPreviewMapboxNavigationAPI
+import com.mapbox.navigation.base.options.NavigationOptions
+import com.mapbox.navigation.base.route.NavigationRoute
+import com.mapbox.navigation.base.trip.model.RouteProgressState
+import com.mapbox.navigation.core.MapboxNavigation
+import com.mapbox.navigation.core.MapboxNavigationProvider
+import com.mapbox.navigation.core.directions.session.RoutesExtra
+import com.mapbox.navigation.core.directions.session.RoutesUpdatedResult
+import com.mapbox.navigation.core.preview.RoutesPreviewUpdate
+import com.mapbox.navigation.core.preview.RoutesPreviewUpdateReasons
+import com.mapbox.navigation.instrumentation_tests.activity.EmptyTestActivity
+import com.mapbox.navigation.instrumentation_tests.utils.MapboxNavigationRule
+import com.mapbox.navigation.instrumentation_tests.utils.coroutines.routeProgressUpdates
+import com.mapbox.navigation.instrumentation_tests.utils.coroutines.routesPreviewUpdates
+import com.mapbox.navigation.instrumentation_tests.utils.coroutines.routesUpdates
+import com.mapbox.navigation.instrumentation_tests.utils.coroutines.sdkTest
+import com.mapbox.navigation.instrumentation_tests.utils.routes.RoutesProvider
+import com.mapbox.navigation.instrumentation_tests.utils.routes.RoutesProvider.toNavigationRoutes
+import com.mapbox.navigation.testing.ui.BaseTest
+import com.mapbox.navigation.testing.ui.utils.getMapboxAccessTokenFromResources
+import com.mapbox.navigation.testing.ui.utils.runOnMainSync
+import kotlinx.coroutines.flow.first
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+
+@OptIn(ExperimentalPreviewMapboxNavigationAPI::class)
+class RoutesPreviewTest : BaseTest<EmptyTestActivity>(EmptyTestActivity::class.java) {
+
+    override fun setupMockLocation(): Location = mockLocationUpdatesRule.generateLocationUpdate {
+        latitude = 38.894721
+        longitude = -77.031991
+    }
+
+    @get:Rule
+    val mapboxNavigationRule = MapboxNavigationRule()
+    private lateinit var mapboxNavigation: MapboxNavigation
+
+    @Before
+    fun setUp() {
+        runOnMainSync {
+            mapboxNavigation = MapboxNavigationProvider.create(
+                NavigationOptions.Builder(activity)
+                    .accessToken(getMapboxAccessTokenFromResources(activity))
+                    .build()
+            )
+        }
+    }
+
+    @Test
+    fun transitions_free_drive_to_preview_to_active_guidance_to_free_drive() = sdkTest {
+        var currentRoutesPreview: RoutesPreviewUpdate? = null
+        mapboxNavigation.registerRoutesPreviewObserver { update ->
+            currentRoutesPreview = update
+        }
+        var currentRoutes: RoutesUpdatedResult? = null
+        mapboxNavigation.registerRoutesObserver { update ->
+            currentRoutes = update
+        }
+        // initial free drive
+        mapboxNavigation.startTripSession()
+        assertNull(currentRoutesPreview)
+        assertNull(currentRoutes)
+        // set routes preview
+        val routes = RoutesProvider.dc_very_short(activity).toNavigationRoutes()
+        mapboxNavigation.setRoutesPreview(routes)
+        mapboxNavigation.routesPreviewUpdates()
+            .first { it.reason == RoutesPreviewUpdateReasons.PREVIEW_NEW }
+        assertEquals(RoutesPreviewUpdateReasons.PREVIEW_NEW, currentRoutesPreview?.reason)
+        assertEquals(routes, currentRoutesPreview!!.routesPreview!!.routesList)
+        assertNull(currentRoutes)
+        // start active guidance
+        mapboxNavigation.setNavigationRoutes(currentRoutesPreview!!.routesPreview!!.routesList)
+        mapboxNavigation.setRoutesPreview(emptyList())
+        mapboxNavigation.routesUpdates()
+            .first { it.reason == RoutesExtra.ROUTES_UPDATE_REASON_NEW }
+        mapboxNavigation.routeProgressUpdates()
+            .first { it.currentState == RouteProgressState.TRACKING }
+        assertEquals(RoutesPreviewUpdateReasons.PREVIEW_CLEAN_UP, currentRoutesPreview?.reason)
+        assertNull(currentRoutesPreview!!.routesPreview)
+        assertEquals(RoutesExtra.ROUTES_UPDATE_REASON_NEW, currentRoutes!!.reason)
+        assertEquals(routes, currentRoutes!!.navigationRoutes)
+        // back to free drive
+        mapboxNavigation.setNavigationRoutes(emptyList())
+        mapboxNavigation.routesUpdates()
+            .first { it.reason == RoutesExtra.ROUTES_UPDATE_REASON_CLEAN_UP }
+        assertEquals(RoutesPreviewUpdateReasons.PREVIEW_CLEAN_UP, currentRoutesPreview?.reason)
+        assertNull(currentRoutesPreview!!.routesPreview)
+        assertEquals(RoutesExtra.ROUTES_UPDATE_REASON_CLEAN_UP, currentRoutes!!.reason)
+        assertEquals(emptyList<NavigationRoute>(), currentRoutes!!.navigationRoutes)
+    }
+
+    @Test
+    fun route_preview_in_parallel_to_active_guidance() = sdkTest {
+        var currentRoutesPreview: RoutesPreviewUpdate? = null
+        mapboxNavigation.registerRoutesPreviewObserver { update ->
+            currentRoutesPreview = update
+        }
+        var currentRoutes: RoutesUpdatedResult? = null
+        mapboxNavigation.registerRoutesObserver { update ->
+            currentRoutes = update
+        }
+        // initial free drive
+        mapboxNavigation.startTripSession()
+        assertNull(currentRoutesPreview)
+        assertNull(currentRoutes)
+        // set routes preview
+        val initialRoutes = RoutesProvider.dc_very_short(activity).toNavigationRoutes()
+        mapboxNavigation.setRoutesPreview(initialRoutes)
+        mapboxNavigation.routesPreviewUpdates()
+            .first { it.reason == RoutesPreviewUpdateReasons.PREVIEW_NEW }
+        // start active guidance
+        mapboxNavigation.setNavigationRoutes(currentRoutesPreview!!.routesPreview!!.routesList)
+        mapboxNavigation.setRoutesPreview(emptyList())
+        mapboxNavigation.routeProgressUpdates()
+            .first { it.currentState == RouteProgressState.TRACKING }
+        // preview a different route not leaving action guidance
+        val updatedRoutes = RoutesProvider.dc_very_short_two_legs(activity).toNavigationRoutes()
+        mapboxNavigation.setRoutesPreview(updatedRoutes)
+        mapboxNavigation.routesPreviewUpdates()
+            .first { it.routesPreview?.routesList == updatedRoutes }
+        assertEquals(
+            "active guidance should track initial routes",
+            initialRoutes,
+            currentRoutes?.navigationRoutes
+        )
+        // user decided to switch to previewed routes
+        mapboxNavigation.setNavigationRoutes(currentRoutesPreview!!.routesPreview!!.routesList)
+        mapboxNavigation.setRoutesPreview(emptyList())
+        mapboxNavigation.routeProgressUpdates().first {
+            it.navigationRoute == updatedRoutes[0]
+        }
+    }
+}
diff --git a/instrumentation-tests/src/androidTest/java/com/mapbox/navigation/instrumentation_tests/utils/coroutines/Adapters.kt b/instrumentation-tests/src/androidTest/java/com/mapbox/navigation/instrumentation_tests/utils/coroutines/Adapters.kt
index c60800b143d..cee8b4d27ff 100644
--- a/instrumentation-tests/src/androidTest/java/com/mapbox/navigation/instrumentation_tests/utils/coroutines/Adapters.kt
+++ b/instrumentation-tests/src/androidTest/java/com/mapbox/navigation/instrumentation_tests/utils/coroutines/Adapters.kt
@@ -6,6 +6,7 @@ import com.mapbox.api.directions.v5.models.BannerInstructions
 import com.mapbox.api.directions.v5.models.RouteOptions
 import com.mapbox.api.directions.v5.models.VoiceInstructions
 import com.mapbox.bindgen.Expected
+import com.mapbox.navigation.base.ExperimentalPreviewMapboxNavigationAPI
 import com.mapbox.navigation.base.route.NavigationRoute
 import com.mapbox.navigation.base.route.NavigationRouterCallback
 import com.mapbox.navigation.base.route.RouterFailure
@@ -18,6 +19,8 @@ import com.mapbox.navigation.core.RoutesSetError
 import com.mapbox.navigation.core.RoutesSetSuccess
 import com.mapbox.navigation.core.directions.session.RoutesObserver
 import com.mapbox.navigation.core.directions.session.RoutesUpdatedResult
+import com.mapbox.navigation.core.preview.RoutesPreviewObserver
+import com.mapbox.navigation.core.preview.RoutesPreviewUpdate
 import com.mapbox.navigation.core.trip.session.BannerInstructionsObserver
 import com.mapbox.navigation.core.trip.session.RoadObjectsOnRouteObserver
 import com.mapbox.navigation.core.trip.session.RouteProgressObserver
@@ -43,6 +46,20 @@ fun MapboxNavigation.routesUpdates(): Flow<RoutesUpdatedResult> {
     }
 }
 
+@ExperimentalPreviewMapboxNavigationAPI
+fun MapboxNavigation.routesPreviewUpdates(): Flow<RoutesPreviewUpdate> {
+    val navigation = this
+    return callbackFlow {
+        val observer = RoutesPreviewObserver {
+            trySend(it)
+        }
+        navigation.registerRoutesPreviewObserver(observer)
+        awaitClose {
+            navigation.unregisterRoutesPreviewObserver(observer)
+        }
+    }
+}
+
 fun MapboxNavigation.routeProgressUpdates(): Flow<RouteProgress> {
     val navigation = this
     return callbackFlow {
diff --git a/libnavigation-core/api/current.txt b/libnavigation-core/api/current.txt
index 20d39b80185..df860215551 100644
--- a/libnavigation-core/api/current.txt
+++ b/libnavigation-core/api/current.txt
@@ -13,6 +13,7 @@ package com.mapbox.navigation.core {
   @UiThread public final class MapboxNavigation {
     ctor public MapboxNavigation(com.mapbox.navigation.base.options.NavigationOptions navigationOptions);
     method public void cancelRouteRequest(long requestId);
+    method @com.mapbox.navigation.base.ExperimentalPreviewMapboxNavigationAPI @kotlin.jvm.Throws(exceptionClasses=IllegalArgumentException::class) public void changeRoutesPreviewPrimaryRoute(com.mapbox.navigation.base.route.NavigationRoute newPrimaryRoute) throws java.lang.IllegalArgumentException;
     method public com.mapbox.navigation.core.routealternatives.AlternativeRouteMetadata? getAlternativeMetadataFor(com.mapbox.navigation.base.route.NavigationRoute navigationRoute);
     method public java.util.List<com.mapbox.navigation.core.routealternatives.AlternativeRouteMetadata> getAlternativeMetadataFor(java.util.List<com.mapbox.navigation.base.route.NavigationRoute> navigationRoutes);
     method public com.mapbox.navigator.Experimental getExperimental();
@@ -26,6 +27,7 @@ package com.mapbox.navigation.core {
     method public com.mapbox.navigation.core.trip.session.eh.RoadObjectMatcher getRoadObjectMatcher();
     method public com.mapbox.navigation.core.trip.session.eh.RoadObjectsStore getRoadObjectsStore();
     method @Deprecated public java.util.List<com.mapbox.api.directions.v5.models.DirectionsRoute> getRoutes();
+    method @com.mapbox.navigation.base.ExperimentalPreviewMapboxNavigationAPI public com.mapbox.navigation.core.preview.RoutesPreview? getRoutesPreview();
     method public com.mapbox.navigation.core.navigator.TilesetDescriptorFactory getTilesetDescriptorFactory();
     method public com.mapbox.navigation.core.trip.session.TripSessionState getTripSessionState();
     method public Integer? getZLevel();
@@ -53,6 +55,7 @@ package com.mapbox.navigation.core {
     method public void registerRouteProgressObserver(com.mapbox.navigation.core.trip.session.RouteProgressObserver routeProgressObserver);
     method @com.mapbox.navigation.base.ExperimentalPreviewMapboxNavigationAPI public void registerRouteRefreshStateObserver(com.mapbox.navigation.core.routerefresh.RouteRefreshStatesObserver routeRefreshStatesObserver);
     method public void registerRoutesObserver(com.mapbox.navigation.core.directions.session.RoutesObserver routesObserver);
+    method @com.mapbox.navigation.base.ExperimentalPreviewMapboxNavigationAPI public void registerRoutesPreviewObserver(com.mapbox.navigation.core.preview.RoutesPreviewObserver observer);
     method public void registerTripSessionStateObserver(com.mapbox.navigation.core.trip.session.TripSessionStateObserver tripSessionStateObserver);
     method public void registerVoiceInstructionsObserver(com.mapbox.navigation.core.trip.session.VoiceInstructionsObserver voiceInstructionsObserver);
     method public void requestAlternativeRoutes();
@@ -73,6 +76,8 @@ package com.mapbox.navigation.core {
     method public void setRerouteOptionsAdapter(com.mapbox.navigation.core.reroute.RerouteOptionsAdapter? rerouteOptionsAdapter);
     method @Deprecated public void setRoutes(java.util.List<? extends com.mapbox.api.directions.v5.models.DirectionsRoute> routes, int initialLegIndex = 0);
     method @Deprecated public void setRoutes(java.util.List<? extends com.mapbox.api.directions.v5.models.DirectionsRoute> routes);
+    method @com.mapbox.navigation.base.ExperimentalPreviewMapboxNavigationAPI public void setRoutesPreview(java.util.List<com.mapbox.navigation.base.route.NavigationRoute> routes, int primaryRouteIndex = 0);
+    method @com.mapbox.navigation.base.ExperimentalPreviewMapboxNavigationAPI public void setRoutesPreview(java.util.List<com.mapbox.navigation.base.route.NavigationRoute> routes);
     method public void setTripNotificationInterceptor(com.mapbox.navigation.base.trip.notification.TripNotificationInterceptor? interceptor);
     method @com.mapbox.navigation.base.ExperimentalPreviewMapboxNavigationAPI public void startReplayTripSession(boolean withForegroundService = true);
     method @RequiresPermission(anyOf={android.Manifest.permission.ACCESS_COARSE_LOCATION, android.Manifest.permission.ACCESS_FINE_LOCATION}) public void startTripSession(boolean withForegroundService = true);
@@ -92,6 +97,7 @@ package com.mapbox.navigation.core {
     method public void unregisterRouteProgressObserver(com.mapbox.navigation.core.trip.session.RouteProgressObserver routeProgressObserver);
     method @com.mapbox.navigation.base.ExperimentalPreviewMapboxNavigationAPI public void unregisterRouteRefreshStateObserver(com.mapbox.navigation.core.routerefresh.RouteRefreshStatesObserver routeRefreshStatesObserver);
     method public void unregisterRoutesObserver(com.mapbox.navigation.core.directions.session.RoutesObserver routesObserver);
+    method @com.mapbox.navigation.base.ExperimentalPreviewMapboxNavigationAPI public void unregisterRoutesPreviewObserver(com.mapbox.navigation.core.preview.RoutesPreviewObserver observer);
     method public void unregisterTripSessionStateObserver(com.mapbox.navigation.core.trip.session.TripSessionStateObserver tripSessionStateObserver);
     method public void unregisterVoiceInstructionsObserver(com.mapbox.navigation.core.trip.session.VoiceInstructionsObserver voiceInstructionsObserver);
     property public final com.mapbox.navigator.Experimental experimental;
@@ -384,6 +390,43 @@ package com.mapbox.navigation.core.navigator {
 
 }
 
+package com.mapbox.navigation.core.preview {
+
+  @StringDef({com.mapbox.navigation.core.preview.RoutesPreviewUpdateReasons.PREVIEW_NEW, com.mapbox.navigation.core.preview.RoutesPreviewUpdateReasons.PREVIEW_CLEAN_UP}) @kotlin.annotation.Retention(kotlin.annotation.AnnotationRetention.BINARY) public @interface RoutePreviewUpdateReason {
+  }
+
+  @com.mapbox.navigation.base.ExperimentalPreviewMapboxNavigationAPI public final class RoutesPreview {
+    method public java.util.List<com.mapbox.navigation.core.routealternatives.AlternativeRouteMetadata> getAlternativesMetadata();
+    method public java.util.List<com.mapbox.navigation.base.route.NavigationRoute> getOriginalRoutesList();
+    method public com.mapbox.navigation.base.route.NavigationRoute getPrimaryRoute();
+    method public int getPrimaryRouteIndex();
+    method public java.util.List<com.mapbox.navigation.base.route.NavigationRoute> getRoutesList();
+    property public final java.util.List<com.mapbox.navigation.core.routealternatives.AlternativeRouteMetadata> alternativesMetadata;
+    property public final java.util.List<com.mapbox.navigation.base.route.NavigationRoute> originalRoutesList;
+    property public final com.mapbox.navigation.base.route.NavigationRoute primaryRoute;
+    property public final int primaryRouteIndex;
+    property public final java.util.List<com.mapbox.navigation.base.route.NavigationRoute> routesList;
+  }
+
+  @com.mapbox.navigation.base.ExperimentalPreviewMapboxNavigationAPI public fun interface RoutesPreviewObserver {
+    method public void routesPreviewUpdated(com.mapbox.navigation.core.preview.RoutesPreviewUpdate update);
+  }
+
+  @com.mapbox.navigation.base.ExperimentalPreviewMapboxNavigationAPI public final class RoutesPreviewUpdate {
+    method public String getReason();
+    method public com.mapbox.navigation.core.preview.RoutesPreview? getRoutesPreview();
+    property public final String reason;
+    property public final com.mapbox.navigation.core.preview.RoutesPreview? routesPreview;
+  }
+
+  public final class RoutesPreviewUpdateReasons {
+    field public static final com.mapbox.navigation.core.preview.RoutesPreviewUpdateReasons INSTANCE;
+    field public static final String PREVIEW_CLEAN_UP = "PREVIEW_CLEAN_UP";
+    field public static final String PREVIEW_NEW = "PREVIEW_SET";
+  }
+
+}
+
 package com.mapbox.navigation.core.replay {
 
   @UiThread public final class MapboxReplayer {
diff --git a/libnavigation-core/src/main/java/com/mapbox/navigation/core/MapboxNavigation.kt b/libnavigation-core/src/main/java/com/mapbox/navigation/core/MapboxNavigation.kt
index f21626e91f0..339fde4033e 100644
--- a/libnavigation-core/src/main/java/com/mapbox/navigation/core/MapboxNavigation.kt
+++ b/libnavigation-core/src/main/java/com/mapbox/navigation/core/MapboxNavigation.kt
@@ -64,6 +64,8 @@ import com.mapbox.navigation.core.internal.utils.paramsProvider
 import com.mapbox.navigation.core.lifecycle.MapboxNavigationApp
 import com.mapbox.navigation.core.navigator.CacheHandleWrapper
 import com.mapbox.navigation.core.navigator.TilesetDescriptorFactory
+import com.mapbox.navigation.core.preview.RoutesPreview
+import com.mapbox.navigation.core.preview.RoutesPreviewObserver
 import com.mapbox.navigation.core.replay.MapboxReplayer
 import com.mapbox.navigation.core.reroute.LegacyRerouteControllerAdapter
 import com.mapbox.navigation.core.reroute.MapboxRerouteController
@@ -275,6 +277,11 @@ class MapboxNavigation @VisibleForTesting internal constructor(
         ),
     )
 
+    @ExperimentalPreviewMapboxNavigationAPI
+    private val routesPreviewController = NavigationComponentProvider.createRoutesPreviewController(
+        threadController.getMainScopeAndRootJob().scope
+    )
+
     private val routeUpdateMutex = Mutex()
 
     // native Router Interface
@@ -844,6 +851,73 @@ class MapboxNavigation @VisibleForTesting internal constructor(
         )
     }
 
+    /***
+     * Sets routes to preview. Triggers an update in [RoutesPreviewObserver].
+     *
+     * If [routes] isn't empty, the route with [primaryRouteIndex] is considered as primary, the others as alternatives.
+     * To cleanup routes preview state pass an empty list as [routes].
+     *
+     * Use [RoutesPreview.routesList] to start Active Guidance after route's preview:
+     * ```
+     * mapboxNavigation.getRoutesPreview()?.routesList?.let{ routesList ->
+     *     mapboxNavigation.setNavigationRoutes(routesList)
+     * }
+     * ```
+     * Routes preview state is controlled by the SDK's user. If you want to stop routes preview when you start active guidance, do it manually:
+     * ```
+     * mapboxNavigation.setRoutesPreview(emptyList())
+     * ```
+     *
+     * @param routes to preview
+     * @param primaryRouteIndex index of primary route from [routes]
+     */
+    @ExperimentalPreviewMapboxNavigationAPI
+    @JvmOverloads
+    fun setRoutesPreview(routes: List<NavigationRoute>, primaryRouteIndex: Int = 0) {
+        routesPreviewController.previewNavigationRoutes(routes, primaryRouteIndex)
+    }
+
+    /***
+     * Changes primary route for current preview state without changing order of [RoutesPreview.originalRoutesList].
+     * Order is important for a case when routes are displayed as a list on UI, the list shouldn't change order when a user choose different primary route.
+     *
+     * In case [changeRoutesPreviewPrimaryRoute] is called while the the other set of routes are being processed, the current state with a new routes will be reapplied after the current processing.
+     *
+     * @param newPrimaryRoute is a new primary route
+     * @throws [IllegalArgumentException] if [newPrimaryRoute] isn't found in the previewed routes list
+     */
+    @ExperimentalPreviewMapboxNavigationAPI
+    @Throws(IllegalArgumentException::class)
+    fun changeRoutesPreviewPrimaryRoute(newPrimaryRoute: NavigationRoute) {
+        routesPreviewController.changeRoutesPreviewPrimaryRoute(newPrimaryRoute)
+    }
+
+    /***
+     * Registers [RoutesPreviewObserver] to be notified when routes preview state changes.
+     * [observer] is immediately called with current preview state
+     *
+     * @param observer to be called on routes preview state changes
+     */
+    @ExperimentalPreviewMapboxNavigationAPI
+    fun registerRoutesPreviewObserver(observer: RoutesPreviewObserver) {
+        routesPreviewController.registerPreviewRoutesObserver(observer)
+    }
+
+    /***
+     * Unregisters observer which were registered using [registerRoutesPreviewObserver]
+     * @param observer which stops receiving updates when routes preview changes
+     */
+    @ExperimentalPreviewMapboxNavigationAPI
+    fun unregisterRoutesPreviewObserver(observer: RoutesPreviewObserver) {
+        routesPreviewController.unregisterPreviewRoutesObserver(observer)
+    }
+
+    /***
+     * Returns current state of routes preview
+     */
+    @ExperimentalPreviewMapboxNavigationAPI
+    fun getRoutesPreview(): RoutesPreview? = routesPreviewController.getRoutesPreview()
+
     /**
      * Requests road graph data update and invokes the callback on result.
      * Use this method if the frequency of application relaunch is too low
diff --git a/libnavigation-core/src/main/java/com/mapbox/navigation/core/NavigationComponentProvider.kt b/libnavigation-core/src/main/java/com/mapbox/navigation/core/NavigationComponentProvider.kt
index 8ff49301c22..0ee42181e10 100644
--- a/libnavigation-core/src/main/java/com/mapbox/navigation/core/NavigationComponentProvider.kt
+++ b/libnavigation-core/src/main/java/com/mapbox/navigation/core/NavigationComponentProvider.kt
@@ -1,6 +1,7 @@
 package com.mapbox.navigation.core
 
 import android.content.Context
+import com.mapbox.navigation.base.ExperimentalPreviewMapboxNavigationAPI
 import com.mapbox.navigation.base.internal.NavigationRouterV2
 import com.mapbox.navigation.base.options.NavigationOptions
 import com.mapbox.navigation.base.trip.notification.TripNotification
@@ -8,6 +9,8 @@ import com.mapbox.navigation.core.accounts.BillingController
 import com.mapbox.navigation.core.arrival.ArrivalProgressObserver
 import com.mapbox.navigation.core.directions.session.DirectionsSession
 import com.mapbox.navigation.core.directions.session.MapboxDirectionsSession
+import com.mapbox.navigation.core.preview.NativeRoutesDataParser
+import com.mapbox.navigation.core.preview.RoutesPreviewController
 import com.mapbox.navigation.core.trip.service.MapboxTripService
 import com.mapbox.navigation.core.trip.service.TripService
 import com.mapbox.navigation.core.trip.session.MapboxTripSession
@@ -22,6 +25,7 @@ import com.mapbox.navigator.ConfigHandle
 import com.mapbox.navigator.HistoryRecorderHandle
 import com.mapbox.navigator.RouterInterface
 import com.mapbox.navigator.TilesConfig
+import kotlinx.coroutines.CoroutineScope
 
 internal object NavigationComponentProvider {
 
@@ -101,4 +105,12 @@ internal object NavigationComponentProvider {
 
     fun createRouteRefreshRequestDataProvider(): RouteRefreshRequestDataProvider =
         RouteRefreshRequestDataProvider()
+
+    @ExperimentalPreviewMapboxNavigationAPI
+    fun createRoutesPreviewController(
+        scope: CoroutineScope
+    ) = RoutesPreviewController(
+        routesDataParser = NativeRoutesDataParser(),
+        scope = scope
+    )
 }
diff --git a/libnavigation-core/src/main/java/com/mapbox/navigation/core/preview/NativeRoutesDataParser.kt b/libnavigation-core/src/main/java/com/mapbox/navigation/core/preview/NativeRoutesDataParser.kt
new file mode 100644
index 00000000000..24fda8ef9d8
--- /dev/null
+++ b/libnavigation-core/src/main/java/com/mapbox/navigation/core/preview/NativeRoutesDataParser.kt
@@ -0,0 +1,18 @@
+package com.mapbox.navigation.core.preview
+
+import com.mapbox.navigation.base.internal.route.nativeRoute
+import com.mapbox.navigation.base.route.NavigationRoute
+import com.mapbox.navigation.utils.internal.ThreadController
+import com.mapbox.navigator.RouteParser
+import com.mapbox.navigator.RoutesData
+import kotlinx.coroutines.withContext
+
+internal class NativeRoutesDataParser : RoutesDataParser {
+    override suspend fun parse(routes: List<NavigationRoute>): RoutesData =
+        withContext(ThreadController.DefaultDispatcher) {
+            RouteParser.createRoutesData(
+                routes.first().nativeRoute(),
+                routes.drop(1).map { it.nativeRoute() }
+            )
+        }
+}
diff --git a/libnavigation-core/src/main/java/com/mapbox/navigation/core/preview/RoutesPreview.kt b/libnavigation-core/src/main/java/com/mapbox/navigation/core/preview/RoutesPreview.kt
new file mode 100644
index 00000000000..fed781f0c0a
--- /dev/null
+++ b/libnavigation-core/src/main/java/com/mapbox/navigation/core/preview/RoutesPreview.kt
@@ -0,0 +1,74 @@
+package com.mapbox.navigation.core.preview
+
+import com.mapbox.navigation.base.ExperimentalPreviewMapboxNavigationAPI
+import com.mapbox.navigation.base.route.NavigationRoute
+import com.mapbox.navigation.core.MapboxNavigation
+import com.mapbox.navigation.core.routealternatives.AlternativeRouteMetadata
+
+/***
+ * @param routesList - previewed routes ordered in way specific for mapbox navigation: [primary, alternative1, alternative2].
+ * @param alternativesMetadata - alternative metadata for valid alternatives from [routesList]
+ * @param originalRoutesList - original routes list which doesn't change order no matter which primary route is selected.
+ * @param primaryRouteIndex - index of primary route from the [originalRoutesList]
+ *
+ * Use [routesList] when you want to pass routes to other Navigation SDK components,
+ * for example start active guidance calling [MapboxNavigation.setNavigationRoutes] or
+ * display a route using route line API. The majority of the Navigation SDK's API accepts routes in this format.
+ *
+ * Use [originalRoutesList] and [primaryRouteIndex] if you want to display routes as a list on UI.
+ * In this case routes' order shouldn't change on UI when users pick different routes as primary.
+ * [MapboxNavigation.changeRoutesPreviewPrimaryRoute] is designed to select a new primary route without
+ * changing the order of the [originalRoutesList].
+ */
+@ExperimentalPreviewMapboxNavigationAPI
+class RoutesPreview internal constructor(
+    val routesList: List<NavigationRoute>,
+    val alternativesMetadata: List<AlternativeRouteMetadata>,
+    val originalRoutesList: List<NavigationRoute>,
+    val primaryRouteIndex: Int,
+) {
+    /***
+     * Primary route used for preview
+     */
+    val primaryRoute = originalRoutesList[primaryRouteIndex]
+
+    /**
+     * Regenerate whenever a change is made
+     */
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (javaClass != other?.javaClass) return false
+
+        other as RoutesPreview
+
+        if (routesList != other.routesList) return false
+        if (alternativesMetadata != other.alternativesMetadata) return false
+        if (originalRoutesList != other.originalRoutesList) return false
+        if (primaryRouteIndex != other.primaryRouteIndex) return false
+
+        return true
+    }
+
+    /**
+     * Regenerate whenever a change is made
+     */
+    override fun hashCode(): Int {
+        var result = routesList.hashCode()
+        result = 31 * result + alternativesMetadata.hashCode()
+        result = 31 * result + originalRoutesList.hashCode()
+        result = 31 * result + primaryRouteIndex.hashCode()
+        return result
+    }
+
+    /**
+     * Regenerate whenever a change is made
+     */
+    override fun toString(): String {
+        return "RoutesPreview(" +
+            "routesList=$routesList, " +
+            "alternativesMetadata=$alternativesMetadata, " +
+            "originalRoutesList=$originalRoutesList, " +
+            "primaryRouteIndex=$primaryRouteIndex" +
+            ")"
+    }
+}
diff --git a/libnavigation-core/src/main/java/com/mapbox/navigation/core/preview/RoutesPreviewController.kt b/libnavigation-core/src/main/java/com/mapbox/navigation/core/preview/RoutesPreviewController.kt
new file mode 100644
index 00000000000..53994682a58
--- /dev/null
+++ b/libnavigation-core/src/main/java/com/mapbox/navigation/core/preview/RoutesPreviewController.kt
@@ -0,0 +1,144 @@
+package com.mapbox.navigation.core.preview
+
+import androidx.annotation.UiThread
+import com.mapbox.navigation.base.ExperimentalPreviewMapboxNavigationAPI
+import com.mapbox.navigation.base.route.NavigationRoute
+import com.mapbox.navigation.core.routealternatives.mapToMetadata
+import com.mapbox.navigator.RoutesData
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import java.util.concurrent.CopyOnWriteArrayList
+
+@ExperimentalPreviewMapboxNavigationAPI
+@UiThread
+internal class RoutesPreviewController(
+    private val routesDataParser: RoutesDataParser,
+    private val scope: CoroutineScope
+) {
+
+    private val mutex = Mutex()
+
+    private var lastUpdate: RoutesPreviewUpdate? = null
+        set(value) {
+            if (value != field) {
+                field = value
+                if (value != null) {
+                    observers.forEach {
+                        it.routesPreviewUpdated(value)
+                    }
+                }
+            }
+        }
+
+    private val observers = CopyOnWriteArrayList<RoutesPreviewObserver>()
+
+    fun registerPreviewRoutesObserver(observer: RoutesPreviewObserver) {
+        observers.add(observer)
+        lastUpdate?.let { observer.routesPreviewUpdated(it) }
+    }
+
+    fun unregisterPreviewRoutesObserver(observer: RoutesPreviewObserver) {
+        observers.remove(observer)
+    }
+
+    fun getRoutesPreview(): RoutesPreview? = lastUpdate?.routesPreview
+
+    fun previewNavigationRoutes(
+        routesToPreview: List<NavigationRoute>,
+        primaryRouteIndex: Int = 0
+    ) {
+        scope.launch {
+            mutex.withLock {
+                previewRoutesInternal(routesToPreview, primaryRouteIndex)
+            }
+        }
+    }
+
+    @Throws(IllegalArgumentException::class)
+    fun changeRoutesPreviewPrimaryRoute(route: NavigationRoute) {
+        val originalRoutes = lastUpdate?.routesPreview?.originalRoutesList
+        require(originalRoutes != null) {
+            "no previewed routes are set"
+        }
+        val routes = originalRoutes.toMutableList()
+        require(routes.remove(route)) {
+            "route ${route.id} isn't found among the list of previewed routes"
+        }
+        routes.add(0, route)
+
+        scope.launch {
+            mutex.withLock {
+                val routesData = routesDataParser.parse(routes)
+                val preview = createRoutesPreview(routes, routesData, originalRoutes)
+                setNewRoutesPreview(preview)
+            }
+        }
+    }
+
+    private fun setNewRoutesPreview(preview: RoutesPreview) {
+        lastUpdate = RoutesPreviewUpdate(
+            reason = RoutesPreviewUpdateReasons.PREVIEW_NEW,
+            routesPreview = preview
+        )
+    }
+
+    private suspend fun previewRoutesInternal(
+        routesToPreview: List<NavigationRoute>,
+        primaryRouteIndex: Int
+    ) {
+        if (routesToPreview.isEmpty()) {
+            lastUpdate = RoutesPreviewUpdate(
+                RoutesPreviewUpdateReasons.PREVIEW_CLEAN_UP,
+                null
+            )
+            return
+        }
+        val previewedRoutes = movePrimaryRouteToTheBeginning(primaryRouteIndex, routesToPreview)
+        val preview =
+            createRoutesPreview(
+                previewedRoutes,
+                routesDataParser.parse(previewedRoutes),
+                routesToPreview
+            )
+        setNewRoutesPreview(preview)
+    }
+
+    private fun movePrimaryRouteToTheBeginning(
+        primaryRouteIndex: Int,
+        routesToPreview: List<NavigationRoute>
+    ): List<NavigationRoute> {
+        val previewedRoutes = if (primaryRouteIndex == 0) {
+            routesToPreview
+        } else {
+            routesToPreview.toMutableList().apply {
+                val primaryRoute = removeAt(primaryRouteIndex)
+                add(0, primaryRoute)
+            }
+        }
+        return previewedRoutes
+    }
+
+    private fun createRoutesPreview(
+        routes: List<NavigationRoute>,
+        routesData: RoutesData,
+        originalRoutes: List<NavigationRoute>
+    ): RoutesPreview {
+        val preview = RoutesPreview(
+            alternativesMetadata = routesData.alternativeRoutes().map { nativeAlternative ->
+                val alternative =
+                    originalRoutes.first { it.id == nativeAlternative.route.routeId }
+                nativeAlternative.mapToMetadata(alternative)
+            },
+            routesList = routes,
+            originalRoutesList = originalRoutes,
+            primaryRouteIndex = originalRoutes.indexOf(routes.first())
+        )
+        return preview
+    }
+}
+
+internal fun interface RoutesDataParser {
+    suspend fun parse(routes: List<NavigationRoute>): RoutesData
+}
diff --git a/libnavigation-core/src/main/java/com/mapbox/navigation/core/preview/RoutesPreviewObserver.kt b/libnavigation-core/src/main/java/com/mapbox/navigation/core/preview/RoutesPreviewObserver.kt
new file mode 100644
index 00000000000..945c6c10efe
--- /dev/null
+++ b/libnavigation-core/src/main/java/com/mapbox/navigation/core/preview/RoutesPreviewObserver.kt
@@ -0,0 +1,64 @@
+package com.mapbox.navigation.core.preview
+
+import com.mapbox.navigation.base.ExperimentalPreviewMapboxNavigationAPI
+import com.mapbox.navigation.core.MapboxNavigation
+
+/**
+ * Interface definition for an observer that gets notified whenever route preview state changes.
+ */
+@ExperimentalPreviewMapboxNavigationAPI
+fun interface RoutesPreviewObserver {
+    /***
+     * Called when route preview state changes. Emits current state on subscription.
+     *
+     * Register the observer using [MapboxNavigation.registerRoutesPreviewObserver].
+     */
+    fun routesPreviewUpdated(update: RoutesPreviewUpdate)
+}
+
+/**
+ * Routes preview update is provided via [RoutesPreviewObserver] whenever route
+ * preview changes state.
+ *
+ * @param reason why route preview has been updated
+ * @param routesPreview current state of route preview, null if routes preview isn't set
+ */
+@ExperimentalPreviewMapboxNavigationAPI
+class RoutesPreviewUpdate internal constructor(
+    @RoutePreviewUpdateReason val reason: String,
+    val routesPreview: RoutesPreview?
+) {
+
+    /**
+     * Regenerate whenever a change is made
+     */
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (javaClass != other?.javaClass) return false
+
+        other as RoutesPreviewUpdate
+        if (reason != other.reason) return false
+        if (routesPreview != other.routesPreview) return false
+
+        return true
+    }
+
+    /**
+     * Regenerate whenever a change is made
+     */
+    override fun hashCode(): Int {
+        var result = reason.hashCode()
+        result = 31 * result + routesPreview.hashCode()
+        return result
+    }
+
+    /**
+     * Regenerate whenever a change is made
+     */
+    override fun toString(): String {
+        return "RoutesPreviewUpdate(" +
+            "reason='$reason', " +
+            "routesPreview=$routesPreview" +
+            ")"
+    }
+}
diff --git a/libnavigation-core/src/main/java/com/mapbox/navigation/core/preview/RoutesPreviewUpdateReasons.kt b/libnavigation-core/src/main/java/com/mapbox/navigation/core/preview/RoutesPreviewUpdateReasons.kt
new file mode 100644
index 00000000000..0aebd93a80e
--- /dev/null
+++ b/libnavigation-core/src/main/java/com/mapbox/navigation/core/preview/RoutesPreviewUpdateReasons.kt
@@ -0,0 +1,34 @@
+package com.mapbox.navigation.core.preview
+
+import androidx.annotation.StringDef
+
+/**
+ * All reasons which can cause routes preview update.
+ * @see [RoutesPreviewObserver]
+ */
+object RoutesPreviewUpdateReasons {
+    /**
+     * Routes for preview were set by user.
+     * [RoutesPreviewUpdate.routesPreview] always has value for this reason.
+     * @see [RoutesPreviewObserver]
+     */
+    const val PREVIEW_NEW = "PREVIEW_SET"
+
+    /***
+     * Routes preview has initial state or were cleanup by user.
+     * [RoutesPreviewUpdate.routesPreview] is always null for this reason.
+     * @see [RoutesPreviewObserver]
+     */
+    const val PREVIEW_CLEAN_UP = "PREVIEW_CLEAN_UP"
+}
+
+/**
+ * Reason of Routes Preview update.
+ * See [RoutesPreviewObserver]
+ */
+@Retention(AnnotationRetention.BINARY)
+@StringDef(
+    RoutesPreviewUpdateReasons.PREVIEW_NEW,
+    RoutesPreviewUpdateReasons.PREVIEW_CLEAN_UP
+)
+annotation class RoutePreviewUpdateReason
diff --git a/libnavigation-core/src/main/java/com/mapbox/navigation/core/routealternatives/RouteAlternativesController.kt b/libnavigation-core/src/main/java/com/mapbox/navigation/core/routealternatives/RouteAlternativesController.kt
index 87f3c40123e..63380bf9f11 100644
--- a/libnavigation-core/src/main/java/com/mapbox/navigation/core/routealternatives/RouteAlternativesController.kt
+++ b/libnavigation-core/src/main/java/com/mapbox/navigation/core/routealternatives/RouteAlternativesController.kt
@@ -240,7 +240,7 @@ internal class RouteAlternativesController constructor(
     }
 }
 
-private fun RouteAlternative.mapToMetadata(
+internal fun RouteAlternative.mapToMetadata(
     navigationRoute: NavigationRoute
 ): AlternativeRouteMetadata {
     return AlternativeRouteMetadata(
diff --git a/libnavigation-core/src/test/java/com/mapbox/navigation/core/preview/RouteDataParserStub.kt b/libnavigation-core/src/test/java/com/mapbox/navigation/core/preview/RouteDataParserStub.kt
new file mode 100644
index 00000000000..df89ac36979
--- /dev/null
+++ b/libnavigation-core/src/test/java/com/mapbox/navigation/core/preview/RouteDataParserStub.kt
@@ -0,0 +1,28 @@
+package com.mapbox.navigation.core.preview
+
+import com.mapbox.navigation.base.internal.route.nativeRoute
+import com.mapbox.navigation.base.route.NavigationRoute
+import com.mapbox.navigator.RouteAlternative
+import com.mapbox.navigator.RoutesData
+import io.mockk.every
+import io.mockk.mockk
+
+internal class RouteDataParserStub : RoutesDataParser {
+    override suspend fun parse(routes: List<NavigationRoute>): RoutesData {
+        return object : RoutesData {
+
+            private var alternativeIdCounter = 1
+
+            override fun primaryRoute() = routes.first().nativeRoute()
+
+            override fun alternativeRoutes(): MutableList<RouteAlternative> =
+                routes.drop(1).map { navigationRoute ->
+                    val nextId = alternativeIdCounter++
+                    mockk<RouteAlternative>(relaxed = true) {
+                        every { id } returns nextId
+                        every { route } returns navigationRoute.nativeRoute()
+                    }
+                }.toMutableList()
+        }
+    }
+}
diff --git a/libnavigation-core/src/test/java/com/mapbox/navigation/core/preview/RoutePreviewControllerFactory.kt b/libnavigation-core/src/test/java/com/mapbox/navigation/core/preview/RoutePreviewControllerFactory.kt
new file mode 100644
index 00000000000..7b4161d2cef
--- /dev/null
+++ b/libnavigation-core/src/test/java/com/mapbox/navigation/core/preview/RoutePreviewControllerFactory.kt
@@ -0,0 +1,18 @@
+package com.mapbox.navigation.core.preview
+
+import com.mapbox.navigation.base.ExperimentalPreviewMapboxNavigationAPI
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.test.TestCoroutineDispatcher
+import kotlinx.coroutines.test.TestCoroutineScope
+
+@ExperimentalPreviewMapboxNavigationAPI
+internal fun createRoutePreviewController(
+    parentScope: CoroutineScope = TestCoroutineScope(SupervisorJob() + TestCoroutineDispatcher()),
+    routesDataParser: RoutesDataParser = RouteDataParserStub()
+): RoutesPreviewController {
+    return RoutesPreviewController(
+        routesDataParser = routesDataParser,
+        scope = parentScope
+    )
+}
diff --git a/libnavigation-core/src/test/java/com/mapbox/navigation/core/preview/RoutesPreviewControllerTest.kt b/libnavigation-core/src/test/java/com/mapbox/navigation/core/preview/RoutesPreviewControllerTest.kt
new file mode 100644
index 00000000000..6893462c996
--- /dev/null
+++ b/libnavigation-core/src/test/java/com/mapbox/navigation/core/preview/RoutesPreviewControllerTest.kt
@@ -0,0 +1,378 @@
+package com.mapbox.navigation.core.preview
+
+import com.mapbox.navigation.base.ExperimentalPreviewMapboxNavigationAPI
+import com.mapbox.navigation.base.internal.route.nativeRoute
+import com.mapbox.navigation.base.route.NavigationRoute
+import com.mapbox.navigation.testing.factories.createDirectionsResponse
+import com.mapbox.navigation.testing.factories.createDirectionsRoute
+import com.mapbox.navigation.testing.factories.createNavigationRoutes
+import com.mapbox.navigator.RouteAlternative
+import com.mapbox.navigator.RouteInterface
+import com.mapbox.navigator.RoutesData
+import io.mockk.every
+import io.mockk.mockk
+import kotlinx.coroutines.CompletableDeferred
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.Test
+
+@OptIn(ExperimentalPreviewMapboxNavigationAPI::class)
+class RoutesPreviewControllerTest {
+
+    @Test
+    fun `default state`() {
+        val routesPreviewController = createRoutePreviewController()
+
+        var previewUpdate: RoutesPreviewUpdate? = null
+        routesPreviewController.registerPreviewRoutesObserver {
+            previewUpdate = it
+        }
+
+        assertNull(previewUpdate)
+    }
+
+    @Test
+    fun `set previewed routes`() {
+        val routesPreviewController = createRoutePreviewController()
+        var previewUpdate: RoutesPreviewUpdate? = null
+        routesPreviewController.registerPreviewRoutesObserver {
+            previewUpdate = it
+        }
+
+        val testRoutes = createNavigationRoutes(
+            response = createDirectionsResponse(
+                uuid = "test",
+                routes = listOf(
+                    createDirectionsRoute(),
+                    createDirectionsRoute()
+                )
+            )
+        )
+        routesPreviewController.previewNavigationRoutes(testRoutes)
+
+        assertNotNull(previewUpdate)
+        assertEquals(previewUpdate!!.routesPreview, routesPreviewController.getRoutesPreview())
+        assertEquals(RoutesPreviewUpdateReasons.PREVIEW_NEW, previewUpdate!!.reason)
+        assertNotNull(previewUpdate!!.routesPreview)
+        val preview = previewUpdate!!.routesPreview!!
+        assertEquals(testRoutes, preview.originalRoutesList)
+        assertEquals(testRoutes, preview.routesList)
+        assertEquals(testRoutes.first(), preview.primaryRoute)
+        assertEquals(testRoutes[1], preview.alternativesMetadata.first().navigationRoute)
+        assertEquals(0, preview.primaryRouteIndex)
+    }
+
+    @Test
+    fun `set previewed routes with the second route as a primary`() {
+        val routesPreviewController = createRoutePreviewController()
+        var previewUpdate: RoutesPreviewUpdate? = null
+        routesPreviewController.registerPreviewRoutesObserver {
+            previewUpdate = it
+        }
+
+        val testRoutes = createNavigationRoutes(
+            response = createDirectionsResponse(
+                uuid = "test",
+                routes = listOf(
+                    createDirectionsRoute(),
+                    createDirectionsRoute()
+                )
+            )
+        )
+        routesPreviewController.previewNavigationRoutes(testRoutes, primaryRouteIndex = 1)
+
+        assertNotNull(previewUpdate)
+        assertNotNull(previewUpdate!!.routesPreview)
+        val preview = previewUpdate!!.routesPreview!!
+        assertEquals(testRoutes, preview.originalRoutesList)
+        assertEquals(listOf("test#1", "test#0"), preview.routesList.map { it.id })
+        assertEquals(testRoutes[1], preview.primaryRoute)
+        assertEquals(testRoutes[0], preview.alternativesMetadata.first().navigationRoute)
+        assertEquals(1, preview.primaryRouteIndex)
+    }
+
+    @Test
+    fun `select different primary route`() {
+        val routesPreviewController = createRoutePreviewController()
+        var previewUpdate: RoutesPreviewUpdate? = null
+        routesPreviewController.registerPreviewRoutesObserver {
+            previewUpdate = it
+        }
+        val testRoutes = createNavigationRoutes(
+            response = createDirectionsResponse(
+                uuid = "test",
+                routes = listOf(
+                    createDirectionsRoute(),
+                    createDirectionsRoute()
+                )
+            )
+        )
+        routesPreviewController.previewNavigationRoutes(testRoutes)
+
+        routesPreviewController.changeRoutesPreviewPrimaryRoute(
+            previewUpdate!!.routesPreview!!.alternativesMetadata.first().navigationRoute
+        )
+
+        val result = previewUpdate!!.routesPreview
+        assertNotNull(result)
+        result!!
+        assertEquals(testRoutes[1], result.primaryRoute)
+        assertEquals(testRoutes[0], result.alternativesMetadata.first().navigationRoute)
+        assertEquals(testRoutes, result.originalRoutesList)
+        assertEquals(
+            listOf(
+                testRoutes[1],
+                testRoutes[0]
+            ),
+            result.routesList
+        )
+        assertEquals(1, result.primaryRouteIndex)
+    }
+
+    @Test
+    fun `switch between previewed routes quicker then internal processing`() {
+        val testRoutes = createNavigationRoutes(
+            response = createDirectionsResponse(
+                uuid = "test",
+                routes = listOf(
+                    createDirectionsRoute(),
+                    createDirectionsRoute(),
+                    createDirectionsRoute(),
+                )
+            )
+        )
+        val waitHandle = CompletableDeferred<Unit>()
+        val routesPreviewController = createRoutePreviewController(
+            routesDataParser = {
+                if (it.first().id == "test#1") {
+                    waitHandle.await()
+                }
+                RouteDataParserStub().parse(it)
+            }
+        )
+        val previewedRoutesIds = mutableListOf<List<String>?>()
+        routesPreviewController.registerPreviewRoutesObserver {
+            previewedRoutesIds.add(it.routesPreview?.routesList?.map { it.id })
+        }
+        routesPreviewController.previewNavigationRoutes(testRoutes)
+
+        routesPreviewController.changeRoutesPreviewPrimaryRoute(testRoutes[1])
+        routesPreviewController.changeRoutesPreviewPrimaryRoute(testRoutes[2])
+        waitHandle.complete(Unit)
+
+        assertEquals(
+            listOf(
+                listOf("test#0", "test#1", "test#2"),
+                listOf("test#1", "test#0", "test#2"),
+                listOf("test#2", "test#0", "test#1")
+            ),
+            previewedRoutesIds
+        )
+    }
+
+    @Test(expected = IllegalArgumentException::class)
+    fun `select wrong primary route`() {
+        val routesPreviewController = createRoutePreviewController()
+        routesPreviewController.previewNavigationRoutes(
+            createNavigationRoutes(
+                response = createDirectionsResponse(
+                    uuid = "test",
+                    routes = listOf(
+                        createDirectionsRoute(),
+                        createDirectionsRoute()
+                    )
+                )
+            )
+        )
+
+        routesPreviewController.changeRoutesPreviewPrimaryRoute(
+            createNavigationRoutes().first()
+        )
+    }
+
+    @Test(expected = IllegalArgumentException::class)
+    fun `select primary route without previewing any routes`() {
+        val routesPreviewController = createRoutePreviewController()
+
+        routesPreviewController.changeRoutesPreviewPrimaryRoute(
+            createNavigationRoutes().first()
+        )
+    }
+
+    @Test
+    fun `unsubscribe from preview updates`() {
+        val routesPreviewController = createRoutePreviewController()
+        var eventsCount = 0
+        val observer = RoutesPreviewObserver { eventsCount++ }
+
+        routesPreviewController.registerPreviewRoutesObserver(observer)
+        routesPreviewController.unregisterPreviewRoutesObserver(observer)
+        routesPreviewController.previewNavigationRoutes(
+            createNavigationRoutes(
+                createDirectionsResponse(uuid = "test1")
+            )
+        )
+        routesPreviewController.previewNavigationRoutes(
+            createNavigationRoutes(
+                createDirectionsResponse(uuid = "test2")
+            )
+        )
+
+        assertEquals(0, eventsCount)
+    }
+
+    @Test
+    fun `clean-up routes preview`() {
+        val routesPreviewController = createRoutePreviewController()
+        var previewUpdate: RoutesPreviewUpdate? = null
+        routesPreviewController.registerPreviewRoutesObserver {
+            previewUpdate = it
+        }
+        val testRoutes = createNavigationRoutes(
+            response = createDirectionsResponse(
+                uuid = "test",
+                routes = listOf(
+                    createDirectionsRoute(),
+                    createDirectionsRoute()
+                )
+            )
+        )
+        routesPreviewController.previewNavigationRoutes(testRoutes)
+
+        routesPreviewController.previewNavigationRoutes(emptyList())
+
+        assertNotNull(previewUpdate)
+        val result = previewUpdate!!
+        assertEquals(RoutesPreviewUpdateReasons.PREVIEW_CLEAN_UP, result.reason)
+        assertNull(result.routesPreview)
+    }
+
+    @Test
+    fun `one of alternatives are invalid`() {
+        val testRoutes = listOf(
+            createNavigationRoutes(createDirectionsResponse(uuid = "primary")).first(),
+            createNavigationRoutes(createDirectionsResponse(uuid = "valid")).first(),
+            createNavigationRoutes(createDirectionsResponse(uuid = "invalid")).first(),
+        )
+        val routesPreviewController = createRoutePreviewController(
+            routesDataParser = {
+                object : RoutesData {
+                    override fun primaryRoute(): RouteInterface = testRoutes.first().nativeRoute()
+
+                    // data for the invalid alternative isn't returned
+                    override fun alternativeRoutes(): MutableList<RouteAlternative> {
+                        return mutableListOf(
+                            mockk(relaxed = true) {
+                                every { route } returns testRoutes[1].nativeRoute()
+                            }
+                        )
+                    }
+                }
+            }
+        )
+
+        routesPreviewController.previewNavigationRoutes(testRoutes)
+        val routesPreview = routesPreviewController.getRoutesPreview()
+
+        assertNotNull(routesPreview)
+        routesPreview!!
+        assertEquals(
+            listOf("valid#0"),
+            routesPreview.alternativesMetadata.map { it.navigationRoute.id }
+        )
+        assertEquals(testRoutes, routesPreview.routesList)
+        assertEquals(testRoutes, routesPreview.originalRoutesList)
+    }
+
+    @Test
+    fun `new routes are set faster then processing`() {
+        val slow = createNavigationRoutes(createDirectionsResponse(uuid = "slow"))
+        val slowWaitHandle = CompletableDeferred<Unit>()
+        val fast = createNavigationRoutes(
+            createDirectionsResponse(
+                uuid = "fast",
+                routes = listOf(
+                    createDirectionsRoute(),
+                    createDirectionsRoute()
+                )
+            )
+        )
+        val routesPreviewController = createRoutePreviewController(
+            routesDataParser = {
+                if (it == slow) {
+                    slowWaitHandle.await()
+                }
+                RouteDataParserStub().parse(it)
+            }
+        )
+        val previewedRoutes = mutableListOf<List<String>?>()
+        routesPreviewController.registerPreviewRoutesObserver {
+            previewedRoutes.add(it.routesPreview?.routesList?.map(NavigationRoute::id))
+        }
+
+        routesPreviewController.previewNavigationRoutes(slow)
+        routesPreviewController.previewNavigationRoutes(fast)
+        routesPreviewController.previewNavigationRoutes(emptyList())
+        slowWaitHandle.complete(Unit)
+
+        assertEquals(
+            listOf(
+                listOf("slow#0"),
+                listOf("fast#0", "fast#1"),
+                null
+            ),
+            previewedRoutes
+        )
+    }
+
+    @Test
+    fun `select primary route while new route is processing`() {
+        val slow = createNavigationRoutes(
+            createDirectionsResponse(
+                uuid = "slow",
+                routes = listOf(
+                    createDirectionsRoute(),
+                    createDirectionsRoute()
+                )
+            )
+        )
+        val slowWaitHandle = CompletableDeferred<Unit>()
+        val fast = createNavigationRoutes(
+            createDirectionsResponse(
+                uuid = "fast",
+                routes = listOf(
+                    createDirectionsRoute(),
+                    createDirectionsRoute()
+                )
+            )
+        )
+        val routesPreviewController = createRoutePreviewController(
+            routesDataParser = {
+                if (it == slow) {
+                    slowWaitHandle.await()
+                }
+                RouteDataParserStub().parse(it)
+            }
+        )
+        val previewedRoutes = mutableListOf<List<String>?>()
+        routesPreviewController.registerPreviewRoutesObserver {
+            previewedRoutes.add(it.routesPreview?.routesList?.map(NavigationRoute::id))
+        }
+
+        routesPreviewController.previewNavigationRoutes(fast)
+        routesPreviewController.previewNavigationRoutes(slow)
+        // user clicks on UI with old routes
+        routesPreviewController.changeRoutesPreviewPrimaryRoute(fast[1])
+        slowWaitHandle.complete(Unit)
+
+        assertEquals(
+            listOf(
+                listOf("fast#0", "fast#1"),
+                listOf("slow#0", "slow#1"),
+                listOf("fast#1", "fast#0"),
+            ),
+            previewedRoutes
+        )
+    }
+}
diff --git a/libnavui-androidauto/src/main/java/com/mapbox/androidauto/preview/CarRoutePreviewScreen2.kt b/libnavui-androidauto/src/main/java/com/mapbox/androidauto/preview/CarRoutePreviewScreen2.kt
new file mode 100644
index 00000000000..ca22311c064
--- /dev/null
+++ b/libnavui-androidauto/src/main/java/com/mapbox/androidauto/preview/CarRoutePreviewScreen2.kt
@@ -0,0 +1,194 @@
+package com.mapbox.androidauto.preview
+
+import android.text.SpannableString
+import androidx.annotation.UiThread
+import androidx.car.app.Screen
+import androidx.car.app.model.Action
+import androidx.car.app.model.ActionStrip
+import androidx.car.app.model.DurationSpan
+import androidx.car.app.model.ItemList
+import androidx.car.app.model.Row
+import androidx.car.app.model.Template
+import androidx.car.app.navigation.model.RoutePreviewNavigationTemplate
+import androidx.lifecycle.DefaultLifecycleObserver
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.LifecycleOwner
+import androidx.lifecycle.lifecycleScope
+import androidx.lifecycle.repeatOnLifecycle
+import com.mapbox.androidauto.MapboxCarContext
+import com.mapbox.androidauto.R
+import com.mapbox.androidauto.feedback.ui.CarFeedbackAction
+import com.mapbox.androidauto.internal.extensions.addBackPressedHandler
+import com.mapbox.androidauto.internal.extensions.handleStyleOnAttached
+import com.mapbox.androidauto.internal.extensions.handleStyleOnDetached
+import com.mapbox.androidauto.internal.logAndroidAuto
+import com.mapbox.androidauto.location.CarLocationRenderer
+import com.mapbox.androidauto.navigation.CarCameraMode
+import com.mapbox.androidauto.navigation.CarDistanceFormatter
+import com.mapbox.androidauto.navigation.CarNavigationCamera
+import com.mapbox.androidauto.navigation.audioguidance.muteAudioGuidance
+import com.mapbox.androidauto.navigation.speedlimit.CarSpeedLimitRenderer
+import com.mapbox.androidauto.placeslistonmap.PlacesListOnMapLayerUtil
+import com.mapbox.androidauto.routes.NavigationCarRoutesProvider2
+import com.mapbox.androidauto.screenmanager.MapboxScreen
+import com.mapbox.androidauto.screenmanager.MapboxScreenManager
+import com.mapbox.androidauto.search.PlaceRecord
+import com.mapbox.geojson.Feature
+import com.mapbox.geojson.FeatureCollection
+import com.mapbox.maps.MapboxExperimental
+import com.mapbox.maps.extension.androidauto.MapboxCarMapObserver
+import com.mapbox.maps.extension.androidauto.MapboxCarMapSurface
+import com.mapbox.maps.plugin.delegates.listeners.OnStyleLoadedListener
+import com.mapbox.navigation.base.ExperimentalPreviewMapboxNavigationAPI
+import com.mapbox.navigation.core.lifecycle.MapboxNavigationApp
+import kotlinx.coroutines.flow.collect
+import kotlinx.coroutines.launch
+
+/**
+ * This will replace [CarRoutePreviewScreen]
+ */
+@OptIn(MapboxExperimental::class, ExperimentalPreviewMapboxNavigationAPI::class)
+internal class CarRoutePreviewScreen2 @UiThread constructor(
+    private val mapboxCarContext: MapboxCarContext,
+    private val placeRecord: PlaceRecord,
+    private val placesLayerUtil: PlacesListOnMapLayerUtil = PlacesListOnMapLayerUtil(),
+) : Screen(mapboxCarContext.carContext) {
+
+    private val routesProvider = NavigationCarRoutesProvider2()
+    private val carRouteLine = CarRouteLine(routesProvider)
+    private val carLocationRenderer = CarLocationRenderer()
+    private val carSpeedLimitRenderer = CarSpeedLimitRenderer(mapboxCarContext)
+    private val carNavigationCamera = CarNavigationCamera(
+        initialCarCameraMode = CarCameraMode.OVERVIEW,
+        alternativeCarCameraMode = CarCameraMode.FOLLOWING,
+        carRoutesProvider = routesProvider,
+    )
+
+    private var styleLoadedListener: OnStyleLoadedListener? = null
+
+    private val surfaceListener = object : MapboxCarMapObserver {
+
+        override fun onAttached(mapboxCarMapSurface: MapboxCarMapSurface) {
+            super.onAttached(mapboxCarMapSurface)
+            logAndroidAuto("CarRoutePreviewScreen loaded")
+            styleLoadedListener = mapboxCarMapSurface.handleStyleOnAttached { style ->
+                placesLayerUtil.initializePlacesListOnMapLayer(
+                    style,
+                    carContext.resources
+                )
+                val coordinate = placeRecord.coordinate ?: return@handleStyleOnAttached
+                val featureCollection =
+                    FeatureCollection.fromFeature(Feature.fromGeometry(coordinate))
+                placesLayerUtil.updatePlacesListOnMapLayer(
+                    style,
+                    featureCollection
+                )
+            }
+        }
+
+        override fun onDetached(mapboxCarMapSurface: MapboxCarMapSurface) {
+            super.onDetached(mapboxCarMapSurface)
+            logAndroidAuto("CarRoutePreviewScreen detached")
+            mapboxCarMapSurface.handleStyleOnDetached(styleLoadedListener)?.let {
+                placesLayerUtil.removePlacesListOnMapLayer(it)
+            }
+        }
+    }
+
+    init {
+        logAndroidAuto("CarRoutePreviewScreen constructor")
+        addBackPressedHandler {
+            logAndroidAuto("CarRoutePreviewScreen onBackPressed")
+            mapboxCarContext.mapboxScreenManager.goBack()
+        }
+        lifecycleScope.launch {
+            lifecycle.repeatOnLifecycle(Lifecycle.State.RESUMED) {
+                routesProvider.routesPreview.collect {
+                    invalidate()
+                }
+            }
+        }
+        lifecycle.muteAudioGuidance()
+        lifecycle.addObserver(object : DefaultLifecycleObserver {
+
+            override fun onResume(owner: LifecycleOwner) {
+                logAndroidAuto("CarRoutePreviewScreen onResume")
+                mapboxCarContext.mapboxCarMap.registerObserver(carLocationRenderer)
+                mapboxCarContext.mapboxCarMap.registerObserver(carSpeedLimitRenderer)
+                mapboxCarContext.mapboxCarMap.registerObserver(carNavigationCamera)
+                mapboxCarContext.mapboxCarMap.registerObserver(carRouteLine)
+                mapboxCarContext.mapboxCarMap.registerObserver(surfaceListener)
+            }
+
+            override fun onPause(owner: LifecycleOwner) {
+                logAndroidAuto("CarRoutePreviewScreen onPause")
+                mapboxCarContext.mapboxCarMap.unregisterObserver(carLocationRenderer)
+                mapboxCarContext.mapboxCarMap.unregisterObserver(carSpeedLimitRenderer)
+                mapboxCarContext.mapboxCarMap.unregisterObserver(carNavigationCamera)
+                mapboxCarContext.mapboxCarMap.unregisterObserver(carRouteLine)
+                mapboxCarContext.mapboxCarMap.unregisterObserver(surfaceListener)
+            }
+        })
+    }
+
+    override fun onGetTemplate(): Template {
+        val listBuilder = ItemList.Builder()
+        val routesPreview = routesProvider.routesPreview.value
+        val navigationRoutes = routesPreview?.originalRoutesList
+            ?: emptyList()
+        navigationRoutes.forEach { navigationRoute ->
+            val route = navigationRoute.directionsRoute
+            val title = route.legs()?.first()?.summary() ?: placeRecord.name
+            val duration = CarDistanceFormatter.formatDistance(route.duration())
+            val routeSpannableString = SpannableString("$duration $title")
+            routeSpannableString.setSpan(
+                DurationSpan.create(route.duration().toLong()),
+                0,
+                duration.length,
+                0
+            )
+
+            listBuilder.addItem(
+                Row.Builder()
+                    .setTitle(routeSpannableString)
+                    .addText(duration)
+                    .build()
+            )
+        }
+        if (routesPreview != null && navigationRoutes.isNotEmpty()) {
+            listBuilder.setSelectedIndex(routesPreview.primaryRouteIndex)
+            listBuilder.setOnSelectedListener { index ->
+                MapboxNavigationApp.current()?.setRoutesPreview(
+                    routesPreview.originalRoutesList,
+                    index
+                )
+            }
+        }
+
+        return RoutePreviewNavigationTemplate.Builder()
+            .setItemList(listBuilder.build())
+            .setTitle(carContext.getString(R.string.car_action_preview_title))
+            .setActionStrip(
+                ActionStrip.Builder()
+                    .addAction(
+                        CarFeedbackAction(
+                            MapboxScreen.ROUTE_PREVIEW_FEEDBACK
+                        ).getAction(this@CarRoutePreviewScreen2)
+                    )
+                    .build()
+            )
+            .setHeaderAction(Action.BACK)
+            .setNavigateAction(
+                Action.Builder()
+                    .setTitle(carContext.getString(R.string.car_action_preview_navigate_button))
+                    .setOnClickListener {
+                        MapboxNavigationApp.current()!!.setNavigationRoutes(
+                            routesPreview!!.routesList
+                        )
+                        MapboxScreenManager.replaceTop(MapboxScreen.ACTIVE_GUIDANCE)
+                    }
+                    .build(),
+            )
+            .build()
+    }
+}
diff --git a/libnavui-androidauto/src/main/java/com/mapbox/androidauto/preview/RoutePreviewScreenFactory2.kt b/libnavui-androidauto/src/main/java/com/mapbox/androidauto/preview/RoutePreviewScreenFactory2.kt
new file mode 100644
index 00000000000..c55bed8f4a2
--- /dev/null
+++ b/libnavui-androidauto/src/main/java/com/mapbox/androidauto/preview/RoutePreviewScreenFactory2.kt
@@ -0,0 +1,37 @@
+package com.mapbox.androidauto.preview
+
+import androidx.car.app.CarContext
+import androidx.car.app.Screen
+import com.mapbox.androidauto.MapboxCarContext
+import com.mapbox.androidauto.freedrive.FreeDriveCarScreen
+import com.mapbox.androidauto.internal.logAndroidAuto
+import com.mapbox.androidauto.screenmanager.MapboxScreenFactory
+import com.mapbox.androidauto.screenmanager.factories.RoutePreviewScreenFactory
+import com.mapbox.navigation.base.ExperimentalPreviewMapboxNavigationAPI
+import com.mapbox.navigation.core.lifecycle.MapboxNavigationApp
+
+/**
+ * This will replace [RoutePreviewScreenFactory]
+ */
+@ExperimentalPreviewMapboxNavigationAPI
+class RoutePreviewScreenFactory2(
+    private val mapboxCarContext: MapboxCarContext
+) : MapboxScreenFactory {
+    override fun create(carContext: CarContext): Screen {
+        val repository = mapboxCarContext.routePreviewRequest.repository
+        val placeRecord = repository?.placeRecord?.value
+        val routes = repository?.routes?.value
+            ?: MapboxNavigationApp.current()?.getRoutesPreview()?.originalRoutesList
+            ?: emptyList()
+        return if (placeRecord == null || routes.isEmpty()) {
+            logAndroidAuto(
+                "Showing free drive screen because route preview can only be shown " +
+                    "when there is a route. placeRecord=$placeRecord routes.size=${routes.size}"
+            )
+            FreeDriveCarScreen(mapboxCarContext)
+        } else {
+            MapboxNavigationApp.current()!!.setRoutesPreview(routes)
+            CarRoutePreviewScreen2(mapboxCarContext, placeRecord)
+        }
+    }
+}
diff --git a/libnavui-androidauto/src/main/java/com/mapbox/androidauto/routes/NavigationCarRoutesProvider2.kt b/libnavui-androidauto/src/main/java/com/mapbox/androidauto/routes/NavigationCarRoutesProvider2.kt
new file mode 100644
index 00000000000..f8eb5fc7027
--- /dev/null
+++ b/libnavui-androidauto/src/main/java/com/mapbox/androidauto/routes/NavigationCarRoutesProvider2.kt
@@ -0,0 +1,62 @@
+package com.mapbox.androidauto.routes
+
+import com.mapbox.navigation.base.ExperimentalPreviewMapboxNavigationAPI
+import com.mapbox.navigation.base.route.NavigationRoute
+import com.mapbox.navigation.core.MapboxNavigation
+import com.mapbox.navigation.core.lifecycle.MapboxNavigationApp
+import com.mapbox.navigation.core.lifecycle.MapboxNavigationObserver
+import com.mapbox.navigation.core.preview.RoutesPreview
+import com.mapbox.navigation.core.preview.RoutesPreviewObserver
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.channels.awaitClose
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.callbackFlow
+
+/**
+ * This will replace [NavigationCarRoutesProvider]
+ */
+@ExperimentalPreviewMapboxNavigationAPI
+@OptIn(ExperimentalCoroutinesApi::class)
+class NavigationCarRoutesProvider2 : CarRoutesProvider {
+
+    private val _routesPreview = MutableStateFlow<RoutesPreview?>(null)
+
+    val routesPreview: StateFlow<RoutesPreview?> = _routesPreview.asStateFlow()
+
+    init {
+        _routesPreview.value = MapboxNavigationApp.current()?.getRoutesPreview()
+    }
+
+    /**
+     * Observes the routes set to [MapboxNavigation].
+     */
+    override val navigationRoutes: Flow<List<NavigationRoute>> = MapboxNavigationApp
+        .flowNavigationRoutes()
+
+    private fun MapboxNavigationApp.flowNavigationRoutes(): Flow<List<NavigationRoute>> =
+        callbackFlow {
+            val routesObserver = RoutesPreviewObserver {
+                val navigationRoutes: List<NavigationRoute> = it.routesPreview?.routesList
+                    ?: emptyList()
+                _routesPreview.value = it.routesPreview
+                trySend(navigationRoutes)
+            }
+            val observer = object : MapboxNavigationObserver {
+                override fun onAttached(mapboxNavigation: MapboxNavigation) {
+                    mapboxNavigation.registerRoutesPreviewObserver(routesObserver)
+                }
+
+                override fun onDetached(mapboxNavigation: MapboxNavigation) {
+                    mapboxNavigation.unregisterRoutesPreviewObserver(routesObserver)
+                    trySend(emptyList())
+                }
+            }
+            registerObserver(observer)
+            awaitClose {
+                unregisterObserver(observer)
+            }
+        }
+}
diff --git a/libnavui-androidauto/src/main/java/com/mapbox/androidauto/screenmanager/MapboxScreenGraph.kt b/libnavui-androidauto/src/main/java/com/mapbox/androidauto/screenmanager/MapboxScreenGraph.kt
index 64480e24b1d..39b955256eb 100644
--- a/libnavui-androidauto/src/main/java/com/mapbox/androidauto/screenmanager/MapboxScreenGraph.kt
+++ b/libnavui-androidauto/src/main/java/com/mapbox/androidauto/screenmanager/MapboxScreenGraph.kt
@@ -3,6 +3,7 @@
 package com.mapbox.androidauto.screenmanager
 
 import com.mapbox.androidauto.MapboxCarContext
+import com.mapbox.androidauto.preview.RoutePreviewScreenFactory2
 import com.mapbox.androidauto.screenmanager.MapboxScreen.ACTIVE_GUIDANCE
 import com.mapbox.androidauto.screenmanager.MapboxScreen.ACTIVE_GUIDANCE_FEEDBACK
 import com.mapbox.androidauto.screenmanager.MapboxScreen.ARRIVAL
@@ -31,6 +32,7 @@ import com.mapbox.androidauto.screenmanager.factories.RoutePreviewScreenFactory
 import com.mapbox.androidauto.screenmanager.factories.SearchPlacesFeedbackScreenFactory
 import com.mapbox.androidauto.screenmanager.factories.SearchPlacesScreenFactory
 import com.mapbox.androidauto.screenmanager.factories.SettingsScreenFactory
+import com.mapbox.navigation.base.ExperimentalPreviewMapboxNavigationAPI
 
 /**
  * This is a predefined application that is designed to collect feedback from drivers.
@@ -70,3 +72,8 @@ fun MapboxCarContext.prepareScreens() = apply {
             to ArrivalScreenFactory(mapboxCarContext)
     )
 }
+
+@ExperimentalPreviewMapboxNavigationAPI
+fun MapboxCarContext.prepareExperimentalScreens() = apply {
+    mapboxScreenManager[ROUTE_PREVIEW] = RoutePreviewScreenFactory2(this)
+}
diff --git a/qa-test-app/src/main/java/com/mapbox/navigation/qa_test_app/car/MainCarSession.kt b/qa-test-app/src/main/java/com/mapbox/navigation/qa_test_app/car/MainCarSession.kt
index efe121cce26..c1bd9744914 100644
--- a/qa-test-app/src/main/java/com/mapbox/navigation/qa_test_app/car/MainCarSession.kt
+++ b/qa-test-app/src/main/java/com/mapbox/navigation/qa_test_app/car/MainCarSession.kt
@@ -19,10 +19,12 @@ import com.mapbox.androidauto.map.logo.CarLogoSurfaceRenderer
 import com.mapbox.androidauto.notification.MapboxCarNotificationOptions
 import com.mapbox.androidauto.screenmanager.MapboxScreen
 import com.mapbox.androidauto.screenmanager.MapboxScreenManager
+import com.mapbox.androidauto.screenmanager.prepareExperimentalScreens
 import com.mapbox.androidauto.screenmanager.prepareScreens
 import com.mapbox.maps.MapInitOptions
 import com.mapbox.maps.MapboxExperimental
 import com.mapbox.maps.extension.androidauto.MapboxCarMap
+import com.mapbox.navigation.base.ExperimentalPreviewMapboxNavigationAPI
 import com.mapbox.navigation.base.options.NavigationOptions
 import com.mapbox.navigation.core.lifecycle.MapboxNavigationApp
 import com.mapbox.navigation.core.trip.session.TripSessionState
@@ -30,14 +32,16 @@ import com.mapbox.navigation.qa_test_app.utils.Utils
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.launch
 
-@OptIn(MapboxExperimental::class)
+@OptIn(MapboxExperimental::class, ExperimentalPreviewMapboxNavigationAPI::class)
 class MainCarSession : Session() {
 
     private val carMapLoader = MainCarMapLoader()
     private val mapboxCarMap = MapboxCarMap()
         .registerObserver(carMapLoader)
+
     private val mapboxCarContext = MapboxCarContext(lifecycle, mapboxCarMap)
         .prepareScreens()
+        .prepareExperimentalScreens()
         .customize {
             notificationOptions = MapboxCarNotificationOptions.Builder()
                 .startAppService(MainCarAppService::class.java)